littlejsengine 1.6.4 → 1.6.92

package/build/littlejs.d.ts

@@ -1,164 +1,160 @@
 declare module "littlejs.esm" {
     /**
      * LittleJS Module Export
-     * <br> - Export engine as a module with extra functions where necessary
+     * - Export engine as a module with extra functions where necessary
      */
     /** Set position of camera in world space
      *  @param {Vector2} pos
      *  @memberof Settings */
-    export function setCameraPos(pos: Vector2): Vector2;
+    export function setCameraPos(pos: Vector2): void;
     /** Set scale of camera in world space
      *  @param {Number} scale
      *  @memberof Settings */
-    export function setCameraScale(scale: number): number;
+    export function setCameraScale(scale: number): void;
     /** Set max size of the canvas
      *  @param {Vector2} size
      *  @memberof Settings */
-    export function setCanvasMaxSize(size: Vector2): Vector2;
+    export function setCanvasMaxSize(size: Vector2): void;
     /** Set fixed size of the canvas
      *  @param {Vector2} size
      *  @memberof Settings */
-    export function setCanvasFixedSize(size: Vector2): Vector2;
+    export function setCanvasFixedSize(size: Vector2): void;
     /** Disables anti aliasing for pixel art if true
      *  @param {Boolean} pixelated
      *  @memberof Settings */
-    export function setCavasPixelated(pixelated: boolean): boolean;
+    export function setCanvasPixelated(pixelated: boolean): void;
     /** Set default font used for text rendering
      *  @param {String} font
      *  @memberof Settings */
-    export function setFontDefault(font: string): string;
+    export function setFontDefault(font: string): void;
     /** Set if webgl rendering is enabled
      *  @param {Boolean} enable
      *  @memberof Settings */
-    export function setGlEnable(enable: boolean): boolean;
+    export function setGlEnable(enable: boolean): void;
     /** Set to not composite the WebGL canvas
      *  @param {Boolean} overlay
      *  @memberof Settings */
-    export function setGlOverlay(overlay: boolean): boolean;
+    export function setGlOverlay(overlay: boolean): void;
     /** Set default size of tiles in pixels
      *  @param {Vector2} size
      *  @memberof Settings */
-    export function setTileSizeDefault(size: Vector2): Vector2;
+    export function setTileSizeDefault(size: Vector2): void;
     /** Set to prevent tile bleeding from neighbors in pixels
      *  @param {Number} scale
      *  @memberof Settings */
-    export function setTileFixBleedScale(scale: number): number;
+    export function setTileFixBleedScale(scale: number): void;
     /** Set if collisions between objects are enabled
      *  @param {Boolean} enable
      *  @memberof Settings */
-    export function setEnablePhysicsSolver(enable: boolean): boolean;
+    export function setEnablePhysicsSolver(enable: boolean): void;
     /** Set default object mass for collison calcuations
      *  @param {Number} mass
      *  @memberof Settings */
-    export function setObjectDefaultMass(mass: number): number;
+    export function setObjectDefaultMass(mass: number): void;
     /** Set how much to slow velocity by each frame
      *  @param {Number} damping
      *  @memberof Settings */
-    export function setObjectDefaultDamping(damp: any): any;
+    export function setObjectDefaultDamping(damp: any): void;
     /** Set how much to slow angular velocity each frame
      *  @param {Number} damping
      *  @memberof Settings */
-    export function setObjectDefaultAngleDamping(damp: any): any;
+    export function setObjectDefaultAngleDamping(damp: any): void;
     /** Set how much to bounce when a collision occur
      *  @param {Number} elasticity
      *  @memberof Settings */
-    export function setObjectDefaultElasticity(elasticity: number): number;
+    export function setObjectDefaultElasticity(elasticity: number): void;
     /** Set how much to slow when touching
      *  @param {Number} friction
      *  @memberof Settings */
-    export function setObjectDefaultFriction(friction: number): number;
+    export function setObjectDefaultFriction(friction: number): void;
     /** Set max speed to avoid fast objects missing collisions
      *  @param {Number} speed
      *  @memberof Settings */
-    export function setObjectMaxSpeed(speed: number): number;
+    export function setObjectMaxSpeed(speed: number): void;
     /** Set how much gravity to apply to objects along the Y axis
      *  @param {Number} gravity
      *  @memberof Settings */
-    export function setGravity(g: any): any;
+    export function setGravity(g: any): void;
     /** Set to scales emit rate of particles
      *  @param {Number} scale
      *  @memberof Settings */
-    export function setParticleEmitRateScale(scale: number): number;
+    export function setParticleEmitRateScale(scale: number): void;
     /** Set if gamepads are enabled
      *  @param {Boolean} enable
      *  @memberof Settings */
-    export function setGamepadsEnable(enable: boolean): boolean;
+    export function setGamepadsEnable(enable: boolean): void;
     /** Set if the dpad input is also routed to the left analog stick
      *  @param {Boolean} enable
      *  @memberof Settings */
-    export function setGamepadDirectionEmulateStick(enable: boolean): boolean;
+    export function setGamepadDirectionEmulateStick(enable: boolean): void;
     /** Set if true the WASD keys are also routed to the direction keys
      *  @param {Boolean} enable
      *  @memberof Settings */
-    export function setInputWASDEmulateDirection(enable: boolean): boolean;
+    export function setInputWASDEmulateDirection(enable: boolean): void;
     /** Set if touch gamepad should appear on mobile devices
      *  @param {Boolean} enable
      *  @memberof Settings */
-    export function setTouchGamepadEnable(enable: boolean): boolean;
+    export function setTouchGamepadEnable(enable: boolean): void;
     /** Set if touch gamepad should be analog stick or 8 way dpad
      *  @param {Boolean} analog
      *  @memberof Settings */
-    export function setTouchGamepadAnalog(analog: boolean): boolean;
+    export function setTouchGamepadAnalog(analog: boolean): void;
     /** Set size of virutal gamepad for touch devices in pixels
      *  @param {Number} size
      *  @memberof Settings */
-    export function setTouchGamepadSize(size: number): number;
+    export function setTouchGamepadSize(size: number): void;
     /** Set transparency of touch gamepad overlay
      *  @param {Number} alpha
      *  @memberof Settings */
-    export function setTouchGamepadAlpha(alpha: number): number;
+    export function setTouchGamepadAlpha(alpha: number): void;
     /** Set to allow vibration hardware if it exists
      *  @param {Boolean} enable
      *  @memberof Settings */
-    export function setVibrateEnable(enable: boolean): boolean;
+    export function setVibrateEnable(enable: boolean): void;
     /** Set to disable all audio code
      *  @param {Boolean} enable
      *  @memberof Settings */
-    export function setSoundEnable(enable: boolean): boolean;
+    export function setSoundEnable(enable: boolean): void;
     /** Set volume scale to apply to all sound, music and speech
      *  @param {Number} volume
      *  @memberof Settings */
-    export function setSoundVolume(volume: number): number;
+    export function setSoundVolume(volume: number): void;
     /** Set default range where sound no longer plays
      *  @param {Number} range
      *  @memberof Settings */
-    export function setSoundDefaultRange(range: number): number;
+    export function setSoundDefaultRange(range: number): void;
     /** Set default range percent to start tapering off sound
      *  @param {Number} taper
      *  @memberof Settings */
-    export function setSoundDefaultTaper(taper: number): number;
+    export function setSoundDefaultTaper(taper: number): void;
     /** Set how long to show medals for in seconds
      *  @param {Number} time
      *  @memberof Settings */
-    export function setMedalDisplayTime(time: number): number;
+    export function setMedalDisplayTime(time: number): void;
     /** Set how quickly to slide on/off medals in seconds
      *  @param {Number} time
      *  @memberof Settings */
-    export function setMedalDisplaySlideTime(time: number): number;
+    export function setMedalDisplaySlideTime(time: number): void;
     /** Set size of medal display
      *  @param {Vector2} size
      *  @memberof Settings */
-    export function setMedalDisplaySize(size: Vector2): Vector2;
+    export function setMedalDisplaySize(size: Vector2): void;
     /** Set size of icon in medal display
      *  @param {Number} size
      *  @memberof Settings */
-    export function setMedalDisplayIconSize(size: number): number;
+    export function setMedalDisplayIconSize(size: number): void;
     /** Set to stop medals from being unlockable
      *  @param {Boolean} preventUnlock
      *  @memberof Settings */
-    export function setMedalsPreventUnlock(prevent: any): any;
+    export function setMedalsPreventUnlock(preventUnlock: boolean): void;
     /** Set if watermark with FPS should be shown
      *  @param {Boolean} show
      *  @memberof Debug */
-    export function setShowWatermark(show: boolean): boolean;
-    /** Set if god mode is enabled
-     *  @param {Boolean} enable
-     *  @memberof Debug */
-    export function setGodMode(enable: boolean): boolean;
+    export function setShowWatermark(show: boolean): void;
     /** Set key code used to toggle debug mode, Esc by default
      *  @param {Number} key
      *  @memberof Debug */
-    export function setDebugKey(key: number): number;
+    export function setDebugKey(key: number): void;
     /** The max size of the canvas, centered if window is larger
      *  @type {Vector2}
      *  @default Vector2(1920,1200)
@@ -170,11 +166,11 @@ declare module "littlejs.esm" {
      *  @default Vector2()
      *  @memberof Settings */
     export let canvasFixedSize: Vector2;
-    /** Disables anti aliasing for pixel art if true
+    /** Disables filtering for crisper pixel art if true
      *  @type {Boolean}
      *  @default
      *  @memberof Settings */
-    export let cavasPixelated: boolean;
+    export let canvasPixelated: boolean;
     /** Default font used for text rendering
      *  @type {String}
      *  @default
@@ -271,8 +267,8 @@ declare module "littlejs.esm" {
      *  @memberof Settings */
     export let inputWASDEmulateDirection: boolean;
     /** True if touch gamepad should appear on mobile devices
-     *  <br> - Supports left analog stick, 4 face buttons and start button (button 9)
-     *  <br> - Must be set by end of gameInit to be activated
+     *  - Supports left analog stick, 4 face buttons and start button (button 9)
+     *  - Must be set by end of gameInit to be activated
      *  @type {Boolean}
      *  @default 0
      *  @memberof Settings */
@@ -347,11 +343,10 @@ declare module "littlejs.esm" {
      *  @default
      *  @memberof Debug */
     export let showWatermark: boolean;
-    /** True if god mode is enabled, handle this however you want
-     *  @type {Boolean}
-     *  @default
+    /** Asserts if the experssion is false, does not do anything in release builds
+     *  @param {Boolean} assertion
+     *  @param {Object}  output
      *  @memberof Debug */
-    export let godMode: boolean;
     export function ASSERT(...assert: any[]): void;
     /** Draw a debug rectangle in world space
      *  @param {Vector2} pos
@@ -405,7 +400,7 @@ declare module "littlejs.esm" {
     export function debugText(text: string, pos: Vector2, size?: number, color?: string, time?: number, angle?: number, font?: string): void;
     /** Clear all debug primitives in the list
      *  @memberof Debug */
-    export function debugClear(): any[];
+    export function debugClear(): void;
     /** Save a canvas to disk
      *  @param {HTMLCanvasElement} canvas
      *  @param {String}            [filename]
@@ -420,69 +415,69 @@ declare module "littlejs.esm" {
      *  @param {Number} value
      *  @return {Number}
      *  @memberof Utilities */
-    export function abs(a: any): number;
+    export function abs(value: number): number;
     /** Returns lowest of two values passed in
      *  @param {Number} valueA
      *  @param {Number} valueB
      *  @return {Number}
      *  @memberof Utilities */
-    export function min(a: any, b: any): number;
+    export function min(valueA: number, valueB: number): number;
     /** Returns highest of two values passed in
      *  @param {Number} valueA
      *  @param {Number} valueB
      *  @return {Number}
      *  @memberof Utilities */
-    export function max(a: any, b: any): number;
+    export function max(valueA: number, valueB: number): number;
     /** Returns the sign of value passed in (also returns 1 if 0)
      *  @param {Number} value
      *  @return {Number}
      *  @memberof Utilities */
-    export function sign(a: any): number;
+    export function sign(value: number): number;
     /** Returns first parm modulo the second param, but adjusted so negative numbers work as expected
      *  @param {Number} dividend
      *  @param {Number} [divisor=1]
      *  @return {Number}
      *  @memberof Utilities */
-    export function mod(a: any, b?: number): number;
+    export function mod(dividend: number, divisor?: number): number;
     /** Clamps the value beween max and min
      *  @param {Number} value
      *  @param {Number} [min=0]
      *  @param {Number} [max=1]
      *  @return {Number}
      *  @memberof Utilities */
-    export function clamp(v: any, min?: number, max?: number): number;
+    export function clamp(value: number, min?: number, max?: number): number;
     /** Returns what percentage the value is between max and min
      *  @param {Number} value
      *  @param {Number} [min=0]
      *  @param {Number} [max=1]
      *  @return {Number}
      *  @memberof Utilities */
-    export function percent(v: any, min?: number, max?: number): number;
+    export function percent(value: number, min?: number, max?: number): number;
     /** Linearly interpolates the percent value between max and min
      *  @param {Number} percent
      *  @param {Number} [min=0]
      *  @param {Number} [max=1]
      *  @return {Number}
      *  @memberof Utilities */
-    export function lerp(p: any, min?: number, max?: number): number;
+    export function lerp(percent: number, min?: number, max?: number): number;
     /** Applies smoothstep function to the percentage value
-     *  @param {Number} value
+     *  @param {Number} percent
      *  @return {Number}
      *  @memberof Utilities */
-    export function smoothStep(p: any): number;
+    export function smoothStep(percent: number): number;
     /** Returns the nearest power of two not less then the value
      *  @param {Number} value
      *  @return {Number}
      *  @memberof Utilities */
-    export function nearestPowerOfTwo(v: any): number;
+    export function nearestPowerOfTwo(value: number): number;
     /** Returns true if two axis aligned bounding boxes are overlapping
      *  @param {Vector2} pointA  - Center of box A
      *  @param {Vector2} sizeA   - Size of box A
      *  @param {Vector2} pointB  - Center of box B
-     *  @param {Vector2} [sizeB] - Size of box B
+     *  @param {Vector2} sizeB   - Size of box B
      *  @return {Boolean}        - True if overlapping
      *  @memberof Utilities */
-    export function isOverlapping(pA: any, sA: any, pB: any, sB: any): boolean;
+    export function isOverlapping(pointA: Vector2, sizeA: Vector2, pointB: Vector2, sizeB: Vector2): boolean;
     /** Returns an oscillating wave between 0 and amplitude with frequency of 1 Hz by default
      *  @param {Number} [frequency=1] - Frequency of the wave in Hz
      *  @param {Number} [amplitude=1] - Amplitude (max height) of the wave
@@ -502,13 +497,13 @@ declare module "littlejs.esm" {
      *  @param {Number} [valueB=0]
      *  @return {Number}
      *  @memberof Random */
-    export function rand(a?: number, b?: number): number;
+    export function rand(valueA?: number, valueB?: number): number;
     /** Returns a floored random value the two values passed in
      *  @param {Number} [valueA=1]
      *  @param {Number} [valueB=0]
      *  @return {Number}
      *  @memberof Random */
-    export function randInt(a?: number, b?: number): number;
+    export function randInt(valueA?: number, valueB?: number): number;
     /** Randomly returns either -1 or 1
      *  @return {Number}
      *  @memberof Random */
@@ -530,7 +525,7 @@ declare module "littlejs.esm" {
      *  @param {Boolean} [linear]
      *  @return {Color}
      *  @memberof Random */
-    export function randColor(cA?: Color, cB?: Color, linear?: boolean): Color;
+    export function randColor(colorA?: Color, colorB?: Color, linear?: boolean): Color;
     /** Seed used by the randSeeded function
      *  @type {Number}
      *  @default
@@ -539,16 +534,16 @@ declare module "littlejs.esm" {
     /** Set seed used by the randSeeded function, should not be 0
      *  @param {Number} seed
      *  @memberof Random */
-    export function setRandSeed(seed: number): number;
+    export function setRandSeed(seed: number): void;
     /** Returns a seeded random value between the two values passed in using randSeed
      *  @param {Number} [valueA=1]
      *  @param {Number} [valueB=0]
      *  @return {Number}
      *  @memberof Random */
-    export function randSeeded(a?: number, b?: number): number;
+    export function randSeeded(valueA?: number, valueB?: number): number;
     /**
      * 2D Vector object with vector math library
-     * <br> - Functions do not change this so they can be chained together
+     * - Functions do not change this so they can be chained together
      * @example
      * let a = new Vector2(2, 3); // vector with coordinates (2, 3)
      * let b = new Vector2;       // vector with coordinates (0, 0)
@@ -568,25 +563,25 @@ declare module "littlejs.esm" {
          *  @return {Vector2} */
         copy(): Vector2;
         /** Returns a copy of this vector plus the vector passed in
-         *  @param {Vector2} vector
+         *  @param {Vector2} v - other vector
          *  @return {Vector2} */
-        add(v: any): Vector2;
+        add(v: Vector2): Vector2;
         /** Returns a copy of this vector minus the vector passed in
-         *  @param {Vector2} vector
+         *  @param {Vector2} v - other vector
          *  @return {Vector2} */
-        subtract(v: any): Vector2;
+        subtract(v: Vector2): Vector2;
         /** Returns a copy of this vector times the vector passed in
-         *  @param {Vector2} vector
+         *  @param {Vector2} v - other vector
          *  @return {Vector2} */
-        multiply(v: any): Vector2;
+        multiply(v: Vector2): Vector2;
         /** Returns a copy of this vector divided by the vector passed in
-         *  @param {Vector2} vector
+         *  @param {Vector2} v - other vector
          *  @return {Vector2} */
-        divide(v: any): Vector2;
+        divide(v: Vector2): Vector2;
         /** Returns a copy of this vector scaled by the vector passed in
-         *  @param {Number} scale
+         *  @param {Number} s - scale
          *  @return {Vector2} */
-        scale(s: any): Vector2;
+        scale(s: number): Vector2;
         /** Returns the length of this vector
          * @return {Number} */
         length(): number;
@@ -594,13 +589,13 @@ declare module "littlejs.esm" {
          * @return {Number} */
         lengthSquared(): number;
         /** Returns the distance from this vector to vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @return {Number} */
-        distance(v: any): number;
+        distance(v: Vector2): number;
         /** Returns the distance squared from this vector to vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @return {Number} */
-        distanceSquared(v: any): number;
+        distanceSquared(v: Vector2): number;
         /** Returns a new vector in same direction as this one with the length passed in
          * @param {Number} [length=1]
          * @return {Vector2} */
@@ -610,13 +605,13 @@ declare module "littlejs.esm" {
          * @return {Vector2} */
         clampLength(length?: number): Vector2;
         /** Returns the dot product of this and the vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @return {Number} */
-        dot(v: any): number;
+        dot(v: Vector2): number;
         /** Returns the cross product of this and the vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @return {Number} */
-        cross(v: any): number;
+        cross(v: Vector2): number;
         /** Returns the angle of this vector, up is angle 0
          * @return {Number} */
         angle(): number;
@@ -624,11 +619,11 @@ declare module "littlejs.esm" {
          * @param {Number} [angle=0]
          * @param {Number} [length=1]
          * @return {Vector2} */
-        setAngle(a?: number, length?: number): Vector2;
+        setAngle(angle?: number, length?: number): Vector2;
         /** Returns copy of this vector rotated by the angle passed in
          * @param {Number} angle
          * @return {Vector2} */
-        rotate(a: any): Vector2;
+        rotate(angle: number): Vector2;
         /** Returns the integer direction of this vector, corrosponding to multiples of 90 degree rotation (0-3)
          * @return {Number} */
         direction(): number;
@@ -642,10 +637,10 @@ declare module "littlejs.esm" {
          * @return {Number} */
         area(): number;
         /** Returns a new vector that is p percent between this and the vector passed in
-         * @param {Vector2} vector
+         * @param {Vector2} v - other vector
          * @param {Number}  percent
          * @return {Vector2} */
-        lerp(v: any, p: any): Vector2;
+        lerp(v: Vector2, percent: number): Vector2;
         /** Returns true if this vector is within the bounds of an array size passed in
          * @param {Vector2} arraySize
          * @return {Boolean} */
@@ -665,11 +660,11 @@ declare module "littlejs.esm" {
      * let e = HSL(.3, 1, .5);         // green using hsl color
      */
     export class Color {
-        /** Create a color with the components passed in, white by default
-         *  @param {Number} [red=1]
-         *  @param {Number} [green=1]
-         *  @param {Number} [blue=1]
-         *  @param {Number} [alpha=1] */
+        /** Create a color with the rgba components passed in, white by default
+         *  @param {Number} [r=1] - red
+         *  @param {Number} [g=1] - green
+         *  @param {Number} [b=1] - blue
+         *  @param {Number} [a=1] - alpha*/
         constructor(r?: number, g?: number, b?: number, a?: number);
         /** @property {Number} - Red */
         r: number;
@@ -683,39 +678,39 @@ declare module "littlejs.esm" {
          * @return {Color} */
         copy(): Color;
         /** Returns a copy of this color plus the color passed in
-         * @param {Color} color
+         * @param {Color} c - other color
          * @return {Color} */
-        add(c: any): Color;
+        add(c: Color): Color;
         /** Returns a copy of this color minus the color passed in
-         * @param {Color} color
+         * @param {Color} c - other color
          * @return {Color} */
-        subtract(c: any): Color;
+        subtract(c: Color): Color;
         /** Returns a copy of this color times the color passed in
-         * @param {Color} color
+         * @param {Color} c - other color
          * @return {Color} */
-        multiply(c: any): Color;
+        multiply(c: Color): Color;
         /** Returns a copy of this color divided by the color passed in
-         * @param {Color} color
+         * @param {Color} c - other color
          * @return {Color} */
-        divide(c: any): Color;
+        divide(c: Color): Color;
         /** Returns a copy of this color scaled by the value passed in, alpha can be scaled separately
          * @param {Number} scale
          * @param {Number} [alphaScale=scale]
          * @return {Color} */
-        scale(s: any, a?: any): Color;
+        scale(scale: number, alphaScale?: number): Color;
         /** Returns a copy of this color clamped to the valid range between 0 and 1
          * @return {Color} */
         clamp(): Color;
         /** Returns a new color that is p percent between this and the color passed in
-         * @param {Color}  color
+         * @param {Color}  c - other color
          * @param {Number} percent
          * @return {Color} */
-        lerp(c: any, p: any): Color;
+        lerp(c: Color, percent: number): Color;
         /** Sets this color given a hue, saturation, lightness, and alpha
-         * @param {Number} [hue=0]
-         * @param {Number} [saturation=0]
-         * @param {Number} [lightness=1]
-         * @param {Number} [alpha=1]
+         * @param {Number} [h=0] - hue
+         * @param {Number} [s=0] - saturation
+         * @param {Number} [l=1] - lightness
+         * @param {Number} [a=1] - alpha
          * @return {Color} */
         setHSLA(h?: number, s?: number, l?: number, a?: number): Color;
         /** Returns this color expressed in hsla format
@@ -795,44 +790,44 @@ declare module "littlejs.esm" {
     export function vec2(x?: number, y?: number): Vector2;
     /**
      * Create a color object with RGBA values
-     * @param {Number} [r=1]
-     * @param {Number} [g=1]
-     * @param {Number} [b=1]
-     * @param {Number} [a=1]
+     * @param {Number} [r=1] - red
+     * @param {Number} [g=1] - green
+     * @param {Number} [b=1] - blue
+     * @param {Number} [a=1] - alpha
      * @return {Color}
      * @memberof Utilities
      */
     export function rgb(r?: number, g?: number, b?: number, a?: number): Color;
     /**
      * Create a color object with HSLA values
-     * @param {Number} [h=0]
-     * @param {Number} [s=0]
-     * @param {Number} [l=1]
-     * @param {Number} [a=1]
+     * @param {Number} [h=0] - hue
+     * @param {Number} [s=0] - saturation
+     * @param {Number} [l=1] - lightness
+     * @param {Number} [a=1] - alpha
      * @return {Color}
      * @memberof Utilities
      */
     export function hsl(h?: number, s?: number, l?: number, a?: number): Color;
     /**
      * LittleJS Object Base Object Class
-     * <br> - Base object class used by the engine
-     * <br> - Automatically adds self to object list
-     * <br> - Will be updated and rendered each frame
-     * <br> - Renders as a sprite from a tilesheet by default
-     * <br> - Can have color and addtive color applied
-     * <br> - 2d Physics and collision system
-     * <br> - Sorted by renderOrder
-     * <br> - Objects can have children attached
-     * <br> - Parents are updated before children, and set child transform
-     * <br> - Call destroy() to get rid of objects
-     * <br>
-     * <br>The physics system used by objects is simple and fast with some caveats...
-     * <br> - Collision uses the axis aligned size, the object's rotation angle is only for rendering
-     * <br> - Objects are guaranteed to not intersect tile collision from physics
-     * <br> - If an object starts or is moved inside tile collision, it will not collide with that tile
-     * <br> - Collision for objects can be set to be solid to block other objects
-     * <br> - Objects may get pushed into overlapping other solid objects, if so they will push away
-     * <br> - Solid objects are more performance intensive and should be used sparingly
+     * - Base object class used by the engine
+     * - Automatically adds self to object list
+     * - Will be updated and rendered each frame
+     * - Renders as a sprite from a tilesheet by default
+     * - Can have color and addtive color applied
+     * - 2d Physics and collision system
+     * - Sorted by renderOrder
+     * - Objects can have children attached
+     * - Parents are updated before children, and set child transform
+     * - Call destroy() to get rid of objects
+     *
+     * The physics system used by objects is simple and fast with some caveats...
+     * - Collision uses the axis aligned size, the object's rotation angle is only for rendering
+     * - Objects are guaranteed to not intersect tile collision from physics
+     * - If an object starts or is moved inside tile collision, it will not collide with that tile
+     * - Collision for objects can be set to be solid to block other objects
+     * - Objects may get pushed into overlapping other solid objects, if so they will push away
+     * - Solid objects are more performance intensive and should be used sparingly
      * @example
      * // create an engine object, normally you would first extend the class with your own
      * const pos = vec2(2,3);
@@ -904,13 +899,13 @@ declare module "littlejs.esm" {
          *  @param {EngineObject} object - the object to test against
          *  @return {Boolean}            - true if the collision should be resolved
          */
-        collideWithObject(o: any): boolean;
+        collideWithObject(object: EngineObject): boolean;
         /** How long since the object was created
          *  @return {Number} */
         getAliveTime(): number;
         /** Apply acceleration to this object (adjust velocity, not affected by mass)
          *  @param {Vector2} acceleration */
-        applyAcceleration(a: any): void;
+        applyAcceleration(acceleration: Vector2): void;
         /** Apply force to this object (adjust velocity, affected by mass)
          *  @param {Vector2} force */
         applyForce(force: Vector2): void;
@@ -1063,9 +1058,9 @@ declare module "littlejs.esm" {
     export let engineFontImage: any;
     /**
      * Font Image Object - Draw text on a 2D canvas by using characters in an image
-     * <br> - 96 characters (from space to tilde) are stored in an image
-     * <br> - Uses a default 8x8 font if none is supplied
-     * <br> - You can also use fonts from the main tile sheet
+     * - 96 characters (from space to tilde) are stored in an image
+     * - Uses a default 8x8 font if none is supplied
+     * - You can also use fonts from the main tile sheet
      * @example
      * // use built in font
      * const font = new ImageFont;
@@ -1129,7 +1124,7 @@ declare module "littlejs.esm" {
     export function keyWasReleased(key: number, device?: number): boolean;
     /** Clears all input
      *  @memberof Input */
-    export function clearInput(): any[][];
+    export function clearInput(): void;
     /** Returns true if device key is down
      *  @param {Number} key
      *  @param {Number} [device=0]
@@ -1197,17 +1192,17 @@ declare module "littlejs.esm" {
     /** Pulse the vibration hardware if it exists
      *  @param {Number} [pattern=100] - a single value in miliseconds or vibration interval array
      *  @memberof Input */
-    export function vibrate(pattern?: number): boolean;
+    export function vibrate(pattern?: number): void;
     /** Cancel any ongoing vibration
      *  @memberof Input */
-    export function vibrateStop(): boolean;
+    export function vibrateStop(): void;
     /** True if a touch device has been detected
      *  @memberof Input */
     export const isTouchDevice: boolean;
     /**
      * Sound Object - Stores a zzfx sound for later use and can be played positionally
-     * <br>
-     * <br><b><a href=https://killedbyapixel.github.io/ZzFX/>Create sounds using the ZzFX Sound Designer.</a></b>
+     *
+     * <a href=https://killedbyapixel.github.io/ZzFX/>Create sounds using the ZzFX Sound Designer.</a>
      * @example
      * // create a sound
      * const sound_example = new Sound([.5,.5]);
@@ -1227,7 +1222,7 @@ declare module "littlejs.esm" {
         /** @property {Number} - At what percentage of range should it start tapering off */
         taper: number;
         randomness: any;
-        cachedSamples: number[];
+        cachedSamples: any[];
         /** Play the sound
          *  @param {Vector2} [pos] - World space position to play the sound, sound is not attenuated if null
          *  @param {Number}  [volume=1] - How much to scale volume by (in addition to range fade)
@@ -1246,8 +1241,8 @@ declare module "littlejs.esm" {
     }
     /**
      * Music Object - Stores a zzfx music track for later use
-     * <br>
-     * <br><b><a href=https://keithclark.github.io/ZzFXM/>Create music with the ZzFXM tracker.</a></b>
+     *
+     * <a href=https://keithclark.github.io/ZzFXM/>Create music with the ZzFXM tracker.</a>
      * @example
      * // create some music
      * const music_example = new Music(
@@ -1332,12 +1327,12 @@ declare module "littlejs.esm" {
      *  @memberof Audio */
     export function playSamples(sampleChannels: any[], volume?: number, rate?: number, pan?: number, loop?: boolean): AudioBufferSourceNode;
     /** Generate and play a ZzFX sound
-     *  <br>
-     *  <br><b><a href=https://killedbyapixel.github.io/ZzFX/>Create sounds using the ZzFX Sound Designer.</a></b>
+     *
+     *  <a href=https://killedbyapixel.github.io/ZzFX/>Create sounds using the ZzFX Sound Designer.</a>
      *  @param {Array} zzfxSound - Array of ZzFX parameters, ex. [.5,.5]
-     *  @return {Array} - Array of audio samples
+     *  @return {AudioBufferSourceNode} - The audio node of the sound played
      *  @memberof Audio */
-    export function zzfx(...zzfxSound: any[]): any[];
+    export function zzfx(...zzfxSound: any[]): AudioBufferSourceNode;
     /** The tile collision layer array, use setTileCollisionData and getTileCollisionData to access
      *  @type {Array}
      *  @memberof TileCollision */
@@ -1354,7 +1349,7 @@ declare module "littlejs.esm" {
      *  @param {Vector2} pos
      *  @param {Number}  [data=0]
      *  @memberof TileCollision */
-    export function setTileCollisionData(pos: Vector2, data?: number): number;
+    export function setTileCollisionData(pos: Vector2, data?: number): void;
     /** Get tile collision data
      *  @param {Vector2} pos
      *  @return {Number}
@@ -1367,7 +1362,7 @@ declare module "littlejs.esm" {
      *  @return {Boolean}
      *  @memberof TileCollision */
     export function tileCollisionTest(pos: Vector2, size?: Vector2, object?: EngineObject): boolean;
-    /** Return the center of tile if any that is hit (this does not return the exact hit point)
+    /** Return the center of tile if any that is hit (does not return the exact intersection)
      *  @param {Vector2}      posStart
      *  @param {Vector2}      posEnd
      *  @param {EngineObject} [object]
@@ -1404,10 +1399,10 @@ declare module "littlejs.esm" {
     }
     /**
      * Tile layer object - cached rendering system for tile layers
-     * <br> - Each Tile layer is rendered to an off screen canvas
-     * <br> - To allow dynamic modifications, layers are rendered using canvas 2d
-     * <br> - Some devices like mobile phones are limited to 4k texture resolution
-     * <br> - So with 16x16 tiles this limits layers to 256x256 on mobile devices
+     * - Each Tile layer is rendered to an off screen canvas
+     * - To allow dynamic modifications, layers are rendered using canvas 2d
+     * - Some devices like mobile phones are limited to 4k texture resolution
+     * - So with 16x16 tiles this limits layers to 256x256 on mobile devices
      * @extends EngineObject
      * @example
      * // create tile collision and visible tile layer
@@ -1597,8 +1592,8 @@ declare module "littlejs.esm" {
      *  @memberof Settings */
     export let medalsPreventUnlock: boolean;
     /** Initialize medals with a save name used for storage
-     *  <br> - Call this after creating all medals
-     *  <br> - Checks if medals are unlocked
+     *  - Call this after creating all medals
+     *  - Checks if medals are unlocked
      *  @param {String} saveName
      *  @memberof Medals */
     export function medalsInit(saveName: string): void;
@@ -1708,7 +1703,7 @@ declare module "littlejs.esm" {
      *  @memberof WebGL */
     export function glSetBlendMode(additive?: boolean): void;
     /** Set the WebGl texture, not normally necessary unless multiple tile sheets are used
-     *  <br> - This may also flush the gl buffer resulting in more draw calls and worse performance
+     *  - This may also flush the gl buffer resulting in more draw calls and worse performance
      *  @param {WebGLTexture} [texture=glTileTexture]
      *  @memberof WebGL */
     export function glSetTexture(texture?: WebGLTexture): void;