diff --git a/.prettierrc.js b/.prettierrc.js
new file mode 100644
index 0000000..88649ad
--- /dev/null
+++ b/.prettierrc.js
@@ -0,0 +1,7 @@
+module.exports = {
+  printWidth: 100,
+  semi: false,
+  singleQuote: true,
+  tabWidth: 2,
+  trailingComma: "all",
+}
diff --git a/.prettierrs.js b/.prettierrs.js
deleted file mode 100644
index 9307727..0000000
--- a/.prettierrs.js
+++ /dev/null
@@ -1,7 +0,0 @@
-module.exports = {
-    printWidth: 100,
-    semi: true,
-    singleQuote: true,
-    tabWidth: 2,
-    trailingComma: 'all',
-  };
diff --git a/.vscode/settings.json b/.vscode/settings.json
index cdb6388..7fe893c 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,24 +1,22 @@
 {
-    "typescript.tsdk": "node_modules/typescript/lib",
-    "editor.tabSize": 2,
-    "eslint.validate": [
-      "javascript",
-      "javascriptreact",
-      {
-        "language": "typescript",
-        "autoFix": true
-      },
-    ],
-    "[javascript]": {
-      "editor.formatOnSave": true
-    },
-    "[typescript]": {
-      "editor.formatOnSave": true
-    },
-    "[html]": {
-      "editor.formatOnSave": true
-    },
-    "editor.codeActionsOnSave": {
-      "source.fixAll.eslint": true
-    },
-  }
\ No newline at end of file
+  "typescript.tsdk": "node_modules/typescript/lib",
+  "editor.tabSize": 2,
+  "editor.formatOnSave": true,
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "eslint.validate": ["javascript", "javascriptreact", "typescript"],
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[html]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "always"
+  }
+}
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index 42d7a88..5153cf9 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -18,6 +18,7 @@
         "json-loader": "^0.5.7",
         "phaser": "^3.60.0",
         "phaser-raycaster": "^0.10.6",
+        "prettier": "^3.8.1",
         "ts-loader": "^9.4.2",
         "typescript": "^5.0.3",
         "webpack": "^5.77.0",
@@ -4732,6 +4733,22 @@
         "node": ">=8"
       }
     },
+    "node_modules/prettier": {
+      "version": "3.8.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.1.tgz",
+      "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
     "node_modules/pretty-error": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/pretty-error/-/pretty-error-4.0.0.tgz",
diff --git a/package.json b/package.json
index 01b211e..fedee80 100644
--- a/package.json
+++ b/package.json
@@ -6,7 +6,8 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "dev": "webpack serve --mode development",
-    "build": "webpack --mode production"
+    "build": "webpack --mode production",
+    "format": "prettier --write \"src/**/*.ts\""
   },
   "repository": {
     "type": "git",
@@ -33,6 +34,7 @@
     "json-loader": "^0.5.7",
     "phaser": "^3.60.0",
     "phaser-raycaster": "^0.10.6",
+    "prettier": "^3.8.1",
     "ts-loader": "^9.4.2",
     "typescript": "^5.0.3",
     "webpack": "^5.77.0",
diff --git a/src/assets/credits.ts b/src/assets/credits.ts
index 1710abc..2452f40 100644
--- a/src/assets/credits.ts
+++ b/src/assets/credits.ts
@@ -1,65 +1,59 @@
-type AssetType =
-  | "2D Art"
-  | "3D Art"
-  | "Textures"
-  | "Music"
-  | "Sound Effects"
-  | "Fonts";
+type AssetType = '2D Art' | '3D Art' | 'Textures' | 'Music' | 'Sound Effects' | 'Fonts'
 
 export interface Asset {
-  type: AssetType;
-  name: string;
-  url: string;
+  type: AssetType
+  name: string
+  url: string
 }
 
 export interface Credit {
-  author: string;
-  url?: string;
-  assets: Asset[];
+  author: string
+  url?: string
+  assets: Asset[]
 }
 
 export const credits: Credit[] = [
   {
-    author: "Riley Gombart",
-    url: "https://opengameart.org/users/rileygombart",
+    author: 'Riley Gombart',
+    url: 'https://opengameart.org/users/rileygombart',
     assets: [
       {
-        type: "2D Art",
-        name: "Animated Top Down Survivor Player",
-        url: "https://opengameart.org/content/animated-top-down-survivor-player",
+        type: '2D Art',
+        name: 'Animated Top Down Survivor Player',
+        url: 'https://opengameart.org/content/animated-top-down-survivor-player',
       },
     ],
   },
   {
-    author: "Kay Lousberg",
-    url: "https://www.kaylousberg.com/",
+    author: 'Kay Lousberg',
+    url: 'https://www.kaylousberg.com/',
     assets: [
       {
-        type: "2D Art",
-        name: "2D Guns",
-        url: "https://opengameart.org/content/2d-guns",
+        type: '2D Art',
+        name: '2D Guns',
+        url: 'https://opengameart.org/content/2d-guns',
       },
     ],
   },
   {
-    author: "Tiziana",
+    author: 'Tiziana',
     assets: [
       {
-        type: "Textures",
-        name: "Even grey stone tile floor 256px",
-        url: "https://opengameart.org/content/even-grey-stone-tile-floor-256px",
+        type: 'Textures',
+        name: 'Even grey stone tile floor 256px',
+        url: 'https://opengameart.org/content/even-grey-stone-tile-floor-256px',
       },
     ],
   },
   {
-    author: "iwanPlays",
-    url: "https://sketchfab.com/iwanPlays",
+    author: 'iwanPlays',
+    url: 'https://sketchfab.com/iwanPlays',
     assets: [
       {
-        type: "3D Art",
-        name: "Industrial Bulkhead Wall Lamp Lowpoly",
-        url: "https://sketchfab.com/3d-models/industrial-bulkhead-wall-lamp-lowpoly-4c50439bcbc247629fe2194862d7acc9",
+        type: '3D Art',
+        name: 'Industrial Bulkhead Wall Lamp Lowpoly',
+        url: 'https://sketchfab.com/3d-models/industrial-bulkhead-wall-lamp-lowpoly-4c50439bcbc247629fe2194862d7acc9',
       },
     ],
   },
-];
+]
diff --git a/src/controls/Inputs.ts b/src/controls/Inputs.ts
deleted file mode 100644
index f2641ae..0000000
--- a/src/controls/Inputs.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-export interface Keys {
-  W: Phaser.Input.Keyboard.Key;
-  A: Phaser.Input.Keyboard.Key;
-  S: Phaser.Input.Keyboard.Key;
-  D: Phaser.Input.Keyboard.Key;
-  E: Phaser.Input.Keyboard.Key;
-  R: Phaser.Input.Keyboard.Key;
-  Z: Phaser.Input.Keyboard.Key;
-  X: Phaser.Input.Keyboard.Key;
-  C: Phaser.Input.Keyboard.Key;
-  F: Phaser.Input.Keyboard.Key;
-  up: Phaser.Input.Keyboard.Key;
-  down: Phaser.Input.Keyboard.Key;
-  left: Phaser.Input.Keyboard.Key;
-  right: Phaser.Input.Keyboard.Key;
-  enter: Phaser.Input.Keyboard.Key;
-  space: Phaser.Input.Keyboard.Key;
-  comma: Phaser.Input.Keyboard.Key;
-  period: Phaser.Input.Keyboard.Key;
-  zero: Phaser.Input.Keyboard.Key;
-  one: Phaser.Input.Keyboard.Key;
-  two: Phaser.Input.Keyboard.Key;
-  three: Phaser.Input.Keyboard.Key;
-  four: Phaser.Input.Keyboard.Key;
-  five: Phaser.Input.Keyboard.Key;
-  six: Phaser.Input.Keyboard.Key;
-  seven: Phaser.Input.Keyboard.Key;
-  eight: Phaser.Input.Keyboard.Key;
-  nine: Phaser.Input.Keyboard.Key;
-  shift: Phaser.Input.Keyboard.Key;
-}
-
-export default class Inputs {
-  private _input: Phaser.Input.InputPlugin;
-  private _keys: Keys;
-  private _padIndex = 0;
-
-  constructor(input: Phaser.Input.InputPlugin) {
-    this._input = input;
-    this._keys = this._input.keyboard.addKeys(
-      "W,A,S,D,Z,X,C,F,E,R,up,left,down,right,space,enter,comma,period,zero,one,two,three,four,five,six,seven,eight,nine,shift"
-    ) as Keys;
-  }
-
-  public get left() {
-    return this.keys.left.isDown || this.keys.A.isDown || this.padAxisH === -1;
-  }
-
-  public get right() {
-    return this.keys.right.isDown || this.keys.D.isDown || this.padAxisH === 1;
-  }
-
-  public get up() {
-    return this.keys.up.isDown || this.keys.W.isDown || this.padAxisV === -1;
-  }
-
-  public get down() {
-    return this.keys.down.isDown || this.keys.S.isDown || this.padAxisV === 1;
-  }
-
-  public get space() {
-    return this.keys.space.isDown;
-  }
-
-  public get keys(): Keys {
-    return this._keys;
-  }
-
-  protected get padA() {
-    return this.padButtons.some(
-      (button) => button.index % 2 === 1 && button.value === 1
-    );
-  }
-
-  protected get padB() {
-    return this.padButtons.some(
-      (button) => button.index % 2 === 0 && button.value === 1
-    );
-  }
-
-  protected get padAxisH(): number {
-    if (this.pad) {
-      const [x] = this.pad.axes;
-
-      return x.getValue();
-    }
-
-    return 0;
-  }
-
-  protected get padAxisV(): number {
-    if (this.pad) {
-      const [_, y] = this.pad.axes;
-
-      return y.getValue();
-    }
-
-    return 0;
-  }
-
-  protected get padButtons() {
-    return this.pad?.buttons ?? [];
-  }
-
-  protected get pad() {
-    const pad = this._input.gamepad;
-
-    if (pad.gamepads.length > this._padIndex) {
-      return pad.gamepads[this._padIndex];
-    }
-
-    return;
-  }
-}
diff --git a/src/controls/inputs.ts b/src/controls/inputs.ts
new file mode 100644
index 0000000..1abd455
--- /dev/null
+++ b/src/controls/inputs.ts
@@ -0,0 +1,111 @@
+export interface Keys {
+  W: Phaser.Input.Keyboard.Key
+  A: Phaser.Input.Keyboard.Key
+  S: Phaser.Input.Keyboard.Key
+  D: Phaser.Input.Keyboard.Key
+  E: Phaser.Input.Keyboard.Key
+  R: Phaser.Input.Keyboard.Key
+  Z: Phaser.Input.Keyboard.Key
+  X: Phaser.Input.Keyboard.Key
+  C: Phaser.Input.Keyboard.Key
+  F: Phaser.Input.Keyboard.Key
+  F8: Phaser.Input.Keyboard.Key
+  up: Phaser.Input.Keyboard.Key
+  down: Phaser.Input.Keyboard.Key
+  left: Phaser.Input.Keyboard.Key
+  right: Phaser.Input.Keyboard.Key
+  enter: Phaser.Input.Keyboard.Key
+  space: Phaser.Input.Keyboard.Key
+  comma: Phaser.Input.Keyboard.Key
+  period: Phaser.Input.Keyboard.Key
+  zero: Phaser.Input.Keyboard.Key
+  one: Phaser.Input.Keyboard.Key
+  two: Phaser.Input.Keyboard.Key
+  three: Phaser.Input.Keyboard.Key
+  four: Phaser.Input.Keyboard.Key
+  five: Phaser.Input.Keyboard.Key
+  six: Phaser.Input.Keyboard.Key
+  seven: Phaser.Input.Keyboard.Key
+  eight: Phaser.Input.Keyboard.Key
+  nine: Phaser.Input.Keyboard.Key
+  shift: Phaser.Input.Keyboard.Key
+}
+
+export default class Inputs {
+  private _input: Phaser.Input.InputPlugin
+  private _keys: Keys
+  private _padIndex = 0
+
+  constructor(input: Phaser.Input.InputPlugin) {
+    this._input = input
+    this._keys = this._input.keyboard.addKeys(
+      'W,A,S,D,Z,X,C,F,E,R,F8,up,left,down,right,space,enter,comma,period,zero,one,two,three,four,five,six,seven,eight,nine,shift',
+    ) as Keys
+  }
+
+  public get left() {
+    return this.keys.left.isDown || this.keys.A.isDown || this.padAxisH === -1
+  }
+
+  public get right() {
+    return this.keys.right.isDown || this.keys.D.isDown || this.padAxisH === 1
+  }
+
+  public get up() {
+    return this.keys.up.isDown || this.keys.W.isDown || this.padAxisV === -1
+  }
+
+  public get down() {
+    return this.keys.down.isDown || this.keys.S.isDown || this.padAxisV === 1
+  }
+
+  public get space() {
+    return this.keys.space.isDown
+  }
+
+  public get keys(): Keys {
+    return this._keys
+  }
+
+  protected get padA() {
+    return this.padButtons.some((button) => button.index % 2 === 1 && button.value === 1)
+  }
+
+  protected get padB() {
+    return this.padButtons.some((button) => button.index % 2 === 0 && button.value === 1)
+  }
+
+  protected get padAxisH(): number {
+    if (this.pad) {
+      const [x] = this.pad.axes
+
+      return x.getValue()
+    }
+
+    return 0
+  }
+
+  protected get padAxisV(): number {
+    if (this.pad) {
+      const [_, y] = this.pad.axes
+
+      return y.getValue()
+    }
+
+    return 0
+  }
+
+  protected get padButtons() {
+    return this.pad?.buttons ?? []
+  }
+
+  protected get pad() {
+    const pad = this._input.gamepad
+
+    if (pad.gamepads.length > this._padIndex) {
+      return pad.gamepads[this._padIndex]
+    }
+
+    return
+  }
+}
diff --git a/src/controls/PlayerInputs.ts b/src/controls/player-inputs.ts
similarity index 63%
rename from src/controls/PlayerInputs.ts
rename to src/controls/player-inputs.ts
index 6898349..f3567bd 100644
--- a/src/controls/PlayerInputs.ts
+++ b/src/controls/player-inputs.ts
@@ -1,3 +1,3 @@
-import Inputs from "./Inputs";
+import Inputs from './inputs'
 
 export default class PlayerInputs extends Inputs {}
diff --git a/src/core/display-object.ext.ts b/src/core/display-object.ext.ts
new file mode 100644
index 0000000..63ba4c0
--- /dev/null
+++ b/src/core/display-object.ext.ts
@@ -0,0 +1,127 @@
+import 'phaser'
+import { StepOrder } from './step-order'
+import {
+  registerInstance,
+  unregisterFromAll,
+  MIXIN_LIGHT_AWARE,
+  MIXIN_LIGHT_SOURCE,
+  MIXIN_POINTABLE,
+  MIXIN_DEBUGGABLE,
+  MIXIN_INTERACTABLE,
+} from './instances'
+
+type MixinSymbol =
+  | typeof MIXIN_LIGHT_AWARE
+  | typeof MIXIN_LIGHT_SOURCE
+  | typeof MIXIN_POINTABLE
+  | typeof MIXIN_DEBUGGABLE
+  | typeof MIXIN_INTERACTABLE
+
+interface StepCallback {
+  fn: (obj: Phaser.GameObjects.GameObject) => void
+  order: StepOrder
+  obj: Phaser.GameObjects.GameObject
+}
+
+const stepCallbacks: StepCallback[] = []
+let stepCallbacksDirty = false
+
+export function runStepCallbacks(): void {
+  if (stepCallbacksDirty) {
+    stepCallbacks.sort((a, b) => a.order - b.order)
+    stepCallbacksDirty = false
+  }
+
+  for (let i = stepCallbacks.length - 1; i >= 0; i--) {
+    const callback = stepCallbacks[i]
+    if (callback.obj.active === false || callback.obj.scene === null) {
+      stepCallbacks.splice(i, 1)
+    }
+  }
+
+  for (const callback of stepCallbacks) {
+    callback.fn(callback.obj)
+  }
+}
+
+export function clearStepCallbacks(): void {
+  stepCallbacks.length = 0
+}
+
+declare module 'phaser' {
+  namespace GameObjects {
+    interface GameObject {
+      mixin<T extends object, C = undefined>(
+        mixinFn: (obj: this, config?: C) => this & T,
+        config?: C,
+      ): this & T
+      merge<T extends object>(props: T): this & T
+      step(fn: (obj: this) => void, order?: StepOrder): this
+      track(mixinKey: symbol): this
+      _trackedMixins?: Set<symbol>
+    }
+  }
+}
+
+const originalDestroy = Phaser.GameObjects.GameObject.prototype.destroy
+
+Phaser.GameObjects.GameObject.prototype.mixin = function <T extends object, C = undefined>(
+  mixinFn: (obj: Phaser.GameObjects.GameObject, config?: C) => Phaser.GameObjects.GameObject & T,
+  config?: C,
+): Phaser.GameObjects.GameObject & T {
+  return mixinFn(this, config)
+}
+
+Phaser.GameObjects.GameObject.prototype.merge = function <T extends object>(
+  props: T,
+): Phaser.GameObjects.GameObject & T {
+  Object.defineProperties(this, Object.getOwnPropertyDescriptors(props))
+  return this as Phaser.GameObjects.GameObject & T
+}
+
+Phaser.GameObjects.GameObject.prototype.step = function (
+  fn: (obj: Phaser.GameObjects.GameObject) => void,
+  order: StepOrder = StepOrder.Default,
+): Phaser.GameObjects.GameObject {
+  stepCallbacks.push({ fn, order, obj: this })
+  stepCallbacksDirty = true
+  return this
+}
+
+Phaser.GameObjects.GameObject.prototype.track = function (
+  mixinKey: MixinSymbol,
+): Phaser.GameObjects.GameObject {
+  if (!this._trackedMixins) {
+    this._trackedMixins = new Set()
+  }
+  this._trackedMixins.add(mixinKey)
+  registerInstance(mixinKey, this)
+  return this
+}
+
+Phaser.GameObjects.GameObject.prototype.destroy = function (fromScene?: boolean): void {
+  unregisterFromAll(this)
+
+  for (let i = stepCallbacks.length - 1; i >= 0; i--) {
+    if (stepCallbacks[i].obj === this) {
+      stepCallbacks.splice(i, 1)
+    }
+  }
+
+  originalDestroy.call(this, fromScene)
+}
+
+declare module 'phaser' {
+  namespace GameObjects {
+    interface Container {
+      mixin<T extends object, C = undefined>(
+        mixinFn: (obj: this, config?: C) => this & T,
+        config?: C,
+      ): this & T
+      merge<T extends object>(props: T): this & T
+      step(fn: (obj: this) => void, order?: StepOrder): this
+      track(mixinKey: symbol): this
+      _trackedMixins?: Set<symbol>
+    }
+  }
+}
diff --git a/src/core/globals.ts b/src/core/globals.ts
new file mode 100644
index 0000000..8242d74
--- /dev/null
+++ b/src/core/globals.ts
@@ -0,0 +1,30 @@
+import PlayerInputs from '../controls/player-inputs'
+import { GameSceneInterface } from '../types/game-scene'
+import { PlayerObject } from '../objects/player.object'
+
+export type { GameSceneInterface as GameScene }
+
+export let scene: GameSceneInterface | undefined
+export let uiScene: Phaser.Scene | undefined
+export let input: PlayerInputs | undefined
+export let player: PlayerObject | undefined
+
+export function setGlobals(gameScene: GameSceneInterface): void {
+  scene = gameScene
+  input = gameScene.inputs
+}
+
+export function setUIScene(ui: Phaser.Scene): void {
+  uiScene = ui
+}
+
+export function setPlayer(playerObj: PlayerObject): void {
+  player = playerObj
+}
+
+export function clearGlobals(): void {
+  scene = undefined
+  uiScene = undefined
+  input = undefined
+  player = undefined
+}
diff --git a/src/core/instances.ts b/src/core/instances.ts
new file mode 100644
index 0000000..c6a79b2
--- /dev/null
+++ b/src/core/instances.ts
@@ -0,0 +1,61 @@
+import { LightAware } from '../mixins/light-aware.mixin'
+import { LightSource } from '../mixins/light-source.mixin'
+
+export const MIXIN_LIGHT_AWARE = Symbol('lightAware')
+export const MIXIN_LIGHT_SOURCE = Symbol('lightSource')
+export const MIXIN_POINTABLE = Symbol('pointable')
+export const MIXIN_DEBUGGABLE = Symbol('debuggable')
+export const MIXIN_INTERACTABLE = Symbol('interactable')
+
+type MixinSymbol =
+  | typeof MIXIN_LIGHT_AWARE
+  | typeof MIXIN_LIGHT_SOURCE
+  | typeof MIXIN_POINTABLE
+  | typeof MIXIN_DEBUGGABLE
+  | typeof MIXIN_INTERACTABLE
+
+interface MixinTypeMap {
+  [MIXIN_LIGHT_AWARE]: LightAware
+  [MIXIN_LIGHT_SOURCE]: LightSource
+}
+
+const instanceRegistry = new Map<MixinSymbol, Set<Phaser.GameObjects.GameObject>>()
+
+export function registerInstance(mixinKey: MixinSymbol, obj: Phaser.GameObjects.GameObject): void {
+  let instances = instanceRegistry.get(mixinKey)
+  if (!instances) {
+    instances = new Set()
+    instanceRegistry.set(mixinKey, instances)
+  }
+  instances.add(obj)
+}
+
+export function unregisterInstance(
+  mixinKey: MixinSymbol,
+  obj: Phaser.GameObjects.GameObject,
+): void {
+  const instances = instanceRegistry.get(mixinKey)
+  if (instances) {
+    instances.delete(obj)
+  }
+}
+
+export function unregisterFromAll(obj: Phaser.GameObjects.GameObject): void {
+  for (const instances of instanceRegistry.values()) {
+    instances.delete(obj)
+  }
+}
+
+export function Instances<K extends keyof MixinTypeMap>(mixinKey: K): Iterable<MixinTypeMap[K]> {
+  const instances = instanceRegistry.get(mixinKey)
+  return instances ? (instances as unknown as Set<MixinTypeMap[K]>) : []
+}
+
+export function InstancesArray<K extends keyof MixinTypeMap>(mixinKey: K): MixinTypeMap[K][] {
+  const instances = instanceRegistry.get(mixinKey)
+  return instances ? (Array.from(instances) as unknown as MixinTypeMap[K][]) : []
+}
+
+export function clearAllInstances(): void {
+  instanceRegistry.clear()
+}
diff --git a/src/core/step-order.ts b/src/core/step-order.ts
new file mode 100644
index 0000000..be94128
--- /dev/null
+++ b/src/core/step-order.ts
@@ -0,0 +1,9 @@
+export enum StepOrder {
+  Input = -100,
+  BeforePhysics = -10,
+  Physics = 0,
+  AfterPhysics = 10,
+  Default = 50,
+  BeforeCamera = 90,
+  BeforeRender = 100,
+}
diff --git a/src/editor/editor-state.ts b/src/editor/editor-state.ts
new file mode 100644
index 0000000..4698b6a
--- /dev/null
+++ b/src/editor/editor-state.ts
@@ -0,0 +1,110 @@
+const STORAGE_KEY = 'spine-editor-state'
+
+export type EditorTab = 'spine' | 'models'
+
+export interface EditorStateData {
+  activeTab: EditorTab
+  selectedSpine: string | null
+  selectedAnimation: string | null
+  loop: boolean
+  loopDelay: number
+  // Models tab state
+  modelsSelectedState: string | null
+}
+
+const defaultState: EditorStateData = {
+  activeTab: 'spine',
+  selectedSpine: null,
+  selectedAnimation: null,
+  loop: true,
+  loopDelay: 500,
+  modelsSelectedState: null,
+}
+
+/**
+ * Manages editor state persistence using localStorage.
+ */
+export class EditorState {
+  private state: EditorStateData
+
+  constructor() {
+    this.state = this.load()
+  }
+
+  private load(): EditorStateData {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY)
+      if (stored) {
+        return { ...defaultState, ...JSON.parse(stored) }
+      }
+    } catch (e) {
+      console.warn('Failed to load editor state:', e)
+    }
+    return { ...defaultState }
+  }
+
+  private save(): void {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(this.state))
+    } catch (e) {
+      console.warn('Failed to save editor state:', e)
+    }
+  }
+
+  get selectedSpine(): string | null {
+    return this.state.selectedSpine
+  }
+
+  set selectedSpine(value: string | null) {
+    this.state.selectedSpine = value
+    this.save()
+  }
+
+  get selectedAnimation(): string | null {
+    return this.state.selectedAnimation
+  }
+
+  set selectedAnimation(value: string | null) {
+    this.state.selectedAnimation = value
+    this.save()
+  }
+
+  get loop(): boolean {
+    return this.state.loop
+  }
+
+  set loop(value: boolean) {
+    this.state.loop = value
+    this.save()
+  }
+
+  get loopDelay(): number {
+    return this.state.loopDelay
+  }
+
+  set loopDelay(value: number) {
+    this.state.loopDelay = value
+    this.save()
+  }
+
+  get activeTab(): EditorTab {
+    return this.state.activeTab
+  }
+
+  set activeTab(value: EditorTab) {
+    this.state.activeTab = value
+    this.save()
+  }
+
+  get modelsSelectedState(): string | null {
+    return this.state.modelsSelectedState
+  }
+
+  set modelsSelectedState(value: string | null) {
+    this.state.modelsSelectedState = value
+    this.save()
+  }
+}
+
+// Export a singleton instance
+export const editorState = new EditorState()
diff --git a/src/editor/index.html b/src/editor/index.html
new file mode 100644
index 0000000..adc5455
--- /dev/null
+++ b/src/editor/index.html
@@ -0,0 +1,435 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
+  <title>Spine Editor</title>
+
+  <style>
+    * {
+      box-sizing: border-box;
+    }
+
+    html,
+    body {
+      margin: 0;
+      padding: 0;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      background-color: #1e1e1e;
+      color: #e0e0e0;
+      overflow: hidden;
+      height: 100%;
+    }
+
+    .editor-container {
+      display: flex;
+      flex-direction: column;
+      height: 100vh;
+    }
+
+    /* Toolbar */
+    .toolbar {
+      display: flex;
+      align-items: center;
+      gap: 16px;
+      padding: 8px 16px;
+      background-color: #2d2d2d;
+      border-bottom: 1px solid #3d3d3d;
+    }
+
+    .toolbar-tabs {
+      display: flex;
+      gap: 4px;
+    }
+
+    .toolbar-tab {
+      padding: 8px 16px;
+      border: none;
+      background-color: transparent;
+      color: #888;
+      cursor: pointer;
+      border-radius: 4px;
+      font-size: 14px;
+      font-weight: 500;
+    }
+
+    .toolbar-tab.active {
+      background-color: #3d3d3d;
+      color: #fff;
+    }
+
+    .toolbar-tab:hover:not(.active) {
+      background-color: #353535;
+      color: #ccc;
+    }
+
+    /* Main content */
+    .main-content {
+      display: flex;
+      flex: 1;
+      overflow: hidden;
+    }
+
+    /* Sidebar */
+    .sidebar {
+      width: 280px;
+      background-color: #252525;
+      border-right: 1px solid #3d3d3d;
+      display: flex;
+      flex-direction: column;
+      padding: 16px;
+      overflow-y: auto;
+    }
+
+    .sidebar-section {
+      margin-bottom: 24px;
+    }
+
+    .sidebar-label {
+      font-size: 12px;
+      font-weight: 600;
+      color: #888;
+      /* text-transform: uppercase; */
+      letter-spacing: 0.5px;
+      margin-bottom: 8px;
+    }
+
+    /* Spine selector */
+    .spine-selector {
+      width: 100%;
+      padding: 10px 12px;
+      background-color: #3d3d3d;
+      border: 1px solid #4d4d4d;
+      border-radius: 6px;
+      color: #e0e0e0;
+      font-size: 14px;
+      cursor: pointer;
+      appearance: none;
+      background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23888' d='M6 8L1 3h10z'/%3E%3C/svg%3E");
+      background-repeat: no-repeat;
+      background-position: right 12px center;
+    }
+
+    .spine-selector:hover {
+      border-color: #5d5d5d;
+    }
+
+    .spine-selector:focus {
+      outline: none;
+      border-color: #0078d4;
+    }
+
+    /* Animation list */
+    .animation-list {
+      list-style: none;
+      padding: 0;
+      margin: 0;
+      background-color: #2d2d2d;
+      border-radius: 6px;
+      border: 1px solid #3d3d3d;
+      max-height: calc(100vh - 280px);
+      overflow-y: auto;
+    }
+
+    .animation-item {
+      padding: 10px 14px;
+      cursor: pointer;
+      font-size: 13px;
+      border-bottom: 1px solid #3d3d3d;
+      transition: background-color 0.15s;
+    }
+
+    .animation-item:last-child {
+      border-bottom: none;
+    }
+
+    .animation-item:hover {
+      background-color: #353535;
+    }
+
+    .animation-item.active {
+      background-color: #0078d4;
+      color: #fff;
+    }
+
+    /* Preview canvas */
+    .preview-container {
+      flex: 1;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background-color: #1a1a1a;
+      position: relative;
+    }
+
+    #preview-canvas {
+      border-radius: 8px;
+      background-color: #2d2d2d;
+    }
+
+    /* Loading state */
+    .loading-overlay {
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background-color: rgba(30, 30, 30, 0.9);
+      font-size: 16px;
+      color: #888;
+    }
+
+    .loading-overlay.hidden {
+      display: none;
+    }
+
+    /* Controls */
+    .preview-controls {
+      position: absolute;
+      bottom: 16px;
+      left: 50%;
+      transform: translateX(-50%);
+      display: flex;
+      gap: 8px;
+      background-color: rgba(45, 45, 45, 0.9);
+      padding: 8px 12px;
+      border-radius: 8px;
+      border: 1px solid #3d3d3d;
+    }
+
+    .control-btn {
+      padding: 8px 16px;
+      background-color: #3d3d3d;
+      border: 1px solid #4d4d4d;
+      border-radius: 4px;
+      color: #e0e0e0;
+      cursor: pointer;
+      font-size: 13px;
+    }
+
+    .control-btn:hover {
+      background-color: #4d4d4d;
+    }
+
+    .control-btn.active {
+      background-color: #0078d4;
+      border-color: #0078d4;
+    }
+
+    /* Checkbox toggle */
+    .checkbox-control {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 8px 0;
+    }
+
+    .checkbox-control input[type="checkbox"] {
+      width: 18px;
+      height: 18px;
+      cursor: pointer;
+    }
+
+    .checkbox-control label {
+      font-size: 13px;
+      cursor: pointer;
+      color: #888;
+    }
+
+    /* Delay control */
+    .delay-control {
+      margin-top: 12px;
+    }
+
+    .delay-control label {
+      display: block;
+      font-size: 13px;
+      margin-bottom: 6px;
+      color: #888;
+    }
+
+    .delay-input-wrapper {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .delay-input-wrapper input[type="number"] {
+      width: 80px;
+      padding: 8px 10px;
+      background-color: #3d3d3d;
+      border: 1px solid #4d4d4d;
+      border-radius: 4px;
+      color: #e0e0e0;
+      font-size: 13px;
+    }
+
+    .delay-input-wrapper input[type="number"]:focus {
+      outline: none;
+      border-color: #0078d4;
+    }
+
+    .delay-unit {
+      font-size: 12px;
+      color: #888;
+    }
+
+    /* Tab content panels */
+    .tab-content {
+      display: none;
+      flex: 1;
+      overflow: hidden;
+    }
+
+    .tab-content.active {
+      display: flex;
+    }
+
+    /* State list for models tab */
+    .state-list {
+      list-style: none;
+      padding: 0;
+      margin: 0;
+      background-color: #2d2d2d;
+      border-radius: 6px;
+      border: 1px solid #3d3d3d;
+      max-height: calc(100vh - 200px);
+      overflow-y: auto;
+    }
+
+    .state-item {
+      padding: 10px 14px;
+      cursor: pointer;
+      font-size: 13px;
+      border-bottom: 1px solid #3d3d3d;
+      transition: background-color 0.15s;
+    }
+
+    .state-item:last-child {
+      border-bottom: none;
+    }
+
+    .state-item:hover {
+      background-color: #353535;
+    }
+
+    .state-item.active {
+      background-color: #0078d4;
+      color: #fff;
+    }
+
+    .state-item.playing {
+      background-color: #2a5d2a;
+      color: #fff;
+    }
+
+    .state-item.playing.active {
+      background-color: #0078d4;
+    }
+
+    /* State info badge */
+    .state-badge {
+      display: inline-block;
+      padding: 2px 6px;
+      font-size: 10px;
+      border-radius: 3px;
+      margin-left: 8px;
+      background-color: #4d4d4d;
+      color: #aaa;
+    }
+
+    .state-badge.weapon {
+      background-color: #3d5a80;
+    }
+
+    .state-badge.action {
+      background-color: #5a3d80;
+    }
+  </style>
+</head>
+
+<body>
+  <div class="editor-container">
+    <div class="toolbar">
+      <div class="toolbar-tabs">
+        <button class="toolbar-tab active" data-tab="spine">spine</button>
+        <button class="toolbar-tab" data-tab="models">models</button>
+        <button class="toolbar-tab" disabled>assets</button>
+      </div>
+    </div>
+
+    <div class="main-content">
+      <!-- Spine Tab Content -->
+      <div class="tab-content active" id="tab-spine">
+        <div class="sidebar">
+          <div class="sidebar-section">
+            <div class="sidebar-label">Select Spine</div>
+            <select class="spine-selector" id="spine-selector">
+              <option value="">Loading...</option>
+            </select>
+          </div>
+
+          <div class="sidebar-section">
+            <div class="checkbox-control">
+              <input type="checkbox" id="loop-toggle" checked>
+              <label for="loop-toggle">Loop animation</label>
+            </div>
+            <div class="delay-control">
+              <label for="loop-delay">Delay between loops (when possible)</label>
+              <div class="delay-input-wrapper">
+                <input type="number" id="loop-delay" min="0" max="5000" step="100" value="500">
+                <span class="delay-unit">ms</span>
+              </div>
+            </div>
+          </div>
+
+          <div class="sidebar-section">
+            <div class="sidebar-label">Animations</div>
+            <ul class="animation-list" id="animation-list">
+              <li class="animation-item">Select a spine to view animations</li>
+            </ul>
+          </div>
+        </div>
+
+        <div class="preview-container">
+          <div id="preview-canvas"></div>
+          <div class="loading-overlay" id="loading-overlay">
+            Loading...
+          </div>
+        </div>
+      </div>
+
+      <!-- Models Tab Content -->
+      <div class="tab-content" id="tab-models">
+        <div class="sidebar">
+          <div class="sidebar-section">
+            <div class="sidebar-label">Player Model</div>
+            <p style="font-size: 13px; color: #888; margin: 0 0 8px 0;">
+              Preview player states as used in game
+            </p>
+          </div>
+
+          <div class="sidebar-section">
+            <div class="sidebar-label">States</div>
+            <ul class="state-list" id="state-list">
+              <li class="state-item">Loading...</li>
+            </ul>
+          </div>
+        </div>
+
+        <div class="preview-container">
+          <div id="models-preview-canvas"></div>
+          <div class="loading-overlay" id="models-loading-overlay">
+            Loading...
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/editor/index.ts b/src/editor/index.ts
new file mode 100644
index 0000000..a8ac94e
--- /dev/null
+++ b/src/editor/index.ts
@@ -0,0 +1,116 @@
+import 'phaser'
+import 'phaser/plugins/spine/dist/SpinePlugin'
+import EditorPreloadScene from './scenes/editor-preload.scene'
+import EditorScene from './scenes/editor.scene'
+import ModelsPreloadScene from './scenes/models-preload.scene'
+import ModelsScene from './scenes/models.scene'
+import { editorState, EditorTab } from './editor-state'
+
+declare global {
+  interface Window {
+    spineGame?: Phaser.Game
+    modelsGame?: Phaser.Game
+    getSpineGame?: () => Phaser.Game | null
+    getModelsGame?: () => Phaser.Game | null
+  }
+}
+
+// Spine tab game configuration
+const spineConfig: Phaser.Types.Core.GameConfig = {
+  type: Phaser.WEBGL,
+  parent: 'preview-canvas',
+  transparent: true,
+  scale: {
+    mode: Phaser.Scale.NONE,
+    width: 600,
+    height: 600,
+  },
+  render: {
+    pixelArt: false,
+    antialias: true,
+  },
+  scene: [EditorPreloadScene, EditorScene],
+  plugins: {
+    scene: [{ key: 'SpinePlugin', plugin: window.SpinePlugin, mapping: 'spine' }],
+  },
+}
+
+// Models tab game configuration
+const modelsConfig: Phaser.Types.Core.GameConfig = {
+  type: Phaser.WEBGL,
+  parent: 'models-preview-canvas',
+  transparent: true,
+  scale: {
+    mode: Phaser.Scale.NONE,
+    width: 600,
+    height: 600,
+  },
+  render: {
+    pixelArt: false,
+    antialias: true,
+  },
+  scene: [ModelsPreloadScene, ModelsScene],
+  plugins: {
+    scene: [{ key: 'SpinePlugin', plugin: window.SpinePlugin, mapping: 'spine' }],
+  },
+}
+
+// Game instances
+let spineGame: Phaser.Game | null = null
+let modelsGame: Phaser.Game | null = null
+
+// Tab switching logic
+function switchTab(tabId: EditorTab) {
+  // Update tab buttons
+  const tabs = document.querySelectorAll('.toolbar-tab[data-tab]')
+  tabs.forEach((tab) => {
+    if (tab.getAttribute('data-tab') === tabId) {
+      tab.classList.add('active')
+    } else {
+      tab.classList.remove('active')
+    }
+  })
+
+  // Update tab content
+  const contents = document.querySelectorAll('.tab-content')
+  contents.forEach((content) => {
+    if (content.id === `tab-${tabId}`) {
+      content.classList.add('active')
+    } else {
+      content.classList.remove('active')
+    }
+  })
+
+  // Initialize game for the tab if needed
+  if (tabId === 'spine' && !spineGame) {
+    spineGame = new Phaser.Game(spineConfig)
+    window.spineGame = spineGame
+  } else if (tabId === 'models' && !modelsGame) {
+    modelsGame = new Phaser.Game(modelsConfig)
+    window.modelsGame = modelsGame
+  }
+
+  // Save active tab
+  editorState.activeTab = tabId
+}
+
+// Initialize tab click handlers
+document.addEventListener('DOMContentLoaded', () => {
+  const tabs = document.querySelectorAll('.toolbar-tab[data-tab]')
+  tabs.forEach((tab) => {
+    tab.addEventListener('click', () => {
+      const tabId = tab.getAttribute('data-tab') as EditorTab
+      if (tabId) {
+        switchTab(tabId)
+      }
+    })
+  })
+
+  // Restore saved tab or default to spine
+  const savedTab = editorState.activeTab
+  switchTab(savedTab)
+})
+
+// Export game instances for external access
+window.getSpineGame = () => spineGame
+window.getModelsGame = () => modelsGame
diff --git a/src/editor/scenes/editor-preload.scene.ts b/src/editor/scenes/editor-preload.scene.ts
new file mode 100644
index 0000000..53768b4
--- /dev/null
+++ b/src/editor/scenes/editor-preload.scene.ts
@@ -0,0 +1,21 @@
+import { SpineModelRegistry } from '../spine-model-registry'
+
+export default class EditorPreloadScene extends Phaser.Scene {
+  constructor() {
+    super('EditorPreloadScene')
+  }
+
+  preload() {
+    // Load all spines from the registry
+    this.load.setPath('assets/spine/')
+
+    const spines = SpineModelRegistry.getSpines()
+    for (const spine of spines) {
+      this.load.spine(spine.key, spine.jsonFile, spine.atlasFile)
+    }
+  }
+
+  create() {
+    this.scene.start('EditorScene')
+  }
+}
diff --git a/src/editor/scenes/editor.scene.ts b/src/editor/scenes/editor.scene.ts
new file mode 100644
index 0000000..63477f9
--- /dev/null
+++ b/src/editor/scenes/editor.scene.ts
@@ -0,0 +1,301 @@
+import { SpineModelRegistry } from '../spine-model-registry'
+import { editorState } from '../editor-state'
+
+export default class EditorScene extends Phaser.Scene {
+  private currentSpine: SpineGameObject | null = null
+  private spineSelector!: HTMLSelectElement
+  private animationList!: HTMLUListElement
+  private loopToggle!: HTMLInputElement
+  private loopDelayInput!: HTMLInputElement
+  private loadingOverlay!: HTMLElement
+  private loopDelayTimer: number | null = null
+  private currentAnimationName: string | null = null
+
+  constructor() {
+    super('EditorScene')
+  }
+
+  create() {
+    // Get DOM elements
+    this.spineSelector = document.getElementById('spine-selector') as HTMLSelectElement
+    this.animationList = document.getElementById('animation-list') as HTMLUListElement
+    this.loopToggle = document.getElementById('loop-toggle') as HTMLInputElement
+    this.loopDelayInput = document.getElementById('loop-delay') as HTMLInputElement
+    this.loadingOverlay = document.getElementById('loading-overlay') as HTMLElement
+
+    // Set up the scene background
+    this.cameras.main.setBackgroundColor(0x2d2d2d)
+
+    // Initialize UI
+    this.setupSpineSelector()
+    this.setupLoopToggle()
+    this.setupLoopDelay()
+
+    // Load persisted state
+    this.restoreState()
+
+    // Hide loading overlay
+    this.loadingOverlay.classList.add('hidden')
+  }
+
+  private setupSpineSelector() {
+    const spines = SpineModelRegistry.getSpines()
+
+    // Clear and populate the selector
+    this.spineSelector.innerHTML = ''
+
+    // Add placeholder option
+    const placeholder = document.createElement('option')
+    placeholder.value = ''
+    placeholder.textContent = 'Select a spine...'
+    this.spineSelector.appendChild(placeholder)
+
+    // Add spine options
+    for (const spine of spines) {
+      const option = document.createElement('option')
+      option.value = spine.key
+      option.textContent = spine.name
+      this.spineSelector.appendChild(option)
+    }
+
+    // Handle selection change
+    this.spineSelector.addEventListener('change', () => {
+      const selectedKey = this.spineSelector.value
+      if (selectedKey) {
+        this.loadSpine(selectedKey)
+        editorState.selectedSpine = selectedKey
+        // Clear animation selection when spine changes
+        editorState.selectedAnimation = null
+      } else {
+        this.clearPreview()
+      }
+    })
+  }
+
+  private setupLoopToggle() {
+    // Restore loop state
+    this.loopToggle.checked = editorState.loop
+
+    this.loopToggle.addEventListener('change', () => {
+      editorState.loop = this.loopToggle.checked
+      // Replay current animation with new loop setting
+      if (this.currentSpine && editorState.selectedAnimation) {
+        this.playAnimation(editorState.selectedAnimation)
+      }
+    })
+  }
+
+  private setupLoopDelay() {
+    // Restore loop delay state
+    this.loopDelayInput.value = String(editorState.loopDelay)
+
+    this.loopDelayInput.addEventListener('change', () => {
+      const delay = parseInt(this.loopDelayInput.value, 10) || 0
+      editorState.loopDelay = Math.max(0, Math.min(5000, delay))
+      this.loopDelayInput.value = String(editorState.loopDelay)
+      // Replay current animation with new delay setting
+      if (this.currentSpine && editorState.selectedAnimation) {
+        this.playAnimation(editorState.selectedAnimation)
+      }
+    })
+  }
+
+  private restoreState() {
+    const savedSpine = editorState.selectedSpine
+    const savedAnimation = editorState.selectedAnimation
+
+    if (savedSpine) {
+      this.spineSelector.value = savedSpine
+      this.loadSpine(savedSpine, savedAnimation)
+    }
+  }
+
+  private loadSpine(key: string, autoPlayAnimation?: string | null) {
+    // Clear existing spine object
+    this.clearPreview()
+
+    try {
+      // Create the spine game object
+      const centerX = this.cameras.main.width / 2
+      const centerY = this.cameras.main.height / 2
+
+      this.currentSpine = this.add.spine(centerX, centerY, key)
+
+      // Scale to fit nicely in the preview
+      this.autoScale()
+
+      // Get available animations
+      const animations = this.getAnimations()
+
+      // Populate animation list
+      this.populateAnimationList(animations)
+
+      // Auto-play animation if specified or first available
+      if (autoPlayAnimation && animations.includes(autoPlayAnimation)) {
+        this.playAnimation(autoPlayAnimation)
+        this.highlightAnimation(autoPlayAnimation)
+      } else if (animations.length > 0) {
+        // Play first animation by default
+        this.playAnimation(animations[0])
+        this.highlightAnimation(animations[0])
+        editorState.selectedAnimation = animations[0]
+      }
+    } catch (error) {
+      console.error('Failed to load spine:', error)
+      this.animationList.innerHTML = '<li class="animation-item">Error loading spine</li>'
+    }
+  }
+
+  private autoScale() {
+    if (!this.currentSpine) return
+
+    const bounds = this.currentSpine.getBounds()
+    const canvasWidth = this.cameras.main.width
+    const canvasHeight = this.cameras.main.height
+    const padding = 100
+
+    const maxWidth = canvasWidth - padding
+    const maxHeight = canvasHeight - padding
+
+    const scaleX = maxWidth / bounds.size.x
+    const scaleY = maxHeight / bounds.size.y
+    const scale = Math.min(scaleX, scaleY, 1.5) // Cap at 1.5x
+
+    this.currentSpine.setScale(scale)
+  }
+
+  private getAnimations(): string[] {
+    if (!this.currentSpine) return []
+
+    try {
+      const skeletonData = this.currentSpine.skeleton.data
+      const animations: string[] = []
+
+      for (let i = 0; i < skeletonData.animations.length; i++) {
+        animations.push(skeletonData.animations[i].name)
+      }
+
+      return animations.sort()
+    } catch (error) {
+      console.error('Failed to get animations:', error)
+      return []
+    }
+  }
+
+  private populateAnimationList(animations: string[]) {
+    this.animationList.innerHTML = ''
+
+    if (animations.length === 0) {
+      const item = document.createElement('li')
+      item.className = 'animation-item'
+      item.textContent = 'No animations found'
+      this.animationList.appendChild(item)
+      return
+    }
+
+    for (const anim of animations) {
+      const item = document.createElement('li')
+      item.className = 'animation-item'
+      item.textContent = anim
+      item.dataset.animation = anim
+
+      item.addEventListener('click', () => {
+        this.playAnimation(anim)
+        this.highlightAnimation(anim)
+        editorState.selectedAnimation = anim
+      })
+
+      this.animationList.appendChild(item)
+    }
+  }
+
+  private highlightAnimation(animationName: string) {
+    // Remove active class from all items
+    const items = this.animationList.querySelectorAll('.animation-item')
+    items.forEach((item) => item.classList.remove('active'))
+
+    // Add active class to selected item
+    const selected = this.animationList.querySelector(`[data-animation="${animationName}"]`)
+    if (selected) {
+      selected.classList.add('active')
+    }
+  }
+
+  private playAnimation(animationName: string) {
+    if (!this.currentSpine) return
+
+    // Clear any pending loop timer
+    this.clearLoopTimer()
+    this.currentAnimationName = animationName
+
+    try {
+      const loop = this.loopToggle.checked
+      // Idle and move animations should loop without delay
+      const isLoopingAnimation =
+        animationName.startsWith('idle_') || animationName.startsWith('move_')
+      const delay = isLoopingAnimation ? 0 : editorState.loopDelay
+
+      // If looping with delay, we handle the loop manually
+      if (loop && delay > 0) {
+        this.currentSpine.play(animationName, false)
+        this.setupDelayedLoop(animationName, delay)
+      } else {
+        this.currentSpine.play(animationName, loop)
+      }
+    } catch (error) {
+      console.error('Failed to play animation:', error)
+    }
+  }
+
+  private setupDelayedLoop(animationName: string, delay: number) {
+    if (!this.currentSpine) return
+
+    // Listen for animation complete - use full listener interface
+    const listener: spine.AnimationStateListener2 = {
+      start: () => {},
+      interrupt: () => {},
+      end: () => {},
+      dispose: () => {},
+      event: () => {},
+      complete: () => {
+        // Only restart if this is still the current animation and looping is enabled
+        if (
+          this.currentAnimationName === animationName &&
+          this.loopToggle.checked &&
+          this.currentSpine
+        ) {
+          this.loopDelayTimer = window.setTimeout(() => {
+            if (
+              this.currentSpine &&
+              this.currentAnimationName === animationName &&
+              this.loopToggle.checked
+            ) {
+              this.currentSpine.play(animationName, false)
+            }
+          }, delay)
+        }
+      },
+    }
+    this.currentSpine.state.addListener(listener)
+  }
+
+  private clearLoopTimer() {
+    if (this.loopDelayTimer !== null) {
+      window.clearTimeout(this.loopDelayTimer)
+      this.loopDelayTimer = null
+    }
+    // Clear any existing listeners
+    if (this.currentSpine) {
+      this.currentSpine.state.clearListeners()
+    }
+  }
+
+  private clearPreview() {
+    this.clearLoopTimer()
+    this.currentAnimationName = null
+    if (this.currentSpine) {
+      this.currentSpine.destroy()
+      this.currentSpine = null
+    }
+  }
+}
diff --git a/src/editor/scenes/models-preload.scene.ts b/src/editor/scenes/models-preload.scene.ts
new file mode 100644
index 0000000..dbcb849
--- /dev/null
+++ b/src/editor/scenes/models-preload.scene.ts
@@ -0,0 +1,16 @@
+export default class ModelsPreloadScene extends Phaser.Scene {
+  constructor() {
+    super('ModelsPreloadScene')
+  }
+
+  preload() {
+    // Load player spine assets
+    this.load.setPath('assets/spine/')
+    this.load.spine('player', 'player.json', 'player.atlas')
+    this.load.spine('player-legs', 'player-legs.json', 'player-legs.atlas')
+  }
+
+  create() {
+    this.scene.start('ModelsScene')
+  }
+}
diff --git a/src/editor/scenes/models.scene.ts b/src/editor/scenes/models.scene.ts
new file mode 100644
index 0000000..850b781
--- /dev/null
+++ b/src/editor/scenes/models.scene.ts
@@ -0,0 +1,459 @@
+import PlayerPuppet, { PlayerWeapon } from '../../objects/player.puppet'
+import { editorState } from '../editor-state'
+
+/**
+ * Overview sequence step - uses PlayerPuppet methods directly.
+ */
+interface OverviewStep {
+  action: (puppet: PlayerPuppet) => void
+  duration: number
+}
+
+/**
+ * Creates the overview sequence using PlayerPuppet's API.
+ * This ensures the editor uses the exact same code as the game.
+ */
+function createOverviewSequence(): OverviewStep[] {
+  return [
+    // Idle with handgun
+    {
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.HANDGUN)
+        p.idle()
+      },
+      duration: 1500,
+    },
+    // Walk forward
+    { action: (p) => p.walk(), duration: 2000 },
+    // Stop and shoot
+    {
+      action: (p) => {
+        p.idle()
+        p.shoot()
+      },
+      duration: 400,
+    },
+    { action: (p) => p.shoot(), duration: 400 },
+    { action: (p) => p.idle(), duration: 800 },
+    // Reload
+    { action: (p) => p.reload(), duration: 1500 },
+    // Switch to rifle, strafe
+    {
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.RIFLE)
+        p.idle()
+      },
+      duration: 500,
+    },
+    { action: (p) => p.strafeRight(), duration: 1500 },
+    { action: (p) => p.strafeLeft(), duration: 1500 },
+    // Shoot rifle
+    {
+      action: (p) => {
+        p.idle()
+        p.shoot()
+      },
+      duration: 300,
+    },
+    { action: (p) => p.shoot(), duration: 300 },
+    { action: (p) => p.shoot(), duration: 300 },
+    { action: (p) => p.idle(), duration: 800 },
+    // Switch to shotgun, run
+    {
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.SHOTGUN)
+        p.idle()
+      },
+      duration: 500,
+    },
+    { action: (p) => p.run(), duration: 2000 },
+    // Shoot shotgun
+    {
+      action: (p) => {
+        p.idle()
+        p.shoot()
+      },
+      duration: 600,
+    },
+    { action: (p) => p.shoot(), duration: 600 },
+    { action: (p) => p.idle(), duration: 800 },
+    // Reload shotgun
+    { action: (p) => p.reload(), duration: 2000 },
+    // Switch to knife
+    {
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.KNIFE)
+        p.idle()
+      },
+      duration: 500,
+    },
+    { action: (p) => p.walk(), duration: 1500 },
+    // Melee attack
+    {
+      action: (p) => {
+        p.idle()
+        p.meleeAttack()
+      },
+      duration: 600,
+    },
+    { action: (p) => p.meleeAttack(), duration: 600 },
+    { action: (p) => p.idle(), duration: 1000 },
+  ]
+}
+
+/**
+ * State item for the sidebar list.
+ */
+interface StateItem {
+  key: string
+  name: string
+  category: 'state' | 'action'
+  action: (puppet: PlayerPuppet) => void
+}
+
+/**
+ * Creates the list of states for the sidebar.
+ */
+function createStateItems(): StateItem[] {
+  return [
+    // Idle states
+    {
+      key: 'idle_handgun',
+      name: 'Idle (Handgun)',
+      category: 'state',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.HANDGUN)
+        p.idle()
+      },
+    },
+    {
+      key: 'idle_shotgun',
+      name: 'Idle (Shotgun)',
+      category: 'state',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.SHOTGUN)
+        p.idle()
+      },
+    },
+    {
+      key: 'idle_rifle',
+      name: 'Idle (Rifle)',
+      category: 'state',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.RIFLE)
+        p.idle()
+      },
+    },
+    {
+      key: 'idle_knife',
+      name: 'Idle (Knife)',
+      category: 'state',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.KNIFE)
+        p.idle()
+      },
+    },
+    // Move states
+    {
+      key: 'walk_handgun',
+      name: 'Walk (Handgun)',
+      category: 'state',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.HANDGUN)
+        p.walk()
+      },
+    },
+    {
+      key: 'walk_rifle',
+      name: 'Walk (Rifle)',
+      category: 'state',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.RIFLE)
+        p.walk()
+      },
+    },
+    {
+      key: 'run_handgun',
+      name: 'Run (Handgun)',
+      category: 'state',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.HANDGUN)
+        p.run()
+      },
+    },
+    {
+      key: 'strafe_rifle',
+      name: 'Strafe (Rifle)',
+      category: 'state',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.RIFLE)
+        p.strafeRight()
+      },
+    },
+    // Actions
+    {
+      key: 'shoot_handgun',
+      name: 'Shoot (Handgun)',
+      category: 'action',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.HANDGUN)
+        p.idle()
+        p.shoot()
+      },
+    },
+    {
+      key: 'shoot_shotgun',
+      name: 'Shoot (Shotgun)',
+      category: 'action',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.SHOTGUN)
+        p.idle()
+        p.shoot()
+      },
+    },
+    {
+      key: 'shoot_rifle',
+      name: 'Shoot (Rifle)',
+      category: 'action',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.RIFLE)
+        p.idle()
+        p.shoot()
+      },
+    },
+    {
+      key: 'reload_handgun',
+      name: 'Reload (Handgun)',
+      category: 'action',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.HANDGUN)
+        p.idle()
+        p.reload()
+      },
+    },
+    {
+      key: 'reload_shotgun',
+      name: 'Reload (Shotgun)',
+      category: 'action',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.SHOTGUN)
+        p.idle()
+        p.reload()
+      },
+    },
+    {
+      key: 'reload_rifle',
+      name: 'Reload (Rifle)',
+      category: 'action',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.RIFLE)
+        p.idle()
+        p.reload()
+      },
+    },
+    {
+      key: 'melee_knife',
+      name: 'Melee Attack (Knife)',
+      category: 'action',
+      action: (p) => {
+        p.selectWeapon(PlayerWeapon.KNIFE)
+        p.idle()
+        p.meleeAttack()
+      },
+    },
+  ]
+}
+
+export default class ModelsScene extends Phaser.Scene {
+  private puppet: PlayerPuppet | null = null
+  private stateList!: HTMLUListElement
+  private loadingOverlay!: HTMLElement
+
+  private overviewSequence: OverviewStep[] = []
+  private stateItems: StateItem[] = []
+  private overviewStepIndex: number = 0
+  private overviewTimer: Phaser.Time.TimerEvent | null = null
+  private isPlayingOverview: boolean = false
+
+  constructor() {
+    super('ModelsScene')
+  }
+
+  create() {
+    // Get DOM elements
+    this.stateList = document.getElementById('state-list') as HTMLUListElement
+    this.loadingOverlay = document.getElementById('models-loading-overlay') as HTMLElement
+
+    // Set up the scene background
+    this.cameras.main.setBackgroundColor(0x2d2d2d)
+
+    // Create the player puppet (uses same code as the game!)
+    this.createPlayerPuppet()
+
+    // Create sequences and state items
+    this.overviewSequence = createOverviewSequence()
+    this.stateItems = createStateItems()
+
+    // Initialize UI
+    this.populateStateList()
+
+    // Restore state or start overview
+    this.restoreState()
+
+    // Hide loading overlay
+    this.loadingOverlay.classList.add('hidden')
+  }
+
+  private createPlayerPuppet() {
+    const centerX = this.cameras.main.width / 2
+    const centerY = this.cameras.main.height / 2
+
+    // Create the puppet - same class used by the game!
+    this.puppet = new PlayerPuppet(this, centerX, centerY)
+  }
+
+  private populateStateList() {
+    this.stateList.innerHTML = ''
+
+    // Add Overview item first
+    const overviewItem = document.createElement('li')
+    overviewItem.className = 'state-item'
+    overviewItem.dataset.key = 'overview'
+
+    const overviewName = document.createElement('span')
+    overviewName.textContent = 'Overview'
+    overviewItem.appendChild(overviewName)
+
+    const overviewBadge = document.createElement('span')
+    overviewBadge.className = 'state-badge'
+    overviewBadge.textContent = 'demo'
+    overviewBadge.style.backgroundColor = '#2a5d2a'
+    overviewItem.appendChild(overviewBadge)
+
+    overviewItem.addEventListener('click', () => {
+      this.startOverview()
+      this.highlightState('overview')
+      editorState.modelsSelectedState = 'overview'
+    })
+
+    this.stateList.appendChild(overviewItem)
+
+    // Add separator
+    const separator = document.createElement('li')
+    separator.style.height = '1px'
+    separator.style.backgroundColor = '#4d4d4d'
+    separator.style.margin = '8px 0'
+    separator.style.padding = '0'
+    this.stateList.appendChild(separator)
+
+    // Add individual states
+    this.stateItems.forEach((state) => {
+      const item = document.createElement('li')
+      item.className = 'state-item'
+      item.dataset.key = state.key
+
+      // Create name span
+      const nameSpan = document.createElement('span')
+      nameSpan.textContent = state.name
+      item.appendChild(nameSpan)
+
+      // Add category badge
+      const badge = document.createElement('span')
+      badge.className = `state-badge ${state.category}`
+      badge.textContent = state.category
+      item.appendChild(badge)
+
+      item.addEventListener('click', () => {
+        this.stopOverview()
+        this.playState(state)
+        this.highlightState(state.key)
+        editorState.modelsSelectedState = state.key
+      })
+
+      this.stateList.appendChild(item)
+    })
+  }
+
+  private restoreState() {
+    const savedState = editorState.modelsSelectedState
+
+    if (savedState === 'overview' || !savedState) {
+      this.startOverview()
+      this.highlightState('overview')
+      return
+    }
+
+    const state = this.stateItems.find((s) => s.key === savedState)
+    if (state) {
+      this.playState(state)
+      this.highlightState(savedState)
+    } else {
+      this.startOverview()
+      this.highlightState('overview')
+    }
+  }
+
+  private startOverview() {
+    this.stopOverview()
+    this.isPlayingOverview = true
+    this.overviewStepIndex = 0
+    this.playOverviewStep()
+  }
+
+  private playOverviewStep() {
+    if (!this.isPlayingOverview || !this.puppet) return
+
+    const step = this.overviewSequence[this.overviewStepIndex]
+
+    // Execute the action on the puppet
+    step.action(this.puppet)
+
+    // Schedule next step
+    this.overviewTimer = this.time.addEvent({
+      delay: step.duration,
+      callback: () => {
+        this.overviewStepIndex = (this.overviewStepIndex + 1) % this.overviewSequence.length
+        this.playOverviewStep()
+      },
+    })
+  }
+
+  private stopOverview() {
+    this.isPlayingOverview = false
+    if (this.overviewTimer) {
+      this.overviewTimer.destroy()
+      this.overviewTimer = null
+    }
+  }
+
+  private playState(state: StateItem) {
+    if (!this.puppet) return
+
+    try {
+      state.action(this.puppet)
+    } catch (error) {
+      console.error('Failed to play state:', error)
+    }
+  }
+
+  private highlightState(stateKey: string) {
+    // Remove active class from all items
+    const items = this.stateList.querySelectorAll('.state-item')
+    items.forEach((item) => item.classList.remove('active'))
+
+    // Add active class to selected item
+    const selected = this.stateList.querySelector(`[data-key="${stateKey}"]`)
+    if (selected) {
+      selected.classList.add('active')
+      selected.scrollIntoView({ behavior: 'smooth', block: 'nearest' })
+    }
+  }
+
+  shutdown() {
+    this.stopOverview()
+    if (this.puppet) {
+      this.puppet.destroy()
+      this.puppet = null
+    }
+  }
+}
diff --git a/src/editor/spine-model-registry.ts b/src/editor/spine-model-registry.ts
new file mode 100644
index 0000000..e17a190
--- /dev/null
+++ b/src/editor/spine-model-registry.ts
@@ -0,0 +1,39 @@
+export interface SpineModelInfo {
+  key: string
+  name: string
+  jsonFile: string
+  atlasFile: string
+}
+
+/**
+ * Registry of available Spine models for the editor.
+ * Add new spines here when they are created.
+ */
+export class SpineModelRegistry {
+  private static spines: SpineModelInfo[] = [
+    {
+      key: 'player',
+      name: 'Player (Upper Body)',
+      jsonFile: 'player.json',
+      atlasFile: 'player.atlas',
+    },
+    {
+      key: 'player-legs',
+      name: 'Player Legs',
+      jsonFile: 'player-legs.json',
+      atlasFile: 'player-legs.atlas',
+    },
+  ]
+
+  static getSpines(): SpineModelInfo[] {
+    return this.spines
+  }
+
+  static getSpine(key: string): SpineModelInfo | undefined {
+    return this.spines.find((m) => m.key === key)
+  }
+
+  static getSpineKeys(): string[] {
+    return this.spines.map((m) => m.key)
+  }
+}
diff --git a/src/GameConfig.ts b/src/game-config.ts
similarity index 97%
rename from src/GameConfig.ts
rename to src/game-config.ts
index 9c9f9ef..b8dac6d 100644
--- a/src/GameConfig.ts
+++ b/src/game-config.ts
@@ -69,7 +69,7 @@ export default {
   },
 
   colors: {
-    darkenTintColor: 0x212121,
+    darkenTintColor: 0x121212,
     darkenShadowTintColor: 0x323232,
     darkenColorMatrixBrightness: 0.2,
   },
@@ -86,4 +86,4 @@ export default {
     reach: 150,
     reachAngle: 15,
   },
-};
+}
diff --git a/src/index.ts b/src/index.ts
index 654a9f0..49aa9cc 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,15 +1,17 @@
-import "phaser";
-import "phaser/plugins/spine/dist/SpinePlugin";
-import DebugScreenPlugin from "./plugins/DebugScreenPlugin";
-import PhaserRaycaster from "phaser-raycaster";
-import PreloadScene from "./scenes/PreloadScene";
-import GameScene from "./scenes/GameScene";
+import 'phaser'
+import 'phaser/plugins/spine/dist/SpinePlugin'
+// Game entry point
+import DebugScreenPlugin from './plugins/debug-screen.plugin'
+import PhaserRaycaster from 'phaser-raycaster'
+import PreloadScene from './scenes/preload.scene'
+import GameScene from './scenes/game.scene'
+import UIScene from './scenes/ui.scene'
 
-const allowDebug = true;
+const allowDebug = true
 
 const config: Phaser.Types.Core.GameConfig = {
   type: Phaser.AUTO,
-  parent: "game",
+  parent: 'game',
   scale: {
     mode: Phaser.Scale.ScaleModes.FIT,
     autoCenter: Phaser.Scale.CENTER_BOTH,
@@ -26,7 +28,7 @@ const config: Phaser.Types.Core.GameConfig = {
     antialiasGL: false,
   },
   physics: {
-    default: "arcade",
+    default: 'arcade',
 
     arcade: {
       debug: allowDebug,
@@ -37,18 +39,18 @@ const config: Phaser.Types.Core.GameConfig = {
       gravity: { y: 0 },
     },
   },
-  scene: [PreloadScene, GameScene],
+  scene: [PreloadScene, GameScene, UIScene],
   plugins: {
     scene: [
-      { key: "DebugScreen", plugin: DebugScreenPlugin, start: true },
-      { key: "SpinePlugin", plugin: window.SpinePlugin, mapping: "spine" },
+      { key: 'DebugScreen', plugin: DebugScreenPlugin, start: true },
+      { key: 'SpinePlugin', plugin: window.SpinePlugin, mapping: 'spine' },
       {
-        key: "PhaserRaycaster",
+        key: 'PhaserRaycaster',
         plugin: PhaserRaycaster,
-        mapping: "raycasterPlugin",
+        mapping: 'raycasterPlugin',
       },
     ],
   },
-};
+}
 
-window.addEventListener("load", () => new Phaser.Game(config));
+window.addEventListener('load', () => new Phaser.Game(config))
diff --git a/src/mixins/debuggable.mixin.ts b/src/mixins/debuggable.mixin.ts
new file mode 100644
index 0000000..ae961d3
--- /dev/null
+++ b/src/mixins/debuggable.mixin.ts
@@ -0,0 +1,59 @@
+import { MIXIN_DEBUGGABLE } from '../core/instances'
+
+export type Debuggable = {
+  hasDebugInfo(): boolean
+  getDebugInfo(): Record<string, unknown>
+  drawDebugPhysics(graphics: Phaser.GameObjects.Graphics): void
+}
+
+export function isDebuggable(obj: unknown): obj is Debuggable {
+  return (
+    obj != null &&
+    typeof obj === 'object' &&
+    'hasDebugInfo' in obj &&
+    'getDebugInfo' in obj &&
+    'drawDebugPhysics' in obj
+  )
+}
+
+export function debuggableMixin<
+  T extends Phaser.GameObjects.GameObject & { x: number; y: number; name?: string },
+>(obj: T, cfg?: { debugInfo?: () => Record<string, unknown> }) {
+  const result = obj as T & Debuggable
+
+  result.hasDebugInfo = function () {
+    return true
+  }
+
+  result.getDebugInfo = function (): Record<string, unknown> {
+    if (cfg?.debugInfo) {
+      return cfg.debugInfo()
+    }
+    return {
+      name: this.name ?? 'unknown',
+      x: this.x,
+      y: this.y,
+    }
+  }
+
+  result.drawDebugPhysics = function (graphics: Phaser.GameObjects.Graphics) {
+    const body = (this as { body?: MatterJS.BodyType }).body
+    if (body?.bounds) {
+      graphics.strokeRect(
+        body.bounds.min.x,
+        body.bounds.min.y,
+        body.bounds.max.x - body.bounds.min.x,
+        body.bounds.max.y - body.bounds.min.y,
+      )
+    }
+  }
+
+  result.track(MIXIN_DEBUGGABLE)
+
+  // Emit event so DebugScreenPlugin can pick up objects after mixin is applied
+  if (obj.scene) {
+    obj.scene.events.emit('debuggable-added', result)
+  }
+
+  return result
+}
diff --git a/src/mixins/interactable.mixin.ts b/src/mixins/interactable.mixin.ts
new file mode 100644
index 0000000..8af6b90
--- /dev/null
+++ b/src/mixins/interactable.mixin.ts
@@ -0,0 +1,29 @@
+import { MIXIN_INTERACTABLE } from '../core/instances'
+
+export type Interactable = {
+  interactRange: number
+  onInteract(): void
+  canInteract(): boolean
+}
+
+export function isInteractable(obj: unknown): obj is Interactable {
+  return obj != null && typeof obj === 'object' && 'onInteract' in obj && 'canInteract' in obj
+}
+
+export function interactableMixin<
+  T extends Phaser.GameObjects.GameObject & { x: number; y: number },
+>(obj: T, cfg?: { onInteract?: () => void; range?: number }) {
+  const result = obj as T & Interactable
+
+  result.interactRange = cfg?.range ?? 150
+
+  result.onInteract = cfg?.onInteract ?? function () {}
+
+  result.canInteract = function () {
+    return this.active
+  }
+
+  result.track(MIXIN_INTERACTABLE)
+
+  return result
+}
diff --git a/src/mixins/light-aware.mixin.ts b/src/mixins/light-aware.mixin.ts
new file mode 100644
index 0000000..f65a3b6
--- /dev/null
+++ b/src/mixins/light-aware.mixin.ts
@@ -0,0 +1,228 @@
+import config from '../game-config'
+import { GameSceneInterface } from '../types/game-scene'
+import { MIXIN_LIGHT_AWARE } from '../core/instances'
+
+export type LightAware = {
+  lightShape: LightAwareShape
+  onLighten(): void
+  onDarken(): void
+  onLightOverReset(): void
+  onLightOver(ray: Raycaster.Ray, intersections: Phaser.Geom.Point[], force: boolean): void
+  onLightningOver(progress: number): void
+  setLightAwareShape(shape: LightAwareShape): void
+  getLightAwareShape(): LightAwareShape
+}
+
+export type LightAwareShape =
+  | (Phaser.GameObjects.Shape & { owner?: LightAware & { body?: unknown } })
+  | null
+
+export function getColorShift(startColor: number, endColor: number, shift: number): number {
+  const tintColor = Phaser.Display.Color.Interpolate.ColorWithColor(
+    Phaser.Display.Color.ValueToColor(startColor),
+    Phaser.Display.Color.ValueToColor(endColor),
+    100,
+    Math.round(shift * 100),
+  )
+  return Phaser.Display.Color.GetColor(tintColor.r, tintColor.g, tintColor.b)
+}
+
+export function getTintColorShift(startColor: number, shift: number): number {
+  return getColorShift(startColor, config.colors.darkenTintColor, shift)
+}
+
+export function isLightAware(obj: unknown): obj is LightAware {
+  return obj != null && typeof obj === 'object' && 'onLighten' in obj && 'onDarken' in obj
+}
+
+export function lightAwareMixin<
+  T extends Phaser.GameObjects.GameObject & {
+    postFX?: Phaser.GameObjects.Components.FX
+    setTint?: (color?: number) => unknown
+    setDepth?: (depth: number) => unknown
+    x: number
+    y: number
+    width?: number
+    height?: number
+    originX?: number
+    originY?: number
+    scaleX?: number
+    scaleY?: number
+    angle?: number
+  },
+>(obj: T, cfg?: { shape?: LightAwareShape; depth?: number }) {
+  const result = obj as T &
+    LightAware & {
+      _lightAwareShadow: Phaser.FX.Shadow | null
+      _textureUnderLight: Phaser.GameObjects.RenderTexture | null
+      _textureUnderLightMask: Phaser.GameObjects.Graphics | null
+    }
+
+  const depth = cfg?.depth ?? config.depths.lightAwareShape
+
+  if (result.setDepth) {
+    result.setDepth(depth)
+  }
+
+  result._lightAwareShadow = null
+  result._textureUnderLight = null
+  result._textureUnderLightMask = null
+  result.lightShape = cfg?.shape ?? null
+
+  if (result.lightShape) {
+    result.lightShape.owner = result
+    result.lightShape.setDepth(depth)
+  }
+
+  result.onLighten = function () {
+    if (!this.postFX) return
+    this._lightAwareShadow ??= this.postFX.addShadow(0, 0, 0.1, 0.3, 0x000000, 2, 3)
+    this.postFX.clear()
+    this.postFX.add(this._lightAwareShadow)
+    this.setTint?.()
+  }
+
+  result.onDarken = function () {
+    if (!this.postFX) return
+    this.postFX.clear()
+    this._lightAwareShadow = null
+    this.setTint?.(config.colors.darkenTintColor)
+  }
+
+  result.onLightOverReset = function () {
+    this._textureUnderLightMask?.clear()
+    if (this._textureUnderLight) {
+      this._textureUnderLight.setCrop(0, 0, 0, 0)
+      this._textureUnderLight.clearMask()
+    }
+  }
+
+  result.onLightOver = function (
+    ray: Raycaster.Ray,
+    intersections: Phaser.Geom.Point[],
+    force: boolean,
+  ) {
+    if (!this.lightShape) return
+    const gameScene = this.scene as GameSceneInterface | undefined
+    if (gameScene && !gameScene.isDark) return
+
+    const owner = this.lightShape.owner
+    const ownerBody = (owner as { body?: MatterJS.BodyType } | undefined)?.body
+    if (!ownerBody) return
+
+    const effectiveIntersections = intersections.filter((intersection) => {
+      return this.scene.matter.query.point([ownerBody], intersection).length > 0
+    })
+
+    const w = this.width ?? 100
+    const h = this.height ?? 100
+
+    if (!effectiveIntersections.length && force) {
+      if (this._textureUnderLightMask && this._textureUnderLight) {
+        this._textureUnderLightMask.fillRect(this.x - w / 2, this.y - h / 2, this.x + w, this.y + h)
+        this._textureUnderLight
+          .setCrop(0, 0, w, h)
+          .setMask(this._textureUnderLightMask.createGeometryMask())
+      }
+      return
+    }
+
+    if (effectiveIntersections.length > 1 && this._textureUnderLightMask) {
+      const first = effectiveIntersections[0]
+      const last = effectiveIntersections[effectiveIntersections.length - 1]
+      const firstAngle = Phaser.Geom.Line.Angle(
+        new Phaser.Geom.Line(ray.origin.x, ray.origin.y, first.x, first.y),
+      )
+      const lastAngle = Phaser.Geom.Line.Angle(
+        new Phaser.Geom.Line(ray.origin.x, ray.origin.y, last.x, last.y),
+      )
+      const boxSize = Math.max(this.scene.cameras.main.width, this.scene.cameras.main.height)
+
+      const boxTopLeft = new Phaser.Math.Vector2(first.x, first.y)
+        .setLength(boxSize)
+        .setAngle(firstAngle - Math.PI / 128)
+        .add(first)
+
+      const boxTopRight = new Phaser.Math.Vector2(last.x, last.y)
+        .setLength(boxSize)
+        .setAngle(lastAngle + Math.PI / 128)
+        .add(last)
+
+      this._textureUnderLightMask.fillTriangle(
+        ray.origin.x,
+        ray.origin.y,
+        boxTopLeft.x,
+        boxTopLeft.y,
+        boxTopRight.x,
+        boxTopRight.y,
+      )
+    }
+
+    if (this._textureUnderLight && this._textureUnderLightMask) {
+      this._textureUnderLight
+        .setCrop(0, 0, w, h)
+        .setMask(this._textureUnderLightMask.createGeometryMask())
+    }
+  }
+
+  result.onLightningOver = function (progress: number) {
+    if (!this.postFX) return
+
+    if (progress === 1) {
+      this.postFX.clear()
+      this._lightAwareShadow = null
+    }
+
+    if (progress < 1) {
+      const color = getTintColorShift(0x000000, progress)
+      if (!this._lightAwareShadow) {
+        this._lightAwareShadow = this.postFX.addShadow(0, 0, 0.1, 0.3, color, 2, 3)
+        this.postFX.clear()
+        this.postFX.add(this._lightAwareShadow)
+      }
+      this._lightAwareShadow.color = color
+    }
+
+    this.setTint?.(getTintColorShift(0xffffff, progress))
+  }
+
+  // Alias for backwards compatibility with old isLightAware() check (has a typo)
+  ;(result as unknown as { onLighningtOver: typeof result.onLightningOver }).onLighningtOver =
+    result.onLightningOver
+
+  result.setLightAwareShape = function (shape: LightAwareShape) {
+    const image = this as unknown as Phaser.GameObjects.Image
+    const w = this.width ?? 100
+    const h = this.height ?? 100
+
+    if (image.texture && image.frame) {
+      this._textureUnderLight = this.scene.add
+        .renderTexture(this.x, this.y, w, h)
+        .drawFrame(image.texture.key, image.frame.name)
+        .setOrigin(this.originX ?? 0.5, this.originY ?? 0.5)
+        .setScale(this.scaleX ?? 1, this.scaleY ?? 1)
+        .setAngle(this.angle ?? 0)
+        .setCrop(0, 0, 0, 0)
+        .setDepth(depth + 1)
+      this._textureUnderLight.setPipeline('Light2D')
+    }
+
+    this._textureUnderLightMask = this.scene.make.graphics().setDepth(depth).fillStyle(0xffffff, 1)
+
+    this.lightShape = shape
+    if (shape) {
+      const namedObj = this as { name?: string }
+      shape.setName?.(`${namedObj.name ?? 'object'}-shape`)
+      shape.setDepth(depth)
+      shape.owner = this
+    }
+  }
+
+  result.getLightAwareShape = function () {
+    return this.lightShape
+  }
+
+  result.track(MIXIN_LIGHT_AWARE)
+
+  return result
+}
diff --git a/src/mixins/light-source.mixin.ts b/src/mixins/light-source.mixin.ts
new file mode 100644
index 0000000..a183c99
--- /dev/null
+++ b/src/mixins/light-source.mixin.ts
@@ -0,0 +1,185 @@
+import config from '../game-config'
+import { Instances, MIXIN_LIGHT_AWARE, MIXIN_LIGHT_SOURCE } from '../core/instances'
+import { lightAwareMixin, isLightAware, LightAwareShape } from './light-aware.mixin'
+import { GameSceneInterface } from '../types/game-scene'
+
+export interface LightSourceConfig {
+  emitOnDayLight: boolean
+  lightColor: number
+  lightAlpha: number
+  collisionRange: number
+  coneDeg: number
+  coneRange: number
+  closeRange: number
+  forceLightOver: boolean
+}
+
+export type LightSource = {
+  lightConfig: LightSourceConfig
+  lightRay: Raycaster.Ray | null
+  lightGraphics: Phaser.GameObjects.Graphics
+  lightRaycaster: Raycaster
+  readonly isLightEnabled: boolean
+  enableLight(): void
+  disableLight(): void
+  emitLight(): void
+  setLightOrigin(x: number, y: number): void
+  setLightAngleDeg(angle: number): void
+  mapLightAwareObject(obj: { getLightAwareShape(): LightAwareShape }): void
+}
+
+export function lightSourceMixin<
+  T extends Phaser.GameObjects.GameObject & { x: number; y: number; name?: string },
+>(obj: T, cfg: { raycaster: Raycaster; config: LightSourceConfig }) {
+  const result = obj as T & LightSource
+
+  result.lightConfig = cfg.config
+  result.lightRaycaster = cfg.raycaster
+  result.lightRay = null
+
+  result.lightGraphics = obj.scene.add
+    .graphics({ fillStyle: { color: cfg.config.lightColor, alpha: cfg.config.lightAlpha } })
+    .setName(`${obj.name ?? 'light'}-graphics`)
+
+  // Map existing light-aware objects
+  const lightAwareShapes: Phaser.GameObjects.Shape[] = []
+  for (const lightAwareObj of Instances(MIXIN_LIGHT_AWARE)) {
+    const shape = lightAwareObj.getLightAwareShape()
+    if (shape) lightAwareShapes.push(shape)
+  }
+  cfg.raycaster.mapGameObjects(lightAwareShapes)
+
+  Object.defineProperty(result, 'isLightEnabled', {
+    get() {
+      return this.lightRay != null
+    },
+  })
+
+  result.enableLight = function () {
+    this.lightRay = this.lightRaycaster.createRay({
+      collisionRange: this.lightConfig.collisionRange,
+    })
+    this.lightRay.autoSlice = true
+  }
+
+  result.disableLight = function () {
+    this.lightGraphics.clear()
+    this.lightRay?.destroy()
+    this.lightRay = null
+  }
+
+  result.setLightOrigin = function (x: number, y: number) {
+    if (this.lightRay) {
+      this.lightRay.origin.x = x
+      this.lightRay.origin.y = y
+    }
+  }
+
+  result.setLightAngleDeg = function (angle: number) {
+    this.lightRay?.setAngleDeg(angle)
+  }
+
+  result.mapLightAwareObject = function (lightAwareObj: { getLightAwareShape(): LightAwareShape }) {
+    const shape = lightAwareObj.getLightAwareShape()
+    if (shape) {
+      this.lightRaycaster.mapGameObjects([shape])
+    }
+  }
+
+  result.emitLight = function () {
+    if (!this.lightRay) return
+
+    const gameScene = this.scene as GameSceneInterface
+    let mappedObjectUnderLight: LightAwareShape = null
+
+    type MappedObject = Phaser.GameObjects.GameObject & {
+      owner?: {
+        onLightOver(ray: Raycaster.Ray, intersections: Phaser.Geom.Point[], force: boolean): void
+        body?: MatterJS.BodyType
+      }
+    }
+
+    const mappedObjects = this.lightRaycaster.mappedObjects.filter((object: MappedObject) => {
+      if (this.lightConfig.forceLightOver && object instanceof Phaser.GameObjects.Shape) {
+        const ownerBody = (object as MappedObject).owner?.body
+        if (
+          ownerBody &&
+          ownerBody.bounds &&
+          this.scene.matter.intersectPoint(this.lightRay!.origin.x, this.lightRay!.origin.y, [
+            ownerBody,
+          ]).length > 0
+        ) {
+          mappedObjectUnderLight = object as LightAwareShape
+          return false
+        }
+      }
+      return true
+    })
+
+    const intersections = this.lightRay.castCone({ objects: mappedObjects })
+    const initialIntersections = intersections.slice()
+    intersections.push(this.lightRay.origin)
+
+    if (!gameScene.isDark) {
+      if (this.lightConfig.emitOnDayLight) {
+        this.lightGraphics.clear().fillPoints(intersections)
+      }
+      return
+    }
+
+    const leftEdgePoint = new Phaser.Math.Vector2(this.lightRay.origin.x, this.lightRay.origin.y)
+      .setLength(this.lightConfig.coneRange)
+      .setAngle(this.lightRay.angle - this.lightRay.cone / 2)
+      .add(this.lightRay.origin)
+
+    gameScene.lightShadowSceneGraphics
+      .fillStyle(0xffffff, 0)
+      .beginPath()
+      .moveTo(this.lightRay.origin.x, this.lightRay.origin.y)
+      .lineTo(leftEdgePoint.x, leftEdgePoint.y)
+      .arc(
+        this.lightRay.origin.x,
+        this.lightRay.origin.y,
+        this.lightConfig.coneRange,
+        this.lightRay.angle - this.lightRay.cone / 2,
+        this.lightRay.angle + this.lightRay.cone / 2,
+      )
+      .lineTo(this.lightRay.origin.x, this.lightRay.origin.y)
+      .fillPath()
+      .fillPoints(intersections)
+
+    gameScene.lightSceneGraphics.fillStyle(0xffffff, 0).fillPoints(intersections)
+    gameScene.lightSceneGraphics
+      .fillStyle(this.lightConfig.lightColor, this.lightConfig.lightAlpha)
+      .fillPoints(intersections)
+
+    type IntersectionPoint = Phaser.Geom.Point & { object?: MappedObject }
+    const affectedObjects = initialIntersections.reduce(
+      (acc: MappedObject[], intersection: IntersectionPoint) => {
+        if (intersection.object && acc.indexOf(intersection.object) === -1) {
+          acc.push(intersection.object)
+        }
+        return acc
+      },
+      [],
+    )
+
+    affectedObjects.forEach((object: MappedObject) => {
+      const owner = object.owner
+      if (owner && isLightAware(owner)) {
+        owner.onLightOver(this.lightRay!, initialIntersections, false)
+      }
+    })
+
+    if (mappedObjectUnderLight) {
+      const owner = mappedObjectUnderLight.owner
+      if (owner && isLightAware(owner)) {
+        owner.onLightOver(this.lightRay!, initialIntersections, true)
+      }
+    }
+  }
+
+  result.track(MIXIN_LIGHT_SOURCE)
+
+  return result
+}
diff --git a/src/mixins/pointable.mixin.ts b/src/mixins/pointable.mixin.ts
new file mode 100644
index 0000000..d973827
--- /dev/null
+++ b/src/mixins/pointable.mixin.ts
@@ -0,0 +1,118 @@
+import config from '../game-config'
+import { Label } from '../objects/label.object'
+import { MIXIN_POINTABLE } from '../core/instances'
+import { uiScene, scene } from '../core/globals'
+
+export type Pointable = {
+  showHighlight(): void
+  removeHighlight(): void
+  showInfo(): void
+  removeInfo(): void
+}
+
+export function isPointable(obj: unknown): obj is Pointable {
+  return (
+    obj != null && typeof obj === 'object' && 'showHighlight' in obj && 'removeHighlight' in obj
+  )
+}
+
+export function pointableMixin<
+  T extends Phaser.GameObjects.GameObject & {
+    postFX?: Phaser.GameObjects.Components.FX
+    x: number
+    y: number
+    width?: number
+    height?: number
+    name?: string
+  },
+>(obj: T, cfg?: { info?: string }) {
+  const result = obj as T & {
+    pointableInfo: string | null
+    showHighlight(): void
+    removeHighlight(): void
+    showInfo(): void
+    removeInfo(): void
+    setInfo(info: string): void
+    hasInfo(): boolean
+    getInfo(): string
+    _highlight: Phaser.FX.Glow | null
+    _label: Label | null
+  }
+
+  result.pointableInfo = cfg?.info ?? null
+  result._highlight = null
+  result._label = null
+
+  result.showHighlight = function () {
+    if (this.postFX) {
+      this._highlight = this.postFX.addGlow(0xffffff, 3, 0.1)
+    }
+  }
+
+  result.removeHighlight = function () {
+    if (this.postFX && this._highlight) {
+      this.postFX.remove(this._highlight)
+      this._highlight = null
+    }
+  }
+
+  result.showInfo = function () {
+    if (this._label) return
+
+    if (!this.hasInfo() || !uiScene || !scene) return
+
+    this._label = new Label(uiScene, 0, 0, this.getInfo())
+    this._label.setScrollFactor(0)
+    uiScene.add.existing(this._label)
+    this._label.setDepth(config.depths.pointableObject)
+
+    const updatePosition = () => {
+      if (!this._label || !scene) return
+      const worldX = this.x + (this.width ?? 0) / 2 + 10
+      const worldY = this.y - (this.height ?? 0) / 2 - 10
+      const camera = scene.cameras.main
+
+      const relX = worldX - camera.worldView.centerX
+      const relY = worldY - camera.worldView.centerY
+      const rot = (camera as unknown as { rotation: number }).rotation
+      const cos = Math.cos(rot)
+      const sin = Math.sin(rot)
+      const rotatedX = relX * cos - relY * sin
+      const rotatedY = relX * sin + relY * cos
+
+      this._label.setPosition(
+        camera.width / 2 + rotatedX * camera.zoom,
+        camera.height / 2 + rotatedY * camera.zoom,
+      )
+    }
+
+    updatePosition()
+    uiScene.events.on(Phaser.Scenes.Events.UPDATE, updatePosition)
+    this._label.once('destroy', () => {
+      uiScene.events.off(Phaser.Scenes.Events.UPDATE, updatePosition)
+    })
+  }
+
+  result.removeInfo = function () {
+    if (this._label) {
+      this._label.destroy()
+      this._label = null
+    }
+  }
+
+  result.setInfo = function (info: string) {
+    this.pointableInfo = info
+  }
+
+  result.hasInfo = function () {
+    return this.getInfo().length > 0
+  }
+
+  result.getInfo = function () {
+    return this.pointableInfo ?? this.name ?? ''
+  }
+
+  result.track(MIXIN_POINTABLE)
+
+  return result
+}
diff --git a/src/objects/CasingEmitter.ts b/src/objects/CasingEmitter.ts
deleted file mode 100644
index 9bdd5f4..0000000
--- a/src/objects/CasingEmitter.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-import GameScene from "../scenes/GameScene";
-import { ILightAware, LightAwareShape } from "../types/LightAware";
-
-export class CasingEmitter
-  extends Phaser.GameObjects.Container
-  implements ILightAware
-{
-  private emitter: Phaser.GameObjects.Particles.ParticleEmitter;
-  private emitterAngle: number;
-  private emitterOfffset: { x: number; y: number };
-  private isDark: boolean;
-  private debug: Phaser.GameObjects.Rectangle;
-
-  constructor(
-    scene: GameScene,
-    x: number,
-    y: number,
-    casingsTexture: string,
-    casingsScale: { from: number; to: number }
-  ) {
-    super(scene, x, y);
-
-    const textures = this.scene.textures.get(casingsTexture);
-    this.emitter = this.scene.add.particles(0, 0, textures, {
-      angle: (): number => {
-        return this.emitterAngle + 90 + Phaser.Math.Between(-15, 15);
-      },
-      rotate: (): number => {
-        return this.emitterAngle + 90 + Phaser.Math.Between(-25, 25);
-      },
-      maxVelocityX: {
-        onEmit: (): number => {
-          return Phaser.Math.Between(220, 245);
-        },
-        onUpdate: (particle: Phaser.GameObjects.Particles.Particle): number => {
-          if (particle.lifeT > 0.5) {
-            return 0;
-          } else if (particle.lifeT > 0.3) {
-            return Phaser.Math.Between(5, 10);
-          } else if (particle.lifeT > 0.1) {
-            return 10;
-          }
-
-          return particle.maxVelocityX;
-        },
-      },
-      maxVelocityY: {
-        onUpdate: (particle: Phaser.GameObjects.Particles.Particle): number => {
-          if (particle.lifeT > 0.5) {
-            return 0;
-          } else if (particle.lifeT > 0.3) {
-            return Phaser.Math.Between(5, 10);
-          } else if (particle.lifeT > 0.1) {
-            return 10;
-          }
-
-          return Phaser.Math.Between(220, 245);
-        },
-      },
-      lifespan: { min: 900, max: 2000 },
-      speed: { min: 20, max: 245 },
-      scale: {
-        onEmit: () => {
-          return casingsScale.from;
-        },
-        onUpdate: (particle: Phaser.GameObjects.Particles.Particle): number => {
-          if (particle.lifeT < 0.08) {
-            return particle.scaleX;
-          }
-
-          return casingsScale.to;
-        },
-      },
-      emitting: false,
-      stopAfter: 1,
-    });
-
-    this.emitter.onParticleEmit(
-      (particle: Phaser.GameObjects.Particles.Particle) => {
-        particle.setPosition(this.emitterOfffset.x, this.emitterOfffset.y);
-        if (this.isDark) {
-          particle.tint = 0x000000;
-        }
-      }
-    );
-
-    this.scene.physics.world.enable(
-      (this.debug = scene.add
-        .rectangle(0, 0, 10, 20, 0xff00ff, 0.5)
-        .setOrigin(0.5, 0.5)
-        .setVisible(this.scene.physics.world.drawDebug))
-    );
-
-    this.scene.add.existing(this.emitter);
-  }
-
-  public setEmitterPosition(
-    center: { x: number; y: number },
-    length: number,
-    angle: number
-  ) {
-    const offset = new Phaser.Math.Vector2(center);
-    offset.setLength(length).setAngle(Phaser.Math.DegToRad(angle));
-
-    this.emitterOfffset = { x: center.x + offset.x, y: center.y + offset.y };
-    this.debug
-      .setPosition(this.emitterOfffset.x, this.emitterOfffset.y)
-      .setVisible(this.scene.physics.world.drawDebug);
-  }
-
-  public setEmitterAngle(angle: number) {
-    this.emitterAngle = angle;
-    this.debug.setAngle(angle).setVisible(this.scene.physics.world.drawDebug);
-  }
-
-  public onLighten(): ILightAware {
-    this.isDark = false;
-    this.updateTintForAllAlive(0xffffff);
-    return this;
-  }
-
-  public onDarken(): ILightAware {
-    this.isDark = true;
-    this.updateTintForAllAlive(0x000000);
-    return this;
-  }
-
-  public onLightOverReset(): ILightAware {
-    return this;
-  }
-
-  public onLightOver(): ILightAware {
-    return this;
-  }
-
-  public onLighningtOver(): ILightAware {
-    return this;
-  }
-
-  public setLightAwareShape(shape: LightAwareShape): ILightAware {
-    return this;
-  }
-
-  public getLightAwareShape(): LightAwareShape {
-    return null;
-  }
-
-  public emitOne(casingName: string) {
-    this.emitter.setEmitterFrame(casingName);
-    this.emitter.start();
-  }
-
-  private updateTintForAllAlive(tint: number) {
-    this.emitter.forEachAlive(
-      (particle: Phaser.GameObjects.Particles.Particle) => {
-        particle.tint = tint;
-      },
-      this.emitter
-    );
-  }
-}
diff --git a/src/objects/EmergencyAlarmLight.ts b/src/objects/EmergencyAlarmLight.ts
deleted file mode 100644
index d973a51..0000000
--- a/src/objects/EmergencyAlarmLight.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import config from "../GameConfig";
-import GameScene from "../scenes/GameScene";
-import { IDebuggable } from "../types/Debuggable";
-import { ILightAware, LightAwareShape } from "../types/LightAware";
-import { LightSource } from "../types/LightSource";
-
-export default class EmergencyAlarmLight
-  extends Phaser.Physics.Arcade.Sprite
-  implements ILightAware, IDebuggable
-{
-  public scene: GameScene;
-  public body: Phaser.Physics.Arcade.Body;
-
-  private light: LightSource;
-
-  constructor(scene: GameScene, x: number, y: number) {
-    super(scene, x, y, "wall-lamp");
-
-    this.name = "emergency-alarm-light";
-
-    this.scene.add.existing(this);
-    this.scene.physics.world.enable(this);
-
-    this.setOrigin(0.5, 0.5)
-      .setDisplaySize(60, 20)
-      .setDepth(config.depths.ceiling);
-
-    this.light = scene
-      .createLightSource(
-        "emergency-alarm-light-source",
-        config.emergencyAlarmLight
-      )
-      .setDepth(config.depths.light);
-  }
-
-  public get isOn(): boolean {
-    return this.light.isEnabled;
-  }
-
-  public turnOn(): EmergencyAlarmLight {
-    this.setTint();
-    this.light
-      .enable()
-      .setOrigin(this.x, this.y)
-      .setAngleDeg(this.angle - 90)
-      .setConeDeg(config.emergencyAlarmLight.coneDeg)
-      .setRayRange(config.emergencyAlarmLight.coneRange);
-    return this;
-  }
-
-  public turnOff(): EmergencyAlarmLight {
-    this.setTint(this.scene.isDark ? 0x111111 : 0x505050);
-    this.light.disable();
-    return this;
-  }
-
-  public hasDebugInfo(): boolean {
-    return true;
-  }
-
-  public getDebugInfo(): object {
-    return {
-      name: this.name,
-      x: this.x,
-      y: this.y,
-      angle: this.angle,
-      isOn: this.isOn,
-    };
-  }
-
-  public drawDebugPhysics(graphics: Phaser.GameObjects.Graphics) {
-    this.light.drawDebugPhysics(graphics);
-  }
-
-  public onLighten(): ILightAware {
-    this.setTint(this.scene.isDark ? 0x111111 : 0x505050);
-    this.light.onLighten();
-    return this;
-  }
-
-  public onDarken(): ILightAware {
-    this.setTint(this.scene.isDark ? 0x111111 : 0x505050);
-    this.light.onDarken();
-    return this;
-  }
-
-  public onLightOverReset(): ILightAware {
-    return this;
-  }
-
-  public onLightOver(): ILightAware {
-    return this;
-  }
-
-  public onLighningtOver(): ILightAware {
-    return this;
-  }
-
-  public setLightAwareShape(shape: LightAwareShape): ILightAware {
-    return this;
-  }
-
-  public getLightAwareShape(): LightAwareShape {
-    return null;
-  }
-}
diff --git a/src/objects/Flashlight.ts b/src/objects/Flashlight.ts
deleted file mode 100644
index abbf44d..0000000
--- a/src/objects/Flashlight.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import config from "../GameConfig";
-import GameScene from "../scenes/GameScene";
-import { IDebuggable } from "../types/Debuggable";
-import { ILightAware, LightAwareShape } from "../types/LightAware";
-import { LightSource } from "../types/LightSource";
-
-export default class Flashlight
-  extends Phaser.Physics.Arcade.Sprite
-  implements IDebuggable
-{
-  public scene: GameScene;
-  public body: Phaser.Physics.Arcade.Body;
-
-  private light: LightSource;
-  private glitchy: boolean = false;
-
-  public get isOn(): boolean {
-    return this.light.isEnabled;
-  }
-
-  public get isOff(): boolean {
-    return !this.isOn;
-  }
-
-  public get isGlitchy(): boolean {
-    return this.glitchy;
-  }
-
-  constructor(scene: GameScene, x: number, y: number, raycaster: Raycaster) {
-    super(scene, x, y, "flashlight");
-
-    this.name = "flashlight";
-
-    this.scene.add.existing(this);
-    this.scene.physics.world.enable(this);
-
-    this.setOrigin(0.5, 0.5)
-      .setDisplaySize(50, 30)
-      .setDepth(config.depths.matterThingTop + 1);
-
-    this.light = scene
-      .createLightSource("flashlight-source", config.flashlight)
-      .setDepth(config.depths.light);
-  }
-  isEnabled: boolean;
-
-  public setPosition(x: number, y: number): this {
-    super.setPosition(x, y);
-    this.light?.setOrigin(x, y);
-    return this;
-  }
-
-  public setAngle(angle: number): this {
-    super.setAngle(angle);
-    this.light?.setAngleDeg(this.angle);
-    return this;
-  }
-
-  public hasDebugInfo(): boolean {
-    return true;
-  }
-
-  public getDebugInfo(): object {
-    return {
-      name: this.name,
-      x: this.x,
-      y: this.y,
-      isOn: this.isOn,
-      rotation: this.rotation,
-      glitchy: this.glitchy,
-    };
-  }
-
-  public drawDebugPhysics(graphics: Phaser.GameObjects.Graphics) {
-    this.light.drawDebugPhysics(graphics);
-  }
-
-  public turnOff() {
-    this.light.disable();
-  }
-
-  public turnOn() {
-    this.light
-      .enable()
-      .setOrigin(this.x, this.y)
-      .setAngleDeg(this.angle)
-      .setConeDeg(config.flashlight.coneDeg)
-      .setRayRange(config.flashlight.coneRange);
-  }
-
-  public setGlitchy(value: boolean) {
-    // TODO: implement
-    console.log("setGlitchy", value);
-    return this;
-  }
-
-  public onLighten(): ILightAware {
-    this.light.onLighten();
-    return this;
-  }
-
-  public onDarken(): ILightAware {
-    this.light.onDarken();
-    return this;
-  }
-
-  public onLightOverReset(): ILightAware {
-    return this;
-  }
-
-  public onLightOver(): ILightAware {
-    return this;
-  }
-
-  public onLighningtOver(): ILightAware {
-    return this;
-  }
-
-  public setLightAwareShape(shape: LightAwareShape): ILightAware {
-    return this;
-  }
-
-  public getLightAwareShape(): LightAwareShape {
-    return null;
-  }
-}
diff --git a/src/objects/Label.ts b/src/objects/Label.ts
deleted file mode 100644
index 1e5d700..0000000
--- a/src/objects/Label.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-export class Label extends Phaser.GameObjects.Container {
-  private text: Phaser.GameObjects.Text;
-  private background: Phaser.GameObjects.Rectangle;
-
-  DEFAULT_BACKGROUND_COLOR: string = "#000000";
-  DEFAULT_BACKGROUND_ALPHA: number = 0.5;
-  DEFAULT_TEXT_COLOR: string = "#ffffff";
-  DEFAULT_STROKE_COLOR: string = "#aaaaaa";
-  DEFAULT_STROKE_THICKNESS: number = 0.5;
-
-  constructor(scene: Phaser.Scene, x: number, y: number, text: string) {
-    super(scene, x, y);
-
-    this.text = this.scene.add.text(x, y, text, {
-      fontFamily: "monospace",
-      fontSize: "14px",
-      padding: {
-        left: 5,
-        right: 5,
-        top: 5,
-        bottom: 5,
-      },
-    });
-
-    this.background = scene.add
-      .rectangle(0, 0, this.text.width, this.text.height)
-      .setOrigin(0, 0);
-
-    this.add([this.background, this.text]);
-
-    this.setBackgroundColor(
-      this.DEFAULT_BACKGROUND_COLOR,
-      this.DEFAULT_BACKGROUND_ALPHA
-    ).setTextColor(this.DEFAULT_TEXT_COLOR);
-    this.resize();
-  }
-
-  public setText(text: string): Label {
-    this.text.setText(text);
-    this.resize();
-    return this;
-  }
-
-  public setBackgroundColor(color: string, alpha: number = 0.5): Label {
-    const colorHex = Phaser.Display.Color.HexStringToColor(color).color;
-    this.background.setFillStyle(colorHex, alpha);
-    return this;
-  }
-
-  public setTextColor(
-    color: string,
-    strokeColor: string = this.DEFAULT_STROKE_COLOR,
-    strokeThickness: number = this.DEFAULT_STROKE_THICKNESS
-  ): Label {
-    this.text.setFill(color).setStroke(strokeColor, strokeThickness);
-    return this;
-  }
-
-  private resize() {
-    this.text.setPosition(0, 0);
-    this.background.setPosition(0, 0);
-    this.width = this.text.width;
-    this.height = this.text.height;
-  }
-}
diff --git a/src/objects/MuzzleFlash.ts b/src/objects/MuzzleFlash.ts
deleted file mode 100644
index 6cca044..0000000
--- a/src/objects/MuzzleFlash.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import config from "../GameConfig";
-import GameScene from "../scenes/GameScene";
-import { IDebuggable } from "../types/Debuggable";
-import { ILightSource, LightSource } from "../types/LightSource";
-
-export default class MuzzleFlash
-  extends Phaser.GameObjects.Sprite
-  implements ILightSource, IDebuggable
-{
-  private muzzleLight: LightSource;
-
-  public body: Phaser.Physics.Arcade.Body;
-
-  public get isEnabled(): boolean {
-    return this.muzzleLight.isEnabled;
-  }
-
-  constructor(scene: GameScene, x: number, y: number) {
-    super(scene, x, y, "muzzle-flash");
-    this.name = "muzzle-flash";
-    this.setOrigin(0.1, 0.5).setScale(0.15).setVisible(false);
-    this.scene.add.existing(this);
-    this.scene.physics.world.enable(this);
-
-    this.muzzleLight = scene
-      .createLightSource("muzzle-flash", config.weapon.muzzle.light)
-      .setDepth(config.depths.light);
-  }
-
-  public flashOnce() {
-    this.setVisible(true);
-    this.muzzleLight
-      .enable()
-      .setOrigin(this.x, this.y)
-      .setAngleDeg(this.angle)
-      .setConeDeg(config.weapon.muzzle.light.coneDeg)
-      .setRayRange(config.weapon.muzzle.light.coneRange);
-
-    this.scene.time.delayedCall(config.weapon.muzzle.duration, () => {
-      this.setVisible(false);
-      this.muzzleLight.disable();
-    });
-  }
-
-  public enable(): ILightSource {
-    return this.muzzleLight.enable();
-  }
-
-  public disable(): ILightSource {
-    return this.muzzleLight.disable();
-  }
-
-  public emitLight(): ILightSource {
-    return this.muzzleLight.emitLight();
-  }
-
-  public hasDebugInfo(): boolean {
-    return false;
-  }
-
-  public getDebugInfo(): object {
-    return {};
-  }
-
-  public drawDebugPhysics(graphics: Phaser.GameObjects.Graphics): void {
-    this.muzzleLight.drawDebugPhysics(graphics);
-  }
-}
diff --git a/src/objects/Player.ts b/src/objects/Player.ts
deleted file mode 100644
index 78ea933..0000000
--- a/src/objects/Player.ts
+++ /dev/null
@@ -1,728 +0,0 @@
-import config from "../GameConfig";
-import GameScene from "../scenes/GameScene";
-import { Event } from "../scenes/Event";
-import Flashlight from "./Flashlight";
-import SpineContainer from "../types/SpineContainer";
-import { CasingEmitter } from "./CasingEmitter";
-import { IDebuggable } from "../types/Debuggable";
-import {
-  ILightAware,
-  LightAwareShape,
-  getTintColorShift,
-} from "../types/LightAware";
-import MuzzleFlash from "./MuzzleFlash";
-
-enum PlayerWeapon {
-  HANDGUN = "handgun",
-  SHOTGUN = "shotgun",
-  RIFLE = "rifle",
-  KNIFE = "knife",
-}
-
-enum PlayerWeaponMode {
-  NONE = "none",
-  SINGLE = "single",
-  BURST = "burst",
-  AUTO = "auto",
-}
-
-enum PlayerState {
-  IDLE = "idle",
-  MOVE = "move",
-}
-
-enum PlayerLegsState {
-  IDLE = "idle",
-  WALK = "walk",
-  STRAFE_LEFT = "strafe_left",
-  STRAFE_RIGHT = "strafe_right",
-  RUN = "run",
-}
-
-export default class Player
-  extends SpineContainer
-  implements ILightAware, IDebuggable
-{
-  public scene: GameScene;
-  public body: Phaser.Physics.Arcade.Body;
-
-  private matterSpot: MatterJS.BodyType;
-  private lightAwareShape: LightAwareShape;
-
-  private readonly casingEmitter: CasingEmitter;
-
-  private legs: SpineGameObject;
-  private flashlight: Flashlight;
-  private shadow: Phaser.FX.Shadow;
-  private darkColorMatrix: Phaser.FX.ColorMatrix;
-  private currentState: PlayerState = PlayerState.IDLE;
-  private currentLegsState: PlayerLegsState = PlayerLegsState.IDLE;
-  private currentWeapon: PlayerWeapon = PlayerWeapon.HANDGUN;
-  private currentWeaponMode: { [key in PlayerWeapon]: PlayerWeaponMode } = {
-    handgun: PlayerWeaponMode.SINGLE,
-    shotgun: PlayerWeaponMode.SINGLE,
-    rifle: PlayerWeaponMode.BURST,
-    knife: PlayerWeaponMode.NONE,
-  };
-  private muzzleFlash: MuzzleFlash;
-  shadowAdded: boolean;
-
-  constructor(scene: GameScene, x: number, y: number) {
-    super(
-      scene,
-      x,
-      y,
-      "player",
-      `${PlayerState.IDLE}_${PlayerWeapon.HANDGUN}`,
-      true
-    );
-
-    this.name = "player";
-
-    this.setScale(0.7, 0.7);
-
-    this.legs = scene.add.spine(0, 0, "player-legs", PlayerState.IDLE, true);
-    this.addSpine(this.legs, 0);
-
-    this.scene.add.existing(this);
-    this.scene.physics.world.enable(this);
-    this.body.setDrag(1, 1);
-
-    this.shadow = this.postFX.addShadow(0, 0, 0.1, 0.3, 0x000000, 2, 3);
-    this.removeShadow();
-
-    this.darkColorMatrix = this.postFX
-      .addColorMatrix()
-      .brightness(config.colors.darkenColorMatrixBrightness);
-
-    const bounds = this.spine.getBounds();
-
-    this.body
-      .setOffset(-bounds.size.x / 3, -bounds.size.y / 3 - 15)
-      .setCircle(bounds.size.x / 3)
-      .setCollideWorldBounds(true);
-
-    this.matterSpot = this.scene.matter.add.circle(this.x, this.y, 50, {
-      isSensor: true,
-      label: "player-spot",
-    });
-
-    this.lightAwareShape = this.scene.add.circle(this.x, this.y, 50);
-    // @ts-ignore
-    this.lightAwareShape.owner = this;
-
-    this.setCurrentState(PlayerState.IDLE, PlayerLegsState.IDLE);
-    this.selectWeapon(PlayerWeapon.HANDGUN);
-
-    this.casingEmitter = new CasingEmitter(
-      this.scene,
-      this.x,
-      this.y,
-      "bullet-casings",
-      { from: 0.4, to: 0.3 }
-    );
-    this.muzzleFlash = new MuzzleFlash(this.scene, this.x, this.y);
-
-    this.setDepth(config.depths.player);
-    this.casingEmitter.setDepth(config.depths.casingEmitter);
-    this.muzzleFlash.setDepth(config.depths.player + 1);
-  }
-
-  public postUpdate() {
-    this.updateMatterSpotPosition();
-    this.updateFlashlightPosition(this.currentWeapon);
-    this.updateMuzzleFlashPosition(this.currentWeapon);
-    this.updateCasingEmitterPosition(this.currentWeapon);
-    this.updateLightAwareShapePosition();
-  }
-
-  public preUpdate() {
-    const { up, down, left, right, keys } = this.scene.inputs;
-
-    if (left) {
-      this.strafeLeft(keys.shift.isDown);
-    } else if (right) {
-      this.strafeRight(keys.shift.isDown);
-    } else if (up) {
-      if (keys.shift.isDown) {
-        this.runForward();
-      } else {
-        this.moveForward();
-      }
-    } else if (down) {
-      if (!keys.shift.isDown) {
-        this.moveBackward();
-      } else {
-        this.runBackward();
-      }
-    } else {
-      this.stop();
-    }
-
-    if (Phaser.Input.Keyboard.JustDown(keys.F)) {
-      this.toggleFlashlight();
-    }
-
-    if (Phaser.Input.Keyboard.JustDown(keys.E)) {
-      this.scene.events.emit(Event.INTERACT_WITH_OBJECT);
-    }
-
-    if (Phaser.Input.Keyboard.JustDown(keys.R)) {
-      this.reload();
-    }
-
-    if (Phaser.Input.Keyboard.JustDown(keys.one)) {
-      this.selectWeapon(PlayerWeapon.KNIFE);
-    }
-
-    if (Phaser.Input.Keyboard.JustDown(keys.two)) {
-      this.selectWeapon(PlayerWeapon.HANDGUN);
-    }
-
-    if (Phaser.Input.Keyboard.JustDown(keys.three)) {
-      this.selectWeapon(PlayerWeapon.SHOTGUN);
-    }
-
-    if (Phaser.Input.Keyboard.JustDown(keys.four)) {
-      this.selectWeapon(PlayerWeapon.RIFLE);
-    }
-
-    if (Phaser.Input.Keyboard.JustDown(keys.space)) {
-      this.attack();
-    }
-  }
-
-  private toggleFlashlight() {
-    if (!this.flashlight) {
-      this.scene.events.emit(Event.FLASHLIGHT_MISSING);
-      return;
-    }
-
-    if (this.flashlight.isOff) {
-      this.flashlight.turnOn();
-    } else {
-      this.flashlight.turnOff();
-    }
-  }
-
-  private setCurrentState(state: PlayerState, legsState: PlayerLegsState) {
-    if (this.currentState !== state) {
-      this.currentState = state;
-      this.spine.setAnimation(0, `${state}_${this.currentWeapon}`, true);
-    }
-
-    if (this.currentLegsState !== legsState) {
-      this.currentLegsState = legsState;
-      this.legs.setAnimation(0, legsState, true);
-    }
-  }
-
-  private stop() {
-    this.setCurrentState(PlayerState.IDLE, PlayerLegsState.IDLE);
-    this.body.setVelocity(0);
-  }
-
-  private strafeRight(fast: boolean = false) {
-    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.STRAFE_RIGHT);
-    this.scene.physics.velocityFromRotation(
-      this.rotation + 0.5 * Math.PI,
-      fast ? config.player.speed.strafeFast : config.player.speed.strafe,
-      this.body.velocity
-    );
-  }
-
-  private strafeLeft(fast: boolean = false) {
-    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.STRAFE_LEFT);
-    this.scene.physics.velocityFromRotation(
-      this.rotation + 0.5 * Math.PI,
-      -(fast ? config.player.speed.strafeFast : config.player.speed.strafe),
-      this.body.velocity
-    );
-  }
-
-  private moveBackward() {
-    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.WALK);
-    this.scene.physics.velocityFromRotation(
-      this.rotation,
-      -config.player.speed.walk,
-      this.body.velocity
-    );
-  }
-
-  private moveForward() {
-    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.WALK);
-    this.scene.physics.velocityFromRotation(
-      this.rotation,
-      config.player.speed.walk,
-      this.body.velocity
-    );
-  }
-
-  private runBackward() {
-    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.RUN);
-    this.scene.physics.velocityFromRotation(
-      this.rotation,
-      -config.player.speed.run,
-      this.body.velocity
-    );
-  }
-
-  private runForward() {
-    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.RUN);
-    this.scene.physics.velocityFromRotation(
-      this.rotation,
-      config.player.speed.run,
-      this.body.velocity
-    );
-  }
-
-  public selectWeapon(weapon: PlayerWeapon) {
-    if (this.currentWeapon === weapon) {
-      const oldMode = this.currentWeaponMode[this.currentWeapon];
-      const newMode = this.nextWeaponMode(this.currentWeapon, oldMode);
-      this.currentWeaponMode[this.currentWeapon] = newMode;
-
-      if (oldMode !== newMode) {
-        this.scene.events.emit(Event.WEAPON_MODE_CHANGED, {
-          weapon: this.currentWeapon,
-          mode: newMode,
-        });
-      }
-
-      return;
-    }
-
-    this.currentWeapon = weapon;
-    this.spine.setAnimation(0, `${this.currentState}_${weapon}`, true);
-  }
-
-  private nextWeaponMode(
-    weapon: PlayerWeapon,
-    currentMode: PlayerWeaponMode
-  ): PlayerWeaponMode {
-    if (weapon !== PlayerWeapon.RIFLE) {
-      return PlayerWeaponMode.SINGLE;
-    }
-
-    if (currentMode === PlayerWeaponMode.SINGLE) {
-      return PlayerWeaponMode.BURST;
-    } else if (currentMode === PlayerWeaponMode.BURST) {
-      return PlayerWeaponMode.AUTO;
-    } else if (currentMode === PlayerWeaponMode.AUTO) {
-      return PlayerWeaponMode.SINGLE;
-    }
-  }
-
-  public attack() {
-    if (this.currentWeapon === PlayerWeapon.KNIFE) {
-      this.spine.setAnimation(0, `meleeattack_${this.currentWeapon}`, false);
-      this.continueCurrentAnimation();
-      return;
-    }
-
-    const mode = this.currentWeaponMode[this.currentWeapon];
-    if (mode === PlayerWeaponMode.SINGLE) {
-      this.shoot();
-    } else if (mode === PlayerWeaponMode.BURST) {
-      this.shoot();
-      this.scene.time.delayedCall(config.weapon.shotDelay, () => {
-        this.shoot();
-      });
-      this.scene.time.delayedCall(config.weapon.shotDelay * 2, () => {
-        this.shoot();
-      });
-    } else if (mode === PlayerWeaponMode.AUTO) {
-      const shootEvent = this.scene.time.addEvent({
-        delay: config.weapon.shotDelay,
-        callback: () => {
-          if (
-            this.scene.input.keyboard.keys[Phaser.Input.Keyboard.KeyCodes.SPACE]
-              .isDown
-          ) {
-            this.shoot();
-          } else {
-            shootEvent.remove();
-          }
-        },
-        loop: true,
-      });
-    }
-  }
-
-  private shoot() {
-    this.spine.setAnimation(0, `shoot_${this.currentWeapon}`, false);
-    this.casingEmitter.emitOne(this.getCasingName(this.currentWeapon));
-    this.muzzleFlash.flashOnce();
-    this.continueCurrentAnimation();
-  }
-
-  private reload() {
-    if (this.currentWeapon === PlayerWeapon.KNIFE) {
-      return;
-    }
-
-    this.spine.setAnimation(0, `reload_${this.currentWeapon}`, false);
-
-    // TODO: add reload time for shotgun
-    // this.spine.addAnimation(0, `reload_${this.currentWeapon}`, false);
-
-    this.continueCurrentAnimation();
-  }
-
-  public interactWithObject(item: Phaser.GameObjects.GameObject) {
-    if (this.isAlmostWithinReach(item)) {
-      this.almostTakeItem();
-      this.scene.events.emit(Event.OBJECT_STILL_TOO_FAR, item);
-      return;
-    }
-
-    if (!this.isWithinReach(item)) {
-      this.scene.events.emit(Event.OBJECT_TOO_FAR, item);
-      return;
-    }
-
-    if (item instanceof Flashlight) {
-      this.takeItem(() => {
-        this.scene.physics.world.remove(item.body);
-        this.scene.children.remove(item);
-
-        this.flashlight = item as Flashlight;
-        return item;
-      });
-    } else {
-      this.scene.events.emit(Event.UNKNOWN_OBJECT, item);
-    }
-  }
-
-  private isWithinReach(item: Phaser.GameObjects.GameObject): boolean {
-    const { distance, angle } = this.distanceTo(item);
-    return distance <= config.player.reach && angle <= config.player.reachAngle;
-  }
-
-  private isAlmostWithinReach(item: Phaser.GameObjects.GameObject): boolean {
-    const { distance, angle } = this.distanceTo(item);
-    return (
-      distance > config.player.reach &&
-      distance <= config.player.reachAlmost &&
-      angle <= config.player.reachAngle
-    );
-  }
-
-  private distanceTo(item: Phaser.GameObjects.GameObject): {
-    distance: number;
-    angle: number;
-  } {
-    const itemBody = item.body as Phaser.Physics.Arcade.Body;
-    const distance = Phaser.Math.Distance.Between(
-      this.x,
-      this.y,
-      itemBody.x,
-      itemBody.y
-    );
-
-    const angle = Phaser.Math.Angle.Between(
-      this.x,
-      this.y,
-      itemBody.x,
-      itemBody.y
-    );
-
-    const degreesAbs = Phaser.Math.RadToDeg(Math.abs(angle - this.rotation));
-    return { distance: distance, angle: degreesAbs };
-  }
-
-  private takeItem(fn: Function) {
-    const listener = {
-      complete: (entry) => {
-        this.spine.state.removeListener(listener);
-
-        const item = fn();
-        this.spine.addAnimation(
-          0,
-          `interact_take_${this.currentWeapon}`,
-          false
-        );
-        this.continueCurrentAnimation();
-
-        if (item) {
-          this.scene.events.emit(Event.OBJECT_PICKED_UP, item);
-        }
-      },
-    };
-
-    this.spine.state.addListener(listener);
-
-    this.spine.setAnimation(0, `interact_reach_${this.currentWeapon}`, false);
-  }
-
-  private almostTakeItem() {
-    const listener = {
-      complete: (entry) => {
-        this.spine.state.removeListener(listener);
-        // pause for a while
-        this.scene.time.delayedCall(150, () => {
-          this.continueCurrentAnimation();
-        });
-      },
-    };
-
-    this.spine.state.addListener(listener);
-
-    this.spine.setAnimation(0, `interact_reach_${this.currentWeapon}`, false);
-  }
-
-  public onDarken(): ILightAware {
-    this.removeShadow();
-    this.darkColorMatrix
-      .reset()
-      .brightness(config.colors.darkenColorMatrixBrightness);
-
-    this.casingEmitter.onDarken();
-    this.flashlight?.onDarken();
-    return this;
-  }
-
-  public onLighten(): ILightAware {
-    this.ensureShadow();
-    this.shadow.color = 0x000000;
-    this.darkColorMatrix.reset();
-
-    this.casingEmitter.onLighten();
-    this.flashlight?.onLighten();
-    return this;
-  }
-
-  public onLightOverReset(): ILightAware {
-    if (this.scene.isDark) {
-      this.darkColorMatrix
-        .reset()
-        .brightness(config.colors.darkenColorMatrixBrightness);
-    }
-    return this;
-  }
-
-  public onLightOver(
-    light: Raycaster.Ray,
-    intersections: Phaser.Geom.Point[]
-  ): ILightAware {
-    this.darkColorMatrix.reset();
-
-    return this;
-  }
-
-  public onLighningtOver(progress: number): ILightAware {
-    this.removeShadow();
-
-    if (progress < 1) {
-      this.ensureShadow();
-      this.shadow.color = getTintColorShift(0x000000, progress);
-    }
-
-    this.darkColorMatrix
-      .reset()
-      .brightness(
-        Phaser.Math.Linear(
-          0,
-          config.colors.darkenColorMatrixBrightness,
-          progress
-        )
-      );
-
-    return this;
-  }
-
-  public setLightAwareShape(shape: LightAwareShape): ILightAware {
-    return this;
-  }
-
-  public getLightAwareShape(): LightAwareShape {
-    return this.lightAwareShape;
-  }
-
-  public hasDebugInfo(): boolean {
-    return true;
-  }
-
-  public getDebugInfo() {
-    return {
-      x: this.x,
-      y: this.y,
-      size: { width: this.body.width, height: this.body.height },
-      angle: this.angle,
-      velocity: this.body.velocity,
-
-      // matterSpot: {
-      //   x: this.matterSpot.position.x,
-      //   y: this.matterSpot.position.y,
-      //   velocity: this.matterSpot.velocity,
-      // },
-
-      currentState: this.currentState,
-      currentLegsState: this.currentLegsState,
-      currentWeapon: this.currentWeapon,
-      currentWeaponMode: this.currentWeaponMode[this.currentWeapon],
-      flashlight: this.flashlight?.getDebugInfo(),
-    };
-  }
-
-  public drawDebugPhysics(graphics: Phaser.GameObjects.Graphics) {
-    this.flashlight?.drawDebugPhysics(graphics);
-  }
-
-  private ensureShadow() {
-    if (this.shadowAdded) {
-      return;
-    }
-
-    this.shadowAdded = true;
-    this.postFX.add(this.shadow);
-  }
-
-  private removeShadow() {
-    this.postFX.remove(this.shadow);
-    this.shadowAdded = false;
-  }
-
-  private continueCurrentAnimation() {
-    this.spine.addAnimation(
-      0,
-      `${this.currentState}_${this.currentWeapon}`,
-      true
-    );
-  }
-
-  private updateMatterSpotPosition() {
-    this.matterSpot.angle = this.angle;
-    this.matterSpot.position.x = this.x;
-    this.matterSpot.position.y = this.y;
-  }
-
-  private updateLightAwareShapePosition() {
-    this.lightAwareShape.x = this.x;
-    this.lightAwareShape.y = this.y;
-  }
-
-  private updateCasingEmitterPosition(weapon: PlayerWeapon) {
-    const adjustByWeapon = {
-      [PlayerWeapon.HANDGUN]: { length: 80, angle: 35 },
-      [PlayerWeapon.SHOTGUN]: { length: 70, angle: 30 },
-      [PlayerWeapon.RIFLE]: { length: 60, angle: 35 },
-      [PlayerWeapon.KNIFE]: { length: 0, angle: 0 },
-    };
-
-    const { length, angle } = adjustByWeapon[weapon];
-    this.casingEmitter.setEmitterPosition(
-      this.body.center,
-      length,
-      this.angle + angle
-    );
-
-    this.casingEmitter.setEmitterAngle(this.angle);
-  }
-
-  private updateMuzzleFlashPosition(weapon: PlayerWeapon) {
-    const scaleByWeapon = {
-      [PlayerWeapon.HANDGUN]: { scale: 0.1 },
-      [PlayerWeapon.SHOTGUN]: { scale: 0.15 },
-      [PlayerWeapon.RIFLE]: { scale: 0.13 },
-      [PlayerWeapon.KNIFE]: { scale: 0 },
-    };
-
-    const scale = scaleByWeapon[weapon].scale;
-    const bone = this.getBonePosition("muzzle");
-    this.muzzleFlash.setScale(scale).setPosition(bone.x, bone.y);
-    this.muzzleFlash.setAngle(this.angle);
-  }
-
-  private updateFlashlightPosition(weapon: PlayerWeapon) {
-    const attachedToByWeapon = {
-      [PlayerWeapon.HANDGUN]: {
-        frontBone: "muzzle",
-        rearBone: "weapon",
-        shift: 10,
-      },
-      [PlayerWeapon.SHOTGUN]: {
-        frontBone: "muzzle",
-        rearBone: "weapon",
-        shift: 60,
-      },
-      [PlayerWeapon.RIFLE]: {
-        frontBone: "muzzle",
-        rearBone: "weapon",
-        shift: 60,
-      },
-      [PlayerWeapon.KNIFE]: {
-        frontBone: "head",
-        rearBone: "head",
-        shift: 0,
-      },
-    };
-
-    const attachedTo = attachedToByWeapon[weapon];
-    const frontBone = this.getBonePosition(attachedTo.frontBone);
-    const rearBone = this.getBonePosition(attachedTo.rearBone);
-
-    const flashlightOffset = new Phaser.Math.Vector2(
-      frontBone.x - rearBone.x,
-      frontBone.y - rearBone.y
-    ).setLength(attachedTo.shift);
-
-    const weaponAngle =
-      attachedTo.frontBone === attachedTo.rearBone
-        ? this.rotation
-        : Phaser.Math.Angle.Between(
-            rearBone.x,
-            rearBone.y,
-            frontBone.x,
-            frontBone.y
-          );
-
-    this.flashlight
-      ?.setPosition(
-        flashlightOffset.x + rearBone.x,
-        flashlightOffset.y + rearBone.y
-      )
-      .setAngle(Phaser.Math.RadToDeg(weaponAngle));
-  }
-
-  private getBonePosition(boneName: string) {
-    const bone = this.spine.skeleton.findBone(boneName);
-    const boneInnerPosition = new Phaser.Math.Vector2(
-      bone.worldX + this.x - this.spine.skeleton.x,
-      bone.worldY + this.y - this.spine.skeleton.y
-    );
-
-    const distance = Phaser.Math.Distance.Between(
-      this.body.center.x,
-      this.body.center.y,
-      boneInnerPosition.x,
-      boneInnerPosition.y
-    );
-
-    const angle = Phaser.Math.Angle.Between(
-      this.body.center.x,
-      this.body.center.y,
-      boneInnerPosition.x,
-      boneInnerPosition.y
-    );
-
-    const bonePosition = new Phaser.Math.Vector2(
-      this.body.center.x,
-      this.body.center.y
-    )
-      .setLength(distance)
-      .setAngle(-angle)
-      .add(this.body.center);
-
-    return bonePosition;
-  }
-
-  private getCasingName(weapon: PlayerWeapon) {
-    // names are based on the spritesheet "bullet-casings"
-    return {
-      [PlayerWeapon.HANDGUN]: "8mm-bullet-case",
-      [PlayerWeapon.SHOTGUN]: "12gauge-bullet-case",
-      [PlayerWeapon.RIFLE]: "ar-bullet-case",
-    }[weapon];
-  }
-}
diff --git a/src/objects/Pointer.ts b/src/objects/Pointer.ts
deleted file mode 100644
index da56e07..0000000
--- a/src/objects/Pointer.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import config from "../GameConfig";
-import { IPointable, isPointable } from "../types/Pointable";
-import Player from "./Player";
-
-export default class Pointer extends Phaser.GameObjects.GameObject {
-  private dot: Phaser.GameObjects.Arc;
-  private currentlyHighlighted: IPointable | null = null;
-
-  public get x(): number {
-    return this.dot.x;
-  }
-
-  public set x(value: number) {
-    this.dot.x = value;
-  }
-
-  public get y(): number {
-    return this.dot.y;
-  }
-
-  public set y(value: number) {
-    this.dot.y = value;
-  }
-
-  constructor(scene: Phaser.Scene, x: number, y: number) {
-    super(scene, "pointer");
-
-    this.dot = scene.add.circle(x, y, 5, 0xffffff, 0.5);
-
-    this.scene.add.existing(this.dot);
-    this.scene.physics.world.enable(this.dot);
-
-    this.dot.setDepth(config.depths.pointer);
-  }
-
-  public update(player: Player) {
-    this.dot.body.velocity.x = player.body.velocity.x;
-    this.dot.body.velocity.y = player.body.velocity.y;
-
-    const withinWorldBounds = this.scene.physics.world.bounds.contains(
-      this.dot.x,
-      this.dot.y
-    );
-
-    this.dot.fillColor = withinWorldBounds ? 0xffffff : 0xff0000;
-
-    const body = this.scene.physics.overlapRect(
-      this.dot.x,
-      this.dot.y,
-      1,
-      1
-    )[0];
-
-    const gameObject = body?.gameObject;
-    const pointableGameObject = isPointable(gameObject);
-
-    if (pointableGameObject && gameObject != this.currentlyHighlighted) {
-      // console.log("highlighting", gameObject);
-
-      this.dot.visible = false;
-      this.currentlyHighlighted?.removeHighlight().removeInfo();
-      gameObject.showHighlight().showInfo();
-
-      this.currentlyHighlighted = gameObject;
-    } else if (!pointableGameObject && this.currentlyHighlighted) {
-      // console.log("removing highlight", this.currentlyHighlighted);
-
-      this.currentlyHighlighted.removeHighlight().removeInfo();
-      this.currentlyHighlighted = null;
-      this.dot.visible = true;
-    }
-  }
-}
diff --git a/src/objects/StaticMatterProjection.ts b/src/objects/StaticMatterProjection.ts
deleted file mode 100644
index 1c843a8..0000000
--- a/src/objects/StaticMatterProjection.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import { StaticMatterThing } from "./StaticMatterThing";
-import { IProjection } from "../types/Projection";
-
-// TODO: refactor this for better performance. right now it creates a lot of objects
-
-export class StaticMatterProjectionCircle
-  extends Phaser.Physics.Arcade.StaticGroup
-  implements IProjection
-{
-  private coordinates: Phaser.Types.Math.Vector2Like[];
-
-  constructor(
-    scene: Phaser.Scene,
-    matterObject: StaticMatterThing,
-    radius: number,
-    minDotsDistance: number = 20
-  ) {
-    super(scene.physics.world, scene);
-
-    this.coordinates = this.normalizeCircleShape(
-      matterObject.getCenter(),
-      radius,
-      minDotsDistance
-    );
-
-    this.coordinates.forEach((coordinate) => {
-      const dot: Phaser.Physics.Arcade.Sprite = this.create(
-        coordinate.x,
-        coordinate.y,
-        "green-dot"
-      );
-      dot.setScale(0.2).setCircle(1).refreshBody();
-    });
-
-    this.setVisible(false);
-  }
-
-  public shift(diff: Phaser.Types.Math.Vector2Like): IProjection {
-    this.getChildren().forEach((child) => {
-      const dot = child as Phaser.Physics.Arcade.Sprite;
-      dot.setPosition(dot.x + diff.x, dot.y + diff.y).refreshBody();
-    });
-
-    this.refresh();
-    return this;
-  }
-
-  private normalizeCircleShape(
-    center: Phaser.Types.Math.Vector2Like,
-    radius: number,
-    minDotsDistance: number
-  ): Phaser.Types.Math.Vector2Like[] {
-    const coordinates: Phaser.Types.Math.Vector2Like[] = [];
-
-    const circumference = 2 * Math.PI * radius;
-    const dotsCount = Math.floor(circumference / minDotsDistance);
-
-    for (let i = 0; i < dotsCount; i++) {
-      const angle = (i / dotsCount) * 2 * Math.PI;
-      const x = center.x + radius * Math.cos(angle);
-      const y = center.y + radius * Math.sin(angle);
-      coordinates.push({ x, y });
-    }
-
-    return coordinates;
-  }
-}
-
-export class StaticMatterProjectionRectangle
-  extends Phaser.Physics.Arcade.StaticGroup
-  implements IProjection
-{
-  private coordinates: Phaser.Types.Math.Vector2Like[];
-
-  constructor(
-    scene: Phaser.Scene,
-    matterObject: StaticMatterThing,
-    minDotsDistance: number = 20
-  ) {
-    super(scene.physics.world, scene);
-
-    this.coordinates = this.normalizeRectShape(
-      [
-        matterObject.getTopLeft(),
-        matterObject.getTopRight(),
-        matterObject.getBottomRight(),
-        matterObject.getBottomLeft(),
-      ],
-      minDotsDistance
-    );
-
-    this.coordinates.forEach((coordinate) => {
-      const dot: Phaser.Physics.Arcade.Sprite = this.create(
-        coordinate.x,
-        coordinate.y,
-        "green-dot"
-      );
-      dot.setScale(0.2).setCircle(1).refreshBody();
-    });
-
-    this.setVisible(false);
-  }
-
-  public shift(diff: Phaser.Types.Math.Vector2Like): IProjection {
-    this.getChildren().forEach((child) => {
-      const dot = child as Phaser.Physics.Arcade.Sprite;
-      dot.setPosition(dot.x + diff.x, dot.y + diff.y).refreshBody();
-    });
-
-    this.refresh();
-    return this;
-  }
-
-  private normalizeRectShape(
-    vertices: Phaser.Types.Math.Vector2Like[],
-    minDistance: number
-  ): Phaser.Types.Math.Vector2Like[] {
-    const normalizedVertices: Phaser.Types.Math.Vector2Like[] = [];
-
-    vertices.forEach((vertex, i) => {
-      normalizedVertices.push(vertex);
-      const nextVertex = vertices[i + 1] || vertices[0];
-      const distance = Phaser.Math.Distance.BetweenPoints(vertex, nextVertex);
-      if (distance > minDistance) {
-        const additionalVertices = Math.floor(distance / minDistance);
-        for (let i = 1; i < additionalVertices; i++) {
-          normalizedVertices.push({
-            x: Phaser.Math.Linear(
-              vertex.x,
-              nextVertex.x,
-              i / additionalVertices
-            ),
-            y: Phaser.Math.Linear(
-              vertex.y,
-              nextVertex.y,
-              i / additionalVertices
-            ),
-          });
-        }
-      }
-    });
-
-    return normalizedVertices;
-  }
-}
diff --git a/src/objects/StaticMatterThing.ts b/src/objects/StaticMatterThing.ts
deleted file mode 100644
index 9c82772..0000000
--- a/src/objects/StaticMatterThing.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import config from "../GameConfig";
-
-export class StaticMatterThing extends Phaser.Physics.Matter.Image {
-  private topImage: Phaser.GameObjects.Image;
-
-  constructor(scene: Phaser.Scene, x: number, y: number, texture: string) {
-    super(scene.matter.world, x, y, texture);
-    scene.add.existing(this);
-
-    this.setName(`static-matter:${texture}`);
-
-    this.setStatic(true);
-
-    this.setFrictionAir(0.9);
-    this.setDensity(0.999);
-    this.setMass(0.999);
-
-    this.setDepth(config.depths.matterThingBottom);
-  }
-
-  public setTint(
-    topLeft?: number,
-    topRight?: number,
-    bottomLeft?: number,
-    bottomRight?: number
-  ): this {
-    super.setTint(topLeft, topRight, bottomLeft, bottomRight);
-
-    this.topImage?.setTint(topLeft, topRight, bottomLeft, bottomRight);
-
-    return this;
-  }
-
-  public createRectangle(
-    widthDelta: number = 0,
-    heightDelta: number = 0
-  ): Phaser.GameObjects.Rectangle {
-    return this.scene.add
-      .rectangle(
-        this.x,
-        this.y,
-        this.width - widthDelta,
-        this.height - heightDelta
-      )
-      .setAngle(this.angle)
-      .setOrigin(this.originX, this.originY)
-      .setScale(this.scaleX, this.scaleY);
-  }
-
-  public createCircle(radius: number): Phaser.GameObjects.Arc {
-    const center = this.getCenter();
-
-    // // a copy of the texture is needed because of the glitch with the raycaster and circles
-    // this.topImage = this.scene.add
-    //   .image(center.x, center.y, this.texture.key)
-    //   .setAngle(this.angle)
-    //   .setOrigin(this.originX, this.originY)
-    //   .setScale(this.scaleX, this.scaleY)
-    //   .setDepth(config.depths.matterThingTop);
-
-    return this.scene.add.circle(center.x, center.y, radius);
-  }
-
-  public createPolygon(
-    vertices: Phaser.Types.Math.Vector2Like[]
-  ): Phaser.GameObjects.Polygon {
-    return this.scene.add
-      .polygon(this.x, this.y, vertices)
-      .setAngle(this.angle)
-      .setOrigin(this.originX, this.originY)
-      .setScale(this.scaleX, this.scaleY);
-  }
-}
diff --git a/src/objects/Weather.ts b/src/objects/Weather.ts
deleted file mode 100644
index 46b8411..0000000
--- a/src/objects/Weather.ts
+++ /dev/null
@@ -1,215 +0,0 @@
-import config from "../GameConfig";
-import GameScene from "../scenes/GameScene";
-import Player from "./Player";
-
-export interface IWeather {
-  isOn: boolean;
-
-  start: () => void;
-  stop: () => void;
-}
-
-export class WeatherConditions {
-  private rain: Rain;
-  private snow: Snow;
-
-  constructor(scene: GameScene, player: Player) {
-    this.rain = new Rain(scene, player);
-    this.snow = new Snow(scene);
-  }
-
-  toggle() {
-    if (this.rain.isOn) {
-      this.rain.stop();
-      this.snow.start();
-    } else if (this.snow.isOn) {
-      this.snow.stop();
-    } else {
-      this.rain.start();
-    }
-  }
-
-  getDebugInfo() {
-    if (this.rain.isOn) {
-      return "rain";
-    }
-
-    if (this.snow.isOn) {
-      return "snow";
-    }
-
-    return "clear";
-  }
-}
-
-export class Snow implements IWeather {
-  private snow: Phaser.GameObjects.Particles.ParticleEmitter;
-
-  public isOn: boolean;
-
-  constructor(private scene: GameScene) {
-    const { width, height } = scene.physics.world.bounds;
-
-    this.snow = scene.add
-      .particles(0, 0, "rain-splash", {
-        x: -100,
-        y: -100,
-        speed: (particle) => {
-          if (particle.lifeCurrent < Math.random() * 500) {
-            return 0;
-          }
-
-          return Math.random() * 100 + 50;
-        },
-        lifespan: 10000 - Math.random() * 3000,
-        quantity: 10,
-        angle: 30,
-        alpha: { start: 1, end: 0.2 },
-        scale: { start: 0.2, end: 0 },
-        tint: {
-          onEmit: () => this.getSnowColor(),
-          onUpdate: () => this.getSnowColor(),
-        },
-      })
-      .setDepth(config.depths.ceiling);
-
-    this.snow.addEmitZone({
-      source: new Phaser.Geom.Rectangle(0, 0, width, height),
-    });
-
-    this.snow.stop();
-  }
-
-  start() {
-    this.isOn = true;
-    this.snow.start();
-  }
-
-  stop() {
-    this.isOn = false;
-    this.snow.stop();
-  }
-
-  private getSnowColor() {
-    return this.scene.isDark ? 0x555555 : 0xffffff;
-  }
-}
-
-export class Rain implements IWeather {
-  private rainSplashParticles: Phaser.GameObjects.Particles.ParticleEmitter;
-  private rainDrops: Phaser.GameObjects.Particles.ParticleEmitter;
-  private lightning: Phaser.Time.TimerEvent;
-
-  public isOn: boolean;
-
-  constructor(private scene: GameScene, private player: Player) {
-    const { width, height } = scene.physics.world.bounds;
-
-    this.rainSplashParticles = scene.add
-      .particles(0, 0, "rain-splash", {
-        x: 0,
-        y: 0,
-        speed: 0,
-        lifespan: 700,
-        quantity: 10,
-        alpha: { start: 0.3, end: 0 },
-        scale: { start: 0.2, end: 0.5 },
-        tint: {
-          onUpdate: () => {
-            return scene.isDark ? 0x000000 : 0x111111;
-          },
-        },
-      })
-      .setDepth(config.depths.matterThingBottom);
-
-    this.rainSplashParticles.addEmitZone({
-      source: new Phaser.Geom.Rectangle(0, 0, width, height),
-    });
-
-    this.rainSplashParticles.stop();
-
-    const rainDropSpeed = 700;
-    this.rainDrops = scene.add
-      .particles(0, 0, "rain-splash", {
-        x: 0,
-        y: 0,
-        angle: (particle) => {
-          const playerSpot = this.player.body.center;
-
-          const angle = Phaser.Math.Angle.Between(
-            particle.x,
-            particle.y,
-            playerSpot.x,
-            playerSpot.y
-          );
-
-          return Phaser.Math.RadToDeg(angle);
-        },
-
-        speed: (particle) => {
-          const playerSpot = this.player.body.center;
-
-          const distance = Phaser.Math.Distance.Between(
-            playerSpot.x,
-            playerSpot.y,
-            particle.x,
-            particle.y
-          );
-
-          return distance > 500
-            ? rainDropSpeed
-            : rainDropSpeed * (distance / 500);
-        },
-        lifespan: 300,
-        quantity: 10,
-        alpha: { start: 0.8, end: 0.2 },
-        scale: { start: 0.2, end: 0 },
-        tint: {
-          onUpdate: () => {
-            return scene.isDark ? 0x000000 : 0x4c4c4c;
-          },
-        },
-      })
-      .setDepth(config.depths.ceiling);
-
-    this.rainDrops.addEmitZone({
-      source: new Phaser.Geom.Rectangle(0, 0, width, height),
-    });
-
-    this.rainDrops.stop();
-  }
-
-  start() {
-    this.isOn = true;
-    this.rainSplashParticles.start();
-    this.rainDrops.start();
-
-    this.lightning = this.scene.time.addEvent({
-      delay: 100,
-      loop: true,
-      callback: () => {
-        if (Math.random() > 0.98) {
-          const flashTime = Math.random() * 800;
-          this.scene.cameras.main.flash(
-            flashTime,
-            0xf0,
-            0xf0,
-            0xf0,
-            false,
-            (_, progress: number) => {
-              this.scene.reactToLightning(progress);
-            }
-          );
-        }
-      },
-    });
-  }
-
-  stop() {
-    this.isOn = false;
-    this.rainSplashParticles.stop();
-    this.rainDrops.stop();
-
-    this.lightning?.destroy();
-  }
-}
diff --git a/src/objects/barrel.object.ts b/src/objects/barrel.object.ts
new file mode 100644
index 0000000..f3644f7
--- /dev/null
+++ b/src/objects/barrel.object.ts
@@ -0,0 +1,43 @@
+import config from '../game-config'
+import { lightAwareMixin, LightAware } from '../mixins/light-aware.mixin'
+
+function barrelMixin<T extends Phaser.Physics.Matter.Image & LightAware>(
+  obj: T,
+  scene: Phaser.Scene,
+) {
+  return obj.merge({
+    createRectangle(widthDelta = 0, heightDelta = 0) {
+      return scene.add
+        .rectangle(obj.x, obj.y, obj.width - widthDelta, obj.height - heightDelta)
+        .setAngle(obj.angle)
+        .setOrigin(obj.originX, obj.originY)
+        .setScale(obj.scaleX, obj.scaleY)
+    },
+    createCircle(radius: number) {
+      const center = obj.getCenter()
+      return scene.add.circle(center.x, center.y, radius)
+    },
+    createPolygon(vertices: Phaser.Types.Math.Vector2Like[]) {
+      return scene.add
+        .polygon(obj.x, obj.y, vertices)
+        .setAngle(obj.angle)
+        .setOrigin(obj.originX, obj.originY)
+        .setScale(obj.scaleX, obj.scaleY)
+    },
+  })
+}
+
+export function createBarrel(scene: Phaser.Scene, x: number, y: number, texture: string) {
+  const gameScene = scene as Phaser.Scene & { matter: Phaser.Physics.Matter.MatterPhysics }
+  const image = gameScene.matter.add.image(x, y, texture, undefined, { isStatic: true })
+
+  image.setName(`barrel:${texture}`)
+  image.setFrictionAir(0.9)
+  image.setDensity(0.999)
+  image.setMass(0.999)
+  image.setDepth(config.depths.matterThingBottom)
+
+  return image.mixin(lightAwareMixin).mixin(barrelMixin, scene)
+}
+
+export type BarrelObject = ReturnType<typeof createBarrel>
diff --git a/src/objects/casing-emitter.object.ts b/src/objects/casing-emitter.object.ts
new file mode 100644
index 0000000..5cd35c3
--- /dev/null
+++ b/src/objects/casing-emitter.object.ts
@@ -0,0 +1,134 @@
+import { GameSceneInterface } from '../types/game-scene'
+
+export interface CasingEmitterLightCallbacks {
+  onLighten(): void
+  onDarken(): void
+}
+
+export class CasingEmitter
+  extends Phaser.GameObjects.Container
+  implements CasingEmitterLightCallbacks
+{
+  private emitter: Phaser.GameObjects.Particles.ParticleEmitter
+  private emitterAngle: number
+  private emitterOfffset: { x: number; y: number }
+  private isDark: boolean
+  private debug: Phaser.GameObjects.Rectangle
+
+  constructor(
+    scene: GameSceneInterface,
+    x: number,
+    y: number,
+    casingsTexture: string,
+    casingsScale: { from: number; to: number },
+  ) {
+    super(scene, x, y)
+
+    const textures = this.scene.textures.get(casingsTexture)
+    this.emitter = this.scene.add.particles(0, 0, textures, {
+      angle: (): number => {
+        return this.emitterAngle + 90 + Phaser.Math.Between(-15, 15)
+      },
+      rotate: (): number => {
+        return this.emitterAngle + 90 + Phaser.Math.Between(-25, 25)
+      },
+      maxVelocityX: {
+        onEmit: (): number => {
+          return Phaser.Math.Between(220, 245)
+        },
+        onUpdate: (particle: Phaser.GameObjects.Particles.Particle): number => {
+          if (particle.lifeT > 0.5) {
+            return 0
+          } else if (particle.lifeT > 0.3) {
+            return Phaser.Math.Between(5, 10)
+          } else if (particle.lifeT > 0.1) {
+            return 10
+          }
+
+          return particle.maxVelocityX
+        },
+      },
+      maxVelocityY: {
+        onUpdate: (particle: Phaser.GameObjects.Particles.Particle): number => {
+          if (particle.lifeT > 0.5) {
+            return 0
+          } else if (particle.lifeT > 0.3) {
+            return Phaser.Math.Between(5, 10)
+          } else if (particle.lifeT > 0.1) {
+            return 10
+          }
+
+          return Phaser.Math.Between(220, 245)
+        },
+      },
+      lifespan: { min: 900, max: 2000 },
+      speed: { min: 20, max: 245 },
+      scale: {
+        onEmit: () => {
+          return casingsScale.from
+        },
+        onUpdate: (particle: Phaser.GameObjects.Particles.Particle): number => {
+          if (particle.lifeT < 0.08) {
+            return particle.scaleX
+          }
+
+          return casingsScale.to
+        },
+      },
+      emitting: false,
+      stopAfter: 1,
+    })
+
+    this.emitter.onParticleEmit((particle: Phaser.GameObjects.Particles.Particle) => {
+      particle.setPosition(this.emitterOfffset.x, this.emitterOfffset.y)
+      if (this.isDark) {
+        particle.tint = 0x000000
+      }
+    })
+
+    this.scene.physics.world.enable(
+      (this.debug = scene.add
+        .rectangle(0, 0, 10, 20, 0xff00ff, 0.5)
+        .setOrigin(0.5, 0.5)
+        .setVisible(this.scene.physics.world.drawDebug)),
+    )
+
+    this.scene.add.existing(this.emitter)
+  }
+
+  public setEmitterPosition(center: { x: number; y: number }, length: number, angle: number) {
+    const offset = new Phaser.Math.Vector2(center)
+    offset.setLength(length).setAngle(Phaser.Math.DegToRad(angle))
+
+    this.emitterOfffset = { x: center.x + offset.x, y: center.y + offset.y }
+    this.debug
+      .setPosition(this.emitterOfffset.x, this.emitterOfffset.y)
+      .setVisible(this.scene.physics.world.drawDebug)
+  }
+
+  public setEmitterAngle(angle: number) {
+    this.emitterAngle = angle
+    this.debug.setAngle(angle).setVisible(this.scene.physics.world.drawDebug)
+  }
+
+  public onLighten(): void {
+    this.isDark = false
+    this.updateTintForAllAlive(0xffffff)
+  }
+
+  public onDarken(): void {
+    this.isDark = true
+    this.updateTintForAllAlive(0x000000)
+  }
+
+  public emitOne(casingName: string) {
+    this.emitter.setEmitterFrame(casingName)
+    this.emitter.start()
+  }
+
+  private updateTintForAllAlive(tint: number) {
+    this.emitter.forEachAlive((particle: Phaser.GameObjects.Particles.Particle) => {
+      particle.tint = tint
+    }, this.emitter)
+  }
+}
diff --git a/src/objects/emergency-light.object.ts b/src/objects/emergency-light.object.ts
new file mode 100644
index 0000000..b2543fa
--- /dev/null
+++ b/src/objects/emergency-light.object.ts
@@ -0,0 +1,96 @@
+import config from '../game-config'
+import { lightSourceMixin, LightSource } from '../mixins/light-source.mixin'
+import { debuggableMixin, Debuggable } from '../mixins/debuggable.mixin'
+import { LightAwareShape } from '../mixins/light-aware.mixin'
+import { GameSceneInterface } from '../types/game-scene'
+import { MIXIN_LIGHT_AWARE } from '../core/instances'
+
+function emergencyLightMixin<T extends Phaser.Physics.Arcade.Sprite & LightSource & Debuggable>(
+  obj: T,
+) {
+  obj.getDebugInfo = function () {
+    return {
+      name: obj.name,
+      x: obj.x,
+      y: obj.y,
+      angle: obj.angle,
+      isOn: obj.isLightEnabled,
+    }
+  }
+
+  obj.drawDebugPhysics = function (graphics: Phaser.GameObjects.Graphics) {
+    if (!obj.lightRay) return
+    graphics.fillStyle(0xff0000, 0.5)
+    obj.lightRay.intersections.forEach((intersection: Phaser.Geom.Point) => {
+      graphics.fillCircle(intersection.x, intersection.y, 3)
+    })
+  }
+
+  return obj.merge({
+    get isOn() {
+      return obj.isLightEnabled
+    },
+    turnOn() {
+      obj.setTint()
+      obj.enableLight()
+      obj.setLightOrigin(obj.x, obj.y)
+      obj.setLightAngleDeg(obj.angle - 90)
+      obj.lightRay?.setConeDeg(config.emergencyAlarmLight.coneDeg)
+      obj.lightRay?.setRayRange(config.emergencyAlarmLight.coneRange)
+    },
+    turnOff() {
+      const gameScene = obj.scene as GameSceneInterface | undefined
+      obj.setTint(gameScene?.isDark ? 0x111111 : 0x505050)
+      obj.disableLight()
+    },
+    onLighten() {
+      if (!obj.isLightEnabled) {
+        obj.setTint(0x505050)
+      }
+    },
+    onDarken() {
+      if (!obj.isLightEnabled) {
+        obj.setTint(0x111111)
+      }
+    },
+    onLightOverReset() {},
+    onLightOver() {},
+    onLightningOver() {},
+    onLighningtOver() {},
+    setLightAwareShape() {},
+    getLightAwareShape(): LightAwareShape {
+      return null
+    },
+    lightShape: null as LightAwareShape,
+  })
+}
+
+export function createEmergencyLight(
+  scene: Phaser.Scene,
+  x: number,
+  y: number,
+  raycaster: Raycaster,
+) {
+  const gameScene = scene as Phaser.Scene & { physics: Phaser.Physics.Arcade.ArcadePhysics }
+  const sprite = gameScene.physics.add.sprite(x, y, 'wall-lamp') as Phaser.Physics.Arcade.Sprite
+
+  sprite.setName('emergency-alarm-light')
+  sprite.setOrigin(0.5, 0.5)
+  sprite.setDisplaySize(60, 20)
+  sprite.setDepth(config.depths.ceiling)
+
+  const result = sprite
+    .mixin(lightSourceMixin, { raycaster, config: config.emergencyAlarmLight })
+    .mixin(debuggableMixin)
+    .mixin(emergencyLightMixin)
+
+  result.lightGraphics.setDepth(config.depths.light)
+  result.track(MIXIN_LIGHT_AWARE)
+
+  const isDark = (scene as GameSceneInterface | undefined)?.isDark ?? false
+  result.setTint(isDark ? 0x111111 : 0x505050)
+
+  return result
+}
+
+export type EmergencyLightObject = ReturnType<typeof createEmergencyLight>
diff --git a/src/objects/flashlight.object.ts b/src/objects/flashlight.object.ts
new file mode 100644
index 0000000..85ab8ea
--- /dev/null
+++ b/src/objects/flashlight.object.ts
@@ -0,0 +1,92 @@
+import config from '../game-config'
+import { lightSourceMixin, LightSource } from '../mixins/light-source.mixin'
+import { pointableMixin } from '../mixins/pointable.mixin'
+import { interactableMixin } from '../mixins/interactable.mixin'
+import { debuggableMixin, Debuggable } from '../mixins/debuggable.mixin'
+
+function flashlightMixin<T extends Phaser.GameObjects.Sprite & LightSource & Debuggable>(obj: T) {
+  let glitchy = false
+
+  const originalSetPosition = obj.setPosition.bind(obj)
+  const originalSetAngle = obj.setAngle.bind(obj)
+
+  obj.setPosition = function (x: number, y: number) {
+    originalSetPosition(x, y)
+    obj.setLightOrigin(x, y)
+    return this
+  }
+
+  obj.setAngle = function (angle: number) {
+    originalSetAngle(angle)
+    obj.setLightAngleDeg(obj.angle)
+    return this
+  }
+
+  obj.getDebugInfo = function () {
+    return {
+      name: obj.name,
+      x: obj.x,
+      y: obj.y,
+      isOn: obj.isLightEnabled,
+      rotation: obj.rotation,
+      glitchy: glitchy,
+    }
+  }
+
+  obj.drawDebugPhysics = function (graphics: Phaser.GameObjects.Graphics) {
+    if (!obj.lightRay) return
+    graphics.fillStyle(0xff0000, 0.5)
+    obj.lightRay.intersections.forEach((intersection: Phaser.Geom.Point) => {
+      graphics.fillCircle(intersection.x, intersection.y, 3)
+    })
+  }
+
+  return obj.merge({
+    get isOn() {
+      return obj.isLightEnabled
+    },
+    get isOff() {
+      return !obj.isLightEnabled
+    },
+    get isGlitchy() {
+      return glitchy
+    },
+    turnOn() {
+      obj.enableLight()
+      obj.setLightOrigin(obj.x, obj.y)
+      obj.setLightAngleDeg(obj.angle)
+      obj.lightRay?.setConeDeg(config.flashlight.coneDeg)
+      obj.lightRay?.setRayRange(config.flashlight.coneRange)
+    },
+    turnOff() {
+      obj.disableLight()
+    },
+    setGlitchy(value: boolean) {
+      glitchy = value
+      return obj
+    },
+  })
+}
+
+export function createFlashlight(scene: Phaser.Scene, x: number, y: number, raycaster: Raycaster) {
+  const gameScene = scene as Phaser.Scene & { physics: Phaser.Physics.Arcade.ArcadePhysics }
+  const sprite = gameScene.physics.add.sprite(x, y, 'flashlight') as Phaser.Physics.Arcade.Sprite
+
+  sprite.setName('flashlight')
+  sprite.setOrigin(0.5, 0.5)
+  sprite.setDisplaySize(50, 30)
+  sprite.setDepth(config.depths.matterThingTop + 1)
+
+  const result = sprite
+    .mixin(lightSourceMixin, { raycaster, config: config.flashlight })
+    .mixin(pointableMixin, { info: 'Flashlight' })
+    .mixin(interactableMixin, { range: 150 })
+    .mixin(debuggableMixin)
+    .mixin(flashlightMixin)
+
+  result.lightGraphics.setDepth(config.depths.light)
+
+  return result
+}
+
+export type FlashlightObject = ReturnType<typeof createFlashlight>
diff --git a/src/objects/label.object.ts b/src/objects/label.object.ts
new file mode 100644
index 0000000..20d7f88
--- /dev/null
+++ b/src/objects/label.object.ts
@@ -0,0 +1,63 @@
+export class Label extends Phaser.GameObjects.Container {
+  private text: Phaser.GameObjects.Text
+  private background: Phaser.GameObjects.Rectangle
+
+  DEFAULT_BACKGROUND_COLOR: string = '#000000'
+  DEFAULT_BACKGROUND_ALPHA: number = 0.5
+  DEFAULT_TEXT_COLOR: string = '#ffffff'
+  DEFAULT_STROKE_COLOR: string = '#aaaaaa'
+  DEFAULT_STROKE_THICKNESS: number = 0.5
+
+  constructor(scene: Phaser.Scene, x: number, y: number, text: string) {
+    super(scene, x, y)
+
+    this.text = this.scene.add.text(x, y, text, {
+      fontFamily: 'monospace',
+      fontSize: '14px',
+      padding: {
+        left: 5,
+        right: 5,
+        top: 5,
+        bottom: 5,
+      },
+    })
+
+    this.background = scene.add.rectangle(0, 0, this.text.width, this.text.height).setOrigin(0, 0)
+
+    this.add([this.background, this.text])
+
+    this.setBackgroundColor(
+      this.DEFAULT_BACKGROUND_COLOR,
+      this.DEFAULT_BACKGROUND_ALPHA,
+    ).setTextColor(this.DEFAULT_TEXT_COLOR)
+    this.resize()
+  }
+
+  public setText(text: string): Label {
+    this.text.setText(text)
+    this.resize()
+    return this
+  }
+
+  public setBackgroundColor(color: string, alpha: number = 0.5): Label {
+    const colorHex = Phaser.Display.Color.HexStringToColor(color).color
+    this.background.setFillStyle(colorHex, alpha)
+    return this
+  }
+
+  public setTextColor(
+    color: string,
+    strokeColor: string = this.DEFAULT_STROKE_COLOR,
+    strokeThickness: number = this.DEFAULT_STROKE_THICKNESS,
+  ): Label {
+    this.text.setFill(color).setStroke(strokeColor, strokeThickness)
+    return this
+  }
+
+  private resize() {
+    this.text.setPosition(0, 0)
+    this.background.setPosition(0, 0)
+    this.width = this.text.width
+    this.height = this.text.height
+  }
+}
diff --git a/src/objects/muzzle-flash.object.ts b/src/objects/muzzle-flash.object.ts
new file mode 100644
index 0000000..e8838ca
--- /dev/null
+++ b/src/objects/muzzle-flash.object.ts
@@ -0,0 +1,40 @@
+import config from '../game-config'
+import { lightSourceMixin, LightSource } from '../mixins/light-source.mixin'
+
+function muzzleFlashMixin<T extends Phaser.Physics.Arcade.Sprite & LightSource>(obj: T) {
+  return obj.merge({
+    flashOnce() {
+      obj.setVisible(true)
+      obj.enableLight()
+      obj.setLightOrigin(obj.x, obj.y)
+      obj.setLightAngleDeg(obj.angle)
+      obj.lightRay?.setConeDeg(config.weapon.muzzle.light.coneDeg)
+      obj.lightRay?.setRayRange(config.weapon.muzzle.light.coneRange)
+
+      obj.scene.time.delayedCall(config.weapon.muzzle.duration, () => {
+        obj.setVisible(false)
+        obj.disableLight()
+      })
+    },
+  })
+}
+
+export function createMuzzleFlash(scene: Phaser.Scene, x: number, y: number, raycaster: Raycaster) {
+  const gameScene = scene as Phaser.Scene & { physics: Phaser.Physics.Arcade.ArcadePhysics }
+  const sprite = gameScene.physics.add.sprite(x, y, 'muzzle-flash') as Phaser.Physics.Arcade.Sprite
+
+  sprite.setName('muzzle-flash')
+  sprite.setOrigin(0.1, 0.5)
+  sprite.setScale(0.15)
+  sprite.setVisible(false)
+
+  const result = sprite
+    .mixin(lightSourceMixin, { raycaster, config: config.weapon.muzzle.light })
+    .mixin(muzzleFlashMixin)
+
+  result.lightGraphics.setDepth(config.depths.light)
+
+  return result
+}
+
+export type MuzzleFlashObject = ReturnType<typeof createMuzzleFlash>
diff --git a/src/objects/player.object.ts b/src/objects/player.object.ts
new file mode 100644
index 0000000..13acfee
--- /dev/null
+++ b/src/objects/player.object.ts
@@ -0,0 +1,630 @@
+import config from '../game-config'
+import { input } from '../core/globals'
+import { Event } from '../scenes/event'
+import { CasingEmitter } from './casing-emitter.object'
+import { createMuzzleFlash } from './muzzle-flash.object'
+import PlayerPuppet, { PlayerWeapon } from './player.puppet'
+import { LightAware, getTintColorShift, LightAwareShape } from '../mixins/light-aware.mixin'
+import { Debuggable } from '../mixins/debuggable.mixin'
+import { FlashlightObject } from './flashlight.object'
+import { GameSceneInterface } from '../types/game-scene'
+import { createSpineListener } from '../types/spine-listener'
+
+enum PlayerWeaponMode {
+  NONE = 'none',
+  SINGLE = 'single',
+  BURST = 'burst',
+  AUTO = 'auto',
+}
+
+export interface PlayerObject extends LightAware, Debuggable {
+  name: string
+  puppet: PlayerPuppet
+  body: Phaser.Physics.Arcade.Body
+  x: number
+  y: number
+  rotation: number
+  angle: number
+  flashlight: FlashlightObject | null
+
+  preUpdate(): void
+  postUpdate(): void
+  attack(): void
+  reload(): void
+  selectWeapon(weapon: PlayerWeapon): void
+  interactWithObject(item: Phaser.GameObjects.GameObject): void
+}
+
+export function createPlayer(
+  scene: Phaser.Scene,
+  x: number,
+  y: number,
+  raycaster: Raycaster,
+): PlayerObject {
+  const gameScene = scene as GameSceneInterface
+
+  const puppet = new PlayerPuppet(scene, x, y)
+  puppet.name = 'player'
+
+  gameScene.physics.world.enable(puppet)
+  const body = puppet.body as Phaser.Physics.Arcade.Body
+  body.setDrag(1, 1)
+
+  const bounds = puppet.spine.getBounds()
+  body
+    .setOffset(-bounds.size.x / 3, -bounds.size.y / 3 - 15)
+    .setCircle(bounds.size.x / 3)
+    .setCollideWorldBounds(true)
+
+  const matterSpot = gameScene.matter.add.circle(x, y, 50, {
+    isSensor: true,
+    label: 'player-spot',
+  })
+
+  const lightAwareShape: LightAwareShape = scene.add.circle(x, y, 50)
+  if (lightAwareShape) lightAwareShape.owner = undefined
+
+  const shadow = puppet.postFX.addShadow(0, 0, 0.1, 0.3, 0x000000, 2, 3)
+  puppet.postFX.remove(shadow)
+  let shadowAdded = false
+
+  const darkColorMatrix = puppet.postFX
+    .addColorMatrix()
+    .brightness(config.colors.darkenColorMatrixBrightness)
+
+  puppet.idle()
+  puppet.selectWeapon(PlayerWeapon.KNIFE)
+
+  const casingEmitter = new CasingEmitter(gameScene, x, y, 'bullet-casings', { from: 0.4, to: 0.3 })
+  const muzzleFlash = createMuzzleFlash(scene, x, y, raycaster)
+
+  puppet.setDepth(config.depths.player)
+  casingEmitter.setDepth(config.depths.casingEmitter)
+  muzzleFlash.setDepth(config.depths.player + 1)
+
+  const currentWeaponMode: Record<PlayerWeapon, PlayerWeaponMode> = {
+    [PlayerWeapon.FLASHLIGHT]: PlayerWeaponMode.NONE,
+    [PlayerWeapon.HANDGUN]: PlayerWeaponMode.SINGLE,
+    [PlayerWeapon.SHOTGUN]: PlayerWeaponMode.SINGLE,
+    [PlayerWeapon.RIFLE]: PlayerWeaponMode.BURST,
+    [PlayerWeapon.KNIFE]: PlayerWeaponMode.NONE,
+  }
+
+  const player: PlayerObject = {
+    name: 'player',
+    puppet,
+    body,
+    flashlight: null,
+    lightShape: lightAwareShape,
+
+    get x() {
+      return puppet.x
+    },
+    set x(value: number) {
+      puppet.x = value
+    },
+    get y() {
+      return puppet.y
+    },
+    set y(value: number) {
+      puppet.y = value
+    },
+    get rotation() {
+      return puppet.rotation
+    },
+    set rotation(value: number) {
+      puppet.rotation = value
+    },
+    get angle() {
+      return puppet.angle
+    },
+    set angle(value: number) {
+      puppet.angle = value
+    },
+
+    preUpdate() {
+      const inputs = input
+      if (!inputs) return
+
+      const { up, down, left, right, keys } = inputs
+
+      if (left) {
+        strafeLeft(keys.shift.isDown)
+      } else if (right) {
+        strafeRight(keys.shift.isDown)
+      } else if (up) {
+        if (keys.shift.isDown) {
+          runForward()
+        } else {
+          moveForward()
+        }
+      } else if (down) {
+        if (!keys.shift.isDown) {
+          moveBackward()
+        } else {
+          runBackward()
+        }
+      } else {
+        stop()
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(keys.F)) {
+        toggleFlashlight()
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(keys.E)) {
+        scene.events.emit(Event.INTERACT_WITH_OBJECT)
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(keys.R)) {
+        this.reload()
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(keys.one)) {
+        toggleKnife()
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(keys.two)) {
+        this.selectWeapon(PlayerWeapon.HANDGUN)
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(keys.three)) {
+        this.selectWeapon(PlayerWeapon.SHOTGUN)
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(keys.four)) {
+        this.selectWeapon(PlayerWeapon.RIFLE)
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(keys.space)) {
+        this.attack()
+      }
+    },
+
+    postUpdate() {
+      updateMatterSpotPosition()
+      updateFlashlightPosition()
+      updateMuzzleFlashPosition()
+      updateCasingEmitterPosition()
+      updateLightAwareShapePosition()
+    },
+
+    attack() {
+      const weapon = puppet.getWeapon()
+
+      if (weapon === PlayerWeapon.KNIFE || weapon === PlayerWeapon.FLASHLIGHT) {
+        puppet.meleeAttack()
+        return
+      }
+
+      const mode = currentWeaponMode[weapon]
+      if (mode === PlayerWeaponMode.SINGLE) {
+        shoot()
+      } else if (mode === PlayerWeaponMode.BURST) {
+        shoot()
+        scene.time.delayedCall(config.weapon.shotDelay, shoot)
+        scene.time.delayedCall(config.weapon.shotDelay * 2, shoot)
+      } else if (mode === PlayerWeaponMode.AUTO) {
+        const shootEvent = scene.time.addEvent({
+          delay: config.weapon.shotDelay,
+          callback: () => {
+            if (scene.input.keyboard!.keys[Phaser.Input.Keyboard.KeyCodes.SPACE].isDown) {
+              shoot()
+            } else {
+              shootEvent.remove()
+            }
+          },
+          loop: true,
+        })
+      }
+    },
+
+    reload() {
+      puppet.reload()
+    },
+
+    selectWeapon(weapon: PlayerWeapon) {
+      const currentWeapon = puppet.getWeapon()
+
+      if (currentWeapon === weapon) {
+        const oldMode = currentWeaponMode[currentWeapon]
+        const newMode = nextWeaponMode(currentWeapon, oldMode)
+        currentWeaponMode[currentWeapon] = newMode
+
+        if (oldMode !== newMode) {
+          scene.events.emit(Event.WEAPON_MODE_CHANGED, { weapon: currentWeapon, mode: newMode })
+        }
+        return
+      }
+
+      puppet.selectWeapon(weapon)
+    },
+
+    interactWithObject(item: Phaser.GameObjects.GameObject) {
+      if (isAlmostWithinReach(item)) {
+        almostTakeItem()
+        scene.events.emit(Event.OBJECT_STILL_TOO_FAR, item)
+        return
+      }
+
+      if (!isWithinReach(item)) {
+        scene.events.emit(Event.OBJECT_TOO_FAR, item)
+        return
+      }
+
+      const flashlightCandidate = item as Partial<FlashlightObject>
+      if (flashlightCandidate.isOn !== undefined && flashlightCandidate.turnOn) {
+        takeItem(() => {
+          const flashlightItem = item as FlashlightObject
+          // Disable physics and hide the sprite instead of removing from scene
+          flashlightItem.body?.enable && (flashlightItem.body.enable = false)
+          flashlightItem.removeHighlight()
+          flashlightItem.removeInfo()
+          flashlightItem.setVisible(false)
+          flashlightItem.setActive(false)
+          player.flashlight = flashlightItem
+          return item
+        })
+      } else {
+        scene.events.emit(Event.UNKNOWN_OBJECT, item)
+      }
+    },
+
+    onLighten() {
+      ensureShadow()
+      shadow.color = 0x000000
+      darkColorMatrix.reset()
+      casingEmitter.onLighten()
+    },
+
+    onDarken() {
+      removeShadow()
+      darkColorMatrix.reset().brightness(config.colors.darkenColorMatrixBrightness)
+      casingEmitter.onDarken()
+    },
+
+    onLightOverReset() {
+      if (gameScene.isDark) {
+        darkColorMatrix.reset().brightness(config.colors.darkenColorMatrixBrightness)
+      }
+    },
+
+    onLightOver(_ray: Raycaster.Ray, _intersections: Phaser.Geom.Point[], _force: boolean) {
+      darkColorMatrix.reset()
+    },
+
+    onLightningOver(progress: number) {
+      removeShadow()
+
+      if (progress < 1) {
+        ensureShadow()
+        shadow.color = getTintColorShift(0x000000, progress)
+      }
+
+      darkColorMatrix
+        .reset()
+        .brightness(Phaser.Math.Linear(0, config.colors.darkenColorMatrixBrightness, progress))
+    },
+
+    setLightAwareShape(_shape: LightAwareShape) {},
+
+    getLightAwareShape() {
+      return lightAwareShape
+    },
+
+    hasDebugInfo() {
+      return true
+    },
+
+    getDebugInfo() {
+      return {
+        x: player.x,
+        y: player.y,
+        size: { width: body.width, height: body.height },
+        angle: player.angle,
+        velocity: body.velocity,
+        currentState: puppet.getState(),
+        currentLegsState: puppet.getLegsState(),
+        currentWeapon: puppet.getWeapon(),
+        currentWeaponMode: currentWeaponMode[puppet.getWeapon()],
+        flashlight: player.flashlight?.getDebugInfo(),
+      }
+    },
+
+    drawDebugPhysics(graphics: Phaser.GameObjects.Graphics) {
+      player.flashlight?.drawDebugPhysics(graphics)
+    },
+  }
+
+  if (lightAwareShape) lightAwareShape.owner = player
+
+  // Map player to muzzle flash so it lights up when firing
+  muzzleFlash.mapLightAwareObject(player)
+
+  function stop() {
+    puppet.idle()
+    body.setVelocity(0)
+  }
+
+  function strafeRight(fast: boolean) {
+    puppet.strafeRight()
+    gameScene.physics.velocityFromRotation(
+      player.rotation + 0.5 * Math.PI,
+      fast ? config.player.speed.strafeFast : config.player.speed.strafe,
+      body.velocity,
+    )
+  }
+
+  function strafeLeft(fast: boolean) {
+    puppet.strafeLeft()
+    gameScene.physics.velocityFromRotation(
+      player.rotation + 0.5 * Math.PI,
+      -(fast ? config.player.speed.strafeFast : config.player.speed.strafe),
+      body.velocity,
+    )
+  }
+
+  function moveBackward() {
+    puppet.walk()
+    gameScene.physics.velocityFromRotation(
+      player.rotation,
+      -config.player.speed.walk,
+      body.velocity,
+    )
+  }
+
+  function moveForward() {
+    puppet.walk()
+    gameScene.physics.velocityFromRotation(player.rotation, config.player.speed.walk, body.velocity)
+  }
+
+  function runBackward() {
+    puppet.run()
+    gameScene.physics.velocityFromRotation(player.rotation, -config.player.speed.run, body.velocity)
+  }
+
+  function runForward() {
+    puppet.run()
+    gameScene.physics.velocityFromRotation(player.rotation, config.player.speed.run, body.velocity)
+  }
+
+  function shoot() {
+    puppet.shoot()
+    casingEmitter.emitOne(getCasingName())
+    muzzleFlash.flashOnce()
+  }
+
+  function toggleFlashlight() {
+    if (!player.flashlight) {
+      scene.events.emit(Event.FLASHLIGHT_MISSING)
+      return
+    }
+
+    if (puppet.getWeapon() === PlayerWeapon.KNIFE) {
+      toggleKnife()
+      return
+    }
+
+    if (player.flashlight.isOff) {
+      player.flashlight.turnOn()
+    } else {
+      player.flashlight.turnOff()
+    }
+  }
+
+  function toggleKnife() {
+    if (puppet.getWeapon() === PlayerWeapon.KNIFE && player.flashlight) {
+      puppet.selectWeapon(PlayerWeapon.FLASHLIGHT)
+      player.flashlight.turnOn()
+    } else {
+      player.flashlight?.turnOff()
+      puppet.selectWeapon(PlayerWeapon.KNIFE)
+    }
+  }
+
+  function nextWeaponMode(weapon: PlayerWeapon, currentMode: PlayerWeaponMode): PlayerWeaponMode {
+    if (weapon !== PlayerWeapon.RIFLE) return PlayerWeaponMode.SINGLE
+    if (currentMode === PlayerWeaponMode.SINGLE) return PlayerWeaponMode.BURST
+    if (currentMode === PlayerWeaponMode.BURST) return PlayerWeaponMode.AUTO
+    if (currentMode === PlayerWeaponMode.AUTO) return PlayerWeaponMode.SINGLE
+    return PlayerWeaponMode.SINGLE
+  }
+
+  function distanceTo(item: Phaser.GameObjects.GameObject) {
+    const itemBody = item.body as Phaser.Physics.Arcade.Body
+    const distance = Phaser.Math.Distance.Between(player.x, player.y, itemBody.x, itemBody.y)
+    const angle = Phaser.Math.Angle.Between(player.x, player.y, itemBody.x, itemBody.y)
+    const degreesAbs = Phaser.Math.RadToDeg(Math.abs(angle - player.rotation))
+    return { distance, angle: degreesAbs }
+  }
+
+  function isWithinReach(item: Phaser.GameObjects.GameObject) {
+    const { distance, angle } = distanceTo(item)
+    return distance <= config.player.reach && angle <= config.player.reachAngle
+  }
+
+  function isAlmostWithinReach(item: Phaser.GameObjects.GameObject) {
+    const { distance, angle } = distanceTo(item)
+    return (
+      distance > config.player.reach &&
+      distance <= config.player.reachAlmost &&
+      angle <= config.player.reachAngle
+    )
+  }
+
+  function takeItem(fn: () => Phaser.GameObjects.GameObject | undefined) {
+    let listener: spine.AnimationStateListener2
+    listener = createSpineListener({
+      complete: () => {
+        puppet.spine.state.removeListener(listener)
+        const item = fn()
+        puppet.interactTake()
+        if (item) {
+          scene.events.emit(Event.OBJECT_PICKED_UP, item)
+        }
+      },
+    })
+    puppet.spine.state.addListener(listener)
+    puppet.interactReach()
+  }
+
+  function almostTakeItem() {
+    let listener: spine.AnimationStateListener2
+    listener = createSpineListener({
+      complete: () => {
+        puppet.spine.state.removeListener(listener)
+        scene.time.delayedCall(150, () => puppet.returnToCurrentState())
+      },
+    })
+    puppet.spine.state.addListener(listener)
+    puppet.interactReach()
+  }
+
+  function ensureShadow() {
+    if (shadowAdded) return
+    shadowAdded = true
+    puppet.postFX.add(shadow)
+  }
+
+  function removeShadow() {
+    puppet.postFX.remove(shadow)
+    shadowAdded = false
+  }
+
+  function updateMatterSpotPosition() {
+    matterSpot.angle = player.angle
+    matterSpot.position.x = player.x
+    matterSpot.position.y = player.y
+  }
+
+  function updateLightAwareShapePosition() {
+    if (lightAwareShape) {
+      lightAwareShape.x = player.x
+      lightAwareShape.y = player.y
+    }
+  }
+
+  function updateCasingEmitterPosition() {
+    const weapon = puppet.getWeapon()
+    const adjustByWeapon: Record<PlayerWeapon, { length: number; angle: number }> = {
+      [PlayerWeapon.HANDGUN]: { length: 80, angle: 35 },
+      [PlayerWeapon.SHOTGUN]: { length: 70, angle: 30 },
+      [PlayerWeapon.RIFLE]: { length: 60, angle: 35 },
+      [PlayerWeapon.KNIFE]: { length: 0, angle: 0 },
+      [PlayerWeapon.FLASHLIGHT]: { length: 0, angle: 0 },
+    }
+
+    const { length, angle } = adjustByWeapon[weapon]
+    casingEmitter.setEmitterPosition(body.center, length, player.angle + angle)
+    casingEmitter.setEmitterAngle(player.angle)
+  }
+
+  function updateMuzzleFlashPosition() {
+    const weapon = puppet.getWeapon()
+    const scaleByWeapon: Record<PlayerWeapon, { scale: number }> = {
+      [PlayerWeapon.HANDGUN]: { scale: 0.1 },
+      [PlayerWeapon.SHOTGUN]: { scale: 0.15 },
+      [PlayerWeapon.RIFLE]: { scale: 0.13 },
+      [PlayerWeapon.KNIFE]: { scale: 0 },
+      [PlayerWeapon.FLASHLIGHT]: { scale: 0 },
+    }
+
+    const scale = scaleByWeapon[weapon].scale
+    const bone = getBonePosition('muzzle')
+    muzzleFlash.setScale(scale).setPosition(bone.x, bone.y)
+    muzzleFlash.setAngle(player.angle)
+  }
+
+  function updateFlashlightPosition() {
+    if (!player.flashlight) return
+
+    const weapon = puppet.getWeapon()
+    const attachedToByWeapon: Record<
+      PlayerWeapon,
+      { frontBone: string; rearBone: string; shift: number }
+    > = {
+      [PlayerWeapon.HANDGUN]: { frontBone: 'muzzle', rearBone: 'weapon', shift: 10 },
+      [PlayerWeapon.SHOTGUN]: { frontBone: 'muzzle', rearBone: 'weapon', shift: 60 },
+      [PlayerWeapon.RIFLE]: { frontBone: 'muzzle', rearBone: 'weapon', shift: 60 },
+      [PlayerWeapon.KNIFE]: { frontBone: 'head', rearBone: 'head', shift: 0 },
+      [PlayerWeapon.FLASHLIGHT]: { frontBone: 'muzzle', rearBone: 'weapon', shift: 0 },
+    }
+
+    const attachedTo = attachedToByWeapon[weapon]
+    const frontBone = getBonePosition(attachedTo.frontBone)
+    const rearBone = getBonePosition(attachedTo.rearBone)
+
+    const flashlightOffset = new Phaser.Math.Vector2(
+      frontBone.x - rearBone.x,
+      frontBone.y - rearBone.y,
+    ).setLength(attachedTo.shift)
+
+    const weaponAngle =
+      attachedTo.frontBone === attachedTo.rearBone
+        ? player.rotation
+        : Phaser.Math.Angle.Between(rearBone.x, rearBone.y, frontBone.x, frontBone.y)
+
+    player.flashlight
+      .setPosition(flashlightOffset.x + rearBone.x, flashlightOffset.y + rearBone.y)
+      .setAngle(Phaser.Math.RadToDeg(weaponAngle))
+  }
+
+  function getBonePosition(boneName: string): Phaser.Math.Vector2 {
+    const bone = puppet.spine.skeleton.findBone(boneName)
+
+    if (gameScene.isPlayerMode) {
+      const boneLocalX = bone.worldX - puppet.spine.skeleton.x
+      const boneLocalY = bone.worldY - puppet.spine.skeleton.y
+
+      const distance = Math.sqrt(boneLocalX * boneLocalX + boneLocalY * boneLocalY)
+      const localAngle = Math.atan2(-boneLocalY, boneLocalX)
+      const worldAngle = localAngle + player.rotation + Math.PI / 2
+
+      return new Phaser.Math.Vector2(
+        body.center.x + Math.cos(worldAngle) * distance,
+        body.center.y + Math.sin(worldAngle) * distance,
+      )
+    }
+
+    const boneInnerPosition = new Phaser.Math.Vector2(
+      bone.worldX + player.x - puppet.spine.skeleton.x,
+      bone.worldY + player.y - puppet.spine.skeleton.y,
+    )
+
+    const distance = Phaser.Math.Distance.Between(
+      body.center.x,
+      body.center.y,
+      boneInnerPosition.x,
+      boneInnerPosition.y,
+    )
+    const angle = Phaser.Math.Angle.Between(
+      body.center.x,
+      body.center.y,
+      boneInnerPosition.x,
+      boneInnerPosition.y,
+    )
+
+    return new Phaser.Math.Vector2(body.center.x, body.center.y)
+      .setLength(distance)
+      .setAngle(-angle)
+      .add(body.center)
+  }
+
+  function getCasingName(): string | undefined {
+    const weapon = puppet.getWeapon()
+    const casingMap: Record<PlayerWeapon, string | undefined> = {
+      [PlayerWeapon.HANDGUN]: '8mm-bullet-case',
+      [PlayerWeapon.SHOTGUN]: '12gauge-bullet-case',
+      [PlayerWeapon.RIFLE]: 'ar-bullet-case',
+      [PlayerWeapon.KNIFE]: undefined,
+      [PlayerWeapon.FLASHLIGHT]: undefined,
+    }
+    return casingMap[weapon]
+  }
+
+  scene.time.delayedCall(0, () => {
+    scene.events.emit('debuggable-added', player)
+  })
+
+  return player
+}
diff --git a/src/objects/player.puppet.ts b/src/objects/player.puppet.ts
new file mode 100644
index 0000000..ef0b303
--- /dev/null
+++ b/src/objects/player.puppet.ts
@@ -0,0 +1,173 @@
+import SpineContainer from '../types/spine-container'
+
+export enum PlayerWeapon {
+  FLASHLIGHT = 'flashlight',
+  HANDGUN = 'handgun',
+  SHOTGUN = 'shotgun',
+  RIFLE = 'rifle',
+  KNIFE = 'knife',
+}
+
+export enum PlayerState {
+  IDLE = 'idle',
+  MOVE = 'move',
+}
+
+export enum PlayerLegsState {
+  IDLE = 'idle',
+  WALK = 'walk',
+  STRAFE_LEFT = 'strafe_left',
+  STRAFE_RIGHT = 'strafe_right',
+  RUN = 'run',
+}
+
+/**
+ * PlayerPuppet - Pure animation layer for the player character.
+ *
+ * Contains two spine objects (upper body + legs) and provides
+ * a clean API for controlling animations. No physics, no inputs,
+ * no game-specific logic.
+ *
+ * Used by:
+ * - Player (game) - adds physics, inputs, effects
+ * - Editor - direct control for previewing animations
+ */
+export default class PlayerPuppet extends SpineContainer {
+  private legs: SpineGameObject
+  private currentState: PlayerState = PlayerState.IDLE
+  private currentLegsState: PlayerLegsState = PlayerLegsState.IDLE
+  private currentWeapon: PlayerWeapon = PlayerWeapon.KNIFE
+
+  constructor(scene: Phaser.Scene, x: number, y: number) {
+    super(scene, x, y, 'player', `${PlayerState.IDLE}_${PlayerWeapon.KNIFE}`, true)
+
+    this.setScale(0.7, 0.7)
+
+    this.legs = scene.add.spine(0, 0, 'player-legs', PlayerLegsState.IDLE, true)
+    this.addSpine(this.legs, 0)
+
+    scene.add.existing(this)
+  }
+
+  // --- State Getters ---
+
+  getState(): PlayerState {
+    return this.currentState
+  }
+
+  getLegsState(): PlayerLegsState {
+    return this.currentLegsState
+  }
+
+  getWeapon(): PlayerWeapon {
+    return this.currentWeapon
+  }
+
+  // --- Movement States ---
+
+  idle(): void {
+    this.setCurrentState(PlayerState.IDLE, PlayerLegsState.IDLE)
+  }
+
+  walk(): void {
+    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.WALK)
+  }
+
+  run(): void {
+    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.RUN)
+  }
+
+  strafeLeft(): void {
+    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.STRAFE_LEFT)
+  }
+
+  strafeRight(): void {
+    this.setCurrentState(PlayerState.MOVE, PlayerLegsState.STRAFE_RIGHT)
+  }
+
+  // --- Weapon ---
+
+  selectWeapon(weapon: PlayerWeapon): void {
+    if (this.currentWeapon === weapon) {
+      return
+    }
+
+    this.switchToState(this.currentState, weapon)
+  }
+
+  // --- Actions (one-shot animations that return to current state) ---
+
+  shoot(): void {
+    if (
+      this.currentWeapon === PlayerWeapon.KNIFE ||
+      this.currentWeapon === PlayerWeapon.FLASHLIGHT
+    ) {
+      return
+    }
+
+    this.spine.setAnimation(0, `shoot_${this.currentWeapon}`, false)
+    this.continueCurrentAnimation()
+  }
+
+  reload(): void {
+    if (
+      this.currentWeapon === PlayerWeapon.KNIFE ||
+      this.currentWeapon === PlayerWeapon.FLASHLIGHT
+    ) {
+      return
+    }
+
+    this.spine.setAnimation(0, `reload_${this.currentWeapon}`, false)
+    this.continueCurrentAnimation()
+  }
+
+  meleeAttack(): void {
+    this.spine.setAnimation(0, `meleeattack_${this.currentWeapon}`, false)
+    this.continueCurrentAnimation()
+  }
+
+  interactReach(): void {
+    this.spine.setAnimation(0, `interact_reach_${this.currentWeapon}`, false)
+  }
+
+  /**
+   * Queue return to current state animation.
+   * Use after one-shot actions that don't automatically continue.
+   */
+  returnToCurrentState(): void {
+    this.continueCurrentAnimation()
+  }
+
+  interactTake(): void {
+    this.spine.addAnimation(0, `interact_take_${this.currentWeapon}`, false)
+    this.continueCurrentAnimation()
+  }
+
+  // --- Internal ---
+
+  private setCurrentState(state: PlayerState, legsState: PlayerLegsState): void {
+    if (this.currentState !== state) {
+      this.switchToState(state, this.currentWeapon)
+    }
+
+    if (this.currentLegsState !== legsState) {
+      const oldLegsState = this.currentLegsState
+      this.currentLegsState = legsState
+      this.legs.setMix(oldLegsState, legsState, 0.2).setAnimation(0, legsState, true)
+    }
+  }
+
+  private switchToState(state: PlayerState, weapon: PlayerWeapon): void {
+    const oldState = `${this.currentState}_${this.currentWeapon}`
+    const newState = `${state}_${weapon}`
+
+    this.spine.setMix(oldState, newState, 0.2).setAnimation(0, newState, true)
+
+    this.currentState = state
+    this.currentWeapon = weapon
+  }
+
+  private continueCurrentAnimation(): void {
+    this.spine.addAnimation(0, `${this.currentState}_${this.currentWeapon}`, true)
+  }
+}
diff --git a/src/objects/pointer.object.ts b/src/objects/pointer.object.ts
new file mode 100644
index 0000000..169f8c6
--- /dev/null
+++ b/src/objects/pointer.object.ts
@@ -0,0 +1,69 @@
+import config from '../game-config'
+import { isPointable, Pointable } from '../mixins/pointable.mixin'
+
+interface PlayerLike {
+  body: Phaser.Physics.Arcade.Body
+}
+
+export default class Pointer extends Phaser.GameObjects.GameObject {
+  private dot: Phaser.GameObjects.Arc
+  private currentlyHighlighted: Pointable | null = null
+
+  public get x(): number {
+    return this.dot.x
+  }
+
+  public set x(value: number) {
+    this.dot.x = value
+  }
+
+  public get y(): number {
+    return this.dot.y
+  }
+
+  public set y(value: number) {
+    this.dot.y = value
+  }
+
+  constructor(scene: Phaser.Scene, x: number, y: number) {
+    super(scene, 'pointer')
+
+    this.dot = scene.add.circle(x, y, 5, 0xffffff, 0.5)
+
+    this.scene.add.existing(this.dot)
+    this.scene.physics.world.enable(this.dot)
+
+    this.dot.setDepth(config.depths.pointer)
+  }
+
+  public update(player: PlayerLike) {
+    this.dot.body.velocity.x = player.body.velocity.x
+    this.dot.body.velocity.y = player.body.velocity.y
+
+    const withinWorldBounds = this.scene.physics.world.bounds.contains(this.dot.x, this.dot.y)
+
+    this.dot.fillColor = withinWorldBounds ? 0xffffff : 0xff0000
+
+    if (this.currentlyHighlighted) {
+      const obj = this.currentlyHighlighted as unknown as { x: number; y: number }
+      const dist = Phaser.Math.Distance.Between(this.dot.x, this.dot.y, obj.x, obj.y)
+      if (dist > 50) {
+        this.currentlyHighlighted.removeHighlight()
+        this.currentlyHighlighted.removeInfo()
+        this.currentlyHighlighted = null
+        this.dot.visible = true
+      }
+      return
+    }
+
+    const body = this.scene.physics.overlapRect(this.dot.x, this.dot.y, 1, 1)[0]
+    const gameObject = body?.gameObject
+
+    if (isPointable(gameObject) && gameObject.active) {
+      this.dot.visible = false
+      gameObject.showHighlight()
+      gameObject.showInfo()
+      this.currentlyHighlighted = gameObject
+    }
+  }
+}
diff --git a/src/objects/static-matter-projection.object.ts b/src/objects/static-matter-projection.object.ts
new file mode 100644
index 0000000..7974db3
--- /dev/null
+++ b/src/objects/static-matter-projection.object.ts
@@ -0,0 +1,128 @@
+export interface Projection {
+  shift(diff: Phaser.Types.Math.Vector2Like): Projection
+}
+
+interface MatterObjectLike {
+  getCenter(): Phaser.Math.Vector2
+  getTopLeft(): Phaser.Math.Vector2
+  getTopRight(): Phaser.Math.Vector2
+  getBottomLeft(): Phaser.Math.Vector2
+  getBottomRight(): Phaser.Math.Vector2
+}
+
+export class StaticMatterProjectionCircle
+  extends Phaser.Physics.Arcade.StaticGroup
+  implements Projection
+{
+  private coordinates: Phaser.Types.Math.Vector2Like[]
+
+  constructor(
+    scene: Phaser.Scene,
+    matterObject: MatterObjectLike,
+    radius: number,
+    minDotsDistance: number = 20,
+  ) {
+    super(scene.physics.world, scene)
+
+    this.coordinates = this.normalizeCircleShape(matterObject.getCenter(), radius, minDotsDistance)
+
+    this.coordinates.forEach((coordinate) => {
+      const dot: Phaser.Physics.Arcade.Sprite = this.create(coordinate.x, coordinate.y, 'green-dot')
+      dot.setScale(0.2).setCircle(1).refreshBody()
+    })
+
+    this.setVisible(false)
+  }
+
+  public shift(diff: Phaser.Types.Math.Vector2Like): Projection {
+    this.getChildren().forEach((child) => {
+      const dot = child as Phaser.Physics.Arcade.Sprite
+      dot.setPosition(dot.x + diff.x, dot.y + diff.y).refreshBody()
+    })
+
+    this.refresh()
+    return this
+  }
+
+  private normalizeCircleShape(
+    center: Phaser.Types.Math.Vector2Like,
+    radius: number,
+    minDotsDistance: number,
+  ): Phaser.Types.Math.Vector2Like[] {
+    const coordinates: Phaser.Types.Math.Vector2Like[] = []
+
+    const circumference = 2 * Math.PI * radius
+    const dotsCount = Math.floor(circumference / minDotsDistance)
+
+    for (let i = 0; i < dotsCount; i++) {
+      const angle = (i / dotsCount) * 2 * Math.PI
+      const x = center.x + radius * Math.cos(angle)
+      const y = center.y + radius * Math.sin(angle)
+      coordinates.push({ x, y })
+    }
+
+    return coordinates
+  }
+}
+
+export class StaticMatterProjectionRectangle
+  extends Phaser.Physics.Arcade.StaticGroup
+  implements Projection
+{
+  private coordinates: Phaser.Types.Math.Vector2Like[]
+
+  constructor(scene: Phaser.Scene, matterObject: MatterObjectLike, minDotsDistance: number = 20) {
+    super(scene.physics.world, scene)
+
+    this.coordinates = this.normalizeRectShape(
+      [
+        matterObject.getTopLeft(),
+        matterObject.getTopRight(),
+        matterObject.getBottomRight(),
+        matterObject.getBottomLeft(),
+      ],
+      minDotsDistance,
+    )
+
+    this.coordinates.forEach((coordinate) => {
+      const dot: Phaser.Physics.Arcade.Sprite = this.create(coordinate.x, coordinate.y, 'green-dot')
+      dot.setScale(0.2).setCircle(1).refreshBody()
+    })
+
+    this.setVisible(false)
+  }
+
+  public shift(diff: Phaser.Types.Math.Vector2Like): Projection {
+    this.getChildren().forEach((child) => {
+      const dot = child as Phaser.Physics.Arcade.Sprite
+      dot.setPosition(dot.x + diff.x, dot.y + diff.y).refreshBody()
+    })
+
+    this.refresh()
+    return this
+  }
+
+  private normalizeRectShape(
+    vertices: Phaser.Types.Math.Vector2Like[],
+    minDistance: number,
+  ): Phaser.Types.Math.Vector2Like[] {
+    const normalizedVertices: Phaser.Types.Math.Vector2Like[] = []
+
+    vertices.forEach((vertex, i) => {
+      normalizedVertices.push(vertex)
+      const nextVertex = vertices[i + 1] || vertices[0]
+      const distance = Phaser.Math.Distance.BetweenPoints(vertex, nextVertex)
+      if (distance > minDistance) {
+        const additionalVertices = Math.floor(distance / minDistance)
+        for (let i = 1; i < additionalVertices; i++) {
+          normalizedVertices.push({
+            x: Phaser.Math.Linear(vertex.x, nextVertex.x, i / additionalVertices),
+            y: Phaser.Math.Linear(vertex.y, nextVertex.y, i / additionalVertices),
+          })
+        }
+      }
+    })
+
+    return normalizedVertices
+  }
+}
diff --git a/src/objects/weather.object.ts b/src/objects/weather.object.ts
new file mode 100644
index 0000000..8556445
--- /dev/null
+++ b/src/objects/weather.object.ts
@@ -0,0 +1,231 @@
+import config from '../game-config'
+import GameScene from '../scenes/game.scene'
+
+interface PlayerLike {
+  body: Phaser.Physics.Arcade.Body
+}
+
+export interface Weather {
+  isOn: boolean
+
+  start: () => void
+  stop: () => void
+}
+
+export class WeatherConditions {
+  private rain: Rain
+  private snow: Snow
+
+  constructor(scene: GameScene, player: PlayerLike) {
+    this.rain = new Rain(scene, player)
+    this.snow = new Snow(scene)
+  }
+
+  toggle() {
+    if (this.rain.isOn) {
+      this.rain.stop()
+      this.snow.start()
+    } else if (this.snow.isOn) {
+      this.snow.stop()
+    } else {
+      this.rain.start()
+    }
+  }
+
+  getDebugInfo() {
+    if (this.rain.isOn) {
+      return 'rain'
+    }
+
+    if (this.snow.isOn) {
+      return 'snow'
+    }
+
+    return 'clear'
+  }
+}
+
+export class Snow implements Weather {
+  private snow: Phaser.GameObjects.Particles.ParticleEmitter
+
+  public isOn: boolean
+
+  constructor(private scene: GameScene) {
+    const { width, height } = scene.physics.world.bounds
+
+    this.snow = scene.add
+      .particles(0, 0, 'rain-splash', {
+        x: -100,
+        y: -100,
+        speed: (particle) => {
+          if (particle.lifeCurrent < Math.random() * 500) {
+            return 0
+          }
+
+          return Math.random() * 100 + 50
+        },
+        lifespan: 10000 - Math.random() * 3000,
+        quantity: 10,
+        angle: 30,
+        alpha: { start: 1, end: 0.2 },
+        scale: { start: 0.2, end: 0 },
+        tint: {
+          onEmit: () => this.getSnowColor(),
+          onUpdate: () => this.getSnowColor(),
+        },
+      })
+      .setDepth(config.depths.ceiling)
+
+    this.snow.addEmitZone({
+      source: new Phaser.Geom.Rectangle(0, 0, width, height),
+    })
+
+    this.snow.stop()
+  }
+
+  start() {
+    this.isOn = true
+    this.snow.start()
+  }
+
+  stop() {
+    this.isOn = false
+    this.snow.stop()
+  }
+
+  private getSnowColor() {
+    return this.scene.isDark ? 0x555555 : 0xffffff
+  }
+}
+
+export class Rain implements Weather {
+  private rainSplashParticles: Phaser.GameObjects.Particles.ParticleEmitter
+  private rainDrops: Phaser.GameObjects.Particles.ParticleEmitter
+  private lightning: Phaser.Time.TimerEvent
+
+  public isOn: boolean
+
+  constructor(
+    private scene: GameScene,
+    private player: PlayerLike,
+  ) {
+    const { width, height } = scene.physics.world.bounds
+
+    this.rainSplashParticles = scene.add
+      .particles(0, 0, 'rain-splash', {
+        x: 0,
+        y: 0,
+        speed: 0,
+        lifespan: 700,
+        quantity: 10,
+        alpha: { start: 0.3, end: 0 },
+        scale: { start: 0.2, end: 0.5 },
+        tint: {
+          onUpdate: () => {
+            return scene.isDark ? 0x000000 : 0x111111
+          },
+        },
+      })
+      .setDepth(config.depths.matterThingBottom)
+
+    this.rainSplashParticles.addEmitZone({
+      source: new Phaser.Geom.Rectangle(0, 0, width, height),
+    })
+
+    this.rainSplashParticles.stop()
+
+    const rainDropSpeed = 700
+    this.rainDrops = scene.add
+      .particles(0, 0, 'rain-splash', {
+        x: 0,
+        y: 0,
+        angle: (particle) => {
+          const playerSpot = this.player.body.center
+
+          const angle = Phaser.Math.Angle.Between(
+            particle.x,
+            particle.y,
+            playerSpot.x,
+            playerSpot.y,
+          )
+
+          return Phaser.Math.RadToDeg(angle)
+        },
+
+        speed: (particle) => {
+          const playerSpot = this.player.body.center
+
+          const distance = Phaser.Math.Distance.Between(
+            playerSpot.x,
+            playerSpot.y,
+            particle.x,
+            particle.y,
+          )
+
+          return distance > 500 ? rainDropSpeed : rainDropSpeed * (distance / 500)
+        },
+        lifespan: 300,
+        quantity: 10,
+        alpha: { start: 0.8, end: 0.2 },
+        scale: { start: 0.2, end: 0 },
+        tint: {
+          onUpdate: () => {
+            return scene.isDark ? 0x000000 : 0x4c4c4c
+          },
+        },
+      })
+      .setDepth(config.depths.ceiling)
+
+    this.rainDrops.addEmitZone({
+      source: new Phaser.Geom.Rectangle(0, 0, width, height),
+    })
+
+    this.rainDrops.stop()
+  }
+
+  start() {
+    this.isOn = true
+    this.rainSplashParticles.start()
+    this.rainDrops.start()
+
+    this.lightning = this.scene.time.addEvent({
+      delay: 100,
+      loop: true,
+      callback: () => {
+        if (Math.random() > 0.98) {
+          this.lightningFlash(Math.random() * 800)
+
+          for (let i = 0; i < Math.random() * 10; i++) {
+            this.scene.time.addEvent({
+              delay: Math.random() * 400,
+              callback: () => {
+                this.lightningFlash(200 + Math.random() * 400)
+              },
+            })
+          }
+        }
+      },
+    })
+  }
+
+  stop() {
+    this.isOn = false
+    this.rainSplashParticles.stop()
+    this.rainDrops.stop()
+
+    this.lightning?.destroy()
+  }
+
+  private lightningFlash(flashDuration: number) {
+    this.scene.cameras.main.flash(
+      flashDuration,
+      0xf0,
+      0xf0,
+      0xf0,
+      false,
+      (_camera: Phaser.Cameras.Scene2D.Camera, progress: number) => {
+        this.scene.reactToLightning(progress)
+      },
+    )
+  }
+}
diff --git a/src/plugins/DebugScreenPlugin.ts b/src/plugins/DebugScreenPlugin.ts
deleted file mode 100644
index 50daddc..0000000
--- a/src/plugins/DebugScreenPlugin.ts
+++ /dev/null
@@ -1,338 +0,0 @@
-import { GameObjects } from "phaser";
-import config from "../GameConfig";
-import { IDebuggable, isDebuggable } from "../types/Debuggable";
-import { isGameScene } from "../scenes/GameScene";
-
-type DebugInfoLevel = "all" | "physics" | "info" | "none";
-
-export default class DebugScreenPlugin extends Phaser.Plugins.ScenePlugin {
-  private debugInfoLevel: DebugInfoLevel = "none";
-  private help: DebugInfoWindow;
-  private sceneDebugInfo: DebugInfoWindow;
-  private debugGraphics: Phaser.GameObjects.Graphics;
-  private debugObjects: {
-    [key: string]: {
-      object: IDebuggable;
-      window: DebugInfoWindow;
-    };
-  } = {};
-
-  private get debugInfoEnabled(): boolean {
-    return this.debugInfoLevel !== "none";
-  }
-
-  private readonly displayBorder: number = 10;
-
-  constructor(
-    scene: Phaser.Scene,
-    pluginManager: Phaser.Plugins.PluginManager
-  ) {
-    super(scene, pluginManager, "DebugScreenPlugin");
-
-    // enable debug by default for development
-    if (process.env.NODE_ENV === "development") {
-      this.debugInfoLevel = "info";
-    }
-
-    this.scene.events.once(Phaser.Scenes.Events.BOOT, () => {
-      this.create();
-    });
-
-    const drawDebugPhysics =
-      this.debugInfoLevel === "all" || this.debugInfoLevel === "physics";
-
-    this.scene.events.once(
-      Phaser.Scenes.Events.READY,
-      (event: Phaser.Scenes.Systems) => {
-        this.debugGraphics = event.scene.add
-          .graphics()
-          .setDepth(config.depths.debug);
-
-        event.scene.physics.world.createDebugGraphic();
-        event.scene.physics.world.drawDebug = drawDebugPhysics;
-
-        if (event.scene.matter) {
-          event.scene.matter.world.createDebugGraphic();
-          event.scene.matter.world.drawDebug = drawDebugPhysics;
-        }
-      }
-    );
-  }
-
-  public create() {
-    this.sceneDebugInfo = new DebugInfoWindow(
-      this.scene,
-      `${this.scene.scene.key}`
-    )
-      .setScrollFactor(0)
-      .setPosition(this.displayBorder, this.displayBorder);
-
-    this.help = new DebugInfoWindow(this.scene, "Help")
-      .setScrollFactor(0)
-      .setText(
-        [
-          "F9       toggle debug info",
-          "8        toggle weather",
-          "9        toggle emergency light",
-          "0        toggle lights",
-          "1,2,3,4  toggle weapons",
-          "A,W,S,D  move",
-          "E        interact with objects",
-          "SPACE    attack",
-          "SHIFT    run",
-        ].join("\n")
-      );
-
-    this.help.setPosition(
-      this.scene.game.canvas.width - this.help.width - this.displayBorder,
-      this.displayBorder
-    );
-
-    this.scene.events.on(
-      Phaser.Scenes.Events.ADDED_TO_SCENE,
-      (object: Phaser.GameObjects.GameObject) => {
-        if (isDebuggable(object)) {
-          this.debugObjects[object.name] = {
-            object: object as IDebuggable,
-            window: object.hasDebugInfo()
-              ? new DebugInfoWindow(this.scene, object.name)
-              : null,
-          };
-        }
-      }
-    );
-
-    this.scene.events.on(
-      Phaser.Scenes.Events.REMOVED_FROM_SCENE,
-      (object: Phaser.GameObjects.GameObject) => {
-        if (isDebuggable(object)) {
-          this.debugObjects[object.name].window.destroy();
-          delete this.debugObjects[object.name];
-        }
-      }
-    );
-
-    this.scene.events.on(Phaser.Scenes.Events.UPDATE, () => {
-      this.resetDebugGraphics(this.debugInfoLevel);
-      this.drawDebugInfo();
-      this.drawDebugPhysics();
-    });
-    this.scene.events.on(Phaser.Scenes.Events.SHUTDOWN, () => this.cleanup());
-    this.scene.events.on(Phaser.Scenes.Events.DESTROY, () => this.cleanup());
-
-    this.scene.input.keyboard.on("keydown-F9", () => {
-      const nextLevel: { [key in DebugInfoLevel]: DebugInfoLevel } = {
-        all: "physics",
-        physics: "info",
-        info: "none",
-        none: "all",
-      };
-
-      this.debugInfoLevel = nextLevel[this.debugInfoLevel];
-      this.resetDebugGraphics(this.debugInfoLevel);
-    });
-  }
-
-  private resetDebugGraphics(level: DebugInfoLevel) {
-    const drawDebugPhysics = level === "physics" || level === "all";
-
-    this.debugGraphics.clear();
-
-    this.scene.physics.world.debugGraphic.clear();
-    this.scene.physics.world.drawDebug = drawDebugPhysics;
-
-    if (this.scene.matter) {
-      this.scene.matter.world.debugGraphic.clear();
-      this.scene.matter.world.drawDebug = drawDebugPhysics;
-    }
-  }
-
-  private drawDebugInfo() {
-    this.sceneDebugInfo.setDebugInfo(this.getSceneDebugInfo(this.scene));
-
-    const drawDebugInfo =
-      this.debugInfoLevel === "all" || this.debugInfoLevel === "info";
-
-    for (const key in this.debugObjects) {
-      if (this.debugObjects[key].window) {
-        this.debugObjects[key].window.visible = drawDebugInfo;
-      }
-    }
-
-    if (!this.debugInfoEnabled) {
-      return;
-    }
-
-    this.sceneDebugInfo.setDebugInfo(this.getSceneDebugInfo(this.scene));
-
-    for (const key in this.debugObjects) {
-      const object = this.debugObjects[key].object;
-      if (!object) {
-        continue;
-      }
-
-      const objectSize = {
-        width: object.body.width,
-        height: object.body.height,
-      };
-
-      const objectInfo = this.debugObjects[key].window;
-      if (!objectInfo) {
-        continue;
-      }
-
-      objectInfo.setDebuggable(object);
-      objectInfo.setPosition(
-        object.body.position.x + objectSize.width + 10,
-        object.body.position.y + objectSize.height + 10
-      );
-    }
-  }
-
-  private drawDebugPhysics() {
-    const drawDebugPhysics =
-      this.debugInfoLevel === "all" || this.debugInfoLevel === "physics";
-
-    if (!drawDebugPhysics) {
-      return;
-    }
-
-    for (const key in this.debugObjects) {
-      const object = this.debugObjects[key].object;
-      if (!object) {
-        console.log("skipping", key);
-        continue;
-      }
-
-      object.drawDebugPhysics(this.debugGraphics);
-    }
-  }
-
-  private cleanup() {
-    this.sceneDebugInfo.destroy();
-    this.help.destroy();
-    for (const key in this.debugObjects) {
-      this.debugObjects[key].window?.destroy();
-    }
-  }
-
-  private getSceneDebugInfo(scene: Phaser.Scene): object {
-    const info = {
-      fps: Math.round(scene.game.loop.actualFps),
-    };
-
-    if (isGameScene(scene)) {
-      const debugInfo = scene.getDebugInfo();
-      Object.assign(info, debugInfo);
-    }
-
-    Object.assign(info, {
-      objects: scene.children.length,
-      bodies: scene.physics.world.bodies.size,
-      collisions: scene.physics.world.colliders.length,
-      lights: scene.lights.lights.length,
-      debugInfoLevel: this.debugInfoLevel,
-      debugObjects: Object.keys(this.debugObjects),
-    });
-
-    return info;
-  }
-}
-
-class DebugInfoWindow extends Phaser.GameObjects.Container {
-  private background: GameObjects.Rectangle;
-  private titleBackground: GameObjects.Rectangle;
-  private title: GameObjects.Text;
-  private text: GameObjects.Text;
-
-  constructor(scene: Phaser.Scene, title: string) {
-    super(scene, 0, 0);
-
-    this.background = this.scene.add
-      .rectangle(0, 0, 0, 0, 0x000000)
-      .setAlpha(0.5);
-    this.titleBackground = this.scene.add
-      .rectangle(0, 0, 0, 0, 0x000000)
-      .setAlpha(0.5);
-
-    this.title = this.addTextObject(0, 0, title);
-    this.text = this.addTextObject(0, 0, "");
-
-    this.add([this.background, this.titleBackground, this.title, this.text]);
-
-    this.scene.add.existing(this);
-    this.setDepth(9999);
-    this.resize();
-  }
-
-  public setDebuggable(debuggable: IDebuggable): DebugInfoWindow {
-    const debugInfo = debuggable?.getDebugInfo();
-    if (!debugInfo) {
-      this.setText("no debug info available");
-      return this;
-    }
-
-    return this.setDebugInfo(debugInfo);
-  }
-
-  public setDebugInfo(debugInfo: object) {
-    const text = this.formatDebugInfo(debugInfo);
-    return this.setText(text);
-  }
-
-  private formatDebugInfo(debugInfo: object, indent = 0) {
-    const maxSpace =
-      Math.max(...Object.keys(debugInfo).map((key) => key.length)) + 2;
-    const indentString = indent ? " ".repeat(indent) : "";
-    return Object.keys(debugInfo)
-      .map(
-        (key) =>
-          `${indentString}${key}${" ".repeat(maxSpace - key.length)}${
-            debugInfo[key] instanceof Object
-              ? "\n" + this.formatDebugInfo(debugInfo[key], indent + 4)
-              : debugInfo[key]
-          }`
-      )
-      .join("\n");
-  }
-
-  public setText(text: string): DebugInfoWindow {
-    this.text.setText(text);
-    this.resize();
-    return this;
-  }
-
-  private resize() {
-    this.title.setPosition(0, 0);
-    this.text.setPosition(0, this.title.height);
-    this.background.height = this.title.height + this.text.height;
-    this.background.width = Math.max(this.title.width, this.text.width);
-    this.titleBackground.setPosition(0, 0);
-    this.titleBackground.height = this.title.height;
-    this.titleBackground.width = this.background.width;
-
-    this.width = this.background.width;
-    this.height = this.background.height;
-  }
-
-  private addTextObject(
-    x: number,
-    y: number,
-    text: string,
-    padding: { top: number; bottom: number; left: number; right: number } = {
-      top: 5,
-      bottom: 5,
-      left: 10,
-      right: 10,
-    }
-  ): GameObjects.Text {
-    return this.scene.add.text(x, y, text, {
-      fontFamily: "monospace",
-      fontSize: "14px",
-      color: "#cccccc",
-      stroke: "#000000",
-      strokeThickness: 0.5,
-      padding: padding,
-    });
-  }
-}
diff --git a/src/plugins/debug-screen.plugin.ts b/src/plugins/debug-screen.plugin.ts
new file mode 100644
index 0000000..8b07f40
--- /dev/null
+++ b/src/plugins/debug-screen.plugin.ts
@@ -0,0 +1,356 @@
+import { GameObjects } from 'phaser'
+import config from '../game-config'
+import { Debuggable, isDebuggable } from '../mixins/debuggable.mixin'
+import { isGameScene } from '../scenes/game.scene'
+import { uiScene, player } from '../core/globals'
+
+type DebugInfoLevel = 'all' | 'physics' | 'info' | 'none'
+type DebuggableObject = Debuggable & {
+  name?: string
+  active?: boolean
+  body?: Phaser.Physics.Arcade.Body
+}
+
+export default class DebugScreenPlugin extends Phaser.Plugins.ScenePlugin {
+  private debugInfoLevel: DebugInfoLevel = 'none'
+  private help: DebugInfoWindow
+  private sceneDebugInfo: DebugInfoWindow
+  private debugGraphics: Phaser.GameObjects.Graphics
+  private debugObjects: {
+    [key: string]: {
+      object: DebuggableObject
+      window: DebugInfoWindow | null
+    }
+  } = {}
+
+  private get debugInfoEnabled(): boolean {
+    return this.debugInfoLevel !== 'none'
+  }
+
+  private readonly displayBorder: number = 10
+
+  constructor(scene: Phaser.Scene, pluginManager: Phaser.Plugins.PluginManager) {
+    super(scene, pluginManager, 'DebugScreenPlugin')
+
+    if (scene.scene.key === 'UIScene') return
+
+    // enable debug by default for development
+    if (process.env.NODE_ENV === 'development') {
+      this.debugInfoLevel = 'info'
+    }
+
+    this.scene.events.on(Phaser.Scenes.Events.UPDATE, () => {
+      if (!this.sceneDebugInfo && uiScene) {
+        this.create()
+      }
+    })
+
+    const drawDebugPhysics = this.debugInfoLevel === 'all' || this.debugInfoLevel === 'physics'
+
+    this.scene.events.once(Phaser.Scenes.Events.READY, (event: Phaser.Scenes.Systems) => {
+      this.debugGraphics = event.scene.add.graphics().setDepth(config.depths.debug)
+
+      event.scene.physics.world.createDebugGraphic()
+      event.scene.physics.world.drawDebug = drawDebugPhysics
+
+      if (event.scene.matter) {
+        event.scene.matter.world.createDebugGraphic()
+        event.scene.matter.world.drawDebug = drawDebugPhysics
+      }
+    })
+  }
+
+  public create() {
+    if (!uiScene) return
+
+    this.sceneDebugInfo = new DebugInfoWindow(uiScene, `${this.scene.scene.key}`)
+      .setScrollFactor(0)
+      .setPosition(this.displayBorder, this.displayBorder)
+
+    this.help = new DebugInfoWindow(uiScene, 'Help')
+      .setScrollFactor(0)
+      .setText(
+        [
+          'F8       toggle camera mode',
+          'F9       toggle debug info',
+          '8        toggle weather',
+          '9        toggle emergency light',
+          '0        toggle lights',
+          '1,2,3,4  toggle weapons',
+          'A,W,S,D  move',
+          'E        interact with objects',
+          'SPACE    attack',
+          'SHIFT    run',
+        ].join('\n'),
+      )
+
+    this.help.setPosition(
+      this.scene.game.canvas.width - this.help.width - this.displayBorder,
+      this.displayBorder,
+    )
+
+    const registerDebuggable = (object: Phaser.GameObjects.GameObject | DebuggableObject) => {
+      if (isDebuggable(object) && object.name && !this.debugObjects[object.name]) {
+        this.debugObjects[object.name] = {
+          object: object as DebuggableObject,
+          window: object.hasDebugInfo() ? new DebugInfoWindow(uiScene, object.name) : null,
+        }
+      }
+    }
+
+    this.scene.children.list.forEach(registerDebuggable)
+    if (player) registerDebuggable(player)
+
+    this.scene.events.on(Phaser.Scenes.Events.ADDED_TO_SCENE, registerDebuggable)
+    this.scene.events.on('debuggable-added', registerDebuggable)
+
+    this.scene.events.on(
+      Phaser.Scenes.Events.REMOVED_FROM_SCENE,
+      (object: Phaser.GameObjects.GameObject) => {
+        if (isDebuggable(object)) {
+          this.debugObjects[object.name].window.destroy()
+          delete this.debugObjects[object.name]
+        }
+      },
+    )
+
+    this.scene.events.on(Phaser.Scenes.Events.UPDATE, () => {
+      this.resetDebugGraphics(this.debugInfoLevel)
+      this.drawDebugInfo()
+      this.drawDebugPhysics()
+    })
+    this.scene.events.on(Phaser.Scenes.Events.SHUTDOWN, () => this.cleanup())
+    this.scene.events.on(Phaser.Scenes.Events.DESTROY, () => this.cleanup())
+
+    this.scene.input.keyboard.on('keydown-F9', () => {
+      const nextLevel: { [key in DebugInfoLevel]: DebugInfoLevel } = {
+        all: 'physics',
+        physics: 'info',
+        info: 'none',
+        none: 'all',
+      }
+
+      this.debugInfoLevel = nextLevel[this.debugInfoLevel]
+      this.resetDebugGraphics(this.debugInfoLevel)
+    })
+  }
+
+  private resetDebugGraphics(level: DebugInfoLevel) {
+    const drawDebugPhysics = level === 'physics' || level === 'all'
+
+    this.debugGraphics.clear()
+
+    this.scene.physics.world.debugGraphic.clear()
+    this.scene.physics.world.drawDebug = drawDebugPhysics
+
+    if (this.scene.matter) {
+      this.scene.matter.world.debugGraphic.clear()
+      this.scene.matter.world.drawDebug = drawDebugPhysics
+    }
+  }
+
+  private drawDebugInfo() {
+    const drawDebugInfo = this.debugInfoLevel === 'all' || this.debugInfoLevel === 'info'
+
+
+    for (const key in this.debugObjects) {
+      const obj = this.debugObjects[key].object
+      const isActive = obj?.active !== false
+      if (this.debugObjects[key].window) {
+        this.debugObjects[key].window.visible = drawDebugInfo && isActive
+      }
+    }
+
+    if (!this.debugInfoEnabled) {
+      return
+    }
+
+    this.sceneDebugInfo.setDebugInfo(this.getSceneDebugInfo(this.scene))
+
+    for (const key in this.debugObjects) {
+      const object = this.debugObjects[key].object
+      if (!object) {
+        continue
+      }
+
+      // Skip inactive objects
+      if (object.active === false) {
+        continue
+      }
+
+      const objectSize = {
+        width: object.body?.width ?? 0,
+        height: object.body?.height ?? 0,
+      }
+
+      const objectInfo = this.debugObjects[key].window
+      if (!objectInfo) {
+        continue
+      }
+
+      objectInfo.setDebuggable(object)
+
+      const worldX = (object.body?.position?.x ?? 0) + objectSize.width / 2
+      const worldY = (object.body?.position?.y ?? 0) + objectSize.height / 2
+      const camera = this.scene.cameras.main
+
+      const relX = worldX - camera.worldView.centerX
+      const relY = worldY - camera.worldView.centerY
+      const rot = (camera as unknown as { rotation: number }).rotation
+      const cos = Math.cos(rot)
+      const sin = Math.sin(rot)
+      const rotatedX = relX * cos - relY * sin
+      const rotatedY = relX * sin + relY * cos
+
+      const screenX = camera.width / 2 + rotatedX * camera.zoom
+      const screenY = camera.height / 2 + rotatedY * camera.zoom
+
+      objectInfo.setScrollFactor(0)
+      objectInfo.setPosition(
+        screenX + objectSize.width / 2 + 10,
+        screenY + objectSize.height / 2 + 10,
+      )
+    }
+  }
+
+  private drawDebugPhysics() {
+    const drawDebugPhysics = this.debugInfoLevel === 'all' || this.debugInfoLevel === 'physics'
+
+    if (!drawDebugPhysics) {
+      return
+    }
+
+    for (const key in this.debugObjects) {
+      const object = this.debugObjects[key].object
+      if (!object) {
+        console.log('skipping', key)
+        continue
+      }
+
+      object.drawDebugPhysics(this.debugGraphics)
+    }
+  }
+
+  private cleanup() {
+    this.sceneDebugInfo.destroy()
+    this.help.destroy()
+    for (const key in this.debugObjects) {
+      this.debugObjects[key].window?.destroy()
+    }
+  }
+
+  private getSceneDebugInfo(scene: Phaser.Scene): Record<string, unknown> {
+    const info: Record<string, unknown> = {
+      fps: Math.round(scene.game.loop.actualFps),
+    }
+
+    if (isGameScene(scene)) {
+      const debugInfo = scene.getDebugInfo()
+      Object.assign(info, debugInfo)
+    }
+
+    Object.assign(info, {
+      objects: scene.children.length,
+      bodies: scene.physics.world.bodies.size,
+      collisions: scene.physics.world.colliders.length,
+      lights: scene.lights.lights.length,
+      debugInfoLevel: this.debugInfoLevel,
+      debugObjects: Object.keys(this.debugObjects),
+    })
+
+    return info
+  }
+}
+
+class DebugInfoWindow extends Phaser.GameObjects.Container {
+  private background: GameObjects.Rectangle
+  private titleBackground: GameObjects.Rectangle
+  private title: GameObjects.Text
+  private text: GameObjects.Text
+
+  constructor(scene: Phaser.Scene, title: string) {
+    super(scene, 0, 0)
+
+    this.background = this.scene.add.rectangle(0, 0, 0, 0, 0x000000).setAlpha(0.5)
+    this.titleBackground = this.scene.add.rectangle(0, 0, 0, 0, 0x000000).setAlpha(0.5)
+
+    this.title = this.addTextObject(0, 0, title)
+    this.text = this.addTextObject(0, 0, '')
+
+    this.add([this.background, this.titleBackground, this.title, this.text])
+
+    this.scene.add.existing(this)
+    this.setDepth(9999)
+    this.resize()
+  }
+
+  public setDebuggable(debuggable: Debuggable): DebugInfoWindow {
+    const debugInfo = debuggable?.getDebugInfo()
+    if (!debugInfo) {
+      this.setText('no debug info available')
+      return this
+    }
+
+    return this.setDebugInfo(debugInfo)
+  }
+
+  public setDebugInfo(debugInfo: Record<string, unknown>) {
+    const text = this.formatDebugInfo(debugInfo)
+    return this.setText(text)
+  }
+
+  private formatDebugInfo(debugInfo: Record<string, unknown>, indent = 0): string {
+    const maxSpace = Math.max(...Object.keys(debugInfo).map((key) => key.length)) + 2
+    const indentString = indent ? ' '.repeat(indent) : ''
+    return Object.keys(debugInfo)
+      .map(
+        (key) =>
+          `${indentString}${key}${' '.repeat(maxSpace - key.length)}${
+            debugInfo[key] instanceof Object
+              ? '\n' + this.formatDebugInfo(debugInfo[key] as Record<string, unknown>, indent + 4)
+              : String(debugInfo[key])
+          }`,
+      )
+      .join('\n')
+  }
+
+  public setText(text: string): DebugInfoWindow {
+    this.text.setText(text)
+    this.resize()
+    return this
+  }
+
+  private resize() {
+    this.title.setPosition(0, 0)
+    this.text.setPosition(0, this.title.height)
+    this.background.height = this.title.height + this.text.height
+    this.background.width = Math.max(this.title.width, this.text.width)
+    this.titleBackground.setPosition(0, 0)
+    this.titleBackground.height = this.title.height
+    this.titleBackground.width = this.background.width
+
+    this.width = this.background.width
+    this.height = this.background.height
+  }
+
+  private addTextObject(
+    x: number,
+    y: number,
+    text: string,
+    padding: { top: number; bottom: number; left: number; right: number } = {
+      top: 5,
+      bottom: 5,
+      left: 10,
+      right: 10,
+    },
+  ): GameObjects.Text {
+    return this.scene.add.text(x, y, text, {
+      fontFamily: 'monospace',
+      fontSize: '14px',
+      color: '#cccccc',
+      stroke: '#000000',
+      strokeThickness: 0.5,
+      padding: padding,
+    })
+  }
+}
diff --git a/src/scenes/Event.ts b/src/scenes/Event.ts
deleted file mode 100644
index 9ab0769..0000000
--- a/src/scenes/Event.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-export enum Event {
-  FLASHLIGHT_MISSING = "flashlight:missing",
-  UNKNOWN_OBJECT = "object:unknown",
-  NO_OBJECT_IN_RANGE = "object:none-in-range",
-  OBJECT_PICKED_UP = "object:picked-up",
-  INTERACT_WITH_OBJECT = "object:interact",
-  OBJECT_TOO_FAR = "object:too-far",
-  OBJECT_STILL_TOO_FAR = "object:still-too-far",
-
-  WEAPON_MODE_CHANGED = "weapon:mode-changed",
-}
diff --git a/src/scenes/GameScene.ts b/src/scenes/GameScene.ts
deleted file mode 100644
index f97bcc9..0000000
--- a/src/scenes/GameScene.ts
+++ /dev/null
@@ -1,469 +0,0 @@
-import PhaserRaycaster from "phaser-raycaster";
-import config from "../GameConfig";
-import PlayerInputs from "../controls/PlayerInputs";
-import Flashlight from "../objects/Flashlight";
-import Pointer from "../objects/Pointer";
-import Player from "../objects/Player";
-import { Event } from "./Event";
-import { Pointable } from "../types/Pointable";
-import {
-  getTintColorShift,
-  isLightAware,
-  LightAware,
-} from "../types/LightAware";
-import { IObstacle } from "../types/Obstacle";
-import { StaticMatterThing } from "../objects/StaticMatterThing";
-import {
-  StaticMatterProjectionRectangle,
-  StaticMatterProjectionCircle,
-} from "../objects/StaticMatterProjection";
-import EmergencyAlarmLight from "../objects/EmergencyAlarmLight";
-import {
-  ILightSource,
-  LightSource,
-  LightSourceConfig,
-} from "../types/LightSource";
-import { Rain, WeatherConditions } from "../objects/Weather";
-
-export interface IGameScene {
-  getDebugInfo(): object;
-}
-
-export function isGameScene(scene: object): scene is IGameScene {
-  if (typeof scene !== "object") {
-    return false;
-  }
-
-  return "getDebugInfo" in scene;
-}
-
-export default class GameScene extends Phaser.Scene implements IGameScene {
-  private _inputs: PlayerInputs;
-  private _isDark: boolean;
-  private _lightSceneGraphics: Phaser.GameObjects.Graphics;
-  private _lightShadowSceneGraphics: Phaser.GameObjects.Graphics;
-
-  private raycasterPlugin: PhaserRaycaster;
-  private fieldUnderLight: Phaser.GameObjects.TileSprite;
-  private fieldUnderLightShadow: Phaser.GameObjects.TileSprite;
-  private field: Phaser.GameObjects.TileSprite;
-  private pointer: Pointer;
-  private player: Player;
-  private lightSources: ILightSource[] = [];
-  private objects: any[] = [];
-  private obstacles: IObstacle[] = [];
-  private redLight: {
-    light: EmergencyAlarmLight;
-    isOn: boolean;
-    enabled: boolean;
-  };
-  private weather: WeatherConditions;
-
-  public get isDark(): boolean {
-    return this._isDark;
-  }
-
-  public get lightSceneGraphics(): Phaser.GameObjects.Graphics {
-    if (this._lightSceneGraphics.postFX.list.length === 0) {
-      this._lightSceneGraphics.setPipeline("Light2D");
-    }
-
-    return this._lightSceneGraphics;
-  }
-
-  public get lightShadowSceneGraphics(): Phaser.GameObjects.Graphics {
-    if (this._lightShadowSceneGraphics.postFX.list.length === 0) {
-      this._lightShadowSceneGraphics.setPipeline("Light2D");
-    }
-
-    return this._lightShadowSceneGraphics;
-  }
-
-  public get inputs(): PlayerInputs {
-    return this._inputs;
-  }
-
-  constructor() {
-    super({
-      key: "GameScene",
-      physics: {
-        arcade: {},
-        matter: {},
-      },
-    });
-  }
-
-  public closestObject(): Phaser.GameObjects.GameObject {
-    return this.physics.closest(
-      this.player,
-      this.physics.world.bodies.entries.filter(
-        (body) => this.objects.indexOf(body.gameObject) > -1
-      )
-    )?.gameObject;
-  }
-
-  create() {
-    const { width, height } = { width: 1600, height: 1200 };
-
-    this.physics.world.setBounds(0, 0, width, height);
-    this.matter.world.setBounds(0, 0, width, height);
-
-    this.fieldUnderLight = this.add
-      .tileSprite(800, 600, width, height, "background")
-      .setDepth(config.depths.background - 2);
-    this.fieldUnderLight.setPipeline("Light2D");
-
-    this.fieldUnderLightShadow = this.add
-      .tileSprite(800, 600, width, height, "background")
-      .setDepth(config.depths.background - 1)
-      .setTint(config.colors.darkenShadowTintColor);
-    this.fieldUnderLightShadow.setPipeline("Light2D");
-
-    this.field = this.add
-      .tileSprite(800, 600, width, height, "background")
-      .setDepth(config.depths.background);
-    this.field.setPipeline("Light2D");
-
-    this.lights.enable();
-    this.lights.setAmbientColor(0xffffff);
-
-    this._lightSceneGraphics = this.add
-      .graphics()
-      .setName("lightSceneGraphics");
-
-    this._lightShadowSceneGraphics = this.add
-      .graphics()
-      .setName("lightShadowSceneGraphics");
-
-    this.field.setMask(
-      this._lightShadowSceneGraphics.createGeometryMask().setInvertAlpha(true)
-    );
-
-    this.fieldUnderLightShadow.setMask(
-      this._lightSceneGraphics.createGeometryMask().setInvertAlpha(true)
-    );
-
-    const barrel = new (LightAware(StaticMatterThing))(
-      this,
-      970,
-      400,
-      "barrel-damaged"
-    )
-      .setScale(0.3)
-      .setOrigin(0.5, 0.5)
-      .setAngle(25);
-
-    barrel.setLightAwareShape(
-      barrel.createPolygon([
-        { x: 3, y: 36 },
-        { x: 211, y: 11 },
-        { x: 310, y: 13 },
-        { x: 440, y: 18 },
-        { x: 518, y: 41 },
-        { x: 625, y: 31 },
-        { x: 629, y: 235 },
-        { x: 592, y: 428 },
-        { x: 496, y: 412 },
-        { x: 444, y: 422 },
-        { x: 404, y: 406 },
-        { x: 390, y: 369 },
-        { x: 320, y: 340 },
-        { x: 271, y: 380 },
-        { x: 209, y: 409 },
-        { x: 81, y: 432 },
-        { x: 32, y: 274 },
-      ])
-    );
-
-    const barrel2 = new (LightAware(StaticMatterThing))(
-      this,
-      770,
-      350,
-      "barrel"
-    )
-      .setScale(0.3)
-      .setCircle(80)
-      .setAngle(-15)
-      .setOrigin(0.5, 0.5);
-
-    barrel2.setLightAwareShape(barrel2.createCircle(73));
-
-    const barrel3 = new (LightAware(StaticMatterThing))(
-      this,
-      900,
-      220,
-      "barrel-damaged-2"
-    )
-      .setScale(0.3)
-      .setCircle(75)
-      .setAngle(165)
-      .setOrigin(0.5, 0.5);
-
-    barrel3.setLightAwareShape(barrel3.createCircle(73));
-
-    this.obstacles.push(new StaticMatterProjectionRectangle(this, barrel));
-    this.obstacles.push(new StaticMatterProjectionCircle(this, barrel2, 75));
-    this.obstacles.push(new StaticMatterProjectionCircle(this, barrel3, 70));
-
-    this.objects.push(
-      new (Pointable(Flashlight))(
-        this,
-        820,
-        360,
-        this.createRaycaster()
-      ).setAngle(-45),
-      barrel,
-      barrel2
-    );
-
-    this.player = new Player(this, 800, 600);
-    this.pointer = new Pointer(this, 800, 500);
-
-    this.weather = new WeatherConditions(this, this.player);
-
-    this.redLight = {
-      light: new EmergencyAlarmLight(this, 10, 200).setAngle(90),
-      isOn: false,
-      enabled: false,
-    };
-
-    this.time.addEvent({
-      delay: 1000,
-      callback: () => (this.redLight.isOn = !this.redLight.isOn),
-      loop: true,
-    });
-
-    // this.darken();
-    this.lighten();
-
-    // Set camera zoom
-    this.cameras.main.zoom = 1;
-
-    // Locks pointer on mousedown
-    this.game.canvas.addEventListener("mousedown", () => {
-      this.game.input.mouse.requestPointerLock();
-    });
-
-    // Move player pointer upon locked pointer move
-    this.input.on(
-      Phaser.Input.Events.POINTER_MOVE,
-      function (pointer: Phaser.Input.Pointer) {
-        if (this.input.mouse.locked) {
-          this.pointer.x += pointer.movementX;
-          this.pointer.y += pointer.movementY;
-        }
-      },
-      this
-    );
-
-    this._inputs = new PlayerInputs(this.input);
-
-    this.events.on(Event.FLASHLIGHT_MISSING, () => {
-      console.error("Flashlight is missing");
-    });
-
-    this.events.on(Event.OBJECT_PICKED_UP, (item: any) => {
-      console.info("Picked up", item.name);
-    });
-
-    this.events.on(Event.UNKNOWN_OBJECT, (item: any) => {
-      console.error("Unknown object", item.name);
-    });
-
-    this.events.on(Event.NO_OBJECT_IN_RANGE, () => {
-      console.error("No object in range");
-    });
-
-    this.events.on(Event.OBJECT_TOO_FAR, (item: any) => {
-      console.error(`${item.name} is too far`);
-    });
-
-    this.events.on(Event.OBJECT_STILL_TOO_FAR, (item: any) => {
-      console.error(`Can't reach this damn ${item.name}. It is still too far`);
-    });
-
-    this.events.on(Event.INTERACT_WITH_OBJECT, () => {
-      const item = this.closestObject();
-      if (item) {
-        this.player.interactWithObject(item);
-      } else {
-        this.events.emit(Event.NO_OBJECT_IN_RANGE);
-      }
-    });
-
-    this.events.on(Phaser.Scenes.Events.POST_UPDATE, () => {
-      this.player?.postUpdate();
-
-      if (Phaser.Input.Keyboard.JustDown(this.inputs.keys.zero)) {
-        if (this.isDark) {
-          this.lighten();
-        } else {
-          this.darken();
-        }
-      }
-
-      if (Phaser.Input.Keyboard.JustDown(this.inputs.keys.nine)) {
-        this.redLight.enabled = !this.redLight.enabled;
-      }
-
-      if (Phaser.Input.Keyboard.JustDown(this.inputs.keys.eight)) {
-        this.weather.toggle();
-      }
-    });
-
-    this.events.on(Phaser.Scenes.Events.PRE_RENDER, () => {
-      // reset light effects
-      this.children.each((child) => {
-        if (isLightAware(child)) {
-          child.onLightOverReset();
-        }
-      });
-
-      this.lightShadowSceneGraphics.clear();
-      this.lightSceneGraphics.clear();
-
-      // update lights
-      if (this.redLight?.enabled) {
-        if (this.redLight.isOn) {
-          this.redLight.light.turnOn();
-        } else {
-          this.redLight.light.turnOff();
-        }
-      }
-
-      this.lightSources.forEach((child) => {
-        if (child.isEnabled) {
-          child.emitLight();
-        }
-      });
-    });
-  }
-
-  public createRaycaster(): Raycaster {
-    return this.raycasterPlugin.createRaycaster();
-  }
-
-  public createLightSource(name: string, config: LightSourceConfig) {
-    const lightSource = new LightSource(
-      this,
-      this.createRaycaster(),
-      name,
-      config
-    );
-    this.lightSources.push(lightSource);
-    return lightSource;
-  }
-
-  public getDebugInfo(): object {
-    return {
-      weather: this.weather.getDebugInfo(),
-    };
-  }
-
-  darken() {
-    this._isDark = true;
-    this.lightSceneGraphics.clear();
-    this.lightShadowSceneGraphics.clear();
-
-    this.field.setTint(config.colors.darkenTintColor);
-
-    this.children.each((child) => {
-      if (isLightAware(child)) {
-        // console.log("darken", child.name);
-        child.onDarken();
-      }
-    });
-  }
-
-  lighten() {
-    this._isDark = false;
-    this.lightSceneGraphics.clear();
-    this.lightShadowSceneGraphics.clear();
-
-    this.field.setTint();
-
-    this.children.each((child) => {
-      if (isLightAware(child)) {
-        // console.log("lighten", child.name);
-        child.onLighten();
-      }
-    });
-  }
-
-  reactToLightning(progress: number) {
-    if (!this.isDark) {
-      return;
-    }
-
-    this.field.setTint(getTintColorShift(0xffffff, progress));
-
-    this.children.each((child) => {
-      if (isLightAware(child)) {
-        child.onLighningtOver(progress);
-      }
-    });
-  }
-
-  update(_time, _delta) {
-    if (this.obstacles.length > 0) {
-      const obstacles = this.obstacles as Phaser.Physics.Arcade.Group[];
-      this.physics.world.collide(this.player, obstacles);
-    }
-
-    // Rotates player to face towards reticle
-    this.player.rotation = Phaser.Math.Angle.Between(
-      this.player.x,
-      this.player.y,
-      this.pointer.x,
-      this.pointer.y
-    );
-
-    // Camera follows player ( can be set in create )
-    this.cameras.main.startFollow(this.player);
-
-    this.pointer.update(this.player);
-
-    this.constrainVelocity(this.player, 500);
-    this.constrainPointer(this.pointer);
-  }
-
-  constrainVelocity(player: Player, maxVelocity: number) {
-    if (!player || !player.body) {
-      return;
-    }
-
-    let vx = player.body.velocity.x;
-    let vy = player.body.velocity.y;
-    let currVelocitySqr = vx * vx + vy * vy;
-
-    if (currVelocitySqr > maxVelocity * maxVelocity) {
-      let angle = Math.atan2(vy, vx);
-      vx = Math.cos(angle) * maxVelocity;
-      vy = Math.sin(angle) * maxVelocity;
-      player.body.velocity.x = vx;
-      player.body.velocity.y = vy;
-    }
-  }
-
-  constrainPointer(pointer: Pointer) {
-    if (
-      this.cameras.main.worldView.right <= 0 ||
-      this.cameras.main.worldView.bottom <= 0
-    ) {
-      return;
-    }
-
-    // can't move pointer offscreen
-    if (pointer.x < this.cameras.main.worldView.x) {
-      pointer.x = this.cameras.main.worldView.x;
-    } else if (pointer.x > this.cameras.main.worldView.right) {
-      pointer.x = this.cameras.main.worldView.right;
-    }
-
-    if (pointer.y < this.cameras.main.worldView.y) {
-      pointer.y = this.cameras.main.worldView.y;
-    } else if (pointer.y > this.cameras.main.worldView.bottom) {
-      pointer.y = this.cameras.main.worldView.bottom;
-    }
-  }
-}
diff --git a/src/scenes/PreloadScene.ts b/src/scenes/PreloadScene.ts
deleted file mode 100644
index a88e131..0000000
--- a/src/scenes/PreloadScene.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-export default class PreloadScene extends Phaser.Scene {
-  constructor() {
-    super("PreloadScene");
-  }
-
-  preload() {
-    this.load.image("flashlight", "assets/images/flashlight.png");
-    this.load.image("background", "assets/images/floor.png");
-    this.load.image("wall-lamp", "assets/images/wall-lamp.png");
-    this.load.image("green-dot", "assets/images/green-dot.png");
-
-    this.load.image("muzzle-flash", "assets/images/muzzle-flash.png");
-    this.load.atlas(
-      "bullet-casings",
-      "assets/particles/bullet-casings.png",
-      "assets/particles/bullet-casings.json"
-    );
-    this.load.image("rain-splash", "assets/particles/rain-splash.png");
-
-    this.load.image("barrel", "assets/images/barrel.png");
-    this.load.image("barrel-damaged", "assets/images/barrel-damaged.png");
-    this.load.image("barrel-damaged-2", "assets/images/barrel-damaged-2.png");
-
-    this.load.setPath("assets/spine/");
-    this.load.spine("player", "player.json", "player.atlas");
-    this.load.spine("player-legs", "player-legs.json", "player-legs.atlas");
-  }
-
-  create() {
-    this.scene.start("GameScene");
-  }
-}
diff --git a/src/scenes/event.ts b/src/scenes/event.ts
new file mode 100644
index 0000000..04ea929
--- /dev/null
+++ b/src/scenes/event.ts
@@ -0,0 +1,11 @@
+export enum Event {
+  FLASHLIGHT_MISSING = 'flashlight:missing',
+  UNKNOWN_OBJECT = 'object:unknown',
+  NO_OBJECT_IN_RANGE = 'object:none-in-range',
+  OBJECT_PICKED_UP = 'object:picked-up',
+  INTERACT_WITH_OBJECT = 'object:interact',
+  OBJECT_TOO_FAR = 'object:too-far',
+  OBJECT_STILL_TOO_FAR = 'object:still-too-far',
+
+  WEAPON_MODE_CHANGED = 'weapon:mode-changed',
+}
diff --git a/src/scenes/game.scene.ts b/src/scenes/game.scene.ts
new file mode 100644
index 0000000..eef3263
--- /dev/null
+++ b/src/scenes/game.scene.ts
@@ -0,0 +1,520 @@
+import PhaserRaycaster from 'phaser-raycaster'
+import config from '../game-config'
+import PlayerInputs from '../controls/player-inputs'
+import Pointer from '../objects/pointer.object'
+import { Event } from './event'
+import {
+  Projection,
+  StaticMatterProjectionRectangle,
+  StaticMatterProjectionCircle,
+} from '../objects/static-matter-projection.object'
+import { WeatherConditions } from '../objects/weather.object'
+
+// Core imports for new architecture
+import '../core/display-object.ext'
+import { setGlobals, setPlayer, setUIScene, clearGlobals } from '../core/globals'
+import { runStepCallbacks, clearStepCallbacks } from '../core/display-object.ext'
+import {
+  clearAllInstances,
+  Instances,
+  MIXIN_LIGHT_AWARE,
+  MIXIN_LIGHT_SOURCE,
+} from '../core/instances'
+import { getTintColorShift } from '../mixins/light-aware.mixin'
+
+// New factory functions
+import { createPlayer, PlayerObject } from '../objects/player.object'
+import { createFlashlight, FlashlightObject } from '../objects/flashlight.object'
+import { createEmergencyLight, EmergencyLightObject } from '../objects/emergency-light.object'
+import { createBarrel, BarrelObject } from '../objects/barrel.object'
+
+export function isGameScene(scene: object): scene is GameScene {
+  return typeof scene === 'object' && 'getDebugInfo' in scene
+}
+
+type CameraMode = 'map' | 'player'
+
+export default class GameScene extends Phaser.Scene {
+  private _inputs: PlayerInputs
+  private _isDark: boolean
+  private _lightSceneGraphics: Phaser.GameObjects.Graphics
+  private _lightShadowSceneGraphics: Phaser.GameObjects.Graphics
+  private _cameraMode: CameraMode = 'map'
+  private _playerAimAngle: number = 0
+  private _pointerDistance: number = 100
+  private _cameraRotation: number = 0
+  private _targetCameraRotation: number = 0
+  private _isTransitioning: boolean = false
+
+  private raycasterPlugin: PhaserRaycaster
+  private fieldUnderLight: Phaser.GameObjects.TileSprite
+  private fieldUnderLightShadow: Phaser.GameObjects.TileSprite
+  private field: Phaser.GameObjects.TileSprite
+  private pointer: Pointer
+  private player: PlayerObject
+  private objects: Phaser.GameObjects.GameObject[] = []
+  private obstacles: Projection[] = []
+  private redLight: { light: EmergencyLightObject; isOn: boolean; enabled: boolean }
+  private weather: WeatherConditions
+
+  public get isDark(): boolean {
+    return this._isDark
+  }
+
+  public get isPlayerMode(): boolean {
+    return this._cameraMode === 'player'
+  }
+
+  public get lightSceneGraphics(): Phaser.GameObjects.Graphics {
+    if (this._lightSceneGraphics.postFX.list.length === 0) {
+      this._lightSceneGraphics.setPipeline('Light2D')
+    }
+    return this._lightSceneGraphics
+  }
+
+  public get lightShadowSceneGraphics(): Phaser.GameObjects.Graphics {
+    if (this._lightShadowSceneGraphics.postFX.list.length === 0) {
+      this._lightShadowSceneGraphics.setPipeline('Light2D')
+    }
+    return this._lightShadowSceneGraphics
+  }
+
+  public get inputs(): PlayerInputs {
+    return this._inputs
+  }
+
+  constructor() {
+    super({
+      key: 'GameScene',
+      physics: {
+        arcade: {},
+        matter: {},
+      },
+    })
+  }
+
+  public closestObject(): Phaser.GameObjects.GameObject {
+    return this.physics.closest(
+      this.player.puppet,
+      this.physics.world.bodies.entries.filter(
+        (body) => this.objects.indexOf(body.gameObject) > -1,
+      ),
+    )?.gameObject
+  }
+
+  private removeFromObjects(item: Phaser.GameObjects.GameObject): void {
+    const index = this.objects.indexOf(item)
+    if (index > -1) {
+      this.objects.splice(index, 1)
+    }
+  }
+
+  create() {
+    const { width, height } = { width: 1600, height: 1200 }
+
+    this.physics.world.setBounds(0, 0, width, height)
+    this.matter.world.setBounds(0, 0, width, height)
+
+    this._inputs = new PlayerInputs(this.input)
+    setGlobals(this)
+
+    this.scene.launch('UIScene')
+    const ui = this.scene.get('UIScene')
+    setUIScene(ui)
+
+    this.fieldUnderLight = this.add
+      .tileSprite(800, 600, width, height, 'background')
+      .setDepth(config.depths.background - 2)
+    this.fieldUnderLight.setPipeline('Light2D')
+
+    this.fieldUnderLightShadow = this.add
+      .tileSprite(800, 600, width, height, 'background')
+      .setDepth(config.depths.background - 1)
+      .setTint(config.colors.darkenShadowTintColor)
+    this.fieldUnderLightShadow.setPipeline('Light2D')
+
+    this.field = this.add
+      .tileSprite(800, 600, width, height, 'background')
+      .setDepth(config.depths.background)
+    this.field.setPipeline('Light2D')
+
+    this.lights.enable()
+    this.lights.setAmbientColor(0xffffff)
+
+    this._lightSceneGraphics = this.add.graphics().setName('lightSceneGraphics')
+    this._lightShadowSceneGraphics = this.add.graphics().setName('lightShadowSceneGraphics')
+
+    this.field.setMask(this._lightShadowSceneGraphics.createGeometryMask().setInvertAlpha(true))
+
+    this.fieldUnderLightShadow.setMask(
+      this._lightSceneGraphics.createGeometryMask().setInvertAlpha(true),
+    )
+
+    // Create barrels using new factory functions
+    const barrel = createBarrel(this, 970, 400, 'barrel-damaged')
+      .setScale(0.3)
+      .setOrigin(0.5, 0.5)
+      .setAngle(25)
+
+    barrel.setLightAwareShape(
+      barrel.createPolygon([
+        { x: 3, y: 36 },
+        { x: 211, y: 11 },
+        { x: 310, y: 13 },
+        { x: 440, y: 18 },
+        { x: 518, y: 41 },
+        { x: 625, y: 31 },
+        { x: 629, y: 235 },
+        { x: 592, y: 428 },
+        { x: 496, y: 412 },
+        { x: 444, y: 422 },
+        { x: 404, y: 406 },
+        { x: 390, y: 369 },
+        { x: 320, y: 340 },
+        { x: 271, y: 380 },
+        { x: 209, y: 409 },
+        { x: 81, y: 432 },
+        { x: 32, y: 274 },
+      ]),
+    )
+
+    const barrel2 = createBarrel(this, 770, 350, 'barrel')
+      .setScale(0.3)
+      .setCircle(80)
+      .setAngle(-15)
+      .setOrigin(0.5, 0.5)
+
+    barrel2.setLightAwareShape(barrel2.createCircle(73))
+
+    const barrel3 = createBarrel(this, 900, 220, 'barrel-damaged-2')
+      .setScale(0.3)
+      .setCircle(75)
+      .setAngle(165)
+      .setOrigin(0.5, 0.5)
+
+    barrel3.setLightAwareShape(barrel3.createCircle(73))
+
+    this.obstacles.push(new StaticMatterProjectionRectangle(this, barrel))
+    this.obstacles.push(new StaticMatterProjectionCircle(this, barrel2, 75))
+    this.obstacles.push(new StaticMatterProjectionCircle(this, barrel3, 70))
+
+    // Create flashlight using new factory function
+    const flashlight = createFlashlight(this, 820, 360, this.createRaycaster()).setAngle(-45)
+    this.objects.push(flashlight, barrel, barrel2)
+
+    // Create player using new factory function
+    this.player = createPlayer(this, 800, 600, this.createRaycaster())
+    setPlayer(this.player)
+
+    this.pointer = new Pointer(this, 800, 500)
+    this.weather = new WeatherConditions(this, this.player)
+
+    // Create emergency light using new factory function
+    const emergencyLight = createEmergencyLight(this, 10, 200, this.createRaycaster()).setAngle(90)
+    emergencyLight.mapLightAwareObject(this.player)
+
+    this.redLight = {
+      light: emergencyLight,
+      isOn: false,
+      enabled: false,
+    }
+
+    this.time.addEvent({
+      delay: 1000,
+      callback: () => (this.redLight.isOn = !this.redLight.isOn),
+      loop: true,
+    })
+
+    this.lighten()
+    this.cameras.main.zoom = 1
+
+    this.game.canvas.addEventListener('mousedown', () => {
+      this.game.input.mouse.requestPointerLock()
+    })
+
+    this.input.on(
+      Phaser.Input.Events.POINTER_MOVE,
+      function (pointer: Phaser.Input.Pointer) {
+        if (!this.input.mouse.locked) return
+
+        if (this._cameraMode === 'map') {
+          this.pointer.x += pointer.movementX
+          this.pointer.y += pointer.movementY
+        } else {
+          const sensitivity = 0.003
+          this._playerAimAngle += pointer.movementX * sensitivity
+          this._targetCameraRotation = -this._playerAimAngle - Math.PI / 2
+          if (this._isTransitioning) {
+            this._cameraRotation = this._targetCameraRotation
+            this._isTransitioning = false
+          }
+          const maxDistance = Math.min(
+            this.cameras.main.width,
+            this.cameras.main.height,
+          ) / 2
+          this._pointerDistance = Phaser.Math.Clamp(
+            this._pointerDistance - pointer.movementY,
+            50,
+            maxDistance,
+          )
+        }
+      },
+      this,
+    )
+
+    this.events.on(Event.FLASHLIGHT_MISSING, () => {
+      console.error('Flashlight is missing')
+    })
+
+    this.events.on(Event.OBJECT_PICKED_UP, (item: Phaser.GameObjects.GameObject) => {
+      console.info('Picked up', item.name)
+      this.removeFromObjects(item)
+    })
+
+    this.events.on(Event.UNKNOWN_OBJECT, (item: Phaser.GameObjects.GameObject) => {
+      console.error('Unknown object', item.name)
+    })
+
+    this.events.on(Event.NO_OBJECT_IN_RANGE, () => {
+      console.error('No object in range')
+    })
+
+    this.events.on(Event.OBJECT_TOO_FAR, (item: Phaser.GameObjects.GameObject) => {
+      console.error(`${item.name} is too far`)
+    })
+
+    this.events.on(Event.OBJECT_STILL_TOO_FAR, (item: Phaser.GameObjects.GameObject) => {
+      console.error(`Can't reach this damn ${item.name}. It is still too far`)
+    })
+
+    this.events.on(Event.INTERACT_WITH_OBJECT, () => {
+      const item = this.closestObject()
+      if (item) {
+        this.player.interactWithObject(item)
+      } else {
+        this.events.emit(Event.NO_OBJECT_IN_RANGE)
+      }
+    })
+
+    this.events.on(Phaser.Scenes.Events.POST_UPDATE, () => {
+      this.player?.postUpdate()
+
+      if (Phaser.Input.Keyboard.JustDown(this.inputs.keys.zero)) {
+        if (this.isDark) {
+          this.lighten()
+        } else {
+          this.darken()
+        }
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(this.inputs.keys.nine)) {
+        this.redLight.enabled = !this.redLight.enabled
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(this.inputs.keys.eight)) {
+        this.weather.toggle()
+      }
+
+      if (Phaser.Input.Keyboard.JustDown(this.inputs.keys.F8)) {
+        this.toggleCameraMode()
+      }
+    })
+
+    this.events.on(Phaser.Scenes.Events.PRE_RENDER, () => {
+      // Reset light effects using new mixin system
+      for (const obj of Instances(MIXIN_LIGHT_AWARE)) {
+        obj.onLightOverReset()
+      }
+      this.player?.onLightOverReset()
+
+      this.lightShadowSceneGraphics.clear()
+      this.lightSceneGraphics.clear()
+
+      if (this.redLight?.enabled) {
+        if (this.redLight.isOn) {
+          this.redLight.light.turnOn()
+        } else {
+          this.redLight.light.turnOff()
+        }
+      }
+
+      // Emit light from all light sources using new mixin system
+      for (const source of Instances(MIXIN_LIGHT_SOURCE)) {
+        if (source.isLightEnabled) {
+          source.emitLight()
+        }
+      }
+    })
+  }
+
+  public createRaycaster(): Raycaster {
+    return this.raycasterPlugin.createRaycaster()
+  }
+
+  public getDebugInfo(): object {
+    return {
+      cameraMode: this._cameraMode,
+      weather: this.weather.getDebugInfo(),
+    }
+  }
+
+  private toggleCameraMode() {
+    if (this._cameraMode === 'map') {
+      this._cameraMode = 'player'
+      this._playerAimAngle = this.player.rotation
+      this._pointerDistance = Phaser.Math.Distance.Between(
+        this.player.x,
+        this.player.y,
+        this.pointer.x,
+        this.pointer.y,
+      )
+      this._targetCameraRotation = -this._playerAimAngle - Math.PI / 2
+    } else {
+      this._cameraMode = 'map'
+      this._targetCameraRotation = 0
+    }
+    this._isTransitioning = true
+  }
+
+  darken() {
+    this._isDark = true
+    this.lightSceneGraphics.clear()
+    this.lightShadowSceneGraphics.clear()
+
+    // Clear all light source graphics (removes day-mode light cones)
+    for (const source of Instances(MIXIN_LIGHT_SOURCE)) {
+      source.lightGraphics.clear()
+    }
+
+    this.field.setTint(config.colors.darkenTintColor)
+
+    for (const obj of Instances(MIXIN_LIGHT_AWARE)) {
+      obj.onDarken()
+    }
+
+    this.player?.onDarken()
+  }
+
+  lighten() {
+    this._isDark = false
+    this.lightSceneGraphics.clear()
+    this.lightShadowSceneGraphics.clear()
+
+    // Clear all light source graphics (removes night-mode light effects)
+    for (const source of Instances(MIXIN_LIGHT_SOURCE)) {
+      source.lightGraphics.clear()
+    }
+
+    this.field.setTint()
+
+    for (const obj of Instances(MIXIN_LIGHT_AWARE)) {
+      obj.onLighten()
+    }
+
+    this.player?.onLighten()
+  }
+
+  reactToLightning(progress: number) {
+    if (!this.isDark) {
+      return
+    }
+
+    this.field.setTint(getTintColorShift(0xffffff, progress))
+
+    for (const obj of Instances(MIXIN_LIGHT_AWARE)) {
+      obj.onLightningOver(progress)
+    }
+
+    this.player?.onLightningOver(progress)
+  }
+
+  update(_time: number, _delta: number) {
+    runStepCallbacks()
+
+    this.player?.preUpdate()
+
+    if (this.obstacles.length > 0) {
+      const obstacles = this.obstacles as unknown as Phaser.Physics.Arcade.Group[]
+      this.physics.world.collide(this.player.puppet, obstacles)
+    }
+
+    if (this._cameraMode === 'map') {
+      this.player.rotation = Phaser.Math.Angle.Between(
+        this.player.x,
+        this.player.y,
+        this.pointer.x,
+        this.pointer.y,
+      )
+    } else {
+      this.pointer.x = this.player.x + Math.cos(this._playerAimAngle) * this._pointerDistance
+      this.pointer.y = this.player.y + Math.sin(this._playerAimAngle) * this._pointerDistance
+      this._targetCameraRotation = -this._playerAimAngle - Math.PI / 2
+      this.player.rotation = this._playerAimAngle
+    }
+
+    if (this._isTransitioning) {
+      const lerpSpeed = 0.1
+      this._cameraRotation = Phaser.Math.Linear(
+        this._cameraRotation,
+        this._targetCameraRotation,
+        lerpSpeed,
+      )
+      if (Math.abs(this._cameraRotation - this._targetCameraRotation) < 0.001) {
+        this._cameraRotation = this._targetCameraRotation
+        this._isTransitioning = false
+      }
+    } else {
+      this._cameraRotation = this._targetCameraRotation
+    }
+    this.cameras.main.setRotation(this._cameraRotation)
+
+    this.cameras.main.startFollow(this.player.puppet)
+
+    this.pointer.update(this.player)
+
+    this.constrainVelocity(this.player, 500)
+    this.constrainPointer(this.pointer)
+  }
+
+  constrainVelocity(player: PlayerObject, maxVelocity: number) {
+    if (!player || !player.body) {
+      return
+    }
+
+    let vx = player.body.velocity.x
+    let vy = player.body.velocity.y
+    let currVelocitySqr = vx * vx + vy * vy
+
+    if (currVelocitySqr > maxVelocity * maxVelocity) {
+      let angle = Math.atan2(vy, vx)
+      vx = Math.cos(angle) * maxVelocity
+      vy = Math.sin(angle) * maxVelocity
+      player.body.velocity.x = vx
+      player.body.velocity.y = vy
+    }
+  }
+
+  constrainPointer(pointer: Pointer) {
+    if (this.cameras.main.worldView.right <= 0 || this.cameras.main.worldView.bottom <= 0) {
+      return
+    }
+
+    if (pointer.x < this.cameras.main.worldView.x) {
+      pointer.x = this.cameras.main.worldView.x
+    } else if (pointer.x > this.cameras.main.worldView.right) {
+      pointer.x = this.cameras.main.worldView.right
+    }
+
+    if (pointer.y < this.cameras.main.worldView.y) {
+      pointer.y = this.cameras.main.worldView.y
+    } else if (pointer.y > this.cameras.main.worldView.bottom) {
+      pointer.y = this.cameras.main.worldView.bottom
+    }
+  }
+
+  shutdown() {
+    clearStepCallbacks()
+    clearAllInstances()
+    clearGlobals()
+  }
+}
diff --git a/src/scenes/preload.scene.ts b/src/scenes/preload.scene.ts
new file mode 100644
index 0000000..18fc75d
--- /dev/null
+++ b/src/scenes/preload.scene.ts
@@ -0,0 +1,32 @@
+export default class PreloadScene extends Phaser.Scene {
+  constructor() {
+    super('PreloadScene')
+  }
+
+  preload() {
+    this.load.image('flashlight', 'assets/images/flashlight.png')
+    this.load.image('background', 'assets/images/floor.png')
+    this.load.image('wall-lamp', 'assets/images/wall-lamp.png')
+    this.load.image('green-dot', 'assets/images/green-dot.png')
+
+    this.load.image('muzzle-flash', 'assets/images/muzzle-flash.png')
+    this.load.atlas(
+      'bullet-casings',
+      'assets/particles/bullet-casings.png',
+      'assets/particles/bullet-casings.json',
+    )
+    this.load.image('rain-splash', 'assets/particles/rain-splash.png')
+
+    this.load.image('barrel', 'assets/images/barrel.png')
+    this.load.image('barrel-damaged', 'assets/images/barrel-damaged.png')
+    this.load.image('barrel-damaged-2', 'assets/images/barrel-damaged-2.png')
+
+    this.load.setPath('assets/spine/')
+    this.load.spine('player', 'player.json', 'player.atlas')
+    this.load.spine('player-legs', 'player-legs.json', 'player-legs.atlas')
+  }
+
+  create() {
+    this.scene.start('GameScene')
+  }
+}
diff --git a/src/scenes/ui.scene.ts b/src/scenes/ui.scene.ts
new file mode 100644
index 0000000..905d5e7
--- /dev/null
+++ b/src/scenes/ui.scene.ts
@@ -0,0 +1,16 @@
+import { scene } from '../core/globals'
+
+export default class UIScene extends Phaser.Scene {
+  constructor() {
+    super({ key: 'UIScene' })
+  }
+
+  create() {
+    this.events.on(Phaser.Scenes.Events.UPDATE, () => {
+      if (!scene) return
+      const mainCamera = scene.cameras.main
+      this.cameras.main.setScroll(mainCamera.scrollX, mainCamera.scrollY)
+      this.cameras.main.setZoom(mainCamera.zoom)
+    })
+  }
+}
diff --git a/src/types/Constructor.ts b/src/types/Constructor.ts
index 333c756..d5840a9 100644
--- a/src/types/Constructor.ts
+++ b/src/types/Constructor.ts
@@ -1,3 +1,3 @@
-export type Constructor = new (...args: any[]) => {};
+export type Constructor = new (...args: unknown[]) => object
 
-export type GenericConstructor<T = {}> = new (...args: any[]) => T;
+export type GenericConstructor<T = object> = new (...args: unknown[]) => T
diff --git a/src/types/Debuggable.ts b/src/types/Debuggable.ts
deleted file mode 100644
index a987526..0000000
--- a/src/types/Debuggable.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-export interface IDebuggable {
-  hasDebugInfo(): boolean;
-  getDebugInfo(): object;
-  drawDebugPhysics(graphics: Phaser.GameObjects.Graphics): void;
-
-  body?: Phaser.Physics.Arcade.Body;
-}
-
-export function isDebuggable(object: any): object is IDebuggable {
-  if (!object) {
-    return false;
-  }
-
-  return (
-    "hasDebugInfo" in object &&
-    "getDebugInfo" in object &&
-    "drawDebugPhysics" in object
-  );
-}
diff --git a/src/types/LightAware.ts b/src/types/LightAware.ts
deleted file mode 100644
index 831dae2..0000000
--- a/src/types/LightAware.ts
+++ /dev/null
@@ -1,278 +0,0 @@
-import config from "../GameConfig";
-import { GenericConstructor } from "./Constructor";
-import GameScene from "../scenes/GameScene";
-
-export type LightAwareShape = null | Phaser.GameObjects.Shape;
-
-export interface ILightAware {
-  onLighten(): ILightAware;
-  onDarken(): ILightAware;
-  onLightOverReset(): ILightAware;
-  onLightOver(
-    light: Raycaster.Ray,
-    intersections: Phaser.Geom.Point[],
-    force: boolean
-  ): ILightAware;
-  onLighningtOver(progress: number): ILightAware;
-
-  setLightAwareShape(shape: LightAwareShape): ILightAware;
-  getLightAwareShape(): LightAwareShape;
-}
-
-export function isLightAware(object: any): object is ILightAware {
-  if (typeof object !== "object") {
-    return false;
-  }
-
-  return (
-    "onLighten" in object &&
-    "onDarken" in object &&
-    "onLightOverReset" in object &&
-    "onLightOver" in object &&
-    "onLighningtOver" in object &&
-    "setLightAwareShape" in object &&
-    "getLightAwareShape" in object
-  );
-}
-
-export function getColorShift(
-  startColor: number,
-  endColor: number,
-  shift: number
-) {
-  const tintColor = Phaser.Display.Color.Interpolate.ColorWithColor(
-    Phaser.Display.Color.ValueToColor(startColor),
-    Phaser.Display.Color.ValueToColor(endColor),
-    100,
-    Math.round(shift * 100)
-  );
-
-  return Phaser.Display.Color.GetColor(tintColor.r, tintColor.g, tintColor.b);
-}
-
-export function getTintColorShift(startColor: number, shift: number) {
-  return getColorShift(startColor, config.colors.darkenTintColor, shift);
-}
-
-export type LightAwareObject = GenericConstructor<{
-  postFX: Phaser.GameObjects.Components.FX;
-  scene: Phaser.Scene;
-  angle: number;
-  originX: number;
-  originY: number;
-  scaleX: number;
-  scaleY: number;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-
-  getCenter(): { x: number; y: number };
-
-  setDepth(depth: number): any;
-  setTint(color?: number): any;
-}>;
-
-export function LightAware<TBase extends LightAwareObject>(
-  Base: TBase
-): GenericConstructor<ILightAware> & TBase {
-  return class extends Base implements ILightAware {
-    private shadow: Phaser.FX.Shadow;
-    private shape: LightAwareShape;
-    private textureUnderLight: Phaser.GameObjects.RenderTexture;
-    private textureUnderLightMask: Phaser.GameObjects.Graphics;
-
-    constructor(...args: any[]) {
-      super(...args);
-
-      this.setDepth(config.depths.lightAwareShape);
-    }
-
-    public onLighten(): ILightAware {
-      this.shadow ??= this.postFX.addShadow(0, 0, 0.1, 0.3, 0x000000, 2, 3);
-
-      this.postFX.clear();
-      this.postFX.add(this.shadow);
-
-      this.setTint();
-      return this;
-    }
-
-    public onDarken(): ILightAware {
-      this.postFX.clear();
-      this.shadow = null;
-
-      this.setTint(config.colors.darkenTintColor);
-      return this;
-    }
-
-    public onLightOverReset(): ILightAware {
-      this.textureUnderLightMask.clear();
-      this.textureUnderLight.setCrop(0, 0, 0, 0);
-      this.textureUnderLight.clearMask();
-      return this;
-    }
-
-    public onLightOver(
-      light: Raycaster.Ray,
-      intersections: Point[],
-      force: boolean
-    ): ILightAware {
-      if (!this.shape) {
-        return this;
-      }
-
-      const gameScene = this.scene as GameScene;
-      if (gameScene && !gameScene.isDark) {
-        return this;
-      }
-
-      // @ts-ignore
-      const owner = this.shape.owner;
-      const ownerBody = owner.body as MatterJS.BodyType;
-
-      const effectiveIntersections = intersections.filter((intersection) => {
-        const overlapped = this.scene.matter.query.point(
-          [ownerBody],
-          intersection
-        );
-        return overlapped.length > 0;
-      });
-
-      if (!effectiveIntersections.length && force) {
-        // console.log("no effective intersections");
-
-        this.textureUnderLightMask.fillRect(
-          this.x - this.width / 2,
-          this.y - this.height / 2,
-          this.x + this.width,
-          this.y + this.height
-        );
-        this.textureUnderLight
-          .setCrop(0, 0, this.width, this.height)
-          .setMask(this.textureUnderLightMask.createGeometryMask());
-
-        return this;
-      }
-
-      if (effectiveIntersections.length > 1) {
-        const firstIntersection = effectiveIntersections[0];
-        const lastIntersection =
-          effectiveIntersections[effectiveIntersections.length - 1];
-
-        const firstIntersectionLine = new Phaser.Geom.Line(
-          light.origin.x,
-          light.origin.y,
-          firstIntersection.x,
-          firstIntersection.y
-        );
-
-        const lastIntersectionLine = new Phaser.Geom.Line(
-          light.origin.x,
-          light.origin.y,
-          lastIntersection.x,
-          lastIntersection.y
-        );
-
-        const firstIntersectionAngle = Phaser.Geom.Line.Angle(
-          firstIntersectionLine
-        );
-
-        const lastIntersectionAngle =
-          Phaser.Geom.Line.Angle(lastIntersectionLine);
-
-        const boxSize = Math.max(
-          this.scene.cameras.main.width,
-          this.scene.cameras.main.height
-        );
-
-        const boxTopLeft = new Phaser.Math.Vector2(
-          firstIntersection.x,
-          firstIntersection.y
-        )
-          .setLength(boxSize)
-          .setAngle(firstIntersectionAngle - Math.PI / 128)
-          .add(firstIntersection);
-
-        const boxTopRight = new Phaser.Math.Vector2(
-          lastIntersection.x,
-          lastIntersection.y
-        )
-          .setLength(boxSize)
-          .setAngle(lastIntersectionAngle + Math.PI / 128)
-          .add(lastIntersection);
-
-        this.textureUnderLightMask.fillTriangle(
-          light.origin.x,
-          light.origin.y,
-          boxTopLeft.x,
-          boxTopLeft.y,
-          boxTopRight.x,
-          boxTopRight.y
-        );
-      }
-
-      this.textureUnderLight
-        .setCrop(0, 0, this.width, this.height)
-        .setMask(this.textureUnderLightMask.createGeometryMask());
-
-      return this;
-    }
-
-    public onLighningtOver(progress: number): ILightAware {
-      if (progress === 1) {
-        this.postFX.clear();
-        this.shadow = null;
-      }
-
-      if (progress < 1) {
-        const color = getTintColorShift(0x000000, progress);
-
-        if (!this.shadow) {
-          this.shadow = this.postFX.addShadow(0, 0, 0.1, 0.3, color, 2, 3);
-          this.postFX.clear();
-          this.postFX.add(this.shadow);
-        }
-
-        this.shadow.color = color;
-      }
-
-      this.setTint(getTintColorShift(0xffffff, progress));
-
-      return this;
-    }
-
-    public setLightAwareShape(shape: LightAwareShape): ILightAware {
-      const image = this as unknown as Phaser.GameObjects.Image;
-
-      this.textureUnderLight = this.scene.add
-        .renderTexture(this.x, this.y, this.width, this.height)
-        .drawFrame(image.texture.key, image.frame.name)
-        .setOrigin(this.originX, this.originY)
-        .setScale(this.scaleX, this.scaleY)
-        .setAngle(this.angle)
-        .setCrop(0, 0, 0, 0)
-        .setDepth(config.depths.lightAwareShape + 1);
-
-      this.textureUnderLight.setPipeline("Light2D");
-
-      this.textureUnderLightMask = this.scene.make
-        .graphics()
-        .setDepth(config.depths.lightAwareShape)
-        .fillStyle(0xffffff, 1);
-
-      this.shape = shape
-        // @ts-ignore
-        .setName(`${this.name}-shape`)
-        .setDepth(config.depths.lightAwareShape);
-
-      // @ts-ignore
-      this.shape.owner = this;
-      return this;
-    }
-
-    public getLightAwareShape(): LightAwareShape {
-      return this.shape;
-    }
-  };
-}
diff --git a/src/types/LightSource.ts b/src/types/LightSource.ts
deleted file mode 100644
index b2a868f..0000000
--- a/src/types/LightSource.ts
+++ /dev/null
@@ -1,320 +0,0 @@
-import GameScene from "../scenes/GameScene";
-import { IDebuggable } from "./Debuggable";
-import { ILightAware, LightAwareShape, isLightAware } from "./LightAware";
-
-export type LightSourceConfig = {
-  emitOnDayLight: boolean;
-  lightColor: number;
-  lightAlpha: number;
-  collisionRange: number;
-  coneDeg: number;
-  coneRange: number;
-  closeRange: number;
-  forceLightOver: boolean;
-};
-
-export interface ILightSource {
-  isEnabled: boolean;
-
-  enable(): ILightSource;
-  disable(): ILightSource;
-  emitLight(): ILightSource;
-}
-
-export function isLightSource(object: any): object is ILightSource {
-  if (object == null) {
-    return false;
-  }
-
-  return "enable" in object && "disable" in object && "emit" in object;
-}
-
-export class LightSource implements ILightSource, IDebuggable {
-  private scene: GameScene;
-  private raycaster: Raycaster;
-  private config: LightSourceConfig;
-  private ray: Raycaster.Ray;
-  private ownGraphics: Phaser.GameObjects.Graphics;
-
-  constructor(
-    scene: GameScene,
-    raycaster: Raycaster,
-    name: string,
-    config: LightSourceConfig
-  ) {
-    this.scene = scene;
-    this.raycaster = raycaster;
-    this.config = config;
-
-    const lightAware = [];
-    scene.children.each((child) => {
-      if (isLightAware(child)) {
-        const shape = child.getLightAwareShape();
-        if (shape) {
-          lightAware.push(shape);
-        }
-      }
-    });
-
-    raycaster.mapGameObjects(lightAware);
-
-    this.ownGraphics = this.scene.add
-      .graphics({
-        fillStyle: {
-          color: config.lightColor,
-          alpha: config.lightAlpha,
-        },
-      })
-      .setName(`${name}-graphics`);
-  }
-
-  public get x(): number {
-    return this.ray.origin.x;
-  }
-
-  public set x(value: number) {
-    if (this.ray == null) {
-      return;
-    }
-
-    this.ray.origin.x = value;
-  }
-
-  public get y(): number {
-    return this.ray?.origin.y;
-  }
-
-  public set y(value: number) {
-    if (this.ray == null) {
-      return;
-    }
-
-    this.ray.origin.y = value;
-  }
-
-  public get angle(): number {
-    return this.ray?.angle;
-  }
-
-  public set angle(value: number) {
-    if (this.ray == null) {
-      return;
-    }
-
-    this.ray.angle = value;
-  }
-
-  public get isEnabled(): boolean {
-    return this.ray != null;
-  }
-
-  public setDepth(depth: number): LightSource {
-    this.ownGraphics.setDepth(depth);
-    return this;
-  }
-
-  public setOrigin(x: number, y: number): LightSource {
-    this.ray?.setOrigin(x, y);
-    return this;
-  }
-
-  public setAngleDeg(angle: number): LightSource {
-    this.ray?.setAngleDeg(angle);
-    return this;
-  }
-
-  public setConeDeg(coneDeg: number) {
-    this.ray?.setConeDeg(coneDeg);
-    return this;
-  }
-
-  public setRayRange(rayRange: number) {
-    this.ray?.setRayRange(rayRange);
-    return this;
-  }
-
-  public enable(): LightSource {
-    this.ray = this.raycaster.createRay({
-      collisionRange: this.config.collisionRange,
-    });
-    this.ray.autoSlice = true;
-
-    return this;
-  }
-
-  public disable(): LightSource {
-    this.ownGraphics.clear();
-
-    this.ray?.destroy();
-    this.ray = null;
-    return this;
-  }
-
-  public emitLight(): LightSource {
-    if (this.ray == null) {
-      return this;
-    }
-
-    let mappedObjectUnderLight = null;
-
-    const mappedObjects = this.raycaster.mappedObjects.filter((object) => {
-      if (this.config.forceLightOver) {
-        if (object instanceof Phaser.GameObjects.Shape) {
-          // @ts-ignore
-          const ownerBody = object.owner
-            ?.body as Phaser.Types.Physics.Matter.MatterBody;
-
-          if (
-            // @ts-ignore
-            ownerBody.bounds &&
-            this.scene.matter.intersectPoint(
-              this.ray.origin.x,
-              this.ray.origin.y,
-              [ownerBody]
-            ).length > 0
-          ) {
-            mappedObjectUnderLight = object;
-            return false;
-          }
-        }
-      }
-
-      return true;
-    });
-
-    const intersections = this.ray.castCone({ objects: mappedObjects });
-
-    const initialIntersections = intersections.slice();
-    intersections.push(this.ray.origin);
-
-    if (!this.scene.isDark) {
-      if (this.config.emitOnDayLight) {
-        this.ownGraphics.clear().fillPoints(intersections);
-      }
-
-      return this;
-    }
-
-    const leftEdgePoint = new Phaser.Math.Vector2(
-      this.ray.origin.x,
-      this.ray.origin.y
-    )
-      .setLength(this.config.coneRange)
-      .setAngle(this.ray.angle - this.ray.cone / 2)
-      .add(this.ray.origin);
-
-    this.scene.lightShadowSceneGraphics
-      .fillStyle(0xffffff, 0)
-      .beginPath()
-      .moveTo(this.ray.origin.x, this.ray.origin.y)
-      .lineTo(leftEdgePoint.x, leftEdgePoint.y)
-      .arc(
-        this.ray.origin.x,
-        this.ray.origin.y,
-        this.config.coneRange,
-        this.ray.angle - this.ray.cone / 2,
-        this.ray.angle + this.ray.cone / 2
-      )
-      .lineTo(this.ray.origin.x, this.ray.origin.y)
-      .fillPath()
-      .fillPoints(intersections);
-
-    this.scene.lightSceneGraphics
-      .fillStyle(0xffffff, 0)
-      .fillPoints(intersections);
-
-    this.scene.lightSceneGraphics
-      .fillStyle(this.config.lightColor, this.config.lightAlpha)
-      .fillPoints(intersections);
-
-    const affectedObjects = initialIntersections.reduce((acc, intersection) => {
-      // @ts-ignore
-      const { object } = intersection;
-
-      if (object && acc.indexOf(object) === -1) {
-        acc.push(object);
-      }
-
-      return acc;
-    }, []);
-
-    affectedObjects.forEach((object) => {
-      const owner = object.owner as ILightAware;
-      if (owner) {
-        owner.onLightOver(this.ray, initialIntersections, false);
-      }
-    });
-
-    if (mappedObjectUnderLight) {
-      const owner = mappedObjectUnderLight.owner as ILightAware;
-      if (owner) {
-        owner.onLightOver(this.ray, initialIntersections, true);
-      }
-    }
-
-    return this;
-  }
-
-  public hasDebugInfo(): boolean {
-    return false;
-  }
-
-  public getDebugInfo(): object {
-    return {};
-  }
-
-  public drawDebugPhysics(graphics: Phaser.GameObjects.Graphics) {
-    if (!this.ray) {
-      return;
-    }
-
-    graphics.fillStyle(0xff0000, 0.5);
-    this.ray.intersections.forEach((intersection) => {
-      // @ts-ignore
-      graphics.fillCircle(intersection.x, intersection.y, 3);
-    });
-
-    graphics.fillStyle(0x000000, 0.2);
-    graphics.lineStyle(1, 0xff00ff, 0.5);
-    this.ray.slicedIntersections.forEach((intersection) => {
-      graphics.strokeTriangle(
-        intersection.x1,
-        intersection.y1,
-        intersection.x2,
-        intersection.y2,
-        intersection.x3,
-        intersection.y3
-      );
-    });
-  }
-
-  public onLighten(): ILightAware {
-    this.ownGraphics.clear();
-    return this;
-  }
-
-  public onDarken(): ILightAware {
-    this.ownGraphics.clear();
-    return this;
-  }
-
-  public onLightOverReset(): ILightAware {
-    return this;
-  }
-
-  public onLightOver(): ILightAware {
-    return this;
-  }
-
-  public onLighningtOver(): ILightAware {
-    return this;
-  }
-
-  public setLightAwareShape(shape: LightAwareShape): ILightAware {
-    return this;
-  }
-
-  public getLightAwareShape(): LightAwareShape {
-    return null;
-  }
-}
diff --git a/src/types/Obstacle.ts b/src/types/Obstacle.ts
deleted file mode 100644
index 771ed42..0000000
--- a/src/types/Obstacle.ts
+++ /dev/null
@@ -1 +0,0 @@
-export interface IObstacle {}
diff --git a/src/types/Pointable.ts b/src/types/Pointable.ts
deleted file mode 100644
index 46b1146..0000000
--- a/src/types/Pointable.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import config from "../GameConfig";
-import { GenericConstructor } from "./Constructor";
-import { Label } from "../objects/Label";
-
-export interface IPointable {
-  showHighlight(): IPointable;
-  removeHighlight(): IPointable;
-
-  showInfo(): IPointable;
-  removeInfo(): IPointable;
-
-  setInfo(info: string): IPointable;
-  hasInfo(): boolean;
-  getInfo(): string;
-}
-
-export function isPointable(object: any): object is IPointable {
-  if (typeof object !== "object") {
-    return false;
-  }
-
-  return (
-    "showHighlight" in object &&
-    "removeHighlight" in object &&
-    "showInfo" in object &&
-    "removeInfo" in object
-  );
-}
-
-type PointableObject = GenericConstructor<{
-  postFX: Phaser.GameObjects.Components.FX;
-  scene: Phaser.Scene;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  name: string;
-}>;
-
-export function Pointable<TBase extends PointableObject>(Base: TBase): TBase {
-  return class extends Base implements IPointable {
-    private highlight: Phaser.FX.Glow;
-    private label: Label;
-    private info?: string = null;
-
-    showHighlight(): IPointable {
-      this.highlight = this.postFX.addGlow(0xffffff, 3, 0.1);
-      return this;
-    }
-
-    removeHighlight(): IPointable {
-      this.postFX.remove(this.highlight);
-      return this;
-    }
-
-    showInfo(): IPointable {
-      if (this.label) {
-        this.label.destroy();
-      }
-
-      if (!this.hasInfo()) {
-        return this;
-      }
-
-      // show info above and to the right of the object
-      const textCoordinates = {
-        x: this.x + this.width / 2 + 10,
-        y: this.y - this.height / 2 - 10,
-      };
-
-      // frame with rounded corners
-      this.label = new Label(
-        this.scene,
-        textCoordinates.x,
-        textCoordinates.y,
-        this.getInfo()
-      );
-      this.scene.add.existing(this.label);
-
-      this.label.setDepth(config.depths.pointableObject);
-
-      return this;
-    }
-
-    removeInfo(): IPointable {
-      if (this.label) {
-        this.label.destroy();
-      }
-
-      return this;
-    }
-
-    setInfo(info: string): IPointable {
-      this.info = info;
-      return this;
-    }
-
-    hasInfo(): boolean {
-      return this.getInfo().length > 0;
-    }
-
-    getInfo(): string {
-      return this.info ?? this.name;
-    }
-  };
-}
diff --git a/src/types/Projection.ts b/src/types/Projection.ts
deleted file mode 100644
index be29a39..0000000
--- a/src/types/Projection.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { IObstacle } from "./Obstacle";
-
-export interface IProjection extends IObstacle {
-  shift(diff: Phaser.Types.Math.Vector2Like): IProjection;
-}
diff --git a/src/types/SpineContainer.ts b/src/types/SpineContainer.ts
deleted file mode 100644
index d606cf2..0000000
--- a/src/types/SpineContainer.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-export default class SpineContainer extends Phaser.GameObjects.Container {
-  private mainSpine: SpineGameObject;
-  private spines: { [key: string]: SpineGameObject } = {};
-
-  get spine() {
-    return this.mainSpine;
-  }
-
-  constructor(
-    scene: Phaser.Scene,
-    x: number,
-    y: number,
-    key: string,
-    anim: string,
-    loop = false
-  ) {
-    super(scene, x, y);
-
-    this.mainSpine = scene.add.spine(0, 0, key, anim, loop);
-
-    scene.physics.add.existing(this);
-
-    this.add(this.mainSpine);
-  }
-
-  public addSpine(spine: SpineGameObject, index?: number) {
-    this.addAt(spine, index);
-    this.spines[spine.key] = spine;
-  }
-
-  public getSpine(key: string) {
-    return this.spines[key];
-  }
-
-  faceDirection(dir: 1 | -1) {
-    if (this.mainSpine.scaleX === dir) {
-      return;
-    }
-
-    this.mainSpine.scaleX = dir;
-  }
-}
diff --git a/src/types/game-scene.ts b/src/types/game-scene.ts
new file mode 100644
index 0000000..b5b6e8a
--- /dev/null
+++ b/src/types/game-scene.ts
@@ -0,0 +1,11 @@
+import PlayerInputs from '../controls/player-inputs'
+
+export interface GameSceneInterface extends Phaser.Scene {
+  isDark: boolean
+  isPlayerMode: boolean
+  inputs: PlayerInputs
+  lightSceneGraphics: Phaser.GameObjects.Graphics
+  lightShadowSceneGraphics: Phaser.GameObjects.Graphics
+  physics: Phaser.Physics.Arcade.ArcadePhysics
+  matter: Phaser.Physics.Matter.MatterPhysics
+}
diff --git a/src/types/global.d.ts b/src/types/global.d.ts
index dcb2600..444d0dd 100644
--- a/src/types/global.d.ts
+++ b/src/types/global.d.ts
@@ -1,3 +1,3 @@
 declare interface Window {
-  SpinePlugin: any;
+  SpinePlugin: typeof Phaser.Plugins.ScenePlugin
 }
diff --git a/src/types/spine-container.ts b/src/types/spine-container.ts
new file mode 100644
index 0000000..57c864c
--- /dev/null
+++ b/src/types/spine-container.ts
@@ -0,0 +1,37 @@
+export default class SpineContainer extends Phaser.GameObjects.Container {
+  private mainSpine: SpineGameObject
+  private spines: { [key: string]: SpineGameObject } = {}
+
+  get spine() {
+    return this.mainSpine
+  }
+
+  constructor(scene: Phaser.Scene, x: number, y: number, key: string, anim: string, loop = false) {
+    super(scene, x, y)
+
+    this.mainSpine = scene.add.spine(0, 0, key, anim, loop)
+
+    if (scene.physics) {
+      scene.physics.add.existing(this)
+    }
+
+    this.add(this.mainSpine)
+  }
+
+  public addSpine(spine: SpineGameObject, index?: number) {
+    this.addAt(spine, index)
+    this.spines[spine.key] = spine
+  }
+
+  public getSpine(key: string) {
+    return this.spines[key]
+  }
+
+  faceDirection(dir: 1 | -1) {
+    if (this.mainSpine.scaleX === dir) {
+      return
+    }
+
+    this.mainSpine.scaleX = dir
+  }
+}
diff --git a/src/types/spine-listener.ts b/src/types/spine-listener.ts
new file mode 100644
index 0000000..ef60359
--- /dev/null
+++ b/src/types/spine-listener.ts
@@ -0,0 +1,23 @@
+// Partial listener - for use when casting to AnimationStateListener2
+export interface SpineAnimationListener {
+  complete?: () => void
+  start?: () => void
+  interrupt?: () => void
+  end?: () => void
+  dispose?: () => void
+  event?: () => void
+}
+
+// Helper to create a partial listener that satisfies the full interface
+export function createSpineListener(
+  listener: SpineAnimationListener,
+): spine.AnimationStateListener2 {
+  return {
+    start: listener.start ?? (() => {}),
+    interrupt: listener.interrupt ?? (() => {}),
+    end: listener.end ?? (() => {}),
+    dispose: listener.dispose ?? (() => {}),
+    complete: listener.complete ?? (() => {}),
+    event: listener.event ?? (() => {}),
+  }
+}
diff --git a/src/types/spine/SpineFile.d.ts b/src/types/spine/SpineFile.d.ts
deleted file mode 100644
index 1a06f8b..0000000
--- a/src/types/spine/SpineFile.d.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-declare namespace Phaser.Loader.FileTypes {
-    interface SpineFileConfig {
-        key: string;
-        textureURL?: string;
-        textureExtension?: string;
-        textureXhrSettings?: Phaser.Types.Loader.XHRSettingsObject;
-        normalMap?: string;
-        atlasURL?: string;
-        atlasExtension?: string;
-        atlasXhrSettings?: Phaser.Types.Loader.XHRSettingsObject;
-    }
-
-    class SpineFile extends Phaser.Loader.MultiFile {
-        constructor(loader: Phaser.Loader.LoaderPlugin, key: string | Phaser.Loader.FileTypes.SpineFileConfig, jsonURL: string | string[], atlasURL: string, preMultipliedAlpha: boolean, jsonXhrSettings: Phaser.Types.Loader.XHRSettingsObject, atlasXhrSettings: Phaser.Types.Loader.XHRSettingsObject)
-
-        addToCache();
-	}
-}
diff --git a/src/types/spine/SpineGameObject.d.ts b/src/types/spine/SpineGameObject.d.ts
deleted file mode 100644
index f8f1167..0000000
--- a/src/types/spine/SpineGameObject.d.ts
+++ /dev/null
@@ -1,194 +0,0 @@
-/// <reference path="./spine.d.ts" />
-/// <reference path="./SpinePlugin.d.ts" />
-
-declare type SpineGameObject = Phaser.GameObjects.GameObject & {
-  // hasTransformComponent: boolean;
-  // copyPosition(
-
-  // declare interface SpineGameObject extends Phaser.GameObjects.GameObject {
-  hasTransformComponent: boolean;
-  copyPosition(
-    source:
-      | Phaser.Types.Math.Vector2Like
-      | Phaser.Types.Math.Vector3Like
-      | Phaser.Types.Math.Vector4Like
-  ): SpineGameObject;
-  getLocalPoint(
-    x: number,
-    y: number,
-    point?: Phaser.Math.Vector2,
-    camera?: Phaser.Cameras.Scene2D.Camera
-  ): Phaser.Math.Vector2;
-
-  alpha: number;
-  angle: number;
-
-  readonly blendMode: number;
-
-  blue: number;
-  bounds: any;
-  displayOriginX: number;
-  displayOriginY: number;
-  drawDebug: boolean;
-  depth: number;
-  displayWidth: number;
-  displayHeight: number;
-  flipX: boolean;
-  flipY: boolean;
-  green: number;
-  height: number;
-  plugin: SpinePlugin;
-  preMultipliedAlpha: boolean;
-  red: number;
-  root: spine.Bone;
-  rotation: number;
-  scale: number;
-  scaleX: number;
-  scaleY: number;
-  scrollFactorX: number;
-  scrollFactorY: number;
-  skeleton: spine.Skeleton;
-  skeletonData: spine.SkeletonData;
-
-  state: spine.AnimationState & Partial<EventListener>;
-
-  stateData: spine.AnimationStateData;
-
-  timeScale: number;
-  visible: boolean;
-  x: number;
-  y: number;
-  z: number;
-  w: number;
-  width: number;
-
-  key: string;
-
-  addAnimation(
-    trackIndex: number,
-    animationName: string,
-    loop?: boolean,
-    delay?: number
-  ): spine.TrackEntry;
-  angleBoneToXY(
-    bone: spine.Bone,
-    worldX: number,
-    worldY: number,
-    offset?: number,
-    minAngle?: number,
-    maxAngle?: number
-  ): SpineGameObject;
-  clearTrack(trackIndex: number): SpineGameObject;
-  clearTracks(): SpineGameObject;
-  findAnimation(animationName: string): spine.Animation;
-  findBone(boneName: string): spine.Bone;
-  findBoneIndex(boneName: string): number;
-  findEvent(eventDataName: string): spine.EventData;
-  findIkConstraint(constraintName: string): spine.IkConstraintData;
-  findPathConstraint(constraintName: string): spine.PathConstraintData;
-  findPathConstraintIndex(constraintName: string): number;
-  findSkin(skinName: string): spine.Skin;
-  findSlot(slotName: string): spine.Slot;
-  findSlotIndex(slotName: string): number;
-  findTransformConstraint(
-    constraintName: string
-  ): spine.TransformConstraintData;
-  getAnimationList(): string[];
-  getAttachment(slotIndex: number, attachmentName: string): spine.Attachment;
-  getAttachmentByName(
-    slotName: string,
-    attachmentName: string
-  ): spine.Attachment;
-  getBoneList(): string[];
-  getBounds(): any;
-  getCurrentAnimation(trackIndex?: number): spine.Animation;
-  getLocalTransformMatrix(
-    tempMatrix?: Phaser.GameObjects.Components.TransformMatrix
-  ): Phaser.GameObjects.Components.TransformMatrix;
-  getParentRotation(): number;
-  getRootBone(): spine.Bone;
-  getSkinList(): string[];
-  getSlotList(): string[];
-  getWorldTransformMatrix(
-    tempMatrix?: Phaser.GameObjects.Components.TransformMatrix,
-    parentMatrix?: Phaser.GameObjects.Components.TransformMatrix
-  ): Phaser.GameObjects.Components.TransformMatrix;
-  play(
-    animationName: string,
-    loop?: boolean,
-    ignoreIfPlaying?: boolean
-  ): SpineGameObject;
-
-  refresh(): SpineGameObject;
-  resetFlip(): SpineGameObject;
-  setAlpha(value?: number): SpineGameObject;
-  setAngle(degrees?: number): SpineGameObject;
-  setAnimation(
-    trackIndex: number,
-    animationName: string,
-    loop?: boolean,
-    ignoreIfPlaying?: boolean
-  ): spine.TrackEntry;
-  setAttachment(slotName: string, attachmentName: string): SpineGameObject;
-  setBonesToSetupPose(): SpineGameObject;
-  setColor(color?: number, slotName?: string): SpineGameObject;
-  setDepth(value: number): SpineGameObject;
-  setDisplaySize(width: number, height: number): SpineGameObject;
-  setEmptyAnimation(trackIndex: number, mixDuration?: number): spine.TrackEntry;
-  setFlipX(value: boolean): SpineGameObject;
-  setFlipY(value: boolean): SpineGameObject;
-  setFlip(x: boolean, y: boolean): SpineGameObject;
-  setMix(fromName: string, toName: string, duration?: number): SpineGameObject;
-  setOffset(offsetX?: number, offsetY?: number): SpineGameObject;
-  setPosition(x?: number, y?: number, z?: number, w?: number): SpineGameObject;
-  setRandomPosition(
-    x?: number,
-    y?: number,
-    width?: number,
-    height?: number
-  ): SpineGameObject;
-  setRotation(radians?: number): SpineGameObject;
-  setScale(x: number, y?: number): SpineGameObject;
-  setScrollFactor(x: number, y?: number): SpineGameObject;
-  setSize(
-    width?: number,
-    height?: number,
-    offsetX?: number,
-    offsetY?: number
-  ): SpineGameObject;
-  setSkeleton(
-    atlasDataKey: string,
-    animationName?: string,
-    loop?: boolean,
-    skeletonJSON?: object
-  ): SpineGameObject;
-  setSkeletonFromJSON(
-    atlasDataKey: string,
-    skeletonJSON: object,
-    animationName?: string,
-    loop?: boolean
-  ): SpineGameObject;
-  setSkin(newSkin: spine.Skin): SpineGameObject;
-  setSkinByName(skinName: string): SpineGameObject;
-  setSlotsToSetupPose(): SpineGameObject;
-  setToSetupPose(): SpineGameObject;
-  setVisible(value: boolean): SpineGameObject;
-  setX(value?: number): SpineGameObject;
-  setY(value?: number): SpineGameObject;
-  setZ(value?: number): SpineGameObject;
-  setW(value?: number): SpineGameObject;
-  toggleFlipX(): SpineGameObject;
-  toggleFlipY(): SpineGameObject;
-  updateSize(): SpineGameObject;
-  willRender(): boolean;
-};
-
-declare interface SpineGameObjectConfig
-  extends Phaser.Types.GameObjects.GameObjectConfig {
-  key?: string;
-  animationName?: string;
-  loop?: boolean;
-  skinName?: string;
-  slotName?: string;
-  attachmentName?: string;
-}
diff --git a/src/types/spine/SpinePlugin.d.ts b/src/types/spine/SpinePlugin.d.ts
deleted file mode 100644
index 899ff48..0000000
--- a/src/types/spine/SpinePlugin.d.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-/// <reference path="./spine.d.ts" />
-/// <reference path="./SpineFile.d.ts" />
-/// <reference path="./SpineGameObject.d.ts" />
-/// <reference path="./SpineContainer.d.ts" />
-
-declare namespace Phaser.Loader {
-    interface LoaderPlugin extends Phaser.Events.EventEmitter {
-        spine(key: string | Phaser.Loader.FileTypes.SpineFileConfig | Phaser.Loader.FileTypes.SpineFileConfig[], jsonURL: string, atlasURL: string | string[], preMultipliedAlpha?: boolean, textureXhrSettings?: Phaser.Types.Loader.XHRSettingsObject, atlasXhrSettings?: Phaser.Types.Loader.XHRSettingsObject): LoaderPlugin;
-    }
-}
-
-declare namespace Phaser.GameObjects {
-    interface GameObjectFactory {
-        spine(x: number, y: number, key?: string, animationName?: string, loop?: boolean): SpineGameObject;
-        spineContainer(x: number, y: number, children?: SpineGameObject | SpineGameObject[]): SpineContainer;
-    }
-
-	interface GameObjectCreator {
-        spine(config: SpineGameObjectConfig, addToScene?: boolean): SpineGameObject;
-        spineContainer(config: SpineContainerConfig, addToScene?: boolean): SpineContainer;
-    }
-}
-
-declare class SpinePlugin extends Phaser.Plugins.ScenePlugin {
-    constructor(scene: Phaser.Scene, pluginManager: Phaser.Plugins.PluginManager);
-
-    readonly isWebGL: boolean;
-
-    cache: Phaser.Cache.BaseCache;
-    spineTextures: Phaser.Cache.BaseCache;
-    json: Phaser.Cache.BaseCache;
-    textures: Phaser.Textures.TextureManager;
-    drawDebug: boolean;
-    gl: WebGLRenderingContext;
-    renderer: Phaser.Renderer.Canvas.CanvasRenderer | Phaser.Renderer.WebGL.WebGLRenderer;
-    sceneRenderer: spine.webgl.SceneRenderer;
-    skeletonRenderer: spine.canvas.SkeletonRenderer | spine.webgl.SkeletonRenderer;
-    skeletonDebugRenderer: spine.webgl.SkeletonDebugRenderer;
-
-    plugin: typeof spine;
-
-    getAtlasCanvas(key: string): spine.TextureAtlas;
-    getAtlasWebGL(key: string): spine.TextureAtlas;
-    worldToLocal(x: number, y: number, skeleton: spine.Skeleton, bone?: spine.Bone): spine.Vector2;
-    getVector2(x: number, y: number): spine.Vector2;
-    getVector3(x: number, y: number, z: number): spine.Vector2;
-    setDebugBones(value?: boolean): SpinePlugin;
-    setDebugRegionAttachments(value?: boolean): SpinePlugin;
-    setDebugBoundingBoxes(value?: boolean): SpinePlugin;
-    setDebugMeshHull(value?: boolean): SpinePlugin;
-    setDebugMeshTriangles(value?: boolean): SpinePlugin;
-    setDebugPaths(value?: boolean): SpinePlugin;
-    setDebugSkeletonXY(value?: boolean): SpinePlugin;
-    setDebugClipping(value?: boolean): SpinePlugin;
-    setEffect(effect?: spine.VertexEffect): SpinePlugin;
-    createSkeleton(key: string, skeletonJSON?: object): any | null;
-    createAnimationState(skeleton: spine.Skeleton): any;
-    getBounds(skeleton: spine.Skeleton): any;
-    onResize(): void;
-    add(x: number, y: number, key?: string, animationName?: string, loop?: boolean): SpineGameObject;
-    make(config: SpineGameObjectConfig, addToScene?: boolean): SpineGameObject;
-}
diff --git a/src/types/spine/spine-canvas.d.ts b/src/types/spine/spine-canvas.d.ts
index d48e84f..b60ca0b 100644
--- a/src/types/spine/spine-canvas.d.ts
+++ b/src/types/spine/spine-canvas.d.ts
@@ -1,1361 +1,1685 @@
 declare module spine {
-    class Animation {
-        name: string;
-        timelines: Array<Timeline>;
-        timelineIds: Array<boolean>;
-        duration: number;
-        constructor(name: string, timelines: Array<Timeline>, duration: number);
-        hasTimeline(id: number): boolean;
-        apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-        static binarySearch(values: ArrayLike<number>, target: number, step?: number): number;
-        static linearSearch(values: ArrayLike<number>, target: number, step: number): number;
-    }
-    interface Timeline {
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-        getPropertyId(): number;
-    }
-    enum MixBlend {
-        setup = 0,
-        first = 1,
-        replace = 2,
-        add = 3
-    }
-    enum MixDirection {
-        mixIn = 0,
-        mixOut = 1
-    }
-    enum TimelineType {
-        rotate = 0,
-        translate = 1,
-        scale = 2,
-        shear = 3,
-        attachment = 4,
-        color = 5,
-        deform = 6,
-        event = 7,
-        drawOrder = 8,
-        ikConstraint = 9,
-        transformConstraint = 10,
-        pathConstraintPosition = 11,
-        pathConstraintSpacing = 12,
-        pathConstraintMix = 13,
-        twoColor = 14
-    }
-    abstract class CurveTimeline implements Timeline {
-        static LINEAR: number;
-        static STEPPED: number;
-        static BEZIER: number;
-        static BEZIER_SIZE: number;
-        private curves;
-        abstract getPropertyId(): number;
-        constructor(frameCount: number);
-        getFrameCount(): number;
-        setLinear(frameIndex: number): void;
-        setStepped(frameIndex: number): void;
-        getCurveType(frameIndex: number): number;
-        setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
-        getCurvePercent(frameIndex: number, percent: number): number;
-        abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class RotateTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_ROTATION: number;
-        static ROTATION: number;
-        boneIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, degrees: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class TranslateTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_X: number;
-        static PREV_Y: number;
-        static X: number;
-        static Y: number;
-        boneIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, x: number, y: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class ScaleTimeline extends TranslateTimeline {
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class ShearTimeline extends TranslateTimeline {
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class ColorTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_R: number;
-        static PREV_G: number;
-        static PREV_B: number;
-        static PREV_A: number;
-        static R: number;
-        static G: number;
-        static B: number;
-        static A: number;
-        slotIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class TwoColorTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_R: number;
-        static PREV_G: number;
-        static PREV_B: number;
-        static PREV_A: number;
-        static PREV_R2: number;
-        static PREV_G2: number;
-        static PREV_B2: number;
-        static R: number;
-        static G: number;
-        static B: number;
-        static A: number;
-        static R2: number;
-        static G2: number;
-        static B2: number;
-        slotIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class AttachmentTimeline implements Timeline {
-        slotIndex: number;
-        frames: ArrayLike<number>;
-        attachmentNames: Array<string>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        getFrameCount(): number;
-        setFrame(frameIndex: number, time: number, attachmentName: string): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class DeformTimeline extends CurveTimeline {
-        slotIndex: number;
-        attachment: VertexAttachment;
-        frames: ArrayLike<number>;
-        frameVertices: Array<ArrayLike<number>>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class EventTimeline implements Timeline {
-        frames: ArrayLike<number>;
-        events: Array<Event>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        getFrameCount(): number;
-        setFrame(frameIndex: number, event: Event): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class DrawOrderTimeline implements Timeline {
-        frames: ArrayLike<number>;
-        drawOrders: Array<Array<number>>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        getFrameCount(): number;
-        setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class IkConstraintTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_MIX: number;
-        static PREV_SOFTNESS: number;
-        static PREV_BEND_DIRECTION: number;
-        static PREV_COMPRESS: number;
-        static PREV_STRETCH: number;
-        static MIX: number;
-        static SOFTNESS: number;
-        static BEND_DIRECTION: number;
-        static COMPRESS: number;
-        static STRETCH: number;
-        ikConstraintIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, mix: number, softness: number, bendDirection: number, compress: boolean, stretch: boolean): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class TransformConstraintTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_ROTATE: number;
-        static PREV_TRANSLATE: number;
-        static PREV_SCALE: number;
-        static PREV_SHEAR: number;
-        static ROTATE: number;
-        static TRANSLATE: number;
-        static SCALE: number;
-        static SHEAR: number;
-        transformConstraintIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number, scaleMix: number, shearMix: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class PathConstraintPositionTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_VALUE: number;
-        static VALUE: number;
-        pathConstraintIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, value: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class PathConstraintMixTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_ROTATE: number;
-        static PREV_TRANSLATE: number;
-        static ROTATE: number;
-        static TRANSLATE: number;
-        pathConstraintIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
+  class Animation {
+    name: string
+    timelines: Array<Timeline>
+    timelineIds: Array<boolean>
+    duration: number
+    constructor(name: string, timelines: Array<Timeline>, duration: number)
+    hasTimeline(id: number): boolean
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      loop: boolean,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+    static binarySearch(values: ArrayLike<number>, target: number, step?: number): number
+    static linearSearch(values: ArrayLike<number>, target: number, step: number): number
+  }
+  interface Timeline {
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+    getPropertyId(): number
+  }
+  enum MixBlend {
+    setup = 0,
+    first = 1,
+    replace = 2,
+    add = 3,
+  }
+  enum MixDirection {
+    mixIn = 0,
+    mixOut = 1,
+  }
+  enum TimelineType {
+    rotate = 0,
+    translate = 1,
+    scale = 2,
+    shear = 3,
+    attachment = 4,
+    color = 5,
+    deform = 6,
+    event = 7,
+    drawOrder = 8,
+    ikConstraint = 9,
+    transformConstraint = 10,
+    pathConstraintPosition = 11,
+    pathConstraintSpacing = 12,
+    pathConstraintMix = 13,
+    twoColor = 14,
+  }
+  abstract class CurveTimeline implements Timeline {
+    static LINEAR: number
+    static STEPPED: number
+    static BEZIER: number
+    static BEZIER_SIZE: number
+    private curves
+    abstract getPropertyId(): number
+    constructor(frameCount: number)
+    getFrameCount(): number
+    setLinear(frameIndex: number): void
+    setStepped(frameIndex: number): void
+    getCurveType(frameIndex: number): number
+    setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void
+    getCurvePercent(frameIndex: number, percent: number): number
+    abstract apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class RotateTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATION: number
+    static ROTATION: number
+    boneIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, degrees: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class TranslateTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_X: number
+    static PREV_Y: number
+    static X: number
+    static Y: number
+    boneIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, x: number, y: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class ScaleTimeline extends TranslateTimeline {
+    constructor(frameCount: number)
+    getPropertyId(): number
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class ShearTimeline extends TranslateTimeline {
+    constructor(frameCount: number)
+    getPropertyId(): number
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class ColorTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_R: number
+    static PREV_G: number
+    static PREV_B: number
+    static PREV_A: number
+    static R: number
+    static G: number
+    static B: number
+    static A: number
+    slotIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class TwoColorTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_R: number
+    static PREV_G: number
+    static PREV_B: number
+    static PREV_A: number
+    static PREV_R2: number
+    static PREV_G2: number
+    static PREV_B2: number
+    static R: number
+    static G: number
+    static B: number
+    static A: number
+    static R2: number
+    static G2: number
+    static B2: number
+    slotIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(
+      frameIndex: number,
+      time: number,
+      r: number,
+      g: number,
+      b: number,
+      a: number,
+      r2: number,
+      g2: number,
+      b2: number,
+    ): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class AttachmentTimeline implements Timeline {
+    slotIndex: number
+    frames: ArrayLike<number>
+    attachmentNames: Array<string>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, time: number, attachmentName: string): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class DeformTimeline extends CurveTimeline {
+    slotIndex: number
+    attachment: VertexAttachment
+    frames: ArrayLike<number>
+    frameVertices: Array<ArrayLike<number>>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class EventTimeline implements Timeline {
+    frames: ArrayLike<number>
+    events: Array<Event>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, event: Event): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class DrawOrderTimeline implements Timeline {
+    frames: ArrayLike<number>
+    drawOrders: Array<Array<number>>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class IkConstraintTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_MIX: number
+    static PREV_SOFTNESS: number
+    static PREV_BEND_DIRECTION: number
+    static PREV_COMPRESS: number
+    static PREV_STRETCH: number
+    static MIX: number
+    static SOFTNESS: number
+    static BEND_DIRECTION: number
+    static COMPRESS: number
+    static STRETCH: number
+    ikConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(
+      frameIndex: number,
+      time: number,
+      mix: number,
+      softness: number,
+      bendDirection: number,
+      compress: boolean,
+      stretch: boolean,
+    ): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class TransformConstraintTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATE: number
+    static PREV_TRANSLATE: number
+    static PREV_SCALE: number
+    static PREV_SHEAR: number
+    static ROTATE: number
+    static TRANSLATE: number
+    static SCALE: number
+    static SHEAR: number
+    transformConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(
+      frameIndex: number,
+      time: number,
+      rotateMix: number,
+      translateMix: number,
+      scaleMix: number,
+      shearMix: number,
+    ): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class PathConstraintPositionTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_VALUE: number
+    static VALUE: number
+    pathConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, value: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
+    constructor(frameCount: number)
+    getPropertyId(): number
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class PathConstraintMixTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATE: number
+    static PREV_TRANSLATE: number
+    static ROTATE: number
+    static TRANSLATE: number
+    pathConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
 }
 declare module spine {
-    class AnimationState {
-        static emptyAnimation: Animation;
-        static SUBSEQUENT: number;
-        static FIRST: number;
-        static HOLD: number;
-        static HOLD_MIX: number;
-        static NOT_LAST: number;
-        data: AnimationStateData;
-        tracks: TrackEntry[];
-        events: Event[];
-        listeners: AnimationStateListener2[];
-        queue: EventQueue;
-        propertyIDs: IntSet;
-        animationsChanged: boolean;
-        timeScale: number;
-        trackEntryPool: Pool<TrackEntry>;
-        constructor(data: AnimationStateData);
-        update(delta: number): void;
-        updateMixingFrom(to: TrackEntry, delta: number): boolean;
-        apply(skeleton: Skeleton): boolean;
-        applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number;
-        applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
-        queueEvents(entry: TrackEntry, animationTime: number): void;
-        clearTracks(): void;
-        clearTrack(trackIndex: number): void;
-        setCurrent(index: number, current: TrackEntry, interrupt: boolean): void;
-        setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-        setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-        addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-        addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
-        setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
-        addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
-        setEmptyAnimations(mixDuration: number): void;
-        expandToIndex(index: number): TrackEntry;
-        trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
-        disposeNext(entry: TrackEntry): void;
-        _animationsChanged(): void;
-        computeHold(entry: TrackEntry): void;
-        computeNotLast(entry: TrackEntry): void;
-        getCurrent(trackIndex: number): TrackEntry;
-        addListener(listener: AnimationStateListener2): void;
-        removeListener(listener: AnimationStateListener2): void;
-        clearListeners(): void;
-        clearListenerNotifications(): void;
-    }
-    class TrackEntry {
-        animation: Animation;
-        next: TrackEntry;
-        mixingFrom: TrackEntry;
-        mixingTo: TrackEntry;
-        listener: AnimationStateListener2;
-        trackIndex: number;
-        loop: boolean;
-        holdPrevious: boolean;
-        eventThreshold: number;
-        attachmentThreshold: number;
-        drawOrderThreshold: number;
-        animationStart: number;
-        animationEnd: number;
-        animationLast: number;
-        nextAnimationLast: number;
-        delay: number;
-        trackTime: number;
-        trackLast: number;
-        nextTrackLast: number;
-        trackEnd: number;
-        timeScale: number;
-        alpha: number;
-        mixTime: number;
-        mixDuration: number;
-        interruptAlpha: number;
-        totalAlpha: number;
-        mixBlend: MixBlend;
-        timelineMode: number[];
-        timelineHoldMix: TrackEntry[];
-        timelinesRotation: number[];
-        reset(): void;
-        getAnimationTime(): number;
-        setAnimationLast(animationLast: number): void;
-        isComplete(): boolean;
-        resetRotationDirections(): void;
-    }
-    class EventQueue {
-        objects: Array<any>;
-        drainDisabled: boolean;
-        animState: AnimationState;
-        constructor(animState: AnimationState);
-        start(entry: TrackEntry): void;
-        interrupt(entry: TrackEntry): void;
-        end(entry: TrackEntry): void;
-        dispose(entry: TrackEntry): void;
-        complete(entry: TrackEntry): void;
-        event(entry: TrackEntry, event: Event): void;
-        drain(): void;
-        clear(): void;
-    }
-    enum EventType {
-        start = 0,
-        interrupt = 1,
-        end = 2,
-        dispose = 3,
-        complete = 4,
-        event = 5
-    }
-    interface AnimationStateListener2 {
-        start(entry: TrackEntry): void;
-        interrupt(entry: TrackEntry): void;
-        end(entry: TrackEntry): void;
-        dispose(entry: TrackEntry): void;
-        complete(entry: TrackEntry): void;
-        event(entry: TrackEntry, event: Event): void;
-    }
-    abstract class AnimationStateAdapter2 implements AnimationStateListener2 {
-        start(entry: TrackEntry): void;
-        interrupt(entry: TrackEntry): void;
-        end(entry: TrackEntry): void;
-        dispose(entry: TrackEntry): void;
-        complete(entry: TrackEntry): void;
-        event(entry: TrackEntry, event: Event): void;
-    }
+  class AnimationState {
+    static emptyAnimation: Animation
+    static SUBSEQUENT: number
+    static FIRST: number
+    static HOLD: number
+    static HOLD_MIX: number
+    static NOT_LAST: number
+    data: AnimationStateData
+    tracks: TrackEntry[]
+    events: Event[]
+    listeners: AnimationStateListener2[]
+    queue: EventQueue
+    propertyIDs: IntSet
+    animationsChanged: boolean
+    timeScale: number
+    trackEntryPool: Pool<TrackEntry>
+    constructor(data: AnimationStateData)
+    update(delta: number): void
+    updateMixingFrom(to: TrackEntry, delta: number): boolean
+    apply(skeleton: Skeleton): boolean
+    applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number
+    applyRotateTimeline(
+      timeline: Timeline,
+      skeleton: Skeleton,
+      time: number,
+      alpha: number,
+      blend: MixBlend,
+      timelinesRotation: Array<number>,
+      i: number,
+      firstFrame: boolean,
+    ): void
+    queueEvents(entry: TrackEntry, animationTime: number): void
+    clearTracks(): void
+    clearTrack(trackIndex: number): void
+    setCurrent(index: number, current: TrackEntry, interrupt: boolean): void
+    setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry
+    setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry
+    addAnimation(
+      trackIndex: number,
+      animationName: string,
+      loop: boolean,
+      delay: number,
+    ): TrackEntry
+    addAnimationWith(
+      trackIndex: number,
+      animation: Animation,
+      loop: boolean,
+      delay: number,
+    ): TrackEntry
+    setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry
+    addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry
+    setEmptyAnimations(mixDuration: number): void
+    expandToIndex(index: number): TrackEntry
+    trackEntry(
+      trackIndex: number,
+      animation: Animation,
+      loop: boolean,
+      last: TrackEntry,
+    ): TrackEntry
+    disposeNext(entry: TrackEntry): void
+    _animationsChanged(): void
+    computeHold(entry: TrackEntry): void
+    computeNotLast(entry: TrackEntry): void
+    getCurrent(trackIndex: number): TrackEntry
+    addListener(listener: AnimationStateListener2): void
+    removeListener(listener: AnimationStateListener2): void
+    clearListeners(): void
+    clearListenerNotifications(): void
+  }
+  class TrackEntry {
+    animation: Animation
+    next: TrackEntry
+    mixingFrom: TrackEntry
+    mixingTo: TrackEntry
+    listener: AnimationStateListener2
+    trackIndex: number
+    loop: boolean
+    holdPrevious: boolean
+    eventThreshold: number
+    attachmentThreshold: number
+    drawOrderThreshold: number
+    animationStart: number
+    animationEnd: number
+    animationLast: number
+    nextAnimationLast: number
+    delay: number
+    trackTime: number
+    trackLast: number
+    nextTrackLast: number
+    trackEnd: number
+    timeScale: number
+    alpha: number
+    mixTime: number
+    mixDuration: number
+    interruptAlpha: number
+    totalAlpha: number
+    mixBlend: MixBlend
+    timelineMode: number[]
+    timelineHoldMix: TrackEntry[]
+    timelinesRotation: number[]
+    reset(): void
+    getAnimationTime(): number
+    setAnimationLast(animationLast: number): void
+    isComplete(): boolean
+    resetRotationDirections(): void
+  }
+  class EventQueue {
+    objects: Array<any>
+    drainDisabled: boolean
+    animState: AnimationState
+    constructor(animState: AnimationState)
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
+    drain(): void
+    clear(): void
+  }
+  enum EventType {
+    start = 0,
+    interrupt = 1,
+    end = 2,
+    dispose = 3,
+    complete = 4,
+    event = 5,
+  }
+  interface AnimationStateListener2 {
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
+  }
+  abstract class AnimationStateAdapter2 implements AnimationStateListener2 {
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
+  }
 }
 declare module spine {
-    class AnimationStateData {
-        skeletonData: SkeletonData;
-        animationToMixTime: Map<number>;
-        defaultMix: number;
-        constructor(skeletonData: SkeletonData);
-        setMix(fromName: string, toName: string, duration: number): void;
-        setMixWith(from: Animation, to: Animation, duration: number): void;
-        getMix(from: Animation, to: Animation): number;
-    }
+  class AnimationStateData {
+    skeletonData: SkeletonData
+    animationToMixTime: Map<number>
+    defaultMix: number
+    constructor(skeletonData: SkeletonData)
+    setMix(fromName: string, toName: string, duration: number): void
+    setMixWith(from: Animation, to: Animation, duration: number): void
+    getMix(from: Animation, to: Animation): number
+  }
 }
 declare module spine {
-    class AssetManager implements Disposable {
-        private pathPrefix;
-        private textureLoader;
-        private assets;
-        private errors;
-        private toLoad;
-        private loaded;
-        constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string);
-        private static downloadText;
-        private static downloadBinary;
-        loadBinary(path: string, success?: (path: string, binary: Uint8Array) => void, error?: (path: string, error: string) => void): void;
-        loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, error: string) => void): void;
-        loadTexture(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
-        loadTextureData(path: string, data: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
-        loadTextureAtlas(path: string, success?: (path: string, atlas: TextureAtlas) => void, error?: (path: string, error: string) => void): void;
-        get(path: string): any;
-        remove(path: string): void;
-        removeAll(): void;
-        isLoadingComplete(): boolean;
-        getToLoad(): number;
-        getLoaded(): number;
-        dispose(): void;
-        hasErrors(): boolean;
-        getErrors(): Map<string>;
-    }
+  class AssetManager implements Disposable {
+    private pathPrefix
+    private textureLoader
+    private assets
+    private errors
+    private toLoad
+    private loaded
+    constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string)
+    private static downloadText
+    private static downloadBinary
+    loadBinary(
+      path: string,
+      success?: (path: string, binary: Uint8Array) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    loadText(
+      path: string,
+      success?: (path: string, text: string) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    loadTexture(
+      path: string,
+      success?: (path: string, image: HTMLImageElement) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    loadTextureData(
+      path: string,
+      data: string,
+      success?: (path: string, image: HTMLImageElement) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    loadTextureAtlas(
+      path: string,
+      success?: (path: string, atlas: TextureAtlas) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    get(path: string): any
+    remove(path: string): void
+    removeAll(): void
+    isLoadingComplete(): boolean
+    getToLoad(): number
+    getLoaded(): number
+    dispose(): void
+    hasErrors(): boolean
+    getErrors(): Map<string>
+  }
 }
 declare module spine {
-    class AtlasAttachmentLoader implements AttachmentLoader {
-        atlas: TextureAtlas;
-        constructor(atlas: TextureAtlas);
-        newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
-        newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
-        newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
-        newPathAttachment(skin: Skin, name: string): PathAttachment;
-        newPointAttachment(skin: Skin, name: string): PointAttachment;
-        newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
-    }
+  class AtlasAttachmentLoader implements AttachmentLoader {
+    atlas: TextureAtlas
+    constructor(atlas: TextureAtlas)
+    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment
+    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment
+    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment
+    newPathAttachment(skin: Skin, name: string): PathAttachment
+    newPointAttachment(skin: Skin, name: string): PointAttachment
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment
+  }
 }
 declare module spine {
-    enum BlendMode {
-        Normal = 0,
-        Additive = 1,
-        Multiply = 2,
-        Screen = 3
-    }
+  enum BlendMode {
+    Normal = 0,
+    Additive = 1,
+    Multiply = 2,
+    Screen = 3,
+  }
 }
 declare module spine {
-    class Bone implements Updatable {
-        data: BoneData;
-        skeleton: Skeleton;
-        parent: Bone;
-        children: Bone[];
-        x: number;
-        y: number;
-        rotation: number;
-        scaleX: number;
-        scaleY: number;
-        shearX: number;
-        shearY: number;
-        ax: number;
-        ay: number;
-        arotation: number;
-        ascaleX: number;
-        ascaleY: number;
-        ashearX: number;
-        ashearY: number;
-        appliedValid: boolean;
-        a: number;
-        b: number;
-        worldX: number;
-        c: number;
-        d: number;
-        worldY: number;
-        sorted: boolean;
-        active: boolean;
-        constructor(data: BoneData, skeleton: Skeleton, parent: Bone);
-        isActive(): boolean;
-        update(): void;
-        updateWorldTransform(): void;
-        updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number): void;
-        setToSetupPose(): void;
-        getWorldRotationX(): number;
-        getWorldRotationY(): number;
-        getWorldScaleX(): number;
-        getWorldScaleY(): number;
-        updateAppliedTransform(): void;
-        worldToLocal(world: Vector2): Vector2;
-        localToWorld(local: Vector2): Vector2;
-        worldToLocalRotation(worldRotation: number): number;
-        localToWorldRotation(localRotation: number): number;
-        rotateWorld(degrees: number): void;
-    }
+  class Bone implements Updatable {
+    data: BoneData
+    skeleton: Skeleton
+    parent: Bone
+    children: Bone[]
+    x: number
+    y: number
+    rotation: number
+    scaleX: number
+    scaleY: number
+    shearX: number
+    shearY: number
+    ax: number
+    ay: number
+    arotation: number
+    ascaleX: number
+    ascaleY: number
+    ashearX: number
+    ashearY: number
+    appliedValid: boolean
+    a: number
+    b: number
+    worldX: number
+    c: number
+    d: number
+    worldY: number
+    sorted: boolean
+    active: boolean
+    constructor(data: BoneData, skeleton: Skeleton, parent: Bone)
+    isActive(): boolean
+    update(): void
+    updateWorldTransform(): void
+    updateWorldTransformWith(
+      x: number,
+      y: number,
+      rotation: number,
+      scaleX: number,
+      scaleY: number,
+      shearX: number,
+      shearY: number,
+    ): void
+    setToSetupPose(): void
+    getWorldRotationX(): number
+    getWorldRotationY(): number
+    getWorldScaleX(): number
+    getWorldScaleY(): number
+    updateAppliedTransform(): void
+    worldToLocal(world: Vector2): Vector2
+    localToWorld(local: Vector2): Vector2
+    worldToLocalRotation(worldRotation: number): number
+    localToWorldRotation(localRotation: number): number
+    rotateWorld(degrees: number): void
+  }
 }
 declare module spine {
-    class BoneData {
-        index: number;
-        name: string;
-        parent: BoneData;
-        length: number;
-        x: number;
-        y: number;
-        rotation: number;
-        scaleX: number;
-        scaleY: number;
-        shearX: number;
-        shearY: number;
-        transformMode: TransformMode;
-        skinRequired: boolean;
-        color: Color;
-        constructor(index: number, name: string, parent: BoneData);
-    }
-    enum TransformMode {
-        Normal = 0,
-        OnlyTranslation = 1,
-        NoRotationOrReflection = 2,
-        NoScale = 3,
-        NoScaleOrReflection = 4
-    }
+  class BoneData {
+    index: number
+    name: string
+    parent: BoneData
+    length: number
+    x: number
+    y: number
+    rotation: number
+    scaleX: number
+    scaleY: number
+    shearX: number
+    shearY: number
+    transformMode: TransformMode
+    skinRequired: boolean
+    color: Color
+    constructor(index: number, name: string, parent: BoneData)
+  }
+  enum TransformMode {
+    Normal = 0,
+    OnlyTranslation = 1,
+    NoRotationOrReflection = 2,
+    NoScale = 3,
+    NoScaleOrReflection = 4,
+  }
 }
 declare module spine {
-    abstract class ConstraintData {
-        name: string;
-        order: number;
-        skinRequired: boolean;
-        constructor(name: string, order: number, skinRequired: boolean);
-    }
+  abstract class ConstraintData {
+    name: string
+    order: number
+    skinRequired: boolean
+    constructor(name: string, order: number, skinRequired: boolean)
+  }
 }
 declare module spine {
-    class Event {
-        data: EventData;
-        intValue: number;
-        floatValue: number;
-        stringValue: string;
-        time: number;
-        volume: number;
-        balance: number;
-        constructor(time: number, data: EventData);
-    }
+  class Event {
+    data: EventData
+    intValue: number
+    floatValue: number
+    stringValue: string
+    time: number
+    volume: number
+    balance: number
+    constructor(time: number, data: EventData)
+  }
 }
 declare module spine {
-    class EventData {
-        name: string;
-        intValue: number;
-        floatValue: number;
-        stringValue: string;
-        audioPath: string;
-        volume: number;
-        balance: number;
-        constructor(name: string);
-    }
+  class EventData {
+    name: string
+    intValue: number
+    floatValue: number
+    stringValue: string
+    audioPath: string
+    volume: number
+    balance: number
+    constructor(name: string)
+  }
 }
 declare module spine {
-    class IkConstraint implements Updatable {
-        data: IkConstraintData;
-        bones: Array<Bone>;
-        target: Bone;
-        bendDirection: number;
-        compress: boolean;
-        stretch: boolean;
-        mix: number;
-        softness: number;
-        active: boolean;
-        constructor(data: IkConstraintData, skeleton: Skeleton);
-        isActive(): boolean;
-        apply(): void;
-        update(): void;
-        apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void;
-        apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, softness: number, alpha: number): void;
-    }
+  class IkConstraint implements Updatable {
+    data: IkConstraintData
+    bones: Array<Bone>
+    target: Bone
+    bendDirection: number
+    compress: boolean
+    stretch: boolean
+    mix: number
+    softness: number
+    active: boolean
+    constructor(data: IkConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
+    apply1(
+      bone: Bone,
+      targetX: number,
+      targetY: number,
+      compress: boolean,
+      stretch: boolean,
+      uniform: boolean,
+      alpha: number,
+    ): void
+    apply2(
+      parent: Bone,
+      child: Bone,
+      targetX: number,
+      targetY: number,
+      bendDir: number,
+      stretch: boolean,
+      softness: number,
+      alpha: number,
+    ): void
+  }
 }
 declare module spine {
-    class IkConstraintData extends ConstraintData {
-        bones: BoneData[];
-        target: BoneData;
-        bendDirection: number;
-        compress: boolean;
-        stretch: boolean;
-        uniform: boolean;
-        mix: number;
-        softness: number;
-        constructor(name: string);
-    }
+  class IkConstraintData extends ConstraintData {
+    bones: BoneData[]
+    target: BoneData
+    bendDirection: number
+    compress: boolean
+    stretch: boolean
+    uniform: boolean
+    mix: number
+    softness: number
+    constructor(name: string)
+  }
 }
 declare module spine {
-    class PathConstraint implements Updatable {
-        static NONE: number;
-        static BEFORE: number;
-        static AFTER: number;
-        static epsilon: number;
-        data: PathConstraintData;
-        bones: Array<Bone>;
-        target: Slot;
-        position: number;
-        spacing: number;
-        rotateMix: number;
-        translateMix: number;
-        spaces: number[];
-        positions: number[];
-        world: number[];
-        curves: number[];
-        lengths: number[];
-        segments: number[];
-        active: boolean;
-        constructor(data: PathConstraintData, skeleton: Skeleton);
-        isActive(): boolean;
-        apply(): void;
-        update(): void;
-        computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): number[];
-        addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
-        addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
-        addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array<number>, o: number, tangents: boolean): void;
-    }
+  class PathConstraint implements Updatable {
+    static NONE: number
+    static BEFORE: number
+    static AFTER: number
+    static epsilon: number
+    data: PathConstraintData
+    bones: Array<Bone>
+    target: Slot
+    position: number
+    spacing: number
+    rotateMix: number
+    translateMix: number
+    spaces: number[]
+    positions: number[]
+    world: number[]
+    curves: number[]
+    lengths: number[]
+    segments: number[]
+    active: boolean
+    constructor(data: PathConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
+    computeWorldPositions(
+      path: PathAttachment,
+      spacesCount: number,
+      tangents: boolean,
+      percentPosition: boolean,
+      percentSpacing: boolean,
+    ): number[]
+    addBeforePosition(
+      p: number,
+      temp: Array<number>,
+      i: number,
+      out: Array<number>,
+      o: number,
+    ): void
+    addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void
+    addCurvePosition(
+      p: number,
+      x1: number,
+      y1: number,
+      cx1: number,
+      cy1: number,
+      cx2: number,
+      cy2: number,
+      x2: number,
+      y2: number,
+      out: Array<number>,
+      o: number,
+      tangents: boolean,
+    ): void
+  }
 }
 declare module spine {
-    class PathConstraintData extends ConstraintData {
-        bones: BoneData[];
-        target: SlotData;
-        positionMode: PositionMode;
-        spacingMode: SpacingMode;
-        rotateMode: RotateMode;
-        offsetRotation: number;
-        position: number;
-        spacing: number;
-        rotateMix: number;
-        translateMix: number;
-        constructor(name: string);
-    }
-    enum PositionMode {
-        Fixed = 0,
-        Percent = 1
-    }
-    enum SpacingMode {
-        Length = 0,
-        Fixed = 1,
-        Percent = 2
-    }
-    enum RotateMode {
-        Tangent = 0,
-        Chain = 1,
-        ChainScale = 2
-    }
+  class PathConstraintData extends ConstraintData {
+    bones: BoneData[]
+    target: SlotData
+    positionMode: PositionMode
+    spacingMode: SpacingMode
+    rotateMode: RotateMode
+    offsetRotation: number
+    position: number
+    spacing: number
+    rotateMix: number
+    translateMix: number
+    constructor(name: string)
+  }
+  enum PositionMode {
+    Fixed = 0,
+    Percent = 1,
+  }
+  enum SpacingMode {
+    Length = 0,
+    Fixed = 1,
+    Percent = 2,
+  }
+  enum RotateMode {
+    Tangent = 0,
+    Chain = 1,
+    ChainScale = 2,
+  }
 }
 declare module spine {
-    class SharedAssetManager implements Disposable {
-        private pathPrefix;
-        private clientAssets;
-        private queuedAssets;
-        private rawAssets;
-        private errors;
-        constructor(pathPrefix?: string);
-        private queueAsset;
-        loadText(clientId: string, path: string): void;
-        loadJson(clientId: string, path: string): void;
-        loadTexture(clientId: string, textureLoader: (image: HTMLImageElement) => any, path: string): void;
-        get(clientId: string, path: string): any;
-        private updateClientAssets;
-        isLoadingComplete(clientId: string): boolean;
-        dispose(): void;
-        hasErrors(): boolean;
-        getErrors(): Map<string>;
-    }
+  class SharedAssetManager implements Disposable {
+    private pathPrefix
+    private clientAssets
+    private queuedAssets
+    private rawAssets
+    private errors
+    constructor(pathPrefix?: string)
+    private queueAsset
+    loadText(clientId: string, path: string): void
+    loadJson(clientId: string, path: string): void
+    loadTexture(
+      clientId: string,
+      textureLoader: (image: HTMLImageElement) => any,
+      path: string,
+    ): void
+    get(clientId: string, path: string): any
+    private updateClientAssets
+    isLoadingComplete(clientId: string): boolean
+    dispose(): void
+    hasErrors(): boolean
+    getErrors(): Map<string>
+  }
 }
 declare module spine {
-    class Skeleton {
-        data: SkeletonData;
-        bones: Array<Bone>;
-        slots: Array<Slot>;
-        drawOrder: Array<Slot>;
-        ikConstraints: Array<IkConstraint>;
-        transformConstraints: Array<TransformConstraint>;
-        pathConstraints: Array<PathConstraint>;
-        _updateCache: Updatable[];
-        updateCacheReset: Updatable[];
-        skin: Skin;
-        color: Color;
-        time: number;
-        scaleX: number;
-        scaleY: number;
-        x: number;
-        y: number;
-        constructor(data: SkeletonData);
-        updateCache(): void;
-        sortIkConstraint(constraint: IkConstraint): void;
-        sortPathConstraint(constraint: PathConstraint): void;
-        sortTransformConstraint(constraint: TransformConstraint): void;
-        sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void;
-        sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void;
-        sortBone(bone: Bone): void;
-        sortReset(bones: Array<Bone>): void;
-        updateWorldTransform(): void;
-        setToSetupPose(): void;
-        setBonesToSetupPose(): void;
-        setSlotsToSetupPose(): void;
-        getRootBone(): Bone;
-        findBone(boneName: string): Bone;
-        findBoneIndex(boneName: string): number;
-        findSlot(slotName: string): Slot;
-        findSlotIndex(slotName: string): number;
-        setSkinByName(skinName: string): void;
-        setSkin(newSkin: Skin): void;
-        getAttachmentByName(slotName: string, attachmentName: string): Attachment;
-        getAttachment(slotIndex: number, attachmentName: string): Attachment;
-        setAttachment(slotName: string, attachmentName: string): void;
-        findIkConstraint(constraintName: string): IkConstraint;
-        findTransformConstraint(constraintName: string): TransformConstraint;
-        findPathConstraint(constraintName: string): PathConstraint;
-        getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
-        update(delta: number): void;
-    }
+  class Skeleton {
+    data: SkeletonData
+    bones: Array<Bone>
+    slots: Array<Slot>
+    drawOrder: Array<Slot>
+    ikConstraints: Array<IkConstraint>
+    transformConstraints: Array<TransformConstraint>
+    pathConstraints: Array<PathConstraint>
+    _updateCache: Updatable[]
+    updateCacheReset: Updatable[]
+    skin: Skin
+    color: Color
+    time: number
+    scaleX: number
+    scaleY: number
+    x: number
+    y: number
+    constructor(data: SkeletonData)
+    updateCache(): void
+    sortIkConstraint(constraint: IkConstraint): void
+    sortPathConstraint(constraint: PathConstraint): void
+    sortTransformConstraint(constraint: TransformConstraint): void
+    sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void
+    sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void
+    sortBone(bone: Bone): void
+    sortReset(bones: Array<Bone>): void
+    updateWorldTransform(): void
+    setToSetupPose(): void
+    setBonesToSetupPose(): void
+    setSlotsToSetupPose(): void
+    getRootBone(): Bone
+    findBone(boneName: string): Bone
+    findBoneIndex(boneName: string): number
+    findSlot(slotName: string): Slot
+    findSlotIndex(slotName: string): number
+    setSkinByName(skinName: string): void
+    setSkin(newSkin: Skin): void
+    getAttachmentByName(slotName: string, attachmentName: string): Attachment
+    getAttachment(slotIndex: number, attachmentName: string): Attachment
+    setAttachment(slotName: string, attachmentName: string): void
+    findIkConstraint(constraintName: string): IkConstraint
+    findTransformConstraint(constraintName: string): TransformConstraint
+    findPathConstraint(constraintName: string): PathConstraint
+    getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void
+    update(delta: number): void
+  }
 }
 declare module spine {
-    class SkeletonBinary {
-        static AttachmentTypeValues: number[];
-        static TransformModeValues: TransformMode[];
-        static PositionModeValues: PositionMode[];
-        static SpacingModeValues: SpacingMode[];
-        static RotateModeValues: RotateMode[];
-        static BlendModeValues: BlendMode[];
-        static BONE_ROTATE: number;
-        static BONE_TRANSLATE: number;
-        static BONE_SCALE: number;
-        static BONE_SHEAR: number;
-        static SLOT_ATTACHMENT: number;
-        static SLOT_COLOR: number;
-        static SLOT_TWO_COLOR: number;
-        static PATH_POSITION: number;
-        static PATH_SPACING: number;
-        static PATH_MIX: number;
-        static CURVE_LINEAR: number;
-        static CURVE_STEPPED: number;
-        static CURVE_BEZIER: number;
-        attachmentLoader: AttachmentLoader;
-        scale: number;
-        private linkedMeshes;
-        constructor(attachmentLoader: AttachmentLoader);
-        readSkeletonData(binary: Uint8Array): SkeletonData;
-        private readSkin;
-        private readAttachment;
-        private readVertices;
-        private readFloatArray;
-        private readShortArray;
-        private readAnimation;
-        private readCurve;
-        setCurve(timeline: CurveTimeline, frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
-    }
+  class SkeletonBinary {
+    static AttachmentTypeValues: number[]
+    static TransformModeValues: TransformMode[]
+    static PositionModeValues: PositionMode[]
+    static SpacingModeValues: SpacingMode[]
+    static RotateModeValues: RotateMode[]
+    static BlendModeValues: BlendMode[]
+    static BONE_ROTATE: number
+    static BONE_TRANSLATE: number
+    static BONE_SCALE: number
+    static BONE_SHEAR: number
+    static SLOT_ATTACHMENT: number
+    static SLOT_COLOR: number
+    static SLOT_TWO_COLOR: number
+    static PATH_POSITION: number
+    static PATH_SPACING: number
+    static PATH_MIX: number
+    static CURVE_LINEAR: number
+    static CURVE_STEPPED: number
+    static CURVE_BEZIER: number
+    attachmentLoader: AttachmentLoader
+    scale: number
+    private linkedMeshes
+    constructor(attachmentLoader: AttachmentLoader)
+    readSkeletonData(binary: Uint8Array): SkeletonData
+    private readSkin
+    private readAttachment
+    private readVertices
+    private readFloatArray
+    private readShortArray
+    private readAnimation
+    private readCurve
+    setCurve(
+      timeline: CurveTimeline,
+      frameIndex: number,
+      cx1: number,
+      cy1: number,
+      cx2: number,
+      cy2: number,
+    ): void
+  }
 }
 declare module spine {
-    class SkeletonBounds {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-        boundingBoxes: BoundingBoxAttachment[];
-        polygons: ArrayLike<number>[];
-        private polygonPool;
-        update(skeleton: Skeleton, updateAabb: boolean): void;
-        aabbCompute(): void;
-        aabbContainsPoint(x: number, y: number): boolean;
-        aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
-        aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
-        containsPoint(x: number, y: number): BoundingBoxAttachment;
-        containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean;
-        intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
-        intersectsSegmentPolygon(polygon: ArrayLike<number>, x1: number, y1: number, x2: number, y2: number): boolean;
-        getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>;
-        getWidth(): number;
-        getHeight(): number;
-    }
+  class SkeletonBounds {
+    minX: number
+    minY: number
+    maxX: number
+    maxY: number
+    boundingBoxes: BoundingBoxAttachment[]
+    polygons: ArrayLike<number>[]
+    private polygonPool
+    update(skeleton: Skeleton, updateAabb: boolean): void
+    aabbCompute(): void
+    aabbContainsPoint(x: number, y: number): boolean
+    aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean
+    aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean
+    containsPoint(x: number, y: number): BoundingBoxAttachment
+    containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean
+    intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment
+    intersectsSegmentPolygon(
+      polygon: ArrayLike<number>,
+      x1: number,
+      y1: number,
+      x2: number,
+      y2: number,
+    ): boolean
+    getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>
+    getWidth(): number
+    getHeight(): number
+  }
 }
 declare module spine {
-    class SkeletonClipping {
-        private triangulator;
-        private clippingPolygon;
-        private clipOutput;
-        clippedVertices: number[];
-        clippedTriangles: number[];
-        private scratch;
-        private clipAttachment;
-        private clippingPolygons;
-        clipStart(slot: Slot, clip: ClippingAttachment): number;
-        clipEndWithSlot(slot: Slot): void;
-        clipEnd(): void;
-        isClipping(): boolean;
-        clipTriangles(vertices: ArrayLike<number>, verticesLength: number, triangles: ArrayLike<number>, trianglesLength: number, uvs: ArrayLike<number>, light: Color, dark: Color, twoColor: boolean): void;
-        clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
-        static makeClockwise(polygon: ArrayLike<number>): void;
-    }
+  class SkeletonClipping {
+    private triangulator
+    private clippingPolygon
+    private clipOutput
+    clippedVertices: number[]
+    clippedTriangles: number[]
+    private scratch
+    private clipAttachment
+    private clippingPolygons
+    clipStart(slot: Slot, clip: ClippingAttachment): number
+    clipEndWithSlot(slot: Slot): void
+    clipEnd(): void
+    isClipping(): boolean
+    clipTriangles(
+      vertices: ArrayLike<number>,
+      verticesLength: number,
+      triangles: ArrayLike<number>,
+      trianglesLength: number,
+      uvs: ArrayLike<number>,
+      light: Color,
+      dark: Color,
+      twoColor: boolean,
+    ): void
+    clip(
+      x1: number,
+      y1: number,
+      x2: number,
+      y2: number,
+      x3: number,
+      y3: number,
+      clippingArea: Array<number>,
+      output: Array<number>,
+    ): boolean
+    static makeClockwise(polygon: ArrayLike<number>): void
+  }
 }
 declare module spine {
-    class SkeletonData {
-        name: string;
-        bones: BoneData[];
-        slots: SlotData[];
-        skins: Skin[];
-        defaultSkin: Skin;
-        events: EventData[];
-        animations: Animation[];
-        ikConstraints: IkConstraintData[];
-        transformConstraints: TransformConstraintData[];
-        pathConstraints: PathConstraintData[];
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        version: string;
-        hash: string;
-        fps: number;
-        imagesPath: string;
-        audioPath: string;
-        findBone(boneName: string): BoneData;
-        findBoneIndex(boneName: string): number;
-        findSlot(slotName: string): SlotData;
-        findSlotIndex(slotName: string): number;
-        findSkin(skinName: string): Skin;
-        findEvent(eventDataName: string): EventData;
-        findAnimation(animationName: string): Animation;
-        findIkConstraint(constraintName: string): IkConstraintData;
-        findTransformConstraint(constraintName: string): TransformConstraintData;
-        findPathConstraint(constraintName: string): PathConstraintData;
-        findPathConstraintIndex(pathConstraintName: string): number;
-    }
+  class SkeletonData {
+    name: string
+    bones: BoneData[]
+    slots: SlotData[]
+    skins: Skin[]
+    defaultSkin: Skin
+    events: EventData[]
+    animations: Animation[]
+    ikConstraints: IkConstraintData[]
+    transformConstraints: TransformConstraintData[]
+    pathConstraints: PathConstraintData[]
+    x: number
+    y: number
+    width: number
+    height: number
+    version: string
+    hash: string
+    fps: number
+    imagesPath: string
+    audioPath: string
+    findBone(boneName: string): BoneData
+    findBoneIndex(boneName: string): number
+    findSlot(slotName: string): SlotData
+    findSlotIndex(slotName: string): number
+    findSkin(skinName: string): Skin
+    findEvent(eventDataName: string): EventData
+    findAnimation(animationName: string): Animation
+    findIkConstraint(constraintName: string): IkConstraintData
+    findTransformConstraint(constraintName: string): TransformConstraintData
+    findPathConstraint(constraintName: string): PathConstraintData
+    findPathConstraintIndex(pathConstraintName: string): number
+  }
 }
 declare module spine {
-    class SkeletonJson {
-        attachmentLoader: AttachmentLoader;
-        scale: number;
-        private linkedMeshes;
-        constructor(attachmentLoader: AttachmentLoader);
-        readSkeletonData(json: string | any): SkeletonData;
-        readAttachment(map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment;
-        readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void;
-        readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
-        readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void;
-        getValue(map: any, prop: string, defaultValue: any): any;
-        static blendModeFromString(str: string): BlendMode;
-        static positionModeFromString(str: string): PositionMode;
-        static spacingModeFromString(str: string): SpacingMode;
-        static rotateModeFromString(str: string): RotateMode;
-        static transformModeFromString(str: string): TransformMode;
-    }
+  class SkeletonJson {
+    attachmentLoader: AttachmentLoader
+    scale: number
+    private linkedMeshes
+    constructor(attachmentLoader: AttachmentLoader)
+    readSkeletonData(json: string | any): SkeletonData
+    readAttachment(
+      map: any,
+      skin: Skin,
+      slotIndex: number,
+      name: string,
+      skeletonData: SkeletonData,
+    ): Attachment
+    readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void
+    readAnimation(map: any, name: string, skeletonData: SkeletonData): void
+    readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void
+    getValue(map: any, prop: string, defaultValue: any): any
+    static blendModeFromString(str: string): BlendMode
+    static positionModeFromString(str: string): PositionMode
+    static spacingModeFromString(str: string): SpacingMode
+    static rotateModeFromString(str: string): RotateMode
+    static transformModeFromString(str: string): TransformMode
+  }
 }
 declare module spine {
-    class SkinEntry {
-        slotIndex: number;
-        name: string;
-        attachment: Attachment;
-        constructor(slotIndex: number, name: string, attachment: Attachment);
-    }
-    class Skin {
-        name: string;
-        attachments: Map<Attachment>[];
-        bones: BoneData[];
-        constraints: ConstraintData[];
-        constructor(name: string);
-        setAttachment(slotIndex: number, name: string, attachment: Attachment): void;
-        addSkin(skin: Skin): void;
-        copySkin(skin: Skin): void;
-        getAttachment(slotIndex: number, name: string): Attachment;
-        removeAttachment(slotIndex: number, name: string): void;
-        getAttachments(): Array<SkinEntry>;
-        getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void;
-        clear(): void;
-        attachAll(skeleton: Skeleton, oldSkin: Skin): void;
-    }
+  class SkinEntry {
+    slotIndex: number
+    name: string
+    attachment: Attachment
+    constructor(slotIndex: number, name: string, attachment: Attachment)
+  }
+  class Skin {
+    name: string
+    attachments: Map<Attachment>[]
+    bones: BoneData[]
+    constraints: ConstraintData[]
+    constructor(name: string)
+    setAttachment(slotIndex: number, name: string, attachment: Attachment): void
+    addSkin(skin: Skin): void
+    copySkin(skin: Skin): void
+    getAttachment(slotIndex: number, name: string): Attachment
+    removeAttachment(slotIndex: number, name: string): void
+    getAttachments(): Array<SkinEntry>
+    getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void
+    clear(): void
+    attachAll(skeleton: Skeleton, oldSkin: Skin): void
+  }
 }
 declare module spine {
-    class Slot {
-        data: SlotData;
-        bone: Bone;
-        color: Color;
-        darkColor: Color;
-        private attachment;
-        private attachmentTime;
-        deform: number[];
-        constructor(data: SlotData, bone: Bone);
-        getAttachment(): Attachment;
-        setAttachment(attachment: Attachment): void;
-        setAttachmentTime(time: number): void;
-        getAttachmentTime(): number;
-        setToSetupPose(): void;
-    }
+  class Slot {
+    data: SlotData
+    bone: Bone
+    color: Color
+    darkColor: Color
+    private attachment
+    private attachmentTime
+    deform: number[]
+    constructor(data: SlotData, bone: Bone)
+    getAttachment(): Attachment
+    setAttachment(attachment: Attachment): void
+    setAttachmentTime(time: number): void
+    getAttachmentTime(): number
+    setToSetupPose(): void
+  }
 }
 declare module spine {
-    class SlotData {
-        index: number;
-        name: string;
-        boneData: BoneData;
-        color: Color;
-        darkColor: Color;
-        attachmentName: string;
-        blendMode: BlendMode;
-        constructor(index: number, name: string, boneData: BoneData);
-    }
+  class SlotData {
+    index: number
+    name: string
+    boneData: BoneData
+    color: Color
+    darkColor: Color
+    attachmentName: string
+    blendMode: BlendMode
+    constructor(index: number, name: string, boneData: BoneData)
+  }
 }
 declare module spine {
-    abstract class Texture {
-        protected _image: HTMLImageElement;
-        constructor(image: HTMLImageElement);
-        getImage(): HTMLImageElement;
-        abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-        abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-        abstract dispose(): void;
-        static filterFromString(text: string): TextureFilter;
-        static wrapFromString(text: string): TextureWrap;
-    }
-    enum TextureFilter {
-        Nearest = 9728,
-        Linear = 9729,
-        MipMap = 9987,
-        MipMapNearestNearest = 9984,
-        MipMapLinearNearest = 9985,
-        MipMapNearestLinear = 9986,
-        MipMapLinearLinear = 9987
-    }
-    enum TextureWrap {
-        MirroredRepeat = 33648,
-        ClampToEdge = 33071,
-        Repeat = 10497
-    }
-    class TextureRegion {
-        renderObject: any;
-        u: number;
-        v: number;
-        u2: number;
-        v2: number;
-        width: number;
-        height: number;
-        rotate: boolean;
-        offsetX: number;
-        offsetY: number;
-        originalWidth: number;
-        originalHeight: number;
-    }
-    class FakeTexture extends Texture {
-        setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-        setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-        dispose(): void;
-    }
+  abstract class Texture {
+    protected _image: HTMLImageElement
+    constructor(image: HTMLImageElement)
+    getImage(): HTMLImageElement
+    abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    abstract dispose(): void
+    static filterFromString(text: string): TextureFilter
+    static wrapFromString(text: string): TextureWrap
+  }
+  enum TextureFilter {
+    Nearest = 9728,
+    Linear = 9729,
+    MipMap = 9987,
+    MipMapNearestNearest = 9984,
+    MipMapLinearNearest = 9985,
+    MipMapNearestLinear = 9986,
+    MipMapLinearLinear = 9987,
+  }
+  enum TextureWrap {
+    MirroredRepeat = 33648,
+    ClampToEdge = 33071,
+    Repeat = 10497,
+  }
+  class TextureRegion {
+    renderObject: any
+    u: number
+    v: number
+    u2: number
+    v2: number
+    width: number
+    height: number
+    rotate: boolean
+    offsetX: number
+    offsetY: number
+    originalWidth: number
+    originalHeight: number
+  }
+  class FakeTexture extends Texture {
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    dispose(): void
+  }
 }
 declare module spine {
-    class TextureAtlas implements Disposable {
-        pages: TextureAtlasPage[];
-        regions: TextureAtlasRegion[];
-        constructor(atlasText: string, textureLoader: (path: string) => any);
-        private load;
-        findRegion(name: string): TextureAtlasRegion;
-        dispose(): void;
-    }
-    class TextureAtlasPage {
-        name: string;
-        minFilter: TextureFilter;
-        magFilter: TextureFilter;
-        uWrap: TextureWrap;
-        vWrap: TextureWrap;
-        texture: Texture;
-        width: number;
-        height: number;
-    }
-    class TextureAtlasRegion extends TextureRegion {
-        page: TextureAtlasPage;
-        name: string;
-        x: number;
-        y: number;
-        index: number;
-        rotate: boolean;
-        degrees: number;
-        texture: Texture;
-    }
+  class TextureAtlas implements Disposable {
+    pages: TextureAtlasPage[]
+    regions: TextureAtlasRegion[]
+    constructor(atlasText: string, textureLoader: (path: string) => any)
+    private load
+    findRegion(name: string): TextureAtlasRegion
+    dispose(): void
+  }
+  class TextureAtlasPage {
+    name: string
+    minFilter: TextureFilter
+    magFilter: TextureFilter
+    uWrap: TextureWrap
+    vWrap: TextureWrap
+    texture: Texture
+    width: number
+    height: number
+  }
+  class TextureAtlasRegion extends TextureRegion {
+    page: TextureAtlasPage
+    name: string
+    x: number
+    y: number
+    index: number
+    rotate: boolean
+    degrees: number
+    texture: Texture
+  }
 }
 declare module spine {
-    class TransformConstraint implements Updatable {
-        data: TransformConstraintData;
-        bones: Array<Bone>;
-        target: Bone;
-        rotateMix: number;
-        translateMix: number;
-        scaleMix: number;
-        shearMix: number;
-        temp: Vector2;
-        active: boolean;
-        constructor(data: TransformConstraintData, skeleton: Skeleton);
-        isActive(): boolean;
-        apply(): void;
-        update(): void;
-        applyAbsoluteWorld(): void;
-        applyRelativeWorld(): void;
-        applyAbsoluteLocal(): void;
-        applyRelativeLocal(): void;
-    }
+  class TransformConstraint implements Updatable {
+    data: TransformConstraintData
+    bones: Array<Bone>
+    target: Bone
+    rotateMix: number
+    translateMix: number
+    scaleMix: number
+    shearMix: number
+    temp: Vector2
+    active: boolean
+    constructor(data: TransformConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
+    applyAbsoluteWorld(): void
+    applyRelativeWorld(): void
+    applyAbsoluteLocal(): void
+    applyRelativeLocal(): void
+  }
 }
 declare module spine {
-    class TransformConstraintData extends ConstraintData {
-        bones: BoneData[];
-        target: BoneData;
-        rotateMix: number;
-        translateMix: number;
-        scaleMix: number;
-        shearMix: number;
-        offsetRotation: number;
-        offsetX: number;
-        offsetY: number;
-        offsetScaleX: number;
-        offsetScaleY: number;
-        offsetShearY: number;
-        relative: boolean;
-        local: boolean;
-        constructor(name: string);
-    }
+  class TransformConstraintData extends ConstraintData {
+    bones: BoneData[]
+    target: BoneData
+    rotateMix: number
+    translateMix: number
+    scaleMix: number
+    shearMix: number
+    offsetRotation: number
+    offsetX: number
+    offsetY: number
+    offsetScaleX: number
+    offsetScaleY: number
+    offsetShearY: number
+    relative: boolean
+    local: boolean
+    constructor(name: string)
+  }
 }
 declare module spine {
-    class Triangulator {
-        private convexPolygons;
-        private convexPolygonsIndices;
-        private indicesArray;
-        private isConcaveArray;
-        private triangles;
-        private polygonPool;
-        private polygonIndicesPool;
-        triangulate(verticesArray: ArrayLike<number>): Array<number>;
-        decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>;
-        private static isConcave;
-        private static positiveArea;
-        private static winding;
-    }
+  class Triangulator {
+    private convexPolygons
+    private convexPolygonsIndices
+    private indicesArray
+    private isConcaveArray
+    private triangles
+    private polygonPool
+    private polygonIndicesPool
+    triangulate(verticesArray: ArrayLike<number>): Array<number>
+    decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>
+    private static isConcave
+    private static positiveArea
+    private static winding
+  }
 }
 declare module spine {
-    interface Updatable {
-        update(): void;
-        isActive(): boolean;
-    }
+  interface Updatable {
+    update(): void
+    isActive(): boolean
+  }
 }
 declare module spine {
-    interface Map<T> {
-        [key: string]: T;
-    }
-    class IntSet {
-        array: number[];
-        add(value: number): boolean;
-        contains(value: number): boolean;
-        remove(value: number): void;
-        clear(): void;
-    }
-    interface Disposable {
-        dispose(): void;
-    }
-    interface Restorable {
-        restore(): void;
-    }
-    class Color {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-        static WHITE: Color;
-        static RED: Color;
-        static GREEN: Color;
-        static BLUE: Color;
-        static MAGENTA: Color;
-        constructor(r?: number, g?: number, b?: number, a?: number);
-        set(r: number, g: number, b: number, a: number): this;
-        setFromColor(c: Color): this;
-        setFromString(hex: string): this;
-        add(r: number, g: number, b: number, a: number): this;
-        clamp(): this;
-        static rgba8888ToColor(color: Color, value: number): void;
-        static rgb888ToColor(color: Color, value: number): void;
-    }
-    class MathUtils {
-        static PI: number;
-        static PI2: number;
-        static radiansToDegrees: number;
-        static radDeg: number;
-        static degreesToRadians: number;
-        static degRad: number;
-        static clamp(value: number, min: number, max: number): number;
-        static cosDeg(degrees: number): number;
-        static sinDeg(degrees: number): number;
-        static signum(value: number): number;
-        static toInt(x: number): number;
-        static cbrt(x: number): number;
-        static randomTriangular(min: number, max: number): number;
-        static randomTriangularWith(min: number, max: number, mode: number): number;
-    }
-    abstract class Interpolation {
-        protected abstract applyInternal(a: number): number;
-        apply(start: number, end: number, a: number): number;
-    }
-    class Pow extends Interpolation {
-        protected power: number;
-        constructor(power: number);
-        applyInternal(a: number): number;
-    }
-    class PowOut extends Pow {
-        constructor(power: number);
-        applyInternal(a: number): number;
-    }
-    class Utils {
-        static SUPPORTS_TYPED_ARRAYS: boolean;
-        static arrayCopy<T>(source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number): void;
-        static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>;
-        static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>;
-        static newArray<T>(size: number, defaultValue: T): Array<T>;
-        static newFloatArray(size: number): ArrayLike<number>;
-        static newShortArray(size: number): ArrayLike<number>;
-        static toFloatArray(array: Array<number>): number[] | Float32Array;
-        static toSinglePrecision(value: number): number;
-        static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
-        static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
-    }
-    class DebugUtils {
-        static logBones(skeleton: Skeleton): void;
-    }
-    class Pool<T> {
-        private items;
-        private instantiator;
-        constructor(instantiator: () => T);
-        obtain(): T;
-        free(item: T): void;
-        freeAll(items: ArrayLike<T>): void;
-        clear(): void;
-    }
-    class Vector2 {
-        x: number;
-        y: number;
-        constructor(x?: number, y?: number);
-        set(x: number, y: number): Vector2;
-        length(): number;
-        normalize(): this;
-    }
-    class TimeKeeper {
-        maxDelta: number;
-        framesPerSecond: number;
-        delta: number;
-        totalTime: number;
-        private lastTime;
-        private frameCount;
-        private frameTime;
-        update(): void;
-    }
-    interface ArrayLike<T> {
-        length: number;
-        [n: number]: T;
-    }
-    class WindowedMean {
-        values: Array<number>;
-        addedValues: number;
-        lastValue: number;
-        mean: number;
-        dirty: boolean;
-        constructor(windowSize?: number);
-        hasEnoughData(): boolean;
-        addValue(value: number): void;
-        getMean(): number;
-    }
+  interface Map<T> {
+    [key: string]: T
+  }
+  class IntSet {
+    array: number[]
+    add(value: number): boolean
+    contains(value: number): boolean
+    remove(value: number): void
+    clear(): void
+  }
+  interface Disposable {
+    dispose(): void
+  }
+  interface Restorable {
+    restore(): void
+  }
+  class Color {
+    r: number
+    g: number
+    b: number
+    a: number
+    static WHITE: Color
+    static RED: Color
+    static GREEN: Color
+    static BLUE: Color
+    static MAGENTA: Color
+    constructor(r?: number, g?: number, b?: number, a?: number)
+    set(r: number, g: number, b: number, a: number): this
+    setFromColor(c: Color): this
+    setFromString(hex: string): this
+    add(r: number, g: number, b: number, a: number): this
+    clamp(): this
+    static rgba8888ToColor(color: Color, value: number): void
+    static rgb888ToColor(color: Color, value: number): void
+  }
+  class MathUtils {
+    static PI: number
+    static PI2: number
+    static radiansToDegrees: number
+    static radDeg: number
+    static degreesToRadians: number
+    static degRad: number
+    static clamp(value: number, min: number, max: number): number
+    static cosDeg(degrees: number): number
+    static sinDeg(degrees: number): number
+    static signum(value: number): number
+    static toInt(x: number): number
+    static cbrt(x: number): number
+    static randomTriangular(min: number, max: number): number
+    static randomTriangularWith(min: number, max: number, mode: number): number
+  }
+  abstract class Interpolation {
+    protected abstract applyInternal(a: number): number
+    apply(start: number, end: number, a: number): number
+  }
+  class Pow extends Interpolation {
+    protected power: number
+    constructor(power: number)
+    applyInternal(a: number): number
+  }
+  class PowOut extends Pow {
+    constructor(power: number)
+    applyInternal(a: number): number
+  }
+  class Utils {
+    static SUPPORTS_TYPED_ARRAYS: boolean
+    static arrayCopy<T>(
+      source: ArrayLike<T>,
+      sourceStart: number,
+      dest: ArrayLike<T>,
+      destStart: number,
+      numElements: number,
+    ): void
+    static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>
+    static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>
+    static newArray<T>(size: number, defaultValue: T): Array<T>
+    static newFloatArray(size: number): ArrayLike<number>
+    static newShortArray(size: number): ArrayLike<number>
+    static toFloatArray(array: Array<number>): number[] | Float32Array
+    static toSinglePrecision(value: number): number
+    static webkit602BugfixHelper(alpha: number, blend: MixBlend): void
+    static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean
+  }
+  class DebugUtils {
+    static logBones(skeleton: Skeleton): void
+  }
+  class Pool<T> {
+    private items
+    private instantiator
+    constructor(instantiator: () => T)
+    obtain(): T
+    free(item: T): void
+    freeAll(items: ArrayLike<T>): void
+    clear(): void
+  }
+  class Vector2 {
+    x: number
+    y: number
+    constructor(x?: number, y?: number)
+    set(x: number, y: number): Vector2
+    length(): number
+    normalize(): this
+  }
+  class TimeKeeper {
+    maxDelta: number
+    framesPerSecond: number
+    delta: number
+    totalTime: number
+    private lastTime
+    private frameCount
+    private frameTime
+    update(): void
+  }
+  interface ArrayLike<T> {
+    length: number
+    [n: number]: T
+  }
+  class WindowedMean {
+    values: Array<number>
+    addedValues: number
+    lastValue: number
+    mean: number
+    dirty: boolean
+    constructor(windowSize?: number)
+    hasEnoughData(): boolean
+    addValue(value: number): void
+    getMean(): number
+  }
 }
 declare module spine {
-    interface VertexEffect {
-        begin(skeleton: Skeleton): void;
-        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-        end(): void;
-    }
+  interface VertexEffect {
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
+  }
 }
 interface Math {
-    fround(n: number): number;
+  fround(n: number): number
 }
 declare module spine {
-    abstract class Attachment {
-        name: string;
-        constructor(name: string);
-        abstract copy(): Attachment;
-    }
-    abstract class VertexAttachment extends Attachment {
-        private static nextID;
-        id: number;
-        bones: Array<number>;
-        vertices: ArrayLike<number>;
-        worldVerticesLength: number;
-        deformAttachment: VertexAttachment;
-        constructor(name: string);
-        computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
-        copyTo(attachment: VertexAttachment): void;
-    }
+  abstract class Attachment {
+    name: string
+    constructor(name: string)
+    abstract copy(): Attachment
+  }
+  abstract class VertexAttachment extends Attachment {
+    private static nextID
+    id: number
+    bones: Array<number>
+    vertices: ArrayLike<number>
+    worldVerticesLength: number
+    deformAttachment: VertexAttachment
+    constructor(name: string)
+    computeWorldVertices(
+      slot: Slot,
+      start: number,
+      count: number,
+      worldVertices: ArrayLike<number>,
+      offset: number,
+      stride: number,
+    ): void
+    copyTo(attachment: VertexAttachment): void
+  }
 }
 declare module spine {
-    interface AttachmentLoader {
-        newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
-        newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
-        newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
-        newPathAttachment(skin: Skin, name: string): PathAttachment;
-        newPointAttachment(skin: Skin, name: string): PointAttachment;
-        newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
-    }
+  interface AttachmentLoader {
+    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment
+    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment
+    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment
+    newPathAttachment(skin: Skin, name: string): PathAttachment
+    newPointAttachment(skin: Skin, name: string): PointAttachment
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment
+  }
 }
 declare module spine {
-    enum AttachmentType {
-        Region = 0,
-        BoundingBox = 1,
-        Mesh = 2,
-        LinkedMesh = 3,
-        Path = 4,
-        Point = 5,
-        Clipping = 6
-    }
+  enum AttachmentType {
+    Region = 0,
+    BoundingBox = 1,
+    Mesh = 2,
+    LinkedMesh = 3,
+    Path = 4,
+    Point = 5,
+    Clipping = 6,
+  }
 }
 declare module spine {
-    class BoundingBoxAttachment extends VertexAttachment {
-        color: Color;
-        constructor(name: string);
-        copy(): Attachment;
-    }
+  class BoundingBoxAttachment extends VertexAttachment {
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class ClippingAttachment extends VertexAttachment {
-        endSlot: SlotData;
-        color: Color;
-        constructor(name: string);
-        copy(): Attachment;
-    }
+  class ClippingAttachment extends VertexAttachment {
+    endSlot: SlotData
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class MeshAttachment extends VertexAttachment {
-        region: TextureRegion;
-        path: string;
-        regionUVs: ArrayLike<number>;
-        uvs: ArrayLike<number>;
-        triangles: Array<number>;
-        color: Color;
-        width: number;
-        height: number;
-        hullLength: number;
-        edges: Array<number>;
-        private parentMesh;
-        tempColor: Color;
-        constructor(name: string);
-        updateUVs(): void;
-        getParentMesh(): MeshAttachment;
-        setParentMesh(parentMesh: MeshAttachment): void;
-        copy(): Attachment;
-        newLinkedMesh(): MeshAttachment;
-    }
+  class MeshAttachment extends VertexAttachment {
+    region: TextureRegion
+    path: string
+    regionUVs: ArrayLike<number>
+    uvs: ArrayLike<number>
+    triangles: Array<number>
+    color: Color
+    width: number
+    height: number
+    hullLength: number
+    edges: Array<number>
+    private parentMesh
+    tempColor: Color
+    constructor(name: string)
+    updateUVs(): void
+    getParentMesh(): MeshAttachment
+    setParentMesh(parentMesh: MeshAttachment): void
+    copy(): Attachment
+    newLinkedMesh(): MeshAttachment
+  }
 }
 declare module spine {
-    class PathAttachment extends VertexAttachment {
-        lengths: Array<number>;
-        closed: boolean;
-        constantSpeed: boolean;
-        color: Color;
-        constructor(name: string);
-        copy(): Attachment;
-    }
+  class PathAttachment extends VertexAttachment {
+    lengths: Array<number>
+    closed: boolean
+    constantSpeed: boolean
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class PointAttachment extends VertexAttachment {
-        x: number;
-        y: number;
-        rotation: number;
-        color: Color;
-        constructor(name: string);
-        computeWorldPosition(bone: Bone, point: Vector2): Vector2;
-        computeWorldRotation(bone: Bone): number;
-        copy(): Attachment;
-    }
+  class PointAttachment extends VertexAttachment {
+    x: number
+    y: number
+    rotation: number
+    color: Color
+    constructor(name: string)
+    computeWorldPosition(bone: Bone, point: Vector2): Vector2
+    computeWorldRotation(bone: Bone): number
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class RegionAttachment extends Attachment {
-        static OX1: number;
-        static OY1: number;
-        static OX2: number;
-        static OY2: number;
-        static OX3: number;
-        static OY3: number;
-        static OX4: number;
-        static OY4: number;
-        static X1: number;
-        static Y1: number;
-        static C1R: number;
-        static C1G: number;
-        static C1B: number;
-        static C1A: number;
-        static U1: number;
-        static V1: number;
-        static X2: number;
-        static Y2: number;
-        static C2R: number;
-        static C2G: number;
-        static C2B: number;
-        static C2A: number;
-        static U2: number;
-        static V2: number;
-        static X3: number;
-        static Y3: number;
-        static C3R: number;
-        static C3G: number;
-        static C3B: number;
-        static C3A: number;
-        static U3: number;
-        static V3: number;
-        static X4: number;
-        static Y4: number;
-        static C4R: number;
-        static C4G: number;
-        static C4B: number;
-        static C4A: number;
-        static U4: number;
-        static V4: number;
-        x: number;
-        y: number;
-        scaleX: number;
-        scaleY: number;
-        rotation: number;
-        width: number;
-        height: number;
-        color: Color;
-        path: string;
-        rendererObject: any;
-        region: TextureRegion;
-        offset: ArrayLike<number>;
-        uvs: ArrayLike<number>;
-        tempColor: Color;
-        constructor(name: string);
-        updateOffset(): void;
-        setRegion(region: TextureRegion): void;
-        computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
-        copy(): Attachment;
-    }
+  class RegionAttachment extends Attachment {
+    static OX1: number
+    static OY1: number
+    static OX2: number
+    static OY2: number
+    static OX3: number
+    static OY3: number
+    static OX4: number
+    static OY4: number
+    static X1: number
+    static Y1: number
+    static C1R: number
+    static C1G: number
+    static C1B: number
+    static C1A: number
+    static U1: number
+    static V1: number
+    static X2: number
+    static Y2: number
+    static C2R: number
+    static C2G: number
+    static C2B: number
+    static C2A: number
+    static U2: number
+    static V2: number
+    static X3: number
+    static Y3: number
+    static C3R: number
+    static C3G: number
+    static C3B: number
+    static C3A: number
+    static U3: number
+    static V3: number
+    static X4: number
+    static Y4: number
+    static C4R: number
+    static C4G: number
+    static C4B: number
+    static C4A: number
+    static U4: number
+    static V4: number
+    x: number
+    y: number
+    scaleX: number
+    scaleY: number
+    rotation: number
+    width: number
+    height: number
+    color: Color
+    path: string
+    rendererObject: any
+    region: TextureRegion
+    offset: ArrayLike<number>
+    uvs: ArrayLike<number>
+    tempColor: Color
+    constructor(name: string)
+    updateOffset(): void
+    setRegion(region: TextureRegion): void
+    computeWorldVertices(
+      bone: Bone,
+      worldVertices: ArrayLike<number>,
+      offset: number,
+      stride: number,
+    ): void
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class JitterEffect implements VertexEffect {
-        jitterX: number;
-        jitterY: number;
-        constructor(jitterX: number, jitterY: number);
-        begin(skeleton: Skeleton): void;
-        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-        end(): void;
-    }
+  class JitterEffect implements VertexEffect {
+    jitterX: number
+    jitterY: number
+    constructor(jitterX: number, jitterY: number)
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
+  }
 }
 declare module spine {
-    class SwirlEffect implements VertexEffect {
-        static interpolation: PowOut;
-        centerX: number;
-        centerY: number;
-        radius: number;
-        angle: number;
-        private worldX;
-        private worldY;
-        constructor(radius: number);
-        begin(skeleton: Skeleton): void;
-        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-        end(): void;
-    }
+  class SwirlEffect implements VertexEffect {
+    static interpolation: PowOut
+    centerX: number
+    centerY: number
+    radius: number
+    angle: number
+    private worldX
+    private worldY
+    constructor(radius: number)
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
+  }
 }
 declare module spine.canvas {
-    class AssetManager extends spine.AssetManager {
-        constructor(pathPrefix?: string);
-    }
+  class AssetManager extends spine.AssetManager {
+    constructor(pathPrefix?: string)
+  }
 }
 declare module spine.canvas {
-    class CanvasTexture extends Texture {
-        constructor(image: HTMLImageElement);
-        setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-        setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-        dispose(): void;
-    }
+  class CanvasTexture extends Texture {
+    constructor(image: HTMLImageElement)
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    dispose(): void
+  }
 }
 declare module spine.canvas {
-    class SkeletonRenderer {
-        static QUAD_TRIANGLES: number[];
-        static VERTEX_SIZE: number;
-        private ctx;
-        triangleRendering: boolean;
-        debugRendering: boolean;
-        private vertices;
-        private tempColor;
-        constructor(context: CanvasRenderingContext2D);
-        draw(skeleton: Skeleton): void;
-        private drawImages;
-        private drawTriangles;
-        private drawTriangle;
-        private computeRegionVertices;
-        private computeMeshVertices;
-    }
+  class SkeletonRenderer {
+    static QUAD_TRIANGLES: number[]
+    static VERTEX_SIZE: number
+    private ctx
+    triangleRendering: boolean
+    debugRendering: boolean
+    private vertices
+    private tempColor
+    constructor(context: CanvasRenderingContext2D)
+    draw(skeleton: Skeleton): void
+    private drawImages
+    private drawTriangles
+    private drawTriangle
+    private computeRegionVertices
+    private computeMeshVertices
+  }
 }
diff --git a/src/types/spine/spine-file.d.ts b/src/types/spine/spine-file.d.ts
new file mode 100644
index 0000000..961bd91
--- /dev/null
+++ b/src/types/spine/spine-file.d.ts
@@ -0,0 +1,26 @@
+declare namespace Phaser.Loader.FileTypes {
+  interface SpineFileConfig {
+    key: string
+    textureURL?: string
+    textureExtension?: string
+    textureXhrSettings?: Phaser.Types.Loader.XHRSettingsObject
+    normalMap?: string
+    atlasURL?: string
+    atlasExtension?: string
+    atlasXhrSettings?: Phaser.Types.Loader.XHRSettingsObject
+  }
+
+  class SpineFile extends Phaser.Loader.MultiFile {
+    constructor(
+      loader: Phaser.Loader.LoaderPlugin,
+      key: string | Phaser.Loader.FileTypes.SpineFileConfig,
+      jsonURL: string | string[],
+      atlasURL: string,
+      preMultipliedAlpha: boolean,
+      jsonXhrSettings: Phaser.Types.Loader.XHRSettingsObject,
+      atlasXhrSettings: Phaser.Types.Loader.XHRSettingsObject,
+    )
+
+    addToCache()
+  }
+}
diff --git a/src/types/spine/spine-game-object.d.ts b/src/types/spine/spine-game-object.d.ts
new file mode 100644
index 0000000..fdc9185
--- /dev/null
+++ b/src/types/spine/spine-game-object.d.ts
@@ -0,0 +1,174 @@
+/// <reference path="./spine.d.ts" />
+/// <reference path="./spine-plugin.d.ts" />
+
+declare type SpineGameObject = Phaser.GameObjects.GameObject & {
+  // hasTransformComponent: boolean;
+  // copyPosition(
+
+  // declare interface SpineGameObject extends Phaser.GameObjects.GameObject {
+  hasTransformComponent: boolean
+  copyPosition(
+    source:
+      | Phaser.Types.Math.Vector2Like
+      | Phaser.Types.Math.Vector3Like
+      | Phaser.Types.Math.Vector4Like,
+  ): SpineGameObject
+  getLocalPoint(
+    x: number,
+    y: number,
+    point?: Phaser.Math.Vector2,
+    camera?: Phaser.Cameras.Scene2D.Camera,
+  ): Phaser.Math.Vector2
+
+  alpha: number
+  angle: number
+
+  readonly blendMode: number
+
+  blue: number
+  bounds: any
+  displayOriginX: number
+  displayOriginY: number
+  drawDebug: boolean
+  depth: number
+  displayWidth: number
+  displayHeight: number
+  flipX: boolean
+  flipY: boolean
+  green: number
+  height: number
+  plugin: SpinePlugin
+  preMultipliedAlpha: boolean
+  red: number
+  root: spine.Bone
+  rotation: number
+  scale: number
+  scaleX: number
+  scaleY: number
+  scrollFactorX: number
+  scrollFactorY: number
+  skeleton: spine.Skeleton
+  skeletonData: spine.SkeletonData
+
+  state: spine.AnimationState & Partial<EventListener>
+
+  stateData: spine.AnimationStateData
+
+  timeScale: number
+  visible: boolean
+  x: number
+  y: number
+  z: number
+  w: number
+  width: number
+
+  key: string
+
+  addAnimation(
+    trackIndex: number,
+    animationName: string,
+    loop?: boolean,
+    delay?: number,
+  ): spine.TrackEntry
+  angleBoneToXY(
+    bone: spine.Bone,
+    worldX: number,
+    worldY: number,
+    offset?: number,
+    minAngle?: number,
+    maxAngle?: number,
+  ): SpineGameObject
+  clearTrack(trackIndex: number): SpineGameObject
+  clearTracks(): SpineGameObject
+  findAnimation(animationName: string): spine.Animation
+  findBone(boneName: string): spine.Bone
+  findBoneIndex(boneName: string): number
+  findEvent(eventDataName: string): spine.EventData
+  findIkConstraint(constraintName: string): spine.IkConstraintData
+  findPathConstraint(constraintName: string): spine.PathConstraintData
+  findPathConstraintIndex(constraintName: string): number
+  findSkin(skinName: string): spine.Skin
+  findSlot(slotName: string): spine.Slot
+  findSlotIndex(slotName: string): number
+  findTransformConstraint(constraintName: string): spine.TransformConstraintData
+  getAnimationList(): string[]
+  getAttachment(slotIndex: number, attachmentName: string): spine.Attachment
+  getAttachmentByName(slotName: string, attachmentName: string): spine.Attachment
+  getBoneList(): string[]
+  getBounds(): any
+  getCurrentAnimation(trackIndex?: number): spine.Animation
+  getLocalTransformMatrix(
+    tempMatrix?: Phaser.GameObjects.Components.TransformMatrix,
+  ): Phaser.GameObjects.Components.TransformMatrix
+  getParentRotation(): number
+  getRootBone(): spine.Bone
+  getSkinList(): string[]
+  getSlotList(): string[]
+  getWorldTransformMatrix(
+    tempMatrix?: Phaser.GameObjects.Components.TransformMatrix,
+    parentMatrix?: Phaser.GameObjects.Components.TransformMatrix,
+  ): Phaser.GameObjects.Components.TransformMatrix
+  play(animationName: string, loop?: boolean, ignoreIfPlaying?: boolean): SpineGameObject
+
+  refresh(): SpineGameObject
+  resetFlip(): SpineGameObject
+  setAlpha(value?: number): SpineGameObject
+  setAngle(degrees?: number): SpineGameObject
+  setAnimation(
+    trackIndex: number,
+    animationName: string,
+    loop?: boolean,
+    ignoreIfPlaying?: boolean,
+  ): spine.TrackEntry
+  setAttachment(slotName: string, attachmentName: string): SpineGameObject
+  setBonesToSetupPose(): SpineGameObject
+  setColor(color?: number, slotName?: string): SpineGameObject
+  setDepth(value: number): SpineGameObject
+  setDisplaySize(width: number, height: number): SpineGameObject
+  setEmptyAnimation(trackIndex: number, mixDuration?: number): spine.TrackEntry
+  setFlipX(value: boolean): SpineGameObject
+  setFlipY(value: boolean): SpineGameObject
+  setFlip(x: boolean, y: boolean): SpineGameObject
+  setMix(fromName: string, toName: string, duration?: number): SpineGameObject
+  setOffset(offsetX?: number, offsetY?: number): SpineGameObject
+  setPosition(x?: number, y?: number, z?: number, w?: number): SpineGameObject
+  setRandomPosition(x?: number, y?: number, width?: number, height?: number): SpineGameObject
+  setRotation(radians?: number): SpineGameObject
+  setScale(x: number, y?: number): SpineGameObject
+  setScrollFactor(x: number, y?: number): SpineGameObject
+  setSize(width?: number, height?: number, offsetX?: number, offsetY?: number): SpineGameObject
+  setSkeleton(
+    atlasDataKey: string,
+    animationName?: string,
+    loop?: boolean,
+    skeletonJSON?: object,
+  ): SpineGameObject
+  setSkeletonFromJSON(
+    atlasDataKey: string,
+    skeletonJSON: object,
+    animationName?: string,
+    loop?: boolean,
+  ): SpineGameObject
+  setSkin(newSkin: spine.Skin): SpineGameObject
+  setSkinByName(skinName: string): SpineGameObject
+  setSlotsToSetupPose(): SpineGameObject
+  setToSetupPose(): SpineGameObject
+  setVisible(value: boolean): SpineGameObject
+  setX(value?: number): SpineGameObject
+  setY(value?: number): SpineGameObject
+  setZ(value?: number): SpineGameObject
+  setW(value?: number): SpineGameObject
+  toggleFlipX(): SpineGameObject
+  toggleFlipY(): SpineGameObject
+  updateSize(): SpineGameObject
+  willRender(): boolean
+}
+
+declare interface SpineGameObjectConfig extends Phaser.Types.GameObjects.GameObjectConfig {
+  key?: string
+  animationName?: string
+  loop?: boolean
+  skinName?: string
+  slotName?: string
+  attachmentName?: string
+}
diff --git a/src/types/spine/spine-plugin.d.ts b/src/types/spine/spine-plugin.d.ts
new file mode 100644
index 0000000..a4c2fa8
--- /dev/null
+++ b/src/types/spine/spine-plugin.d.ts
@@ -0,0 +1,81 @@
+/// <reference path="./spine.d.ts" />
+/// <reference path="./spine-file.d.ts" />
+/// <reference path="./spine-game-object.d.ts" />
+
+declare namespace Phaser.Loader {
+  interface LoaderPlugin extends Phaser.Events.EventEmitter {
+    spine(
+      key:
+        | string
+        | Phaser.Loader.FileTypes.SpineFileConfig
+        | Phaser.Loader.FileTypes.SpineFileConfig[],
+      jsonURL: string,
+      atlasURL: string | string[],
+      preMultipliedAlpha?: boolean,
+      textureXhrSettings?: Phaser.Types.Loader.XHRSettingsObject,
+      atlasXhrSettings?: Phaser.Types.Loader.XHRSettingsObject,
+    ): LoaderPlugin
+  }
+}
+
+declare namespace Phaser.GameObjects {
+  interface GameObjectFactory {
+    spine(
+      x: number,
+      y: number,
+      key?: string,
+      animationName?: string,
+      loop?: boolean,
+    ): SpineGameObject
+    spineContainer(
+      x: number,
+      y: number,
+      children?: SpineGameObject | SpineGameObject[],
+    ): SpineContainer
+  }
+
+  interface GameObjectCreator {
+    spine(config: SpineGameObjectConfig, addToScene?: boolean): SpineGameObject
+    spineContainer(config: SpineContainerConfig, addToScene?: boolean): SpineContainer
+  }
+}
+
+declare class SpinePlugin extends Phaser.Plugins.ScenePlugin {
+  constructor(scene: Phaser.Scene, pluginManager: Phaser.Plugins.PluginManager)
+
+  readonly isWebGL: boolean
+
+  cache: Phaser.Cache.BaseCache
+  spineTextures: Phaser.Cache.BaseCache
+  json: Phaser.Cache.BaseCache
+  textures: Phaser.Textures.TextureManager
+  drawDebug: boolean
+  gl: WebGLRenderingContext
+  renderer: Phaser.Renderer.Canvas.CanvasRenderer | Phaser.Renderer.WebGL.WebGLRenderer
+  sceneRenderer: spine.webgl.SceneRenderer
+  skeletonRenderer: spine.canvas.SkeletonRenderer | spine.webgl.SkeletonRenderer
+  skeletonDebugRenderer: spine.webgl.SkeletonDebugRenderer
+
+  plugin: typeof spine
+
+  getAtlasCanvas(key: string): spine.TextureAtlas
+  getAtlasWebGL(key: string): spine.TextureAtlas
+  worldToLocal(x: number, y: number, skeleton: spine.Skeleton, bone?: spine.Bone): spine.Vector2
+  getVector2(x: number, y: number): spine.Vector2
+  getVector3(x: number, y: number, z: number): spine.Vector2
+  setDebugBones(value?: boolean): SpinePlugin
+  setDebugRegionAttachments(value?: boolean): SpinePlugin
+  setDebugBoundingBoxes(value?: boolean): SpinePlugin
+  setDebugMeshHull(value?: boolean): SpinePlugin
+  setDebugMeshTriangles(value?: boolean): SpinePlugin
+  setDebugPaths(value?: boolean): SpinePlugin
+  setDebugSkeletonXY(value?: boolean): SpinePlugin
+  setDebugClipping(value?: boolean): SpinePlugin
+  setEffect(effect?: spine.VertexEffect): SpinePlugin
+  createSkeleton(key: string, skeletonJSON?: object): any | null
+  createAnimationState(skeleton: spine.Skeleton): any
+  getBounds(skeleton: spine.Skeleton): any
+  onResize(): void
+  add(x: number, y: number, key?: string, animationName?: string, loop?: boolean): SpineGameObject
+  make(config: SpineGameObjectConfig, addToScene?: boolean): SpineGameObject
+}
diff --git a/src/types/spine/spine-webgl.d.ts b/src/types/spine/spine-webgl.d.ts
index 2f24b21..522361c 100644
--- a/src/types/spine/spine-webgl.d.ts
+++ b/src/types/spine/spine-webgl.d.ts
@@ -1,1717 +1,2230 @@
 declare module spine {
-    class Animation {
-        name: string;
-        timelines: Array<Timeline>;
-        timelineIds: Array<boolean>;
-        duration: number;
-        constructor(name: string, timelines: Array<Timeline>, duration: number);
-        hasTimeline(id: number): boolean;
-        apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-        static binarySearch(values: ArrayLike<number>, target: number, step?: number): number;
-        static linearSearch(values: ArrayLike<number>, target: number, step: number): number;
-    }
-    interface Timeline {
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-        getPropertyId(): number;
-    }
-    enum MixBlend {
-        setup = 0,
-        first = 1,
-        replace = 2,
-        add = 3
-    }
-    enum MixDirection {
-        mixIn = 0,
-        mixOut = 1
-    }
-    enum TimelineType {
-        rotate = 0,
-        translate = 1,
-        scale = 2,
-        shear = 3,
-        attachment = 4,
-        color = 5,
-        deform = 6,
-        event = 7,
-        drawOrder = 8,
-        ikConstraint = 9,
-        transformConstraint = 10,
-        pathConstraintPosition = 11,
-        pathConstraintSpacing = 12,
-        pathConstraintMix = 13,
-        twoColor = 14
-    }
-    abstract class CurveTimeline implements Timeline {
-        static LINEAR: number;
-        static STEPPED: number;
-        static BEZIER: number;
-        static BEZIER_SIZE: number;
-        private curves;
-        abstract getPropertyId(): number;
-        constructor(frameCount: number);
-        getFrameCount(): number;
-        setLinear(frameIndex: number): void;
-        setStepped(frameIndex: number): void;
-        getCurveType(frameIndex: number): number;
-        setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
-        getCurvePercent(frameIndex: number, percent: number): number;
-        abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class RotateTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_ROTATION: number;
-        static ROTATION: number;
-        boneIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, degrees: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class TranslateTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_X: number;
-        static PREV_Y: number;
-        static X: number;
-        static Y: number;
-        boneIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, x: number, y: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class ScaleTimeline extends TranslateTimeline {
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class ShearTimeline extends TranslateTimeline {
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class ColorTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_R: number;
-        static PREV_G: number;
-        static PREV_B: number;
-        static PREV_A: number;
-        static R: number;
-        static G: number;
-        static B: number;
-        static A: number;
-        slotIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class TwoColorTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_R: number;
-        static PREV_G: number;
-        static PREV_B: number;
-        static PREV_A: number;
-        static PREV_R2: number;
-        static PREV_G2: number;
-        static PREV_B2: number;
-        static R: number;
-        static G: number;
-        static B: number;
-        static A: number;
-        static R2: number;
-        static G2: number;
-        static B2: number;
-        slotIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class AttachmentTimeline implements Timeline {
-        slotIndex: number;
-        frames: ArrayLike<number>;
-        attachmentNames: Array<string>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        getFrameCount(): number;
-        setFrame(frameIndex: number, time: number, attachmentName: string): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class DeformTimeline extends CurveTimeline {
-        slotIndex: number;
-        attachment: VertexAttachment;
-        frames: ArrayLike<number>;
-        frameVertices: Array<ArrayLike<number>>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class EventTimeline implements Timeline {
-        frames: ArrayLike<number>;
-        events: Array<Event>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        getFrameCount(): number;
-        setFrame(frameIndex: number, event: Event): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class DrawOrderTimeline implements Timeline {
-        frames: ArrayLike<number>;
-        drawOrders: Array<Array<number>>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        getFrameCount(): number;
-        setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class IkConstraintTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_MIX: number;
-        static PREV_SOFTNESS: number;
-        static PREV_BEND_DIRECTION: number;
-        static PREV_COMPRESS: number;
-        static PREV_STRETCH: number;
-        static MIX: number;
-        static SOFTNESS: number;
-        static BEND_DIRECTION: number;
-        static COMPRESS: number;
-        static STRETCH: number;
-        ikConstraintIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, mix: number, softness: number, bendDirection: number, compress: boolean, stretch: boolean): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class TransformConstraintTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_ROTATE: number;
-        static PREV_TRANSLATE: number;
-        static PREV_SCALE: number;
-        static PREV_SHEAR: number;
-        static ROTATE: number;
-        static TRANSLATE: number;
-        static SCALE: number;
-        static SHEAR: number;
-        transformConstraintIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number, scaleMix: number, shearMix: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class PathConstraintPositionTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_VALUE: number;
-        static VALUE: number;
-        pathConstraintIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, value: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
-    class PathConstraintMixTimeline extends CurveTimeline {
-        static ENTRIES: number;
-        static PREV_TIME: number;
-        static PREV_ROTATE: number;
-        static PREV_TRANSLATE: number;
-        static ROTATE: number;
-        static TRANSLATE: number;
-        pathConstraintIndex: number;
-        frames: ArrayLike<number>;
-        constructor(frameCount: number);
-        getPropertyId(): number;
-        setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void;
-        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-    }
+  class Animation {
+    name: string
+    timelines: Array<Timeline>
+    timelineIds: Array<boolean>
+    duration: number
+    constructor(name: string, timelines: Array<Timeline>, duration: number)
+    hasTimeline(id: number): boolean
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      loop: boolean,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+    static binarySearch(values: ArrayLike<number>, target: number, step?: number): number
+    static linearSearch(values: ArrayLike<number>, target: number, step: number): number
+  }
+  interface Timeline {
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+    getPropertyId(): number
+  }
+  enum MixBlend {
+    setup = 0,
+    first = 1,
+    replace = 2,
+    add = 3,
+  }
+  enum MixDirection {
+    mixIn = 0,
+    mixOut = 1,
+  }
+  enum TimelineType {
+    rotate = 0,
+    translate = 1,
+    scale = 2,
+    shear = 3,
+    attachment = 4,
+    color = 5,
+    deform = 6,
+    event = 7,
+    drawOrder = 8,
+    ikConstraint = 9,
+    transformConstraint = 10,
+    pathConstraintPosition = 11,
+    pathConstraintSpacing = 12,
+    pathConstraintMix = 13,
+    twoColor = 14,
+  }
+  abstract class CurveTimeline implements Timeline {
+    static LINEAR: number
+    static STEPPED: number
+    static BEZIER: number
+    static BEZIER_SIZE: number
+    private curves
+    abstract getPropertyId(): number
+    constructor(frameCount: number)
+    getFrameCount(): number
+    setLinear(frameIndex: number): void
+    setStepped(frameIndex: number): void
+    getCurveType(frameIndex: number): number
+    setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void
+    getCurvePercent(frameIndex: number, percent: number): number
+    abstract apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class RotateTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATION: number
+    static ROTATION: number
+    boneIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, degrees: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class TranslateTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_X: number
+    static PREV_Y: number
+    static X: number
+    static Y: number
+    boneIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, x: number, y: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class ScaleTimeline extends TranslateTimeline {
+    constructor(frameCount: number)
+    getPropertyId(): number
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class ShearTimeline extends TranslateTimeline {
+    constructor(frameCount: number)
+    getPropertyId(): number
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class ColorTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_R: number
+    static PREV_G: number
+    static PREV_B: number
+    static PREV_A: number
+    static R: number
+    static G: number
+    static B: number
+    static A: number
+    slotIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class TwoColorTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_R: number
+    static PREV_G: number
+    static PREV_B: number
+    static PREV_A: number
+    static PREV_R2: number
+    static PREV_G2: number
+    static PREV_B2: number
+    static R: number
+    static G: number
+    static B: number
+    static A: number
+    static R2: number
+    static G2: number
+    static B2: number
+    slotIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(
+      frameIndex: number,
+      time: number,
+      r: number,
+      g: number,
+      b: number,
+      a: number,
+      r2: number,
+      g2: number,
+      b2: number,
+    ): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class AttachmentTimeline implements Timeline {
+    slotIndex: number
+    frames: ArrayLike<number>
+    attachmentNames: Array<string>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, time: number, attachmentName: string): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      events: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class DeformTimeline extends CurveTimeline {
+    slotIndex: number
+    attachment: VertexAttachment
+    frames: ArrayLike<number>
+    frameVertices: Array<ArrayLike<number>>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class EventTimeline implements Timeline {
+    frames: ArrayLike<number>
+    events: Array<Event>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, event: Event): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class DrawOrderTimeline implements Timeline {
+    frames: ArrayLike<number>
+    drawOrders: Array<Array<number>>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class IkConstraintTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_MIX: number
+    static PREV_SOFTNESS: number
+    static PREV_BEND_DIRECTION: number
+    static PREV_COMPRESS: number
+    static PREV_STRETCH: number
+    static MIX: number
+    static SOFTNESS: number
+    static BEND_DIRECTION: number
+    static COMPRESS: number
+    static STRETCH: number
+    ikConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(
+      frameIndex: number,
+      time: number,
+      mix: number,
+      softness: number,
+      bendDirection: number,
+      compress: boolean,
+      stretch: boolean,
+    ): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class TransformConstraintTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATE: number
+    static PREV_TRANSLATE: number
+    static PREV_SCALE: number
+    static PREV_SHEAR: number
+    static ROTATE: number
+    static TRANSLATE: number
+    static SCALE: number
+    static SHEAR: number
+    transformConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(
+      frameIndex: number,
+      time: number,
+      rotateMix: number,
+      translateMix: number,
+      scaleMix: number,
+      shearMix: number,
+    ): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class PathConstraintPositionTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_VALUE: number
+    static VALUE: number
+    pathConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, value: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
+    constructor(frameCount: number)
+    getPropertyId(): number
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
+  class PathConstraintMixTimeline extends CurveTimeline {
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATE: number
+    static PREV_TRANSLATE: number
+    static ROTATE: number
+    static TRANSLATE: number
+    pathConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void
+    apply(
+      skeleton: Skeleton,
+      lastTime: number,
+      time: number,
+      firedEvents: Array<Event>,
+      alpha: number,
+      blend: MixBlend,
+      direction: MixDirection,
+    ): void
+  }
 }
 declare module spine {
-    class AnimationState {
-        static emptyAnimation: Animation;
-        static SUBSEQUENT: number;
-        static FIRST: number;
-        static HOLD: number;
-        static HOLD_MIX: number;
-        static NOT_LAST: number;
-        data: AnimationStateData;
-        tracks: TrackEntry[];
-        events: Event[];
-        listeners: AnimationStateListener2[];
-        queue: EventQueue;
-        propertyIDs: IntSet;
-        animationsChanged: boolean;
-        timeScale: number;
-        trackEntryPool: Pool<TrackEntry>;
-        constructor(data: AnimationStateData);
-        update(delta: number): void;
-        updateMixingFrom(to: TrackEntry, delta: number): boolean;
-        apply(skeleton: Skeleton): boolean;
-        applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number;
-        applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
-        queueEvents(entry: TrackEntry, animationTime: number): void;
-        clearTracks(): void;
-        clearTrack(trackIndex: number): void;
-        setCurrent(index: number, current: TrackEntry, interrupt: boolean): void;
-        setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-        setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-        addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-        addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
-        setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
-        addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
-        setEmptyAnimations(mixDuration: number): void;
-        expandToIndex(index: number): TrackEntry;
-        trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
-        disposeNext(entry: TrackEntry): void;
-        _animationsChanged(): void;
-        computeHold(entry: TrackEntry): void;
-        computeNotLast(entry: TrackEntry): void;
-        getCurrent(trackIndex: number): TrackEntry;
-        addListener(listener: AnimationStateListener2): void;
-        removeListener(listener: AnimationStateListener2): void;
-        clearListeners(): void;
-        clearListenerNotifications(): void;
-    }
-    class TrackEntry {
-        animation: Animation;
-        next: TrackEntry;
-        mixingFrom: TrackEntry;
-        mixingTo: TrackEntry;
-        listener: AnimationStateListener2;
-        trackIndex: number;
-        loop: boolean;
-        holdPrevious: boolean;
-        eventThreshold: number;
-        attachmentThreshold: number;
-        drawOrderThreshold: number;
-        animationStart: number;
-        animationEnd: number;
-        animationLast: number;
-        nextAnimationLast: number;
-        delay: number;
-        trackTime: number;
-        trackLast: number;
-        nextTrackLast: number;
-        trackEnd: number;
-        timeScale: number;
-        alpha: number;
-        mixTime: number;
-        mixDuration: number;
-        interruptAlpha: number;
-        totalAlpha: number;
-        mixBlend: MixBlend;
-        timelineMode: number[];
-        timelineHoldMix: TrackEntry[];
-        timelinesRotation: number[];
-        reset(): void;
-        getAnimationTime(): number;
-        setAnimationLast(animationLast: number): void;
-        isComplete(): boolean;
-        resetRotationDirections(): void;
-    }
-    class EventQueue {
-        objects: Array<any>;
-        drainDisabled: boolean;
-        animState: AnimationState;
-        constructor(animState: AnimationState);
-        start(entry: TrackEntry): void;
-        interrupt(entry: TrackEntry): void;
-        end(entry: TrackEntry): void;
-        dispose(entry: TrackEntry): void;
-        complete(entry: TrackEntry): void;
-        event(entry: TrackEntry, event: Event): void;
-        drain(): void;
-        clear(): void;
-    }
-    enum EventType {
-        start = 0,
-        interrupt = 1,
-        end = 2,
-        dispose = 3,
-        complete = 4,
-        event = 5
-    }
-    interface AnimationStateListener2 {
-        start(entry: TrackEntry): void;
-        interrupt(entry: TrackEntry): void;
-        end(entry: TrackEntry): void;
-        dispose(entry: TrackEntry): void;
-        complete(entry: TrackEntry): void;
-        event(entry: TrackEntry, event: Event): void;
-    }
-    abstract class AnimationStateAdapter2 implements AnimationStateListener2 {
-        start(entry: TrackEntry): void;
-        interrupt(entry: TrackEntry): void;
-        end(entry: TrackEntry): void;
-        dispose(entry: TrackEntry): void;
-        complete(entry: TrackEntry): void;
-        event(entry: TrackEntry, event: Event): void;
-    }
+  class AnimationState {
+    static emptyAnimation: Animation
+    static SUBSEQUENT: number
+    static FIRST: number
+    static HOLD: number
+    static HOLD_MIX: number
+    static NOT_LAST: number
+    data: AnimationStateData
+    tracks: TrackEntry[]
+    events: Event[]
+    listeners: AnimationStateListener2[]
+    queue: EventQueue
+    propertyIDs: IntSet
+    animationsChanged: boolean
+    timeScale: number
+    trackEntryPool: Pool<TrackEntry>
+    constructor(data: AnimationStateData)
+    update(delta: number): void
+    updateMixingFrom(to: TrackEntry, delta: number): boolean
+    apply(skeleton: Skeleton): boolean
+    applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number
+    applyRotateTimeline(
+      timeline: Timeline,
+      skeleton: Skeleton,
+      time: number,
+      alpha: number,
+      blend: MixBlend,
+      timelinesRotation: Array<number>,
+      i: number,
+      firstFrame: boolean,
+    ): void
+    queueEvents(entry: TrackEntry, animationTime: number): void
+    clearTracks(): void
+    clearTrack(trackIndex: number): void
+    setCurrent(index: number, current: TrackEntry, interrupt: boolean): void
+    setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry
+    setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry
+    addAnimation(
+      trackIndex: number,
+      animationName: string,
+      loop: boolean,
+      delay: number,
+    ): TrackEntry
+    addAnimationWith(
+      trackIndex: number,
+      animation: Animation,
+      loop: boolean,
+      delay: number,
+    ): TrackEntry
+    setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry
+    addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry
+    setEmptyAnimations(mixDuration: number): void
+    expandToIndex(index: number): TrackEntry
+    trackEntry(
+      trackIndex: number,
+      animation: Animation,
+      loop: boolean,
+      last: TrackEntry,
+    ): TrackEntry
+    disposeNext(entry: TrackEntry): void
+    _animationsChanged(): void
+    computeHold(entry: TrackEntry): void
+    computeNotLast(entry: TrackEntry): void
+    getCurrent(trackIndex: number): TrackEntry
+    addListener(listener: AnimationStateListener2): void
+    removeListener(listener: AnimationStateListener2): void
+    clearListeners(): void
+    clearListenerNotifications(): void
+  }
+  class TrackEntry {
+    animation: Animation
+    next: TrackEntry
+    mixingFrom: TrackEntry
+    mixingTo: TrackEntry
+    listener: AnimationStateListener2
+    trackIndex: number
+    loop: boolean
+    holdPrevious: boolean
+    eventThreshold: number
+    attachmentThreshold: number
+    drawOrderThreshold: number
+    animationStart: number
+    animationEnd: number
+    animationLast: number
+    nextAnimationLast: number
+    delay: number
+    trackTime: number
+    trackLast: number
+    nextTrackLast: number
+    trackEnd: number
+    timeScale: number
+    alpha: number
+    mixTime: number
+    mixDuration: number
+    interruptAlpha: number
+    totalAlpha: number
+    mixBlend: MixBlend
+    timelineMode: number[]
+    timelineHoldMix: TrackEntry[]
+    timelinesRotation: number[]
+    reset(): void
+    getAnimationTime(): number
+    setAnimationLast(animationLast: number): void
+    isComplete(): boolean
+    resetRotationDirections(): void
+  }
+  class EventQueue {
+    objects: Array<any>
+    drainDisabled: boolean
+    animState: AnimationState
+    constructor(animState: AnimationState)
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
+    drain(): void
+    clear(): void
+  }
+  enum EventType {
+    start = 0,
+    interrupt = 1,
+    end = 2,
+    dispose = 3,
+    complete = 4,
+    event = 5,
+  }
+  interface AnimationStateListener2 {
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
+  }
+  abstract class AnimationStateAdapter2 implements AnimationStateListener2 {
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
+  }
 }
 declare module spine {
-    class AnimationStateData {
-        skeletonData: SkeletonData;
-        animationToMixTime: Map<number>;
-        defaultMix: number;
-        constructor(skeletonData: SkeletonData);
-        setMix(fromName: string, toName: string, duration: number): void;
-        setMixWith(from: Animation, to: Animation, duration: number): void;
-        getMix(from: Animation, to: Animation): number;
-    }
+  class AnimationStateData {
+    skeletonData: SkeletonData
+    animationToMixTime: Map<number>
+    defaultMix: number
+    constructor(skeletonData: SkeletonData)
+    setMix(fromName: string, toName: string, duration: number): void
+    setMixWith(from: Animation, to: Animation, duration: number): void
+    getMix(from: Animation, to: Animation): number
+  }
 }
 declare module spine {
-    class AssetManager implements Disposable {
-        private pathPrefix;
-        private textureLoader;
-        private assets;
-        private errors;
-        private toLoad;
-        private loaded;
-        constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string);
-        private static downloadText;
-        private static downloadBinary;
-        loadBinary(path: string, success?: (path: string, binary: Uint8Array) => void, error?: (path: string, error: string) => void): void;
-        loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, error: string) => void): void;
-        loadTexture(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
-        loadTextureData(path: string, data: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
-        loadTextureAtlas(path: string, success?: (path: string, atlas: TextureAtlas) => void, error?: (path: string, error: string) => void): void;
-        get(path: string): any;
-        remove(path: string): void;
-        removeAll(): void;
-        isLoadingComplete(): boolean;
-        getToLoad(): number;
-        getLoaded(): number;
-        dispose(): void;
-        hasErrors(): boolean;
-        getErrors(): Map<string>;
-    }
+  class AssetManager implements Disposable {
+    private pathPrefix
+    private textureLoader
+    private assets
+    private errors
+    private toLoad
+    private loaded
+    constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string)
+    private static downloadText
+    private static downloadBinary
+    loadBinary(
+      path: string,
+      success?: (path: string, binary: Uint8Array) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    loadText(
+      path: string,
+      success?: (path: string, text: string) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    loadTexture(
+      path: string,
+      success?: (path: string, image: HTMLImageElement) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    loadTextureData(
+      path: string,
+      data: string,
+      success?: (path: string, image: HTMLImageElement) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    loadTextureAtlas(
+      path: string,
+      success?: (path: string, atlas: TextureAtlas) => void,
+      error?: (path: string, error: string) => void,
+    ): void
+    get(path: string): any
+    remove(path: string): void
+    removeAll(): void
+    isLoadingComplete(): boolean
+    getToLoad(): number
+    getLoaded(): number
+    dispose(): void
+    hasErrors(): boolean
+    getErrors(): Map<string>
+  }
 }
 declare module spine {
-    class AtlasAttachmentLoader implements AttachmentLoader {
-        atlas: TextureAtlas;
-        constructor(atlas: TextureAtlas);
-        newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
-        newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
-        newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
-        newPathAttachment(skin: Skin, name: string): PathAttachment;
-        newPointAttachment(skin: Skin, name: string): PointAttachment;
-        newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
-    }
+  class AtlasAttachmentLoader implements AttachmentLoader {
+    atlas: TextureAtlas
+    constructor(atlas: TextureAtlas)
+    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment
+    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment
+    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment
+    newPathAttachment(skin: Skin, name: string): PathAttachment
+    newPointAttachment(skin: Skin, name: string): PointAttachment
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment
+  }
 }
 declare module spine {
-    enum BlendMode {
-        Normal = 0,
-        Additive = 1,
-        Multiply = 2,
-        Screen = 3
-    }
+  enum BlendMode {
+    Normal = 0,
+    Additive = 1,
+    Multiply = 2,
+    Screen = 3,
+  }
 }
 declare module spine {
-    class Bone implements Updatable {
-        data: BoneData;
-        skeleton: Skeleton;
-        parent: Bone;
-        children: Bone[];
-        x: number;
-        y: number;
-        rotation: number;
-        scaleX: number;
-        scaleY: number;
-        shearX: number;
-        shearY: number;
-        ax: number;
-        ay: number;
-        arotation: number;
-        ascaleX: number;
-        ascaleY: number;
-        ashearX: number;
-        ashearY: number;
-        appliedValid: boolean;
-        a: number;
-        b: number;
-        worldX: number;
-        c: number;
-        d: number;
-        worldY: number;
-        sorted: boolean;
-        active: boolean;
-        constructor(data: BoneData, skeleton: Skeleton, parent: Bone);
-        isActive(): boolean;
-        update(): void;
-        updateWorldTransform(): void;
-        updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number): void;
-        setToSetupPose(): void;
-        getWorldRotationX(): number;
-        getWorldRotationY(): number;
-        getWorldScaleX(): number;
-        getWorldScaleY(): number;
-        updateAppliedTransform(): void;
-        worldToLocal(world: Vector2): Vector2;
-        localToWorld(local: Vector2): Vector2;
-        worldToLocalRotation(worldRotation: number): number;
-        localToWorldRotation(localRotation: number): number;
-        rotateWorld(degrees: number): void;
-    }
+  class Bone implements Updatable {
+    data: BoneData
+    skeleton: Skeleton
+    parent: Bone
+    children: Bone[]
+    x: number
+    y: number
+    rotation: number
+    scaleX: number
+    scaleY: number
+    shearX: number
+    shearY: number
+    ax: number
+    ay: number
+    arotation: number
+    ascaleX: number
+    ascaleY: number
+    ashearX: number
+    ashearY: number
+    appliedValid: boolean
+    a: number
+    b: number
+    worldX: number
+    c: number
+    d: number
+    worldY: number
+    sorted: boolean
+    active: boolean
+    constructor(data: BoneData, skeleton: Skeleton, parent: Bone)
+    isActive(): boolean
+    update(): void
+    updateWorldTransform(): void
+    updateWorldTransformWith(
+      x: number,
+      y: number,
+      rotation: number,
+      scaleX: number,
+      scaleY: number,
+      shearX: number,
+      shearY: number,
+    ): void
+    setToSetupPose(): void
+    getWorldRotationX(): number
+    getWorldRotationY(): number
+    getWorldScaleX(): number
+    getWorldScaleY(): number
+    updateAppliedTransform(): void
+    worldToLocal(world: Vector2): Vector2
+    localToWorld(local: Vector2): Vector2
+    worldToLocalRotation(worldRotation: number): number
+    localToWorldRotation(localRotation: number): number
+    rotateWorld(degrees: number): void
+  }
 }
 declare module spine {
-    class BoneData {
-        index: number;
-        name: string;
-        parent: BoneData;
-        length: number;
-        x: number;
-        y: number;
-        rotation: number;
-        scaleX: number;
-        scaleY: number;
-        shearX: number;
-        shearY: number;
-        transformMode: TransformMode;
-        skinRequired: boolean;
-        color: Color;
-        constructor(index: number, name: string, parent: BoneData);
-    }
-    enum TransformMode {
-        Normal = 0,
-        OnlyTranslation = 1,
-        NoRotationOrReflection = 2,
-        NoScale = 3,
-        NoScaleOrReflection = 4
-    }
+  class BoneData {
+    index: number
+    name: string
+    parent: BoneData
+    length: number
+    x: number
+    y: number
+    rotation: number
+    scaleX: number
+    scaleY: number
+    shearX: number
+    shearY: number
+    transformMode: TransformMode
+    skinRequired: boolean
+    color: Color
+    constructor(index: number, name: string, parent: BoneData)
+  }
+  enum TransformMode {
+    Normal = 0,
+    OnlyTranslation = 1,
+    NoRotationOrReflection = 2,
+    NoScale = 3,
+    NoScaleOrReflection = 4,
+  }
 }
 declare module spine {
-    abstract class ConstraintData {
-        name: string;
-        order: number;
-        skinRequired: boolean;
-        constructor(name: string, order: number, skinRequired: boolean);
-    }
+  abstract class ConstraintData {
+    name: string
+    order: number
+    skinRequired: boolean
+    constructor(name: string, order: number, skinRequired: boolean)
+  }
 }
 declare module spine {
-    class Event {
-        data: EventData;
-        intValue: number;
-        floatValue: number;
-        stringValue: string;
-        time: number;
-        volume: number;
-        balance: number;
-        constructor(time: number, data: EventData);
-    }
+  class Event {
+    data: EventData
+    intValue: number
+    floatValue: number
+    stringValue: string
+    time: number
+    volume: number
+    balance: number
+    constructor(time: number, data: EventData)
+  }
 }
 declare module spine {
-    class EventData {
-        name: string;
-        intValue: number;
-        floatValue: number;
-        stringValue: string;
-        audioPath: string;
-        volume: number;
-        balance: number;
-        constructor(name: string);
-    }
+  class EventData {
+    name: string
+    intValue: number
+    floatValue: number
+    stringValue: string
+    audioPath: string
+    volume: number
+    balance: number
+    constructor(name: string)
+  }
 }
 declare module spine {
-    class IkConstraint implements Updatable {
-        data: IkConstraintData;
-        bones: Array<Bone>;
-        target: Bone;
-        bendDirection: number;
-        compress: boolean;
-        stretch: boolean;
-        mix: number;
-        softness: number;
-        active: boolean;
-        constructor(data: IkConstraintData, skeleton: Skeleton);
-        isActive(): boolean;
-        apply(): void;
-        update(): void;
-        apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void;
-        apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, softness: number, alpha: number): void;
-    }
+  class IkConstraint implements Updatable {
+    data: IkConstraintData
+    bones: Array<Bone>
+    target: Bone
+    bendDirection: number
+    compress: boolean
+    stretch: boolean
+    mix: number
+    softness: number
+    active: boolean
+    constructor(data: IkConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
+    apply1(
+      bone: Bone,
+      targetX: number,
+      targetY: number,
+      compress: boolean,
+      stretch: boolean,
+      uniform: boolean,
+      alpha: number,
+    ): void
+    apply2(
+      parent: Bone,
+      child: Bone,
+      targetX: number,
+      targetY: number,
+      bendDir: number,
+      stretch: boolean,
+      softness: number,
+      alpha: number,
+    ): void
+  }
 }
 declare module spine {
-    class IkConstraintData extends ConstraintData {
-        bones: BoneData[];
-        target: BoneData;
-        bendDirection: number;
-        compress: boolean;
-        stretch: boolean;
-        uniform: boolean;
-        mix: number;
-        softness: number;
-        constructor(name: string);
-    }
+  class IkConstraintData extends ConstraintData {
+    bones: BoneData[]
+    target: BoneData
+    bendDirection: number
+    compress: boolean
+    stretch: boolean
+    uniform: boolean
+    mix: number
+    softness: number
+    constructor(name: string)
+  }
 }
 declare module spine {
-    class PathConstraint implements Updatable {
-        static NONE: number;
-        static BEFORE: number;
-        static AFTER: number;
-        static epsilon: number;
-        data: PathConstraintData;
-        bones: Array<Bone>;
-        target: Slot;
-        position: number;
-        spacing: number;
-        rotateMix: number;
-        translateMix: number;
-        spaces: number[];
-        positions: number[];
-        world: number[];
-        curves: number[];
-        lengths: number[];
-        segments: number[];
-        active: boolean;
-        constructor(data: PathConstraintData, skeleton: Skeleton);
-        isActive(): boolean;
-        apply(): void;
-        update(): void;
-        computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): number[];
-        addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
-        addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
-        addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array<number>, o: number, tangents: boolean): void;
-    }
+  class PathConstraint implements Updatable {
+    static NONE: number
+    static BEFORE: number
+    static AFTER: number
+    static epsilon: number
+    data: PathConstraintData
+    bones: Array<Bone>
+    target: Slot
+    position: number
+    spacing: number
+    rotateMix: number
+    translateMix: number
+    spaces: number[]
+    positions: number[]
+    world: number[]
+    curves: number[]
+    lengths: number[]
+    segments: number[]
+    active: boolean
+    constructor(data: PathConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
+    computeWorldPositions(
+      path: PathAttachment,
+      spacesCount: number,
+      tangents: boolean,
+      percentPosition: boolean,
+      percentSpacing: boolean,
+    ): number[]
+    addBeforePosition(
+      p: number,
+      temp: Array<number>,
+      i: number,
+      out: Array<number>,
+      o: number,
+    ): void
+    addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void
+    addCurvePosition(
+      p: number,
+      x1: number,
+      y1: number,
+      cx1: number,
+      cy1: number,
+      cx2: number,
+      cy2: number,
+      x2: number,
+      y2: number,
+      out: Array<number>,
+      o: number,
+      tangents: boolean,
+    ): void
+  }
 }
 declare module spine {
-    class PathConstraintData extends ConstraintData {
-        bones: BoneData[];
-        target: SlotData;
-        positionMode: PositionMode;
-        spacingMode: SpacingMode;
-        rotateMode: RotateMode;
-        offsetRotation: number;
-        position: number;
-        spacing: number;
-        rotateMix: number;
-        translateMix: number;
-        constructor(name: string);
-    }
-    enum PositionMode {
-        Fixed = 0,
-        Percent = 1
-    }
-    enum SpacingMode {
-        Length = 0,
-        Fixed = 1,
-        Percent = 2
-    }
-    enum RotateMode {
-        Tangent = 0,
-        Chain = 1,
-        ChainScale = 2
-    }
+  class PathConstraintData extends ConstraintData {
+    bones: BoneData[]
+    target: SlotData
+    positionMode: PositionMode
+    spacingMode: SpacingMode
+    rotateMode: RotateMode
+    offsetRotation: number
+    position: number
+    spacing: number
+    rotateMix: number
+    translateMix: number
+    constructor(name: string)
+  }
+  enum PositionMode {
+    Fixed = 0,
+    Percent = 1,
+  }
+  enum SpacingMode {
+    Length = 0,
+    Fixed = 1,
+    Percent = 2,
+  }
+  enum RotateMode {
+    Tangent = 0,
+    Chain = 1,
+    ChainScale = 2,
+  }
 }
 declare module spine {
-    class SharedAssetManager implements Disposable {
-        private pathPrefix;
-        private clientAssets;
-        private queuedAssets;
-        private rawAssets;
-        private errors;
-        constructor(pathPrefix?: string);
-        private queueAsset;
-        loadText(clientId: string, path: string): void;
-        loadJson(clientId: string, path: string): void;
-        loadTexture(clientId: string, textureLoader: (image: HTMLImageElement) => any, path: string): void;
-        get(clientId: string, path: string): any;
-        private updateClientAssets;
-        isLoadingComplete(clientId: string): boolean;
-        dispose(): void;
-        hasErrors(): boolean;
-        getErrors(): Map<string>;
-    }
+  class SharedAssetManager implements Disposable {
+    private pathPrefix
+    private clientAssets
+    private queuedAssets
+    private rawAssets
+    private errors
+    constructor(pathPrefix?: string)
+    private queueAsset
+    loadText(clientId: string, path: string): void
+    loadJson(clientId: string, path: string): void
+    loadTexture(
+      clientId: string,
+      textureLoader: (image: HTMLImageElement) => any,
+      path: string,
+    ): void
+    get(clientId: string, path: string): any
+    private updateClientAssets
+    isLoadingComplete(clientId: string): boolean
+    dispose(): void
+    hasErrors(): boolean
+    getErrors(): Map<string>
+  }
 }
 declare module spine {
-    class Skeleton {
-        data: SkeletonData;
-        bones: Array<Bone>;
-        slots: Array<Slot>;
-        drawOrder: Array<Slot>;
-        ikConstraints: Array<IkConstraint>;
-        transformConstraints: Array<TransformConstraint>;
-        pathConstraints: Array<PathConstraint>;
-        _updateCache: Updatable[];
-        updateCacheReset: Updatable[];
-        skin: Skin;
-        color: Color;
-        time: number;
-        scaleX: number;
-        scaleY: number;
-        x: number;
-        y: number;
-        constructor(data: SkeletonData);
-        updateCache(): void;
-        sortIkConstraint(constraint: IkConstraint): void;
-        sortPathConstraint(constraint: PathConstraint): void;
-        sortTransformConstraint(constraint: TransformConstraint): void;
-        sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void;
-        sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void;
-        sortBone(bone: Bone): void;
-        sortReset(bones: Array<Bone>): void;
-        updateWorldTransform(): void;
-        setToSetupPose(): void;
-        setBonesToSetupPose(): void;
-        setSlotsToSetupPose(): void;
-        getRootBone(): Bone;
-        findBone(boneName: string): Bone;
-        findBoneIndex(boneName: string): number;
-        findSlot(slotName: string): Slot;
-        findSlotIndex(slotName: string): number;
-        setSkinByName(skinName: string): void;
-        setSkin(newSkin: Skin): void;
-        getAttachmentByName(slotName: string, attachmentName: string): Attachment;
-        getAttachment(slotIndex: number, attachmentName: string): Attachment;
-        setAttachment(slotName: string, attachmentName: string): void;
-        findIkConstraint(constraintName: string): IkConstraint;
-        findTransformConstraint(constraintName: string): TransformConstraint;
-        findPathConstraint(constraintName: string): PathConstraint;
-        getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
-        update(delta: number): void;
-    }
+  class Skeleton {
+    data: SkeletonData
+    bones: Array<Bone>
+    slots: Array<Slot>
+    drawOrder: Array<Slot>
+    ikConstraints: Array<IkConstraint>
+    transformConstraints: Array<TransformConstraint>
+    pathConstraints: Array<PathConstraint>
+    _updateCache: Updatable[]
+    updateCacheReset: Updatable[]
+    skin: Skin
+    color: Color
+    time: number
+    scaleX: number
+    scaleY: number
+    x: number
+    y: number
+    constructor(data: SkeletonData)
+    updateCache(): void
+    sortIkConstraint(constraint: IkConstraint): void
+    sortPathConstraint(constraint: PathConstraint): void
+    sortTransformConstraint(constraint: TransformConstraint): void
+    sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void
+    sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void
+    sortBone(bone: Bone): void
+    sortReset(bones: Array<Bone>): void
+    updateWorldTransform(): void
+    setToSetupPose(): void
+    setBonesToSetupPose(): void
+    setSlotsToSetupPose(): void
+    getRootBone(): Bone
+    findBone(boneName: string): Bone
+    findBoneIndex(boneName: string): number
+    findSlot(slotName: string): Slot
+    findSlotIndex(slotName: string): number
+    setSkinByName(skinName: string): void
+    setSkin(newSkin: Skin): void
+    getAttachmentByName(slotName: string, attachmentName: string): Attachment
+    getAttachment(slotIndex: number, attachmentName: string): Attachment
+    setAttachment(slotName: string, attachmentName: string): void
+    findIkConstraint(constraintName: string): IkConstraint
+    findTransformConstraint(constraintName: string): TransformConstraint
+    findPathConstraint(constraintName: string): PathConstraint
+    getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void
+    update(delta: number): void
+  }
 }
 declare module spine {
-    class SkeletonBinary {
-        static AttachmentTypeValues: number[];
-        static TransformModeValues: TransformMode[];
-        static PositionModeValues: PositionMode[];
-        static SpacingModeValues: SpacingMode[];
-        static RotateModeValues: RotateMode[];
-        static BlendModeValues: BlendMode[];
-        static BONE_ROTATE: number;
-        static BONE_TRANSLATE: number;
-        static BONE_SCALE: number;
-        static BONE_SHEAR: number;
-        static SLOT_ATTACHMENT: number;
-        static SLOT_COLOR: number;
-        static SLOT_TWO_COLOR: number;
-        static PATH_POSITION: number;
-        static PATH_SPACING: number;
-        static PATH_MIX: number;
-        static CURVE_LINEAR: number;
-        static CURVE_STEPPED: number;
-        static CURVE_BEZIER: number;
-        attachmentLoader: AttachmentLoader;
-        scale: number;
-        private linkedMeshes;
-        constructor(attachmentLoader: AttachmentLoader);
-        readSkeletonData(binary: Uint8Array): SkeletonData;
-        private readSkin;
-        private readAttachment;
-        private readVertices;
-        private readFloatArray;
-        private readShortArray;
-        private readAnimation;
-        private readCurve;
-        setCurve(timeline: CurveTimeline, frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
-    }
+  class SkeletonBinary {
+    static AttachmentTypeValues: number[]
+    static TransformModeValues: TransformMode[]
+    static PositionModeValues: PositionMode[]
+    static SpacingModeValues: SpacingMode[]
+    static RotateModeValues: RotateMode[]
+    static BlendModeValues: BlendMode[]
+    static BONE_ROTATE: number
+    static BONE_TRANSLATE: number
+    static BONE_SCALE: number
+    static BONE_SHEAR: number
+    static SLOT_ATTACHMENT: number
+    static SLOT_COLOR: number
+    static SLOT_TWO_COLOR: number
+    static PATH_POSITION: number
+    static PATH_SPACING: number
+    static PATH_MIX: number
+    static CURVE_LINEAR: number
+    static CURVE_STEPPED: number
+    static CURVE_BEZIER: number
+    attachmentLoader: AttachmentLoader
+    scale: number
+    private linkedMeshes
+    constructor(attachmentLoader: AttachmentLoader)
+    readSkeletonData(binary: Uint8Array): SkeletonData
+    private readSkin
+    private readAttachment
+    private readVertices
+    private readFloatArray
+    private readShortArray
+    private readAnimation
+    private readCurve
+    setCurve(
+      timeline: CurveTimeline,
+      frameIndex: number,
+      cx1: number,
+      cy1: number,
+      cx2: number,
+      cy2: number,
+    ): void
+  }
 }
 declare module spine {
-    class SkeletonBounds {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-        boundingBoxes: BoundingBoxAttachment[];
-        polygons: ArrayLike<number>[];
-        private polygonPool;
-        update(skeleton: Skeleton, updateAabb: boolean): void;
-        aabbCompute(): void;
-        aabbContainsPoint(x: number, y: number): boolean;
-        aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
-        aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
-        containsPoint(x: number, y: number): BoundingBoxAttachment;
-        containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean;
-        intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
-        intersectsSegmentPolygon(polygon: ArrayLike<number>, x1: number, y1: number, x2: number, y2: number): boolean;
-        getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>;
-        getWidth(): number;
-        getHeight(): number;
-    }
+  class SkeletonBounds {
+    minX: number
+    minY: number
+    maxX: number
+    maxY: number
+    boundingBoxes: BoundingBoxAttachment[]
+    polygons: ArrayLike<number>[]
+    private polygonPool
+    update(skeleton: Skeleton, updateAabb: boolean): void
+    aabbCompute(): void
+    aabbContainsPoint(x: number, y: number): boolean
+    aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean
+    aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean
+    containsPoint(x: number, y: number): BoundingBoxAttachment
+    containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean
+    intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment
+    intersectsSegmentPolygon(
+      polygon: ArrayLike<number>,
+      x1: number,
+      y1: number,
+      x2: number,
+      y2: number,
+    ): boolean
+    getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>
+    getWidth(): number
+    getHeight(): number
+  }
 }
 declare module spine {
-    class SkeletonClipping {
-        private triangulator;
-        private clippingPolygon;
-        private clipOutput;
-        clippedVertices: number[];
-        clippedTriangles: number[];
-        private scratch;
-        private clipAttachment;
-        private clippingPolygons;
-        clipStart(slot: Slot, clip: ClippingAttachment): number;
-        clipEndWithSlot(slot: Slot): void;
-        clipEnd(): void;
-        isClipping(): boolean;
-        clipTriangles(vertices: ArrayLike<number>, verticesLength: number, triangles: ArrayLike<number>, trianglesLength: number, uvs: ArrayLike<number>, light: Color, dark: Color, twoColor: boolean): void;
-        clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
-        static makeClockwise(polygon: ArrayLike<number>): void;
-    }
+  class SkeletonClipping {
+    private triangulator
+    private clippingPolygon
+    private clipOutput
+    clippedVertices: number[]
+    clippedTriangles: number[]
+    private scratch
+    private clipAttachment
+    private clippingPolygons
+    clipStart(slot: Slot, clip: ClippingAttachment): number
+    clipEndWithSlot(slot: Slot): void
+    clipEnd(): void
+    isClipping(): boolean
+    clipTriangles(
+      vertices: ArrayLike<number>,
+      verticesLength: number,
+      triangles: ArrayLike<number>,
+      trianglesLength: number,
+      uvs: ArrayLike<number>,
+      light: Color,
+      dark: Color,
+      twoColor: boolean,
+    ): void
+    clip(
+      x1: number,
+      y1: number,
+      x2: number,
+      y2: number,
+      x3: number,
+      y3: number,
+      clippingArea: Array<number>,
+      output: Array<number>,
+    ): boolean
+    static makeClockwise(polygon: ArrayLike<number>): void
+  }
 }
 declare module spine {
-    class SkeletonData {
-        name: string;
-        bones: BoneData[];
-        slots: SlotData[];
-        skins: Skin[];
-        defaultSkin: Skin;
-        events: EventData[];
-        animations: Animation[];
-        ikConstraints: IkConstraintData[];
-        transformConstraints: TransformConstraintData[];
-        pathConstraints: PathConstraintData[];
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        version: string;
-        hash: string;
-        fps: number;
-        imagesPath: string;
-        audioPath: string;
-        findBone(boneName: string): BoneData;
-        findBoneIndex(boneName: string): number;
-        findSlot(slotName: string): SlotData;
-        findSlotIndex(slotName: string): number;
-        findSkin(skinName: string): Skin;
-        findEvent(eventDataName: string): EventData;
-        findAnimation(animationName: string): Animation;
-        findIkConstraint(constraintName: string): IkConstraintData;
-        findTransformConstraint(constraintName: string): TransformConstraintData;
-        findPathConstraint(constraintName: string): PathConstraintData;
-        findPathConstraintIndex(pathConstraintName: string): number;
-    }
+  class SkeletonData {
+    name: string
+    bones: BoneData[]
+    slots: SlotData[]
+    skins: Skin[]
+    defaultSkin: Skin
+    events: EventData[]
+    animations: Animation[]
+    ikConstraints: IkConstraintData[]
+    transformConstraints: TransformConstraintData[]
+    pathConstraints: PathConstraintData[]
+    x: number
+    y: number
+    width: number
+    height: number
+    version: string
+    hash: string
+    fps: number
+    imagesPath: string
+    audioPath: string
+    findBone(boneName: string): BoneData
+    findBoneIndex(boneName: string): number
+    findSlot(slotName: string): SlotData
+    findSlotIndex(slotName: string): number
+    findSkin(skinName: string): Skin
+    findEvent(eventDataName: string): EventData
+    findAnimation(animationName: string): Animation
+    findIkConstraint(constraintName: string): IkConstraintData
+    findTransformConstraint(constraintName: string): TransformConstraintData
+    findPathConstraint(constraintName: string): PathConstraintData
+    findPathConstraintIndex(pathConstraintName: string): number
+  }
 }
 declare module spine {
-    class SkeletonJson {
-        attachmentLoader: AttachmentLoader;
-        scale: number;
-        private linkedMeshes;
-        constructor(attachmentLoader: AttachmentLoader);
-        readSkeletonData(json: string | any): SkeletonData;
-        readAttachment(map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment;
-        readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void;
-        readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
-        readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void;
-        getValue(map: any, prop: string, defaultValue: any): any;
-        static blendModeFromString(str: string): BlendMode;
-        static positionModeFromString(str: string): PositionMode;
-        static spacingModeFromString(str: string): SpacingMode;
-        static rotateModeFromString(str: string): RotateMode;
-        static transformModeFromString(str: string): TransformMode;
-    }
+  class SkeletonJson {
+    attachmentLoader: AttachmentLoader
+    scale: number
+    private linkedMeshes
+    constructor(attachmentLoader: AttachmentLoader)
+    readSkeletonData(json: string | any): SkeletonData
+    readAttachment(
+      map: any,
+      skin: Skin,
+      slotIndex: number,
+      name: string,
+      skeletonData: SkeletonData,
+    ): Attachment
+    readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void
+    readAnimation(map: any, name: string, skeletonData: SkeletonData): void
+    readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void
+    getValue(map: any, prop: string, defaultValue: any): any
+    static blendModeFromString(str: string): BlendMode
+    static positionModeFromString(str: string): PositionMode
+    static spacingModeFromString(str: string): SpacingMode
+    static rotateModeFromString(str: string): RotateMode
+    static transformModeFromString(str: string): TransformMode
+  }
 }
 declare module spine {
-    class SkinEntry {
-        slotIndex: number;
-        name: string;
-        attachment: Attachment;
-        constructor(slotIndex: number, name: string, attachment: Attachment);
-    }
-    class Skin {
-        name: string;
-        attachments: Map<Attachment>[];
-        bones: BoneData[];
-        constraints: ConstraintData[];
-        constructor(name: string);
-        setAttachment(slotIndex: number, name: string, attachment: Attachment): void;
-        addSkin(skin: Skin): void;
-        copySkin(skin: Skin): void;
-        getAttachment(slotIndex: number, name: string): Attachment;
-        removeAttachment(slotIndex: number, name: string): void;
-        getAttachments(): Array<SkinEntry>;
-        getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void;
-        clear(): void;
-        attachAll(skeleton: Skeleton, oldSkin: Skin): void;
-    }
+  class SkinEntry {
+    slotIndex: number
+    name: string
+    attachment: Attachment
+    constructor(slotIndex: number, name: string, attachment: Attachment)
+  }
+  class Skin {
+    name: string
+    attachments: Map<Attachment>[]
+    bones: BoneData[]
+    constraints: ConstraintData[]
+    constructor(name: string)
+    setAttachment(slotIndex: number, name: string, attachment: Attachment): void
+    addSkin(skin: Skin): void
+    copySkin(skin: Skin): void
+    getAttachment(slotIndex: number, name: string): Attachment
+    removeAttachment(slotIndex: number, name: string): void
+    getAttachments(): Array<SkinEntry>
+    getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void
+    clear(): void
+    attachAll(skeleton: Skeleton, oldSkin: Skin): void
+  }
 }
 declare module spine {
-    class Slot {
-        data: SlotData;
-        bone: Bone;
-        color: Color;
-        darkColor: Color;
-        private attachment;
-        private attachmentTime;
-        deform: number[];
-        constructor(data: SlotData, bone: Bone);
-        getAttachment(): Attachment;
-        setAttachment(attachment: Attachment): void;
-        setAttachmentTime(time: number): void;
-        getAttachmentTime(): number;
-        setToSetupPose(): void;
-    }
+  class Slot {
+    data: SlotData
+    bone: Bone
+    color: Color
+    darkColor: Color
+    private attachment
+    private attachmentTime
+    deform: number[]
+    constructor(data: SlotData, bone: Bone)
+    getAttachment(): Attachment
+    setAttachment(attachment: Attachment): void
+    setAttachmentTime(time: number): void
+    getAttachmentTime(): number
+    setToSetupPose(): void
+  }
 }
 declare module spine {
-    class SlotData {
-        index: number;
-        name: string;
-        boneData: BoneData;
-        color: Color;
-        darkColor: Color;
-        attachmentName: string;
-        blendMode: BlendMode;
-        constructor(index: number, name: string, boneData: BoneData);
-    }
+  class SlotData {
+    index: number
+    name: string
+    boneData: BoneData
+    color: Color
+    darkColor: Color
+    attachmentName: string
+    blendMode: BlendMode
+    constructor(index: number, name: string, boneData: BoneData)
+  }
 }
 declare module spine {
-    abstract class Texture {
-        protected _image: HTMLImageElement;
-        constructor(image: HTMLImageElement);
-        getImage(): HTMLImageElement;
-        abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-        abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-        abstract dispose(): void;
-        static filterFromString(text: string): TextureFilter;
-        static wrapFromString(text: string): TextureWrap;
-    }
-    enum TextureFilter {
-        Nearest = 9728,
-        Linear = 9729,
-        MipMap = 9987,
-        MipMapNearestNearest = 9984,
-        MipMapLinearNearest = 9985,
-        MipMapNearestLinear = 9986,
-        MipMapLinearLinear = 9987
-    }
-    enum TextureWrap {
-        MirroredRepeat = 33648,
-        ClampToEdge = 33071,
-        Repeat = 10497
-    }
-    class TextureRegion {
-        renderObject: any;
-        u: number;
-        v: number;
-        u2: number;
-        v2: number;
-        width: number;
-        height: number;
-        rotate: boolean;
-        offsetX: number;
-        offsetY: number;
-        originalWidth: number;
-        originalHeight: number;
-    }
-    class FakeTexture extends Texture {
-        setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-        setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-        dispose(): void;
-    }
+  abstract class Texture {
+    protected _image: HTMLImageElement
+    constructor(image: HTMLImageElement)
+    getImage(): HTMLImageElement
+    abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    abstract dispose(): void
+    static filterFromString(text: string): TextureFilter
+    static wrapFromString(text: string): TextureWrap
+  }
+  enum TextureFilter {
+    Nearest = 9728,
+    Linear = 9729,
+    MipMap = 9987,
+    MipMapNearestNearest = 9984,
+    MipMapLinearNearest = 9985,
+    MipMapNearestLinear = 9986,
+    MipMapLinearLinear = 9987,
+  }
+  enum TextureWrap {
+    MirroredRepeat = 33648,
+    ClampToEdge = 33071,
+    Repeat = 10497,
+  }
+  class TextureRegion {
+    renderObject: any
+    u: number
+    v: number
+    u2: number
+    v2: number
+    width: number
+    height: number
+    rotate: boolean
+    offsetX: number
+    offsetY: number
+    originalWidth: number
+    originalHeight: number
+  }
+  class FakeTexture extends Texture {
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    dispose(): void
+  }
 }
 declare module spine {
-    class TextureAtlas implements Disposable {
-        pages: TextureAtlasPage[];
-        regions: TextureAtlasRegion[];
-        constructor(atlasText: string, textureLoader: (path: string) => any);
-        private load;
-        findRegion(name: string): TextureAtlasRegion;
-        dispose(): void;
-    }
-    class TextureAtlasPage {
-        name: string;
-        minFilter: TextureFilter;
-        magFilter: TextureFilter;
-        uWrap: TextureWrap;
-        vWrap: TextureWrap;
-        texture: Texture;
-        width: number;
-        height: number;
-    }
-    class TextureAtlasRegion extends TextureRegion {
-        page: TextureAtlasPage;
-        name: string;
-        x: number;
-        y: number;
-        index: number;
-        rotate: boolean;
-        degrees: number;
-        texture: Texture;
-    }
+  class TextureAtlas implements Disposable {
+    pages: TextureAtlasPage[]
+    regions: TextureAtlasRegion[]
+    constructor(atlasText: string, textureLoader: (path: string) => any)
+    private load
+    findRegion(name: string): TextureAtlasRegion
+    dispose(): void
+  }
+  class TextureAtlasPage {
+    name: string
+    minFilter: TextureFilter
+    magFilter: TextureFilter
+    uWrap: TextureWrap
+    vWrap: TextureWrap
+    texture: Texture
+    width: number
+    height: number
+  }
+  class TextureAtlasRegion extends TextureRegion {
+    page: TextureAtlasPage
+    name: string
+    x: number
+    y: number
+    index: number
+    rotate: boolean
+    degrees: number
+    texture: Texture
+  }
 }
 declare module spine {
-    class TransformConstraint implements Updatable {
-        data: TransformConstraintData;
-        bones: Array<Bone>;
-        target: Bone;
-        rotateMix: number;
-        translateMix: number;
-        scaleMix: number;
-        shearMix: number;
-        temp: Vector2;
-        active: boolean;
-        constructor(data: TransformConstraintData, skeleton: Skeleton);
-        isActive(): boolean;
-        apply(): void;
-        update(): void;
-        applyAbsoluteWorld(): void;
-        applyRelativeWorld(): void;
-        applyAbsoluteLocal(): void;
-        applyRelativeLocal(): void;
-    }
+  class TransformConstraint implements Updatable {
+    data: TransformConstraintData
+    bones: Array<Bone>
+    target: Bone
+    rotateMix: number
+    translateMix: number
+    scaleMix: number
+    shearMix: number
+    temp: Vector2
+    active: boolean
+    constructor(data: TransformConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
+    applyAbsoluteWorld(): void
+    applyRelativeWorld(): void
+    applyAbsoluteLocal(): void
+    applyRelativeLocal(): void
+  }
 }
 declare module spine {
-    class TransformConstraintData extends ConstraintData {
-        bones: BoneData[];
-        target: BoneData;
-        rotateMix: number;
-        translateMix: number;
-        scaleMix: number;
-        shearMix: number;
-        offsetRotation: number;
-        offsetX: number;
-        offsetY: number;
-        offsetScaleX: number;
-        offsetScaleY: number;
-        offsetShearY: number;
-        relative: boolean;
-        local: boolean;
-        constructor(name: string);
-    }
+  class TransformConstraintData extends ConstraintData {
+    bones: BoneData[]
+    target: BoneData
+    rotateMix: number
+    translateMix: number
+    scaleMix: number
+    shearMix: number
+    offsetRotation: number
+    offsetX: number
+    offsetY: number
+    offsetScaleX: number
+    offsetScaleY: number
+    offsetShearY: number
+    relative: boolean
+    local: boolean
+    constructor(name: string)
+  }
 }
 declare module spine {
-    class Triangulator {
-        private convexPolygons;
-        private convexPolygonsIndices;
-        private indicesArray;
-        private isConcaveArray;
-        private triangles;
-        private polygonPool;
-        private polygonIndicesPool;
-        triangulate(verticesArray: ArrayLike<number>): Array<number>;
-        decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>;
-        private static isConcave;
-        private static positiveArea;
-        private static winding;
-    }
+  class Triangulator {
+    private convexPolygons
+    private convexPolygonsIndices
+    private indicesArray
+    private isConcaveArray
+    private triangles
+    private polygonPool
+    private polygonIndicesPool
+    triangulate(verticesArray: ArrayLike<number>): Array<number>
+    decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>
+    private static isConcave
+    private static positiveArea
+    private static winding
+  }
 }
 declare module spine {
-    interface Updatable {
-        update(): void;
-        isActive(): boolean;
-    }
+  interface Updatable {
+    update(): void
+    isActive(): boolean
+  }
 }
 declare module spine {
-    interface Map<T> {
-        [key: string]: T;
-    }
-    class IntSet {
-        array: number[];
-        add(value: number): boolean;
-        contains(value: number): boolean;
-        remove(value: number): void;
-        clear(): void;
-    }
-    interface Disposable {
-        dispose(): void;
-    }
-    interface Restorable {
-        restore(): void;
-    }
-    class Color {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-        static WHITE: Color;
-        static RED: Color;
-        static GREEN: Color;
-        static BLUE: Color;
-        static MAGENTA: Color;
-        constructor(r?: number, g?: number, b?: number, a?: number);
-        set(r: number, g: number, b: number, a: number): this;
-        setFromColor(c: Color): this;
-        setFromString(hex: string): this;
-        add(r: number, g: number, b: number, a: number): this;
-        clamp(): this;
-        static rgba8888ToColor(color: Color, value: number): void;
-        static rgb888ToColor(color: Color, value: number): void;
-    }
-    class MathUtils {
-        static PI: number;
-        static PI2: number;
-        static radiansToDegrees: number;
-        static radDeg: number;
-        static degreesToRadians: number;
-        static degRad: number;
-        static clamp(value: number, min: number, max: number): number;
-        static cosDeg(degrees: number): number;
-        static sinDeg(degrees: number): number;
-        static signum(value: number): number;
-        static toInt(x: number): number;
-        static cbrt(x: number): number;
-        static randomTriangular(min: number, max: number): number;
-        static randomTriangularWith(min: number, max: number, mode: number): number;
-    }
-    abstract class Interpolation {
-        protected abstract applyInternal(a: number): number;
-        apply(start: number, end: number, a: number): number;
-    }
-    class Pow extends Interpolation {
-        protected power: number;
-        constructor(power: number);
-        applyInternal(a: number): number;
-    }
-    class PowOut extends Pow {
-        constructor(power: number);
-        applyInternal(a: number): number;
-    }
-    class Utils {
-        static SUPPORTS_TYPED_ARRAYS: boolean;
-        static arrayCopy<T>(source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number): void;
-        static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>;
-        static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>;
-        static newArray<T>(size: number, defaultValue: T): Array<T>;
-        static newFloatArray(size: number): ArrayLike<number>;
-        static newShortArray(size: number): ArrayLike<number>;
-        static toFloatArray(array: Array<number>): number[] | Float32Array;
-        static toSinglePrecision(value: number): number;
-        static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
-        static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
-    }
-    class DebugUtils {
-        static logBones(skeleton: Skeleton): void;
-    }
-    class Pool<T> {
-        private items;
-        private instantiator;
-        constructor(instantiator: () => T);
-        obtain(): T;
-        free(item: T): void;
-        freeAll(items: ArrayLike<T>): void;
-        clear(): void;
-    }
-    class Vector2 {
-        x: number;
-        y: number;
-        constructor(x?: number, y?: number);
-        set(x: number, y: number): Vector2;
-        length(): number;
-        normalize(): this;
-    }
-    class TimeKeeper {
-        maxDelta: number;
-        framesPerSecond: number;
-        delta: number;
-        totalTime: number;
-        private lastTime;
-        private frameCount;
-        private frameTime;
-        update(): void;
-    }
-    interface ArrayLike<T> {
-        length: number;
-        [n: number]: T;
-    }
-    class WindowedMean {
-        values: Array<number>;
-        addedValues: number;
-        lastValue: number;
-        mean: number;
-        dirty: boolean;
-        constructor(windowSize?: number);
-        hasEnoughData(): boolean;
-        addValue(value: number): void;
-        getMean(): number;
-    }
+  interface Map<T> {
+    [key: string]: T
+  }
+  class IntSet {
+    array: number[]
+    add(value: number): boolean
+    contains(value: number): boolean
+    remove(value: number): void
+    clear(): void
+  }
+  interface Disposable {
+    dispose(): void
+  }
+  interface Restorable {
+    restore(): void
+  }
+  class Color {
+    r: number
+    g: number
+    b: number
+    a: number
+    static WHITE: Color
+    static RED: Color
+    static GREEN: Color
+    static BLUE: Color
+    static MAGENTA: Color
+    constructor(r?: number, g?: number, b?: number, a?: number)
+    set(r: number, g: number, b: number, a: number): this
+    setFromColor(c: Color): this
+    setFromString(hex: string): this
+    add(r: number, g: number, b: number, a: number): this
+    clamp(): this
+    static rgba8888ToColor(color: Color, value: number): void
+    static rgb888ToColor(color: Color, value: number): void
+  }
+  class MathUtils {
+    static PI: number
+    static PI2: number
+    static radiansToDegrees: number
+    static radDeg: number
+    static degreesToRadians: number
+    static degRad: number
+    static clamp(value: number, min: number, max: number): number
+    static cosDeg(degrees: number): number
+    static sinDeg(degrees: number): number
+    static signum(value: number): number
+    static toInt(x: number): number
+    static cbrt(x: number): number
+    static randomTriangular(min: number, max: number): number
+    static randomTriangularWith(min: number, max: number, mode: number): number
+  }
+  abstract class Interpolation {
+    protected abstract applyInternal(a: number): number
+    apply(start: number, end: number, a: number): number
+  }
+  class Pow extends Interpolation {
+    protected power: number
+    constructor(power: number)
+    applyInternal(a: number): number
+  }
+  class PowOut extends Pow {
+    constructor(power: number)
+    applyInternal(a: number): number
+  }
+  class Utils {
+    static SUPPORTS_TYPED_ARRAYS: boolean
+    static arrayCopy<T>(
+      source: ArrayLike<T>,
+      sourceStart: number,
+      dest: ArrayLike<T>,
+      destStart: number,
+      numElements: number,
+    ): void
+    static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>
+    static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>
+    static newArray<T>(size: number, defaultValue: T): Array<T>
+    static newFloatArray(size: number): ArrayLike<number>
+    static newShortArray(size: number): ArrayLike<number>
+    static toFloatArray(array: Array<number>): number[] | Float32Array
+    static toSinglePrecision(value: number): number
+    static webkit602BugfixHelper(alpha: number, blend: MixBlend): void
+    static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean
+  }
+  class DebugUtils {
+    static logBones(skeleton: Skeleton): void
+  }
+  class Pool<T> {
+    private items
+    private instantiator
+    constructor(instantiator: () => T)
+    obtain(): T
+    free(item: T): void
+    freeAll(items: ArrayLike<T>): void
+    clear(): void
+  }
+  class Vector2 {
+    x: number
+    y: number
+    constructor(x?: number, y?: number)
+    set(x: number, y: number): Vector2
+    length(): number
+    normalize(): this
+  }
+  class TimeKeeper {
+    maxDelta: number
+    framesPerSecond: number
+    delta: number
+    totalTime: number
+    private lastTime
+    private frameCount
+    private frameTime
+    update(): void
+  }
+  interface ArrayLike<T> {
+    length: number
+    [n: number]: T
+  }
+  class WindowedMean {
+    values: Array<number>
+    addedValues: number
+    lastValue: number
+    mean: number
+    dirty: boolean
+    constructor(windowSize?: number)
+    hasEnoughData(): boolean
+    addValue(value: number): void
+    getMean(): number
+  }
 }
 declare module spine {
-    interface VertexEffect {
-        begin(skeleton: Skeleton): void;
-        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-        end(): void;
-    }
+  interface VertexEffect {
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
+  }
 }
 interface Math {
-    fround(n: number): number;
+  fround(n: number): number
 }
 declare module spine {
-    abstract class Attachment {
-        name: string;
-        constructor(name: string);
-        abstract copy(): Attachment;
-    }
-    abstract class VertexAttachment extends Attachment {
-        private static nextID;
-        id: number;
-        bones: Array<number>;
-        vertices: ArrayLike<number>;
-        worldVerticesLength: number;
-        deformAttachment: VertexAttachment;
-        constructor(name: string);
-        computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
-        copyTo(attachment: VertexAttachment): void;
-    }
+  abstract class Attachment {
+    name: string
+    constructor(name: string)
+    abstract copy(): Attachment
+  }
+  abstract class VertexAttachment extends Attachment {
+    private static nextID
+    id: number
+    bones: Array<number>
+    vertices: ArrayLike<number>
+    worldVerticesLength: number
+    deformAttachment: VertexAttachment
+    constructor(name: string)
+    computeWorldVertices(
+      slot: Slot,
+      start: number,
+      count: number,
+      worldVertices: ArrayLike<number>,
+      offset: number,
+      stride: number,
+    ): void
+    copyTo(attachment: VertexAttachment): void
+  }
 }
 declare module spine {
-    interface AttachmentLoader {
-        newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
-        newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
-        newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
-        newPathAttachment(skin: Skin, name: string): PathAttachment;
-        newPointAttachment(skin: Skin, name: string): PointAttachment;
-        newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
-    }
+  interface AttachmentLoader {
+    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment
+    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment
+    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment
+    newPathAttachment(skin: Skin, name: string): PathAttachment
+    newPointAttachment(skin: Skin, name: string): PointAttachment
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment
+  }
 }
 declare module spine {
-    enum AttachmentType {
-        Region = 0,
-        BoundingBox = 1,
-        Mesh = 2,
-        LinkedMesh = 3,
-        Path = 4,
-        Point = 5,
-        Clipping = 6
-    }
+  enum AttachmentType {
+    Region = 0,
+    BoundingBox = 1,
+    Mesh = 2,
+    LinkedMesh = 3,
+    Path = 4,
+    Point = 5,
+    Clipping = 6,
+  }
 }
 declare module spine {
-    class BoundingBoxAttachment extends VertexAttachment {
-        color: Color;
-        constructor(name: string);
-        copy(): Attachment;
-    }
+  class BoundingBoxAttachment extends VertexAttachment {
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class ClippingAttachment extends VertexAttachment {
-        endSlot: SlotData;
-        color: Color;
-        constructor(name: string);
-        copy(): Attachment;
-    }
+  class ClippingAttachment extends VertexAttachment {
+    endSlot: SlotData
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class MeshAttachment extends VertexAttachment {
-        region: TextureRegion;
-        path: string;
-        regionUVs: ArrayLike<number>;
-        uvs: ArrayLike<number>;
-        triangles: Array<number>;
-        color: Color;
-        width: number;
-        height: number;
-        hullLength: number;
-        edges: Array<number>;
-        private parentMesh;
-        tempColor: Color;
-        constructor(name: string);
-        updateUVs(): void;
-        getParentMesh(): MeshAttachment;
-        setParentMesh(parentMesh: MeshAttachment): void;
-        copy(): Attachment;
-        newLinkedMesh(): MeshAttachment;
-    }
+  class MeshAttachment extends VertexAttachment {
+    region: TextureRegion
+    path: string
+    regionUVs: ArrayLike<number>
+    uvs: ArrayLike<number>
+    triangles: Array<number>
+    color: Color
+    width: number
+    height: number
+    hullLength: number
+    edges: Array<number>
+    private parentMesh
+    tempColor: Color
+    constructor(name: string)
+    updateUVs(): void
+    getParentMesh(): MeshAttachment
+    setParentMesh(parentMesh: MeshAttachment): void
+    copy(): Attachment
+    newLinkedMesh(): MeshAttachment
+  }
 }
 declare module spine {
-    class PathAttachment extends VertexAttachment {
-        lengths: Array<number>;
-        closed: boolean;
-        constantSpeed: boolean;
-        color: Color;
-        constructor(name: string);
-        copy(): Attachment;
-    }
+  class PathAttachment extends VertexAttachment {
+    lengths: Array<number>
+    closed: boolean
+    constantSpeed: boolean
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class PointAttachment extends VertexAttachment {
-        x: number;
-        y: number;
-        rotation: number;
-        color: Color;
-        constructor(name: string);
-        computeWorldPosition(bone: Bone, point: Vector2): Vector2;
-        computeWorldRotation(bone: Bone): number;
-        copy(): Attachment;
-    }
+  class PointAttachment extends VertexAttachment {
+    x: number
+    y: number
+    rotation: number
+    color: Color
+    constructor(name: string)
+    computeWorldPosition(bone: Bone, point: Vector2): Vector2
+    computeWorldRotation(bone: Bone): number
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class RegionAttachment extends Attachment {
-        static OX1: number;
-        static OY1: number;
-        static OX2: number;
-        static OY2: number;
-        static OX3: number;
-        static OY3: number;
-        static OX4: number;
-        static OY4: number;
-        static X1: number;
-        static Y1: number;
-        static C1R: number;
-        static C1G: number;
-        static C1B: number;
-        static C1A: number;
-        static U1: number;
-        static V1: number;
-        static X2: number;
-        static Y2: number;
-        static C2R: number;
-        static C2G: number;
-        static C2B: number;
-        static C2A: number;
-        static U2: number;
-        static V2: number;
-        static X3: number;
-        static Y3: number;
-        static C3R: number;
-        static C3G: number;
-        static C3B: number;
-        static C3A: number;
-        static U3: number;
-        static V3: number;
-        static X4: number;
-        static Y4: number;
-        static C4R: number;
-        static C4G: number;
-        static C4B: number;
-        static C4A: number;
-        static U4: number;
-        static V4: number;
-        x: number;
-        y: number;
-        scaleX: number;
-        scaleY: number;
-        rotation: number;
-        width: number;
-        height: number;
-        color: Color;
-        path: string;
-        rendererObject: any;
-        region: TextureRegion;
-        offset: ArrayLike<number>;
-        uvs: ArrayLike<number>;
-        tempColor: Color;
-        constructor(name: string);
-        updateOffset(): void;
-        setRegion(region: TextureRegion): void;
-        computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
-        copy(): Attachment;
-    }
+  class RegionAttachment extends Attachment {
+    static OX1: number
+    static OY1: number
+    static OX2: number
+    static OY2: number
+    static OX3: number
+    static OY3: number
+    static OX4: number
+    static OY4: number
+    static X1: number
+    static Y1: number
+    static C1R: number
+    static C1G: number
+    static C1B: number
+    static C1A: number
+    static U1: number
+    static V1: number
+    static X2: number
+    static Y2: number
+    static C2R: number
+    static C2G: number
+    static C2B: number
+    static C2A: number
+    static U2: number
+    static V2: number
+    static X3: number
+    static Y3: number
+    static C3R: number
+    static C3G: number
+    static C3B: number
+    static C3A: number
+    static U3: number
+    static V3: number
+    static X4: number
+    static Y4: number
+    static C4R: number
+    static C4G: number
+    static C4B: number
+    static C4A: number
+    static U4: number
+    static V4: number
+    x: number
+    y: number
+    scaleX: number
+    scaleY: number
+    rotation: number
+    width: number
+    height: number
+    color: Color
+    path: string
+    rendererObject: any
+    region: TextureRegion
+    offset: ArrayLike<number>
+    uvs: ArrayLike<number>
+    tempColor: Color
+    constructor(name: string)
+    updateOffset(): void
+    setRegion(region: TextureRegion): void
+    computeWorldVertices(
+      bone: Bone,
+      worldVertices: ArrayLike<number>,
+      offset: number,
+      stride: number,
+    ): void
+    copy(): Attachment
+  }
 }
 declare module spine {
-    class JitterEffect implements VertexEffect {
-        jitterX: number;
-        jitterY: number;
-        constructor(jitterX: number, jitterY: number);
-        begin(skeleton: Skeleton): void;
-        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-        end(): void;
-    }
+  class JitterEffect implements VertexEffect {
+    jitterX: number
+    jitterY: number
+    constructor(jitterX: number, jitterY: number)
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
+  }
 }
 declare module spine {
-    class SwirlEffect implements VertexEffect {
-        static interpolation: PowOut;
-        centerX: number;
-        centerY: number;
-        radius: number;
-        angle: number;
-        private worldX;
-        private worldY;
-        constructor(radius: number);
-        begin(skeleton: Skeleton): void;
-        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-        end(): void;
-    }
+  class SwirlEffect implements VertexEffect {
+    static interpolation: PowOut
+    centerX: number
+    centerY: number
+    radius: number
+    angle: number
+    private worldX
+    private worldY
+    constructor(radius: number)
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
+  }
 }
 declare module spine.webgl {
-    class AssetManager extends spine.AssetManager {
-        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix?: string);
-    }
+  class AssetManager extends spine.AssetManager {
+    constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix?: string)
+  }
 }
 declare module spine.webgl {
-    class OrthoCamera {
-        position: Vector3;
-        direction: Vector3;
-        up: Vector3;
-        near: number;
-        far: number;
-        zoom: number;
-        viewportWidth: number;
-        viewportHeight: number;
-        projectionView: Matrix4;
-        inverseProjectionView: Matrix4;
-        projection: Matrix4;
-        view: Matrix4;
-        private tmp;
-        constructor(viewportWidth: number, viewportHeight: number);
-        update(): void;
-        screenToWorld(screenCoords: Vector3, screenWidth: number, screenHeight: number): Vector3;
-        setViewport(viewportWidth: number, viewportHeight: number): void;
-    }
+  class OrthoCamera {
+    position: Vector3
+    direction: Vector3
+    up: Vector3
+    near: number
+    far: number
+    zoom: number
+    viewportWidth: number
+    viewportHeight: number
+    projectionView: Matrix4
+    inverseProjectionView: Matrix4
+    projection: Matrix4
+    view: Matrix4
+    private tmp
+    constructor(viewportWidth: number, viewportHeight: number)
+    update(): void
+    screenToWorld(screenCoords: Vector3, screenWidth: number, screenHeight: number): Vector3
+    setViewport(viewportWidth: number, viewportHeight: number): void
+  }
 }
 declare module spine.webgl {
-    class GLTexture extends Texture implements Disposable, Restorable {
-        private context;
-        private texture;
-        private boundUnit;
-        private useMipMaps;
-        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement, useMipMaps?: boolean);
-        setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-        setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-        update(useMipMaps: boolean): void;
-        restore(): void;
-        bind(unit?: number): void;
-        unbind(): void;
-        dispose(): void;
-    }
+  class GLTexture extends Texture implements Disposable, Restorable {
+    private context
+    private texture
+    private boundUnit
+    private useMipMaps
+    constructor(
+      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
+      image: HTMLImageElement,
+      useMipMaps?: boolean,
+    )
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    update(useMipMaps: boolean): void
+    restore(): void
+    bind(unit?: number): void
+    unbind(): void
+    dispose(): void
+  }
 }
 declare module spine.webgl {
-    const M00 = 0;
-    const M01 = 4;
-    const M02 = 8;
-    const M03 = 12;
-    const M10 = 1;
-    const M11 = 5;
-    const M12 = 9;
-    const M13 = 13;
-    const M20 = 2;
-    const M21 = 6;
-    const M22 = 10;
-    const M23 = 14;
-    const M30 = 3;
-    const M31 = 7;
-    const M32 = 11;
-    const M33 = 15;
-    class Matrix4 {
-        temp: Float32Array;
-        values: Float32Array;
-        private static xAxis;
-        private static yAxis;
-        private static zAxis;
-        private static tmpMatrix;
-        constructor();
-        set(values: ArrayLike<number>): Matrix4;
-        transpose(): Matrix4;
-        identity(): Matrix4;
-        invert(): Matrix4;
-        determinant(): number;
-        translate(x: number, y: number, z: number): Matrix4;
-        copy(): Matrix4;
-        projection(near: number, far: number, fovy: number, aspectRatio: number): Matrix4;
-        ortho2d(x: number, y: number, width: number, height: number): Matrix4;
-        ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
-        multiply(matrix: Matrix4): Matrix4;
-        multiplyLeft(matrix: Matrix4): Matrix4;
-        lookAt(position: Vector3, direction: Vector3, up: Vector3): this;
-        static initTemps(): void;
-    }
+  const M00 = 0
+  const M01 = 4
+  const M02 = 8
+  const M03 = 12
+  const M10 = 1
+  const M11 = 5
+  const M12 = 9
+  const M13 = 13
+  const M20 = 2
+  const M21 = 6
+  const M22 = 10
+  const M23 = 14
+  const M30 = 3
+  const M31 = 7
+  const M32 = 11
+  const M33 = 15
+  class Matrix4 {
+    temp: Float32Array
+    values: Float32Array
+    private static xAxis
+    private static yAxis
+    private static zAxis
+    private static tmpMatrix
+    constructor()
+    set(values: ArrayLike<number>): Matrix4
+    transpose(): Matrix4
+    identity(): Matrix4
+    invert(): Matrix4
+    determinant(): number
+    translate(x: number, y: number, z: number): Matrix4
+    copy(): Matrix4
+    projection(near: number, far: number, fovy: number, aspectRatio: number): Matrix4
+    ortho2d(x: number, y: number, width: number, height: number): Matrix4
+    ortho(
+      left: number,
+      right: number,
+      bottom: number,
+      top: number,
+      near: number,
+      far: number,
+    ): Matrix4
+    multiply(matrix: Matrix4): Matrix4
+    multiplyLeft(matrix: Matrix4): Matrix4
+    lookAt(position: Vector3, direction: Vector3, up: Vector3): this
+    static initTemps(): void
+  }
 }
 declare module spine.webgl {
-    class Mesh implements Disposable, Restorable {
-        private attributes;
-        private context;
-        private vertices;
-        private verticesBuffer;
-        private verticesLength;
-        private dirtyVertices;
-        private indices;
-        private indicesBuffer;
-        private indicesLength;
-        private dirtyIndices;
-        private elementsPerVertex;
-        getAttributes(): VertexAttribute[];
-        maxVertices(): number;
-        numVertices(): number;
-        setVerticesLength(length: number): void;
-        getVertices(): Float32Array;
-        maxIndices(): number;
-        numIndices(): number;
-        setIndicesLength(length: number): void;
-        getIndices(): Uint16Array;
-        getVertexSizeInFloats(): number;
-        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, attributes: VertexAttribute[], maxVertices: number, maxIndices: number);
-        setVertices(vertices: Array<number>): void;
-        setIndices(indices: Array<number>): void;
-        draw(shader: Shader, primitiveType: number): void;
-        drawWithOffset(shader: Shader, primitiveType: number, offset: number, count: number): void;
-        bind(shader: Shader): void;
-        unbind(shader: Shader): void;
-        private update;
-        restore(): void;
-        dispose(): void;
-    }
-    class VertexAttribute {
-        name: string;
-        type: VertexAttributeType;
-        numElements: number;
-        constructor(name: string, type: VertexAttributeType, numElements: number);
-    }
-    class Position2Attribute extends VertexAttribute {
-        constructor();
-    }
-    class Position3Attribute extends VertexAttribute {
-        constructor();
-    }
-    class TexCoordAttribute extends VertexAttribute {
-        constructor(unit?: number);
-    }
-    class ColorAttribute extends VertexAttribute {
-        constructor();
-    }
-    class Color2Attribute extends VertexAttribute {
-        constructor();
-    }
-    enum VertexAttributeType {
-        Float = 0
-    }
+  class Mesh implements Disposable, Restorable {
+    private attributes
+    private context
+    private vertices
+    private verticesBuffer
+    private verticesLength
+    private dirtyVertices
+    private indices
+    private indicesBuffer
+    private indicesLength
+    private dirtyIndices
+    private elementsPerVertex
+    getAttributes(): VertexAttribute[]
+    maxVertices(): number
+    numVertices(): number
+    setVerticesLength(length: number): void
+    getVertices(): Float32Array
+    maxIndices(): number
+    numIndices(): number
+    setIndicesLength(length: number): void
+    getIndices(): Uint16Array
+    getVertexSizeInFloats(): number
+    constructor(
+      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
+      attributes: VertexAttribute[],
+      maxVertices: number,
+      maxIndices: number,
+    )
+    setVertices(vertices: Array<number>): void
+    setIndices(indices: Array<number>): void
+    draw(shader: Shader, primitiveType: number): void
+    drawWithOffset(shader: Shader, primitiveType: number, offset: number, count: number): void
+    bind(shader: Shader): void
+    unbind(shader: Shader): void
+    private update
+    restore(): void
+    dispose(): void
+  }
+  class VertexAttribute {
+    name: string
+    type: VertexAttributeType
+    numElements: number
+    constructor(name: string, type: VertexAttributeType, numElements: number)
+  }
+  class Position2Attribute extends VertexAttribute {
+    constructor()
+  }
+  class Position3Attribute extends VertexAttribute {
+    constructor()
+  }
+  class TexCoordAttribute extends VertexAttribute {
+    constructor(unit?: number)
+  }
+  class ColorAttribute extends VertexAttribute {
+    constructor()
+  }
+  class Color2Attribute extends VertexAttribute {
+    constructor()
+  }
+  enum VertexAttributeType {
+    Float = 0,
+  }
 }
 declare module spine.webgl {
-    class PolygonBatcher implements Disposable {
-        private context;
-        private drawCalls;
-        private isDrawing;
-        private mesh;
-        private shader;
-        private lastTexture;
-        private verticesLength;
-        private indicesLength;
-        private srcBlend;
-        private dstBlend;
-        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint?: boolean, maxVertices?: number);
-        begin(shader: Shader): void;
-        setBlendMode(srcBlend: number, dstBlend: number): void;
-        draw(texture: GLTexture, vertices: ArrayLike<number>, indices: Array<number>): void;
-        private flush;
-        end(): void;
-        getDrawCalls(): number;
-        dispose(): void;
-    }
+  class PolygonBatcher implements Disposable {
+    private context
+    private drawCalls
+    private isDrawing
+    private mesh
+    private shader
+    private lastTexture
+    private verticesLength
+    private indicesLength
+    private srcBlend
+    private dstBlend
+    constructor(
+      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
+      twoColorTint?: boolean,
+      maxVertices?: number,
+    )
+    begin(shader: Shader): void
+    setBlendMode(srcBlend: number, dstBlend: number): void
+    draw(texture: GLTexture, vertices: ArrayLike<number>, indices: Array<number>): void
+    private flush
+    end(): void
+    getDrawCalls(): number
+    dispose(): void
+  }
 }
 declare module spine.webgl {
-    class SceneRenderer implements Disposable {
-        context: ManagedWebGLRenderingContext;
-        canvas: HTMLCanvasElement;
-        camera: OrthoCamera;
-        batcher: PolygonBatcher;
-        private twoColorTint;
-        private batcherShader;
-        private shapes;
-        private shapesShader;
-        private activeRenderer;
-        skeletonRenderer: SkeletonRenderer;
-        skeletonDebugRenderer: SkeletonDebugRenderer;
-        private QUAD;
-        private QUAD_TRIANGLES;
-        private WHITE;
-        constructor(canvas: HTMLCanvasElement, context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint?: boolean);
-        begin(): void;
-        drawSkeleton(skeleton: Skeleton, premultipliedAlpha?: boolean, slotRangeStart?: number, slotRangeEnd?: number): void;
-        drawSkeletonDebug(skeleton: Skeleton, premultipliedAlpha?: boolean, ignoredBones?: Array<string>): void;
-        drawTexture(texture: GLTexture, x: number, y: number, width: number, height: number, color?: Color): void;
-        drawTextureUV(texture: GLTexture, x: number, y: number, width: number, height: number, u: number, v: number, u2: number, v2: number, color?: Color): void;
-        drawTextureRotated(texture: GLTexture, x: number, y: number, width: number, height: number, pivotX: number, pivotY: number, angle: number, color?: Color, premultipliedAlpha?: boolean): void;
-        drawRegion(region: TextureAtlasRegion, x: number, y: number, width: number, height: number, color?: Color, premultipliedAlpha?: boolean): void;
-        line(x: number, y: number, x2: number, y2: number, color?: Color, color2?: Color): void;
-        triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color?: Color, color2?: Color, color3?: Color): void;
-        quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, color2?: Color, color3?: Color, color4?: Color): void;
-        rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void;
-        rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color?: Color): void;
-        polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void;
-        circle(filled: boolean, x: number, y: number, radius: number, color?: Color, segments?: number): void;
-        curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color?: Color): void;
-        end(): void;
-        resize(resizeMode: ResizeMode): void;
-        private enableRenderer;
-        dispose(): void;
-    }
-    enum ResizeMode {
-        Stretch = 0,
-        Expand = 1,
-        Fit = 2
-    }
+  class SceneRenderer implements Disposable {
+    context: ManagedWebGLRenderingContext
+    canvas: HTMLCanvasElement
+    camera: OrthoCamera
+    batcher: PolygonBatcher
+    private twoColorTint
+    private batcherShader
+    private shapes
+    private shapesShader
+    private activeRenderer
+    skeletonRenderer: SkeletonRenderer
+    skeletonDebugRenderer: SkeletonDebugRenderer
+    private QUAD
+    private QUAD_TRIANGLES
+    private WHITE
+    constructor(
+      canvas: HTMLCanvasElement,
+      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
+      twoColorTint?: boolean,
+    )
+    begin(): void
+    drawSkeleton(
+      skeleton: Skeleton,
+      premultipliedAlpha?: boolean,
+      slotRangeStart?: number,
+      slotRangeEnd?: number,
+    ): void
+    drawSkeletonDebug(
+      skeleton: Skeleton,
+      premultipliedAlpha?: boolean,
+      ignoredBones?: Array<string>,
+    ): void
+    drawTexture(
+      texture: GLTexture,
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      color?: Color,
+    ): void
+    drawTextureUV(
+      texture: GLTexture,
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      u: number,
+      v: number,
+      u2: number,
+      v2: number,
+      color?: Color,
+    ): void
+    drawTextureRotated(
+      texture: GLTexture,
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      pivotX: number,
+      pivotY: number,
+      angle: number,
+      color?: Color,
+      premultipliedAlpha?: boolean,
+    ): void
+    drawRegion(
+      region: TextureAtlasRegion,
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      color?: Color,
+      premultipliedAlpha?: boolean,
+    ): void
+    line(x: number, y: number, x2: number, y2: number, color?: Color, color2?: Color): void
+    triangle(
+      filled: boolean,
+      x: number,
+      y: number,
+      x2: number,
+      y2: number,
+      x3: number,
+      y3: number,
+      color?: Color,
+      color2?: Color,
+      color3?: Color,
+    ): void
+    quad(
+      filled: boolean,
+      x: number,
+      y: number,
+      x2: number,
+      y2: number,
+      x3: number,
+      y3: number,
+      x4: number,
+      y4: number,
+      color?: Color,
+      color2?: Color,
+      color3?: Color,
+      color4?: Color,
+    ): void
+    rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void
+    rectLine(
+      filled: boolean,
+      x1: number,
+      y1: number,
+      x2: number,
+      y2: number,
+      width: number,
+      color?: Color,
+    ): void
+    polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void
+    circle(
+      filled: boolean,
+      x: number,
+      y: number,
+      radius: number,
+      color?: Color,
+      segments?: number,
+    ): void
+    curve(
+      x1: number,
+      y1: number,
+      cx1: number,
+      cy1: number,
+      cx2: number,
+      cy2: number,
+      x2: number,
+      y2: number,
+      segments: number,
+      color?: Color,
+    ): void
+    end(): void
+    resize(resizeMode: ResizeMode): void
+    private enableRenderer
+    dispose(): void
+  }
+  enum ResizeMode {
+    Stretch = 0,
+    Expand = 1,
+    Fit = 2,
+  }
 }
 declare module spine.webgl {
-    class Shader implements Disposable, Restorable {
-        private vertexShader;
-        private fragmentShader;
-        static MVP_MATRIX: string;
-        static POSITION: string;
-        static COLOR: string;
-        static COLOR2: string;
-        static TEXCOORDS: string;
-        static SAMPLER: string;
-        private context;
-        private vs;
-        private vsSource;
-        private fs;
-        private fsSource;
-        private program;
-        private tmp2x2;
-        private tmp3x3;
-        private tmp4x4;
-        getProgram(): WebGLProgram;
-        getVertexShader(): string;
-        getFragmentShader(): string;
-        getVertexShaderSource(): string;
-        getFragmentSource(): string;
-        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, vertexShader: string, fragmentShader: string);
-        private compile;
-        private compileShader;
-        private compileProgram;
-        restore(): void;
-        bind(): void;
-        unbind(): void;
-        setUniformi(uniform: string, value: number): void;
-        setUniformf(uniform: string, value: number): void;
-        setUniform2f(uniform: string, value: number, value2: number): void;
-        setUniform3f(uniform: string, value: number, value2: number, value3: number): void;
-        setUniform4f(uniform: string, value: number, value2: number, value3: number, value4: number): void;
-        setUniform2x2f(uniform: string, value: ArrayLike<number>): void;
-        setUniform3x3f(uniform: string, value: ArrayLike<number>): void;
-        setUniform4x4f(uniform: string, value: ArrayLike<number>): void;
-        getUniformLocation(uniform: string): WebGLUniformLocation;
-        getAttributeLocation(attribute: string): number;
-        dispose(): void;
-        static newColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
-        static newTwoColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
-        static newColored(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
-    }
+  class Shader implements Disposable, Restorable {
+    private vertexShader
+    private fragmentShader
+    static MVP_MATRIX: string
+    static POSITION: string
+    static COLOR: string
+    static COLOR2: string
+    static TEXCOORDS: string
+    static SAMPLER: string
+    private context
+    private vs
+    private vsSource
+    private fs
+    private fsSource
+    private program
+    private tmp2x2
+    private tmp3x3
+    private tmp4x4
+    getProgram(): WebGLProgram
+    getVertexShader(): string
+    getFragmentShader(): string
+    getVertexShaderSource(): string
+    getFragmentSource(): string
+    constructor(
+      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
+      vertexShader: string,
+      fragmentShader: string,
+    )
+    private compile
+    private compileShader
+    private compileProgram
+    restore(): void
+    bind(): void
+    unbind(): void
+    setUniformi(uniform: string, value: number): void
+    setUniformf(uniform: string, value: number): void
+    setUniform2f(uniform: string, value: number, value2: number): void
+    setUniform3f(uniform: string, value: number, value2: number, value3: number): void
+    setUniform4f(
+      uniform: string,
+      value: number,
+      value2: number,
+      value3: number,
+      value4: number,
+    ): void
+    setUniform2x2f(uniform: string, value: ArrayLike<number>): void
+    setUniform3x3f(uniform: string, value: ArrayLike<number>): void
+    setUniform4x4f(uniform: string, value: ArrayLike<number>): void
+    getUniformLocation(uniform: string): WebGLUniformLocation
+    getAttributeLocation(attribute: string): number
+    dispose(): void
+    static newColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader
+    static newTwoColoredTextured(
+      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
+    ): Shader
+    static newColored(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader
+  }
 }
 declare module spine.webgl {
-    class ShapeRenderer implements Disposable {
-        private context;
-        private isDrawing;
-        private mesh;
-        private shapeType;
-        private color;
-        private shader;
-        private vertexIndex;
-        private tmp;
-        private srcBlend;
-        private dstBlend;
-        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, maxVertices?: number);
-        begin(shader: Shader): void;
-        setBlendMode(srcBlend: number, dstBlend: number): void;
-        setColor(color: Color): void;
-        setColorWith(r: number, g: number, b: number, a: number): void;
-        point(x: number, y: number, color?: Color): void;
-        line(x: number, y: number, x2: number, y2: number, color?: Color): void;
-        triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color?: Color, color2?: Color, color3?: Color): void;
-        quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, color2?: Color, color3?: Color, color4?: Color): void;
-        rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void;
-        rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color?: Color): void;
-        x(x: number, y: number, size: number): void;
-        polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void;
-        circle(filled: boolean, x: number, y: number, radius: number, color?: Color, segments?: number): void;
-        curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color?: Color): void;
-        private vertex;
-        end(): void;
-        private flush;
-        private check;
-        dispose(): void;
-    }
-    enum ShapeType {
-        Point = 0,
-        Line = 1,
-        Filled = 4
-    }
+  class ShapeRenderer implements Disposable {
+    private context
+    private isDrawing
+    private mesh
+    private shapeType
+    private color
+    private shader
+    private vertexIndex
+    private tmp
+    private srcBlend
+    private dstBlend
+    constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, maxVertices?: number)
+    begin(shader: Shader): void
+    setBlendMode(srcBlend: number, dstBlend: number): void
+    setColor(color: Color): void
+    setColorWith(r: number, g: number, b: number, a: number): void
+    point(x: number, y: number, color?: Color): void
+    line(x: number, y: number, x2: number, y2: number, color?: Color): void
+    triangle(
+      filled: boolean,
+      x: number,
+      y: number,
+      x2: number,
+      y2: number,
+      x3: number,
+      y3: number,
+      color?: Color,
+      color2?: Color,
+      color3?: Color,
+    ): void
+    quad(
+      filled: boolean,
+      x: number,
+      y: number,
+      x2: number,
+      y2: number,
+      x3: number,
+      y3: number,
+      x4: number,
+      y4: number,
+      color?: Color,
+      color2?: Color,
+      color3?: Color,
+      color4?: Color,
+    ): void
+    rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void
+    rectLine(
+      filled: boolean,
+      x1: number,
+      y1: number,
+      x2: number,
+      y2: number,
+      width: number,
+      color?: Color,
+    ): void
+    x(x: number, y: number, size: number): void
+    polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void
+    circle(
+      filled: boolean,
+      x: number,
+      y: number,
+      radius: number,
+      color?: Color,
+      segments?: number,
+    ): void
+    curve(
+      x1: number,
+      y1: number,
+      cx1: number,
+      cy1: number,
+      cx2: number,
+      cy2: number,
+      x2: number,
+      y2: number,
+      segments: number,
+      color?: Color,
+    ): void
+    private vertex
+    end(): void
+    private flush
+    private check
+    dispose(): void
+  }
+  enum ShapeType {
+    Point = 0,
+    Line = 1,
+    Filled = 4,
+  }
 }
 declare module spine.webgl {
-    class SkeletonDebugRenderer implements Disposable {
-        boneLineColor: Color;
-        boneOriginColor: Color;
-        attachmentLineColor: Color;
-        triangleLineColor: Color;
-        pathColor: Color;
-        clipColor: Color;
-        aabbColor: Color;
-        drawBones: boolean;
-        drawRegionAttachments: boolean;
-        drawBoundingBoxes: boolean;
-        drawMeshHull: boolean;
-        drawMeshTriangles: boolean;
-        drawPaths: boolean;
-        drawSkeletonXY: boolean;
-        drawClipping: boolean;
-        premultipliedAlpha: boolean;
-        scale: number;
-        boneWidth: number;
-        private context;
-        private bounds;
-        private temp;
-        private vertices;
-        private static LIGHT_GRAY;
-        private static GREEN;
-        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext);
-        draw(shapes: ShapeRenderer, skeleton: Skeleton, ignoredBones?: Array<string>): void;
-        dispose(): void;
-    }
+  class SkeletonDebugRenderer implements Disposable {
+    boneLineColor: Color
+    boneOriginColor: Color
+    attachmentLineColor: Color
+    triangleLineColor: Color
+    pathColor: Color
+    clipColor: Color
+    aabbColor: Color
+    drawBones: boolean
+    drawRegionAttachments: boolean
+    drawBoundingBoxes: boolean
+    drawMeshHull: boolean
+    drawMeshTriangles: boolean
+    drawPaths: boolean
+    drawSkeletonXY: boolean
+    drawClipping: boolean
+    premultipliedAlpha: boolean
+    scale: number
+    boneWidth: number
+    private context
+    private bounds
+    private temp
+    private vertices
+    private static LIGHT_GRAY
+    private static GREEN
+    constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext)
+    draw(shapes: ShapeRenderer, skeleton: Skeleton, ignoredBones?: Array<string>): void
+    dispose(): void
+  }
 }
 declare module spine.webgl {
-    class SkeletonRenderer {
-        static QUAD_TRIANGLES: number[];
-        premultipliedAlpha: boolean;
-        vertexEffect: VertexEffect;
-        private tempColor;
-        private tempColor2;
-        private vertices;
-        private vertexSize;
-        private twoColorTint;
-        private renderable;
-        private clipper;
-        private temp;
-        private temp2;
-        private temp3;
-        private temp4;
-        constructor(context: ManagedWebGLRenderingContext, twoColorTint?: boolean);
-        draw(batcher: PolygonBatcher, skeleton: Skeleton, slotRangeStart?: number, slotRangeEnd?: number): void;
-    }
+  class SkeletonRenderer {
+    static QUAD_TRIANGLES: number[]
+    premultipliedAlpha: boolean
+    vertexEffect: VertexEffect
+    private tempColor
+    private tempColor2
+    private vertices
+    private vertexSize
+    private twoColorTint
+    private renderable
+    private clipper
+    private temp
+    private temp2
+    private temp3
+    private temp4
+    constructor(context: ManagedWebGLRenderingContext, twoColorTint?: boolean)
+    draw(
+      batcher: PolygonBatcher,
+      skeleton: Skeleton,
+      slotRangeStart?: number,
+      slotRangeEnd?: number,
+    ): void
+  }
 }
 declare module spine.webgl {
-    class Vector3 {
-        x: number;
-        y: number;
-        z: number;
-        constructor(x?: number, y?: number, z?: number);
-        setFrom(v: Vector3): Vector3;
-        set(x: number, y: number, z: number): Vector3;
-        add(v: Vector3): Vector3;
-        sub(v: Vector3): Vector3;
-        scale(s: number): Vector3;
-        normalize(): Vector3;
-        cross(v: Vector3): Vector3;
-        multiply(matrix: Matrix4): Vector3;
-        project(matrix: Matrix4): Vector3;
-        dot(v: Vector3): number;
-        length(): number;
-        distance(v: Vector3): number;
-    }
+  class Vector3 {
+    x: number
+    y: number
+    z: number
+    constructor(x?: number, y?: number, z?: number)
+    setFrom(v: Vector3): Vector3
+    set(x: number, y: number, z: number): Vector3
+    add(v: Vector3): Vector3
+    sub(v: Vector3): Vector3
+    scale(s: number): Vector3
+    normalize(): Vector3
+    cross(v: Vector3): Vector3
+    multiply(matrix: Matrix4): Vector3
+    project(matrix: Matrix4): Vector3
+    dot(v: Vector3): number
+    length(): number
+    distance(v: Vector3): number
+  }
 }
 declare module spine.webgl {
-    class ManagedWebGLRenderingContext {
-        canvas: HTMLCanvasElement | OffscreenCanvas;
-        gl: WebGLRenderingContext;
-        private restorables;
-        constructor(canvasOrContext: HTMLCanvasElement | WebGLRenderingContext, contextConfig?: any);
-        addRestorable(restorable: Restorable): void;
-        removeRestorable(restorable: Restorable): void;
-    }
-    class WebGLBlendModeConverter {
-        static ZERO: number;
-        static ONE: number;
-        static SRC_COLOR: number;
-        static ONE_MINUS_SRC_COLOR: number;
-        static SRC_ALPHA: number;
-        static ONE_MINUS_SRC_ALPHA: number;
-        static DST_ALPHA: number;
-        static ONE_MINUS_DST_ALPHA: number;
-        static DST_COLOR: number;
-        static getDestGLBlendMode(blendMode: BlendMode): number;
-        static getSourceGLBlendMode(blendMode: BlendMode, premultipliedAlpha?: boolean): number;
-    }
+  class ManagedWebGLRenderingContext {
+    canvas: HTMLCanvasElement | OffscreenCanvas
+    gl: WebGLRenderingContext
+    private restorables
+    constructor(canvasOrContext: HTMLCanvasElement | WebGLRenderingContext, contextConfig?: any)
+    addRestorable(restorable: Restorable): void
+    removeRestorable(restorable: Restorable): void
+  }
+  class WebGLBlendModeConverter {
+    static ZERO: number
+    static ONE: number
+    static SRC_COLOR: number
+    static ONE_MINUS_SRC_COLOR: number
+    static SRC_ALPHA: number
+    static ONE_MINUS_SRC_ALPHA: number
+    static DST_ALPHA: number
+    static ONE_MINUS_DST_ALPHA: number
+    static DST_COLOR: number
+    static getDestGLBlendMode(blendMode: BlendMode): number
+    static getSourceGLBlendMode(blendMode: BlendMode, premultipliedAlpha?: boolean): number
+  }
 }
diff --git a/src/types/spine/spine.d.ts b/src/types/spine/spine.d.ts
index 5de191a..5bbd549 100644
--- a/src/types/spine/spine.d.ts
+++ b/src/types/spine/spine.d.ts
@@ -1,11 +1,11 @@
 declare module spine {
   class Animation {
-    name: string;
-    timelines: Array<Timeline>;
-    timelineIds: Array<boolean>;
-    duration: number;
-    constructor(name: string, timelines: Array<Timeline>, duration: number);
-    hasTimeline(id: number): boolean;
+    name: string
+    timelines: Array<Timeline>
+    timelineIds: Array<boolean>
+    duration: number
+    constructor(name: string, timelines: Array<Timeline>, duration: number)
+    hasTimeline(id: number): boolean
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -14,18 +14,10 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
-    static binarySearch(
-      values: ArrayLike<number>,
-      target: number,
-      step?: number
-    ): number;
-    static linearSearch(
-      values: ArrayLike<number>,
-      target: number,
-      step: number
-    ): number;
+      direction: MixDirection,
+    ): void
+    static binarySearch(values: ArrayLike<number>, target: number, step?: number): number
+    static linearSearch(values: ArrayLike<number>, target: number, step: number): number
   }
   interface Timeline {
     apply(
@@ -35,9 +27,9 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
-    getPropertyId(): number;
+      direction: MixDirection,
+    ): void
+    getPropertyId(): number
   }
   enum MixBlend {
     setup = 0,
@@ -67,25 +59,19 @@ declare module spine {
     twoColor = 14,
   }
   abstract class CurveTimeline implements Timeline {
-    static LINEAR: number;
-    static STEPPED: number;
-    static BEZIER: number;
-    static BEZIER_SIZE: number;
-    private curves;
-    abstract getPropertyId(): number;
-    constructor(frameCount: number);
-    getFrameCount(): number;
-    setLinear(frameIndex: number): void;
-    setStepped(frameIndex: number): void;
-    getCurveType(frameIndex: number): number;
-    setCurve(
-      frameIndex: number,
-      cx1: number,
-      cy1: number,
-      cx2: number,
-      cy2: number
-    ): void;
-    getCurvePercent(frameIndex: number, percent: number): number;
+    static LINEAR: number
+    static STEPPED: number
+    static BEZIER: number
+    static BEZIER_SIZE: number
+    private curves
+    abstract getPropertyId(): number
+    constructor(frameCount: number)
+    getFrameCount(): number
+    setLinear(frameIndex: number): void
+    setStepped(frameIndex: number): void
+    getCurveType(frameIndex: number): number
+    setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void
+    getCurvePercent(frameIndex: number, percent: number): number
     abstract apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -93,19 +79,19 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class RotateTimeline extends CurveTimeline {
-    static ENTRIES: number;
-    static PREV_TIME: number;
-    static PREV_ROTATION: number;
-    static ROTATION: number;
-    boneIndex: number;
-    frames: ArrayLike<number>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    setFrame(frameIndex: number, time: number, degrees: number): void;
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATION: number
+    static ROTATION: number
+    boneIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, degrees: number): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -113,21 +99,21 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class TranslateTimeline extends CurveTimeline {
-    static ENTRIES: number;
-    static PREV_TIME: number;
-    static PREV_X: number;
-    static PREV_Y: number;
-    static X: number;
-    static Y: number;
-    boneIndex: number;
-    frames: ArrayLike<number>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    setFrame(frameIndex: number, time: number, x: number, y: number): void;
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_X: number
+    static PREV_Y: number
+    static X: number
+    static Y: number
+    boneIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, x: number, y: number): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -135,12 +121,12 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class ScaleTimeline extends TranslateTimeline {
-    constructor(frameCount: number);
-    getPropertyId(): number;
+    constructor(frameCount: number)
+    getPropertyId(): number
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -148,12 +134,12 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class ShearTimeline extends TranslateTimeline {
-    constructor(frameCount: number);
-    getPropertyId(): number;
+    constructor(frameCount: number)
+    getPropertyId(): number
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -161,32 +147,25 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class ColorTimeline extends CurveTimeline {
-    static ENTRIES: number;
-    static PREV_TIME: number;
-    static PREV_R: number;
-    static PREV_G: number;
-    static PREV_B: number;
-    static PREV_A: number;
-    static R: number;
-    static G: number;
-    static B: number;
-    static A: number;
-    slotIndex: number;
-    frames: ArrayLike<number>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    setFrame(
-      frameIndex: number,
-      time: number,
-      r: number,
-      g: number,
-      b: number,
-      a: number
-    ): void;
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_R: number
+    static PREV_G: number
+    static PREV_B: number
+    static PREV_A: number
+    static R: number
+    static G: number
+    static B: number
+    static A: number
+    slotIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -194,30 +173,30 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class TwoColorTimeline extends CurveTimeline {
-    static ENTRIES: number;
-    static PREV_TIME: number;
-    static PREV_R: number;
-    static PREV_G: number;
-    static PREV_B: number;
-    static PREV_A: number;
-    static PREV_R2: number;
-    static PREV_G2: number;
-    static PREV_B2: number;
-    static R: number;
-    static G: number;
-    static B: number;
-    static A: number;
-    static R2: number;
-    static G2: number;
-    static B2: number;
-    slotIndex: number;
-    frames: ArrayLike<number>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_R: number
+    static PREV_G: number
+    static PREV_B: number
+    static PREV_A: number
+    static PREV_R2: number
+    static PREV_G2: number
+    static PREV_B2: number
+    static R: number
+    static G: number
+    static B: number
+    static A: number
+    static R2: number
+    static G2: number
+    static B2: number
+    slotIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
     setFrame(
       frameIndex: number,
       time: number,
@@ -227,8 +206,8 @@ declare module spine {
       a: number,
       r2: number,
       g2: number,
-      b2: number
-    ): void;
+      b2: number,
+    ): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -236,17 +215,17 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class AttachmentTimeline implements Timeline {
-    slotIndex: number;
-    frames: ArrayLike<number>;
-    attachmentNames: Array<string>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    getFrameCount(): number;
-    setFrame(frameIndex: number, time: number, attachmentName: string): void;
+    slotIndex: number
+    frames: ArrayLike<number>
+    attachmentNames: Array<string>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, time: number, attachmentName: string): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -254,21 +233,17 @@ declare module spine {
       events: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class DeformTimeline extends CurveTimeline {
-    slotIndex: number;
-    attachment: VertexAttachment;
-    frames: ArrayLike<number>;
-    frameVertices: Array<ArrayLike<number>>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    setFrame(
-      frameIndex: number,
-      time: number,
-      vertices: ArrayLike<number>
-    ): void;
+    slotIndex: number
+    attachment: VertexAttachment
+    frames: ArrayLike<number>
+    frameVertices: Array<ArrayLike<number>>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -276,16 +251,16 @@ declare module spine {
       firedEvents: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class EventTimeline implements Timeline {
-    frames: ArrayLike<number>;
-    events: Array<Event>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    getFrameCount(): number;
-    setFrame(frameIndex: number, event: Event): void;
+    frames: ArrayLike<number>
+    events: Array<Event>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, event: Event): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -293,16 +268,16 @@ declare module spine {
       firedEvents: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class DrawOrderTimeline implements Timeline {
-    frames: ArrayLike<number>;
-    drawOrders: Array<Array<number>>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    getFrameCount(): number;
-    setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
+    frames: ArrayLike<number>
+    drawOrders: Array<Array<number>>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    getFrameCount(): number
+    setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -310,26 +285,26 @@ declare module spine {
       firedEvents: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class IkConstraintTimeline extends CurveTimeline {
-    static ENTRIES: number;
-    static PREV_TIME: number;
-    static PREV_MIX: number;
-    static PREV_SOFTNESS: number;
-    static PREV_BEND_DIRECTION: number;
-    static PREV_COMPRESS: number;
-    static PREV_STRETCH: number;
-    static MIX: number;
-    static SOFTNESS: number;
-    static BEND_DIRECTION: number;
-    static COMPRESS: number;
-    static STRETCH: number;
-    ikConstraintIndex: number;
-    frames: ArrayLike<number>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_MIX: number
+    static PREV_SOFTNESS: number
+    static PREV_BEND_DIRECTION: number
+    static PREV_COMPRESS: number
+    static PREV_STRETCH: number
+    static MIX: number
+    static SOFTNESS: number
+    static BEND_DIRECTION: number
+    static COMPRESS: number
+    static STRETCH: number
+    ikConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
     setFrame(
       frameIndex: number,
       time: number,
@@ -337,8 +312,8 @@ declare module spine {
       softness: number,
       bendDirection: number,
       compress: boolean,
-      stretch: boolean
-    ): void;
+      stretch: boolean,
+    ): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -346,32 +321,32 @@ declare module spine {
       firedEvents: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class TransformConstraintTimeline extends CurveTimeline {
-    static ENTRIES: number;
-    static PREV_TIME: number;
-    static PREV_ROTATE: number;
-    static PREV_TRANSLATE: number;
-    static PREV_SCALE: number;
-    static PREV_SHEAR: number;
-    static ROTATE: number;
-    static TRANSLATE: number;
-    static SCALE: number;
-    static SHEAR: number;
-    transformConstraintIndex: number;
-    frames: ArrayLike<number>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATE: number
+    static PREV_TRANSLATE: number
+    static PREV_SCALE: number
+    static PREV_SHEAR: number
+    static ROTATE: number
+    static TRANSLATE: number
+    static SCALE: number
+    static SHEAR: number
+    transformConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
     setFrame(
       frameIndex: number,
       time: number,
       rotateMix: number,
       translateMix: number,
       scaleMix: number,
-      shearMix: number
-    ): void;
+      shearMix: number,
+    ): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -379,19 +354,19 @@ declare module spine {
       firedEvents: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class PathConstraintPositionTimeline extends CurveTimeline {
-    static ENTRIES: number;
-    static PREV_TIME: number;
-    static PREV_VALUE: number;
-    static VALUE: number;
-    pathConstraintIndex: number;
-    frames: ArrayLike<number>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    setFrame(frameIndex: number, time: number, value: number): void;
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_VALUE: number
+    static VALUE: number
+    pathConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, value: number): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -399,12 +374,12 @@ declare module spine {
       firedEvents: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
-    constructor(frameCount: number);
-    getPropertyId(): number;
+    constructor(frameCount: number)
+    getPropertyId(): number
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -412,26 +387,21 @@ declare module spine {
       firedEvents: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
   class PathConstraintMixTimeline extends CurveTimeline {
-    static ENTRIES: number;
-    static PREV_TIME: number;
-    static PREV_ROTATE: number;
-    static PREV_TRANSLATE: number;
-    static ROTATE: number;
-    static TRANSLATE: number;
-    pathConstraintIndex: number;
-    frames: ArrayLike<number>;
-    constructor(frameCount: number);
-    getPropertyId(): number;
-    setFrame(
-      frameIndex: number,
-      time: number,
-      rotateMix: number,
-      translateMix: number
-    ): void;
+    static ENTRIES: number
+    static PREV_TIME: number
+    static PREV_ROTATE: number
+    static PREV_TRANSLATE: number
+    static ROTATE: number
+    static TRANSLATE: number
+    pathConstraintIndex: number
+    frames: ArrayLike<number>
+    constructor(frameCount: number)
+    getPropertyId(): number
+    setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void
     apply(
       skeleton: Skeleton,
       lastTime: number,
@@ -439,36 +409,32 @@ declare module spine {
       firedEvents: Array<Event>,
       alpha: number,
       blend: MixBlend,
-      direction: MixDirection
-    ): void;
+      direction: MixDirection,
+    ): void
   }
 }
 declare module spine {
   class AnimationState {
-    static emptyAnimation: Animation;
-    static SUBSEQUENT: number;
-    static FIRST: number;
-    static HOLD: number;
-    static HOLD_MIX: number;
-    static NOT_LAST: number;
-    data: AnimationStateData;
-    tracks: TrackEntry[];
-    events: Event[];
-    listeners: AnimationStateListener2[];
-    queue: EventQueue;
-    propertyIDs: IntSet;
-    animationsChanged: boolean;
-    timeScale: number;
-    trackEntryPool: Pool<TrackEntry>;
-    constructor(data: AnimationStateData);
-    update(delta: number): void;
-    updateMixingFrom(to: TrackEntry, delta: number): boolean;
-    apply(skeleton: Skeleton): boolean;
-    applyMixingFrom(
-      to: TrackEntry,
-      skeleton: Skeleton,
-      blend: MixBlend
-    ): number;
+    static emptyAnimation: Animation
+    static SUBSEQUENT: number
+    static FIRST: number
+    static HOLD: number
+    static HOLD_MIX: number
+    static NOT_LAST: number
+    data: AnimationStateData
+    tracks: TrackEntry[]
+    events: Event[]
+    listeners: AnimationStateListener2[]
+    queue: EventQueue
+    propertyIDs: IntSet
+    animationsChanged: boolean
+    timeScale: number
+    trackEntryPool: Pool<TrackEntry>
+    constructor(data: AnimationStateData)
+    update(delta: number): void
+    updateMixingFrom(to: TrackEntry, delta: number): boolean
+    apply(skeleton: Skeleton): boolean
+    applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number
     applyRotateTimeline(
       timeline: Timeline,
       skeleton: Skeleton,
@@ -477,120 +443,108 @@ declare module spine {
       blend: MixBlend,
       timelinesRotation: Array<number>,
       i: number,
-      firstFrame: boolean
-    ): void;
-    queueEvents(entry: TrackEntry, animationTime: number): void;
-    clearTracks(): void;
-    clearTrack(trackIndex: number): void;
-    setCurrent(index: number, current: TrackEntry, interrupt: boolean): void;
-    setAnimation(
-      trackIndex: number,
-      animationName: string,
-      loop: boolean
-    ): TrackEntry;
-    setAnimationWith(
-      trackIndex: number,
-      animation: Animation,
-      loop: boolean
-    ): TrackEntry;
+      firstFrame: boolean,
+    ): void
+    queueEvents(entry: TrackEntry, animationTime: number): void
+    clearTracks(): void
+    clearTrack(trackIndex: number): void
+    setCurrent(index: number, current: TrackEntry, interrupt: boolean): void
+    setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry
+    setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry
     addAnimation(
       trackIndex: number,
       animationName: string,
       loop: boolean,
-      delay: number
-    ): TrackEntry;
+      delay: number,
+    ): TrackEntry
     addAnimationWith(
       trackIndex: number,
       animation: Animation,
       loop: boolean,
-      delay: number
-    ): TrackEntry;
-    setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
-    addEmptyAnimation(
-      trackIndex: number,
-      mixDuration: number,
-      delay: number
-    ): TrackEntry;
-    setEmptyAnimations(mixDuration: number): void;
-    expandToIndex(index: number): TrackEntry;
+      delay: number,
+    ): TrackEntry
+    setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry
+    addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry
+    setEmptyAnimations(mixDuration: number): void
+    expandToIndex(index: number): TrackEntry
     trackEntry(
       trackIndex: number,
       animation: Animation,
       loop: boolean,
-      last: TrackEntry
-    ): TrackEntry;
-    disposeNext(entry: TrackEntry): void;
-    _animationsChanged(): void;
-    computeHold(entry: TrackEntry): void;
-    computeNotLast(entry: TrackEntry): void;
-    getCurrent(trackIndex: number): TrackEntry;
+      last: TrackEntry,
+    ): TrackEntry
+    disposeNext(entry: TrackEntry): void
+    _animationsChanged(): void
+    computeHold(entry: TrackEntry): void
+    computeNotLast(entry: TrackEntry): void
+    getCurrent(trackIndex: number): TrackEntry
     addListener(
       listener:
         | AnimationStateListener2
         | {
-            complete?: (trackIndex: number, loopCount: number) => void;
-          }
-    ): void;
+            complete?: (trackIndex: number, loopCount: number) => void
+          },
+    ): void
     removeListener(
       listener:
         | AnimationStateListener2
         | {
-            complete?: (trackIndex: number, loopCount: number) => void;
-          }
-    ): void;
-    clearListeners(): void;
-    clearListenerNotifications(): void;
+            complete?: (trackIndex: number, loopCount: number) => void
+          },
+    ): void
+    clearListeners(): void
+    clearListenerNotifications(): void
   }
   class TrackEntry {
-    animation: Animation;
-    next: TrackEntry;
-    mixingFrom: TrackEntry;
-    mixingTo: TrackEntry;
-    listener: AnimationStateListener2;
-    trackIndex: number;
-    loop: boolean;
-    holdPrevious: boolean;
-    eventThreshold: number;
-    attachmentThreshold: number;
-    drawOrderThreshold: number;
-    animationStart: number;
-    animationEnd: number;
-    animationLast: number;
-    nextAnimationLast: number;
-    delay: number;
-    trackTime: number;
-    trackLast: number;
-    nextTrackLast: number;
-    trackEnd: number;
-    timeScale: number;
-    alpha: number;
-    mixTime: number;
-    mixDuration: number;
-    interruptAlpha: number;
-    totalAlpha: number;
-    mixBlend: MixBlend;
-    timelineMode: number[];
-    timelineHoldMix: TrackEntry[];
-    timelinesRotation: number[];
-    reset(): void;
-    getAnimationTime(): number;
-    setAnimationLast(animationLast: number): void;
-    isComplete(): boolean;
-    resetRotationDirections(): void;
+    animation: Animation
+    next: TrackEntry
+    mixingFrom: TrackEntry
+    mixingTo: TrackEntry
+    listener: AnimationStateListener2
+    trackIndex: number
+    loop: boolean
+    holdPrevious: boolean
+    eventThreshold: number
+    attachmentThreshold: number
+    drawOrderThreshold: number
+    animationStart: number
+    animationEnd: number
+    animationLast: number
+    nextAnimationLast: number
+    delay: number
+    trackTime: number
+    trackLast: number
+    nextTrackLast: number
+    trackEnd: number
+    timeScale: number
+    alpha: number
+    mixTime: number
+    mixDuration: number
+    interruptAlpha: number
+    totalAlpha: number
+    mixBlend: MixBlend
+    timelineMode: number[]
+    timelineHoldMix: TrackEntry[]
+    timelinesRotation: number[]
+    reset(): void
+    getAnimationTime(): number
+    setAnimationLast(animationLast: number): void
+    isComplete(): boolean
+    resetRotationDirections(): void
   }
   class EventQueue {
-    objects: Array<any>;
-    drainDisabled: boolean;
-    animState: AnimationState;
-    constructor(animState: AnimationState);
-    start(entry: TrackEntry): void;
-    interrupt(entry: TrackEntry): void;
-    end(entry: TrackEntry): void;
-    dispose(entry: TrackEntry): void;
-    complete(entry: TrackEntry): void;
-    event(entry: TrackEntry, event: Event): void;
-    drain(): void;
-    clear(): void;
+    objects: Array<any>
+    drainDisabled: boolean
+    animState: AnimationState
+    constructor(animState: AnimationState)
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
+    drain(): void
+    clear(): void
   }
   enum EventType {
     start = 0,
@@ -601,98 +555,91 @@ declare module spine {
     event = 5,
   }
   interface AnimationStateListener2 {
-    start(entry: TrackEntry): void;
-    interrupt(entry: TrackEntry): void;
-    end(entry: TrackEntry): void;
-    dispose(entry: TrackEntry): void;
-    complete(entry: TrackEntry): void;
-    event(entry: TrackEntry, event: Event): void;
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
   }
   abstract class AnimationStateAdapter2 implements AnimationStateListener2 {
-    start(entry: TrackEntry): void;
-    interrupt(entry: TrackEntry): void;
-    end(entry: TrackEntry): void;
-    dispose(entry: TrackEntry): void;
-    complete(entry: TrackEntry): void;
-    event(entry: TrackEntry, event: Event): void;
+    start(entry: TrackEntry): void
+    interrupt(entry: TrackEntry): void
+    end(entry: TrackEntry): void
+    dispose(entry: TrackEntry): void
+    complete(entry: TrackEntry): void
+    event(entry: TrackEntry, event: Event): void
   }
 }
 declare module spine {
   class AnimationStateData {
-    skeletonData: SkeletonData;
-    animationToMixTime: Map<number>;
-    defaultMix: number;
-    constructor(skeletonData: SkeletonData);
-    setMix(fromName: string, toName: string, duration: number): void;
-    setMixWith(from: Animation, to: Animation, duration: number): void;
-    getMix(from: Animation, to: Animation): number;
+    skeletonData: SkeletonData
+    animationToMixTime: Map<number>
+    defaultMix: number
+    constructor(skeletonData: SkeletonData)
+    setMix(fromName: string, toName: string, duration: number): void
+    setMixWith(from: Animation, to: Animation, duration: number): void
+    getMix(from: Animation, to: Animation): number
   }
 }
 declare module spine {
   class AssetManager implements Disposable {
-    private pathPrefix;
-    private textureLoader;
-    private assets;
-    private errors;
-    private toLoad;
-    private loaded;
-    constructor(
-      textureLoader: (image: HTMLImageElement) => any,
-      pathPrefix?: string
-    );
-    private static downloadText;
-    private static downloadBinary;
+    private pathPrefix
+    private textureLoader
+    private assets
+    private errors
+    private toLoad
+    private loaded
+    constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string)
+    private static downloadText
+    private static downloadBinary
     loadBinary(
       path: string,
       success?: (path: string, binary: Uint8Array) => void,
-      error?: (path: string, error: string) => void
-    ): void;
+      error?: (path: string, error: string) => void,
+    ): void
     loadText(
       path: string,
       success?: (path: string, text: string) => void,
-      error?: (path: string, error: string) => void
-    ): void;
+      error?: (path: string, error: string) => void,
+    ): void
     loadTexture(
       path: string,
       success?: (path: string, image: HTMLImageElement) => void,
-      error?: (path: string, error: string) => void
-    ): void;
+      error?: (path: string, error: string) => void,
+    ): void
     loadTextureData(
       path: string,
       data: string,
       success?: (path: string, image: HTMLImageElement) => void,
-      error?: (path: string, error: string) => void
-    ): void;
+      error?: (path: string, error: string) => void,
+    ): void
     loadTextureAtlas(
       path: string,
       success?: (path: string, atlas: TextureAtlas) => void,
-      error?: (path: string, error: string) => void
-    ): void;
-    get(path: string): any;
-    remove(path: string): void;
-    removeAll(): void;
-    isLoadingComplete(): boolean;
-    getToLoad(): number;
-    getLoaded(): number;
-    dispose(): void;
-    hasErrors(): boolean;
-    getErrors(): Map<string>;
+      error?: (path: string, error: string) => void,
+    ): void
+    get(path: string): any
+    remove(path: string): void
+    removeAll(): void
+    isLoadingComplete(): boolean
+    getToLoad(): number
+    getLoaded(): number
+    dispose(): void
+    hasErrors(): boolean
+    getErrors(): Map<string>
   }
 }
 declare module spine {
   class AtlasAttachmentLoader implements AttachmentLoader {
-    atlas: TextureAtlas;
-    constructor(atlas: TextureAtlas);
-    newRegionAttachment(
-      skin: Skin,
-      name: string,
-      path: string
-    ): RegionAttachment;
-    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
-    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
-    newPathAttachment(skin: Skin, name: string): PathAttachment;
-    newPointAttachment(skin: Skin, name: string): PointAttachment;
-    newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
+    atlas: TextureAtlas
+    constructor(atlas: TextureAtlas)
+    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment
+    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment
+    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment
+    newPathAttachment(skin: Skin, name: string): PathAttachment
+    newPointAttachment(skin: Skin, name: string): PointAttachment
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment
   }
 }
 declare module spine {
@@ -705,37 +652,37 @@ declare module spine {
 }
 declare module spine {
   class Bone implements Updatable {
-    data: BoneData;
-    skeleton: Skeleton;
-    parent: Bone;
-    children: Bone[];
-    x: number;
-    y: number;
-    rotation: number;
-    scaleX: number;
-    scaleY: number;
-    shearX: number;
-    shearY: number;
-    ax: number;
-    ay: number;
-    arotation: number;
-    ascaleX: number;
-    ascaleY: number;
-    ashearX: number;
-    ashearY: number;
-    appliedValid: boolean;
-    a: number;
-    b: number;
-    worldX: number;
-    c: number;
-    d: number;
-    worldY: number;
-    sorted: boolean;
-    active: boolean;
-    constructor(data: BoneData, skeleton: Skeleton, parent: Bone);
-    isActive(): boolean;
-    update(): void;
-    updateWorldTransform(): void;
+    data: BoneData
+    skeleton: Skeleton
+    parent: Bone
+    children: Bone[]
+    x: number
+    y: number
+    rotation: number
+    scaleX: number
+    scaleY: number
+    shearX: number
+    shearY: number
+    ax: number
+    ay: number
+    arotation: number
+    ascaleX: number
+    ascaleY: number
+    ashearX: number
+    ashearY: number
+    appliedValid: boolean
+    a: number
+    b: number
+    worldX: number
+    c: number
+    d: number
+    worldY: number
+    sorted: boolean
+    active: boolean
+    constructor(data: BoneData, skeleton: Skeleton, parent: Bone)
+    isActive(): boolean
+    update(): void
+    updateWorldTransform(): void
     updateWorldTransformWith(
       x: number,
       y: number,
@@ -743,38 +690,38 @@ declare module spine {
       scaleX: number,
       scaleY: number,
       shearX: number,
-      shearY: number
-    ): void;
-    setToSetupPose(): void;
-    getWorldRotationX(): number;
-    getWorldRotationY(): number;
-    getWorldScaleX(): number;
-    getWorldScaleY(): number;
-    updateAppliedTransform(): void;
-    worldToLocal(world: Vector2): Vector2;
-    localToWorld(local: Vector2): Vector2;
-    worldToLocalRotation(worldRotation: number): number;
-    localToWorldRotation(localRotation: number): number;
-    rotateWorld(degrees: number): void;
+      shearY: number,
+    ): void
+    setToSetupPose(): void
+    getWorldRotationX(): number
+    getWorldRotationY(): number
+    getWorldScaleX(): number
+    getWorldScaleY(): number
+    updateAppliedTransform(): void
+    worldToLocal(world: Vector2): Vector2
+    localToWorld(local: Vector2): Vector2
+    worldToLocalRotation(worldRotation: number): number
+    localToWorldRotation(localRotation: number): number
+    rotateWorld(degrees: number): void
   }
 }
 declare module spine {
   class BoneData {
-    index: number;
-    name: string;
-    parent: BoneData;
-    length: number;
-    x: number;
-    y: number;
-    rotation: number;
-    scaleX: number;
-    scaleY: number;
-    shearX: number;
-    shearY: number;
-    transformMode: TransformMode;
-    skinRequired: boolean;
-    color: Color;
-    constructor(index: number, name: string, parent: BoneData);
+    index: number
+    name: string
+    parent: BoneData
+    length: number
+    x: number
+    y: number
+    rotation: number
+    scaleX: number
+    scaleY: number
+    shearX: number
+    shearY: number
+    transformMode: TransformMode
+    skinRequired: boolean
+    color: Color
+    constructor(index: number, name: string, parent: BoneData)
   }
   enum TransformMode {
     Normal = 0,
@@ -786,51 +733,51 @@ declare module spine {
 }
 declare module spine {
   abstract class ConstraintData {
-    name: string;
-    order: number;
-    skinRequired: boolean;
-    constructor(name: string, order: number, skinRequired: boolean);
+    name: string
+    order: number
+    skinRequired: boolean
+    constructor(name: string, order: number, skinRequired: boolean)
   }
 }
 declare module spine {
   class Event {
-    data: EventData;
-    intValue: number;
-    floatValue: number;
-    stringValue: string;
-    time: number;
-    volume: number;
-    balance: number;
-    constructor(time: number, data: EventData);
+    data: EventData
+    intValue: number
+    floatValue: number
+    stringValue: string
+    time: number
+    volume: number
+    balance: number
+    constructor(time: number, data: EventData)
   }
 }
 declare module spine {
   class EventData {
-    name: string;
-    intValue: number;
-    floatValue: number;
-    stringValue: string;
-    audioPath: string;
-    volume: number;
-    balance: number;
-    constructor(name: string);
+    name: string
+    intValue: number
+    floatValue: number
+    stringValue: string
+    audioPath: string
+    volume: number
+    balance: number
+    constructor(name: string)
   }
 }
 declare module spine {
   class IkConstraint implements Updatable {
-    data: IkConstraintData;
-    bones: Array<Bone>;
-    target: Bone;
-    bendDirection: number;
-    compress: boolean;
-    stretch: boolean;
-    mix: number;
-    softness: number;
-    active: boolean;
-    constructor(data: IkConstraintData, skeleton: Skeleton);
-    isActive(): boolean;
-    apply(): void;
-    update(): void;
+    data: IkConstraintData
+    bones: Array<Bone>
+    target: Bone
+    bendDirection: number
+    compress: boolean
+    stretch: boolean
+    mix: number
+    softness: number
+    active: boolean
+    constructor(data: IkConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
     apply1(
       bone: Bone,
       targetX: number,
@@ -838,8 +785,8 @@ declare module spine {
       compress: boolean,
       stretch: boolean,
       uniform: boolean,
-      alpha: number
-    ): void;
+      alpha: number,
+    ): void
     apply2(
       parent: Bone,
       child: Bone,
@@ -848,68 +795,62 @@ declare module spine {
       bendDir: number,
       stretch: boolean,
       softness: number,
-      alpha: number
-    ): void;
+      alpha: number,
+    ): void
   }
 }
 declare module spine {
   class IkConstraintData extends ConstraintData {
-    bones: BoneData[];
-    target: BoneData;
-    bendDirection: number;
-    compress: boolean;
-    stretch: boolean;
-    uniform: boolean;
-    mix: number;
-    softness: number;
-    constructor(name: string);
+    bones: BoneData[]
+    target: BoneData
+    bendDirection: number
+    compress: boolean
+    stretch: boolean
+    uniform: boolean
+    mix: number
+    softness: number
+    constructor(name: string)
   }
 }
 declare module spine {
   class PathConstraint implements Updatable {
-    static NONE: number;
-    static BEFORE: number;
-    static AFTER: number;
-    static epsilon: number;
-    data: PathConstraintData;
-    bones: Array<Bone>;
-    target: Slot;
-    position: number;
-    spacing: number;
-    rotateMix: number;
-    translateMix: number;
-    spaces: number[];
-    positions: number[];
-    world: number[];
-    curves: number[];
-    lengths: number[];
-    segments: number[];
-    active: boolean;
-    constructor(data: PathConstraintData, skeleton: Skeleton);
-    isActive(): boolean;
-    apply(): void;
-    update(): void;
+    static NONE: number
+    static BEFORE: number
+    static AFTER: number
+    static epsilon: number
+    data: PathConstraintData
+    bones: Array<Bone>
+    target: Slot
+    position: number
+    spacing: number
+    rotateMix: number
+    translateMix: number
+    spaces: number[]
+    positions: number[]
+    world: number[]
+    curves: number[]
+    lengths: number[]
+    segments: number[]
+    active: boolean
+    constructor(data: PathConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
     computeWorldPositions(
       path: PathAttachment,
       spacesCount: number,
       tangents: boolean,
       percentPosition: boolean,
-      percentSpacing: boolean
-    ): number[];
+      percentSpacing: boolean,
+    ): number[]
     addBeforePosition(
       p: number,
       temp: Array<number>,
       i: number,
       out: Array<number>,
-      o: number
-    ): void;
-    addAfterPosition(
-      p: number,
-      temp: Array<number>,
-      i: number,
-      out: Array<number>,
-      o: number
-    ): void;
+      o: number,
+    ): void
+    addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void
     addCurvePosition(
       p: number,
       x1: number,
@@ -922,23 +863,23 @@ declare module spine {
       y2: number,
       out: Array<number>,
       o: number,
-      tangents: boolean
-    ): void;
+      tangents: boolean,
+    ): void
   }
 }
 declare module spine {
   class PathConstraintData extends ConstraintData {
-    bones: BoneData[];
-    target: SlotData;
-    positionMode: PositionMode;
-    spacingMode: SpacingMode;
-    rotateMode: RotateMode;
-    offsetRotation: number;
-    position: number;
-    spacing: number;
-    rotateMix: number;
-    translateMix: number;
-    constructor(name: string);
+    bones: BoneData[]
+    target: SlotData
+    positionMode: PositionMode
+    spacingMode: SpacingMode
+    rotateMode: RotateMode
+    offsetRotation: number
+    position: number
+    spacing: number
+    rotateMix: number
+    translateMix: number
+    constructor(name: string)
   }
   enum PositionMode {
     Fixed = 0,
@@ -957,183 +898,162 @@ declare module spine {
 }
 declare module spine {
   class SharedAssetManager implements Disposable {
-    private pathPrefix;
-    private clientAssets;
-    private queuedAssets;
-    private rawAssets;
-    private errors;
-    constructor(pathPrefix?: string);
-    private queueAsset;
-    loadText(clientId: string, path: string): void;
-    loadJson(clientId: string, path: string): void;
+    private pathPrefix
+    private clientAssets
+    private queuedAssets
+    private rawAssets
+    private errors
+    constructor(pathPrefix?: string)
+    private queueAsset
+    loadText(clientId: string, path: string): void
+    loadJson(clientId: string, path: string): void
     loadTexture(
       clientId: string,
       textureLoader: (image: HTMLImageElement) => any,
-      path: string
-    ): void;
-    get(clientId: string, path: string): any;
-    private updateClientAssets;
-    isLoadingComplete(clientId: string): boolean;
-    dispose(): void;
-    hasErrors(): boolean;
-    getErrors(): Map<string>;
+      path: string,
+    ): void
+    get(clientId: string, path: string): any
+    private updateClientAssets
+    isLoadingComplete(clientId: string): boolean
+    dispose(): void
+    hasErrors(): boolean
+    getErrors(): Map<string>
   }
 }
 declare module spine {
   class Skeleton {
-    data: SkeletonData;
-    bones: Array<Bone>;
-    slots: Array<Slot>;
-    drawOrder: Array<Slot>;
-    ikConstraints: Array<IkConstraint>;
-    transformConstraints: Array<TransformConstraint>;
-    pathConstraints: Array<PathConstraint>;
-    _updateCache: Updatable[];
-    updateCacheReset: Updatable[];
-    skin: Skin;
-    color: Color;
-    time: number;
-    scaleX: number;
-    scaleY: number;
-    x: number;
-    y: number;
-    constructor(data: SkeletonData);
-    updateCache(): void;
-    sortIkConstraint(constraint: IkConstraint): void;
-    sortPathConstraint(constraint: PathConstraint): void;
-    sortTransformConstraint(constraint: TransformConstraint): void;
-    sortPathConstraintAttachment(
-      skin: Skin,
-      slotIndex: number,
-      slotBone: Bone
-    ): void;
-    sortPathConstraintAttachmentWith(
-      attachment: Attachment,
-      slotBone: Bone
-    ): void;
-    sortBone(bone: Bone): void;
-    sortReset(bones: Array<Bone>): void;
-    updateWorldTransform(): void;
-    setToSetupPose(): void;
-    setBonesToSetupPose(): void;
-    setSlotsToSetupPose(): void;
-    getRootBone(): Bone;
-    findBone(boneName: string): Bone;
-    findBoneIndex(boneName: string): number;
-    findSlot(slotName: string): Slot;
-    findSlotIndex(slotName: string): number;
-    setSkinByName(skinName: string): void;
-    setSkin(newSkin: Skin): void;
-    getAttachmentByName(slotName: string, attachmentName: string): Attachment;
-    getAttachment(slotIndex: number, attachmentName: string): Attachment;
-    setAttachment(slotName: string, attachmentName: string): void;
-    findIkConstraint(constraintName: string): IkConstraint;
-    findTransformConstraint(constraintName: string): TransformConstraint;
-    findPathConstraint(constraintName: string): PathConstraint;
-    getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
-    update(delta: number): void;
+    data: SkeletonData
+    bones: Array<Bone>
+    slots: Array<Slot>
+    drawOrder: Array<Slot>
+    ikConstraints: Array<IkConstraint>
+    transformConstraints: Array<TransformConstraint>
+    pathConstraints: Array<PathConstraint>
+    _updateCache: Updatable[]
+    updateCacheReset: Updatable[]
+    skin: Skin
+    color: Color
+    time: number
+    scaleX: number
+    scaleY: number
+    x: number
+    y: number
+    constructor(data: SkeletonData)
+    updateCache(): void
+    sortIkConstraint(constraint: IkConstraint): void
+    sortPathConstraint(constraint: PathConstraint): void
+    sortTransformConstraint(constraint: TransformConstraint): void
+    sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void
+    sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void
+    sortBone(bone: Bone): void
+    sortReset(bones: Array<Bone>): void
+    updateWorldTransform(): void
+    setToSetupPose(): void
+    setBonesToSetupPose(): void
+    setSlotsToSetupPose(): void
+    getRootBone(): Bone
+    findBone(boneName: string): Bone
+    findBoneIndex(boneName: string): number
+    findSlot(slotName: string): Slot
+    findSlotIndex(slotName: string): number
+    setSkinByName(skinName: string): void
+    setSkin(newSkin: Skin): void
+    getAttachmentByName(slotName: string, attachmentName: string): Attachment
+    getAttachment(slotIndex: number, attachmentName: string): Attachment
+    setAttachment(slotName: string, attachmentName: string): void
+    findIkConstraint(constraintName: string): IkConstraint
+    findTransformConstraint(constraintName: string): TransformConstraint
+    findPathConstraint(constraintName: string): PathConstraint
+    getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void
+    update(delta: number): void
   }
 }
 declare module spine {
   class SkeletonBinary {
-    static AttachmentTypeValues: number[];
-    static TransformModeValues: TransformMode[];
-    static PositionModeValues: PositionMode[];
-    static SpacingModeValues: SpacingMode[];
-    static RotateModeValues: RotateMode[];
-    static BlendModeValues: BlendMode[];
-    static BONE_ROTATE: number;
-    static BONE_TRANSLATE: number;
-    static BONE_SCALE: number;
-    static BONE_SHEAR: number;
-    static SLOT_ATTACHMENT: number;
-    static SLOT_COLOR: number;
-    static SLOT_TWO_COLOR: number;
-    static PATH_POSITION: number;
-    static PATH_SPACING: number;
-    static PATH_MIX: number;
-    static CURVE_LINEAR: number;
-    static CURVE_STEPPED: number;
-    static CURVE_BEZIER: number;
-    attachmentLoader: AttachmentLoader;
-    scale: number;
-    private linkedMeshes;
-    constructor(attachmentLoader: AttachmentLoader);
-    readSkeletonData(binary: Uint8Array): SkeletonData;
-    private readSkin;
-    private readAttachment;
-    private readVertices;
-    private readFloatArray;
-    private readShortArray;
-    private readAnimation;
-    private readCurve;
+    static AttachmentTypeValues: number[]
+    static TransformModeValues: TransformMode[]
+    static PositionModeValues: PositionMode[]
+    static SpacingModeValues: SpacingMode[]
+    static RotateModeValues: RotateMode[]
+    static BlendModeValues: BlendMode[]
+    static BONE_ROTATE: number
+    static BONE_TRANSLATE: number
+    static BONE_SCALE: number
+    static BONE_SHEAR: number
+    static SLOT_ATTACHMENT: number
+    static SLOT_COLOR: number
+    static SLOT_TWO_COLOR: number
+    static PATH_POSITION: number
+    static PATH_SPACING: number
+    static PATH_MIX: number
+    static CURVE_LINEAR: number
+    static CURVE_STEPPED: number
+    static CURVE_BEZIER: number
+    attachmentLoader: AttachmentLoader
+    scale: number
+    private linkedMeshes
+    constructor(attachmentLoader: AttachmentLoader)
+    readSkeletonData(binary: Uint8Array): SkeletonData
+    private readSkin
+    private readAttachment
+    private readVertices
+    private readFloatArray
+    private readShortArray
+    private readAnimation
+    private readCurve
     setCurve(
       timeline: CurveTimeline,
       frameIndex: number,
       cx1: number,
       cy1: number,
       cx2: number,
-      cy2: number
-    ): void;
+      cy2: number,
+    ): void
   }
 }
 declare module spine {
   class SkeletonBounds {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-    boundingBoxes: BoundingBoxAttachment[];
-    polygons: ArrayLike<number>[];
-    private polygonPool;
-    update(skeleton: Skeleton, updateAabb: boolean): void;
-    aabbCompute(): void;
-    aabbContainsPoint(x: number, y: number): boolean;
-    aabbIntersectsSegment(
-      x1: number,
-      y1: number,
-      x2: number,
-      y2: number
-    ): boolean;
-    aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
-    containsPoint(x: number, y: number): BoundingBoxAttachment;
-    containsPointPolygon(
-      polygon: ArrayLike<number>,
-      x: number,
-      y: number
-    ): boolean;
-    intersectsSegment(
-      x1: number,
-      y1: number,
-      x2: number,
-      y2: number
-    ): BoundingBoxAttachment;
+    minX: number
+    minY: number
+    maxX: number
+    maxY: number
+    boundingBoxes: BoundingBoxAttachment[]
+    polygons: ArrayLike<number>[]
+    private polygonPool
+    update(skeleton: Skeleton, updateAabb: boolean): void
+    aabbCompute(): void
+    aabbContainsPoint(x: number, y: number): boolean
+    aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean
+    aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean
+    containsPoint(x: number, y: number): BoundingBoxAttachment
+    containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean
+    intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment
     intersectsSegmentPolygon(
       polygon: ArrayLike<number>,
       x1: number,
       y1: number,
       x2: number,
-      y2: number
-    ): boolean;
-    getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>;
-    getWidth(): number;
-    getHeight(): number;
+      y2: number,
+    ): boolean
+    getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>
+    getWidth(): number
+    getHeight(): number
   }
 }
 declare module spine {
   class SkeletonClipping {
-    private triangulator;
-    private clippingPolygon;
-    private clipOutput;
-    clippedVertices: number[];
-    clippedTriangles: number[];
-    private scratch;
-    private clipAttachment;
-    private clippingPolygons;
-    clipStart(slot: Slot, clip: ClippingAttachment): number;
-    clipEndWithSlot(slot: Slot): void;
-    clipEnd(): void;
-    isClipping(): boolean;
+    private triangulator
+    private clippingPolygon
+    private clipOutput
+    clippedVertices: number[]
+    clippedTriangles: number[]
+    private scratch
+    private clipAttachment
+    private clippingPolygons
+    clipStart(slot: Slot, clip: ClippingAttachment): number
+    clipEndWithSlot(slot: Slot): void
+    clipEnd(): void
+    isClipping(): boolean
     clipTriangles(
       vertices: ArrayLike<number>,
       verticesLength: number,
@@ -1142,8 +1062,8 @@ declare module spine {
       uvs: ArrayLike<number>,
       light: Color,
       dark: Color,
-      twoColor: boolean
-    ): void;
+      twoColor: boolean,
+    ): void
     clip(
       x1: number,
       y1: number,
@@ -1152,147 +1072,133 @@ declare module spine {
       x3: number,
       y3: number,
       clippingArea: Array<number>,
-      output: Array<number>
-    ): boolean;
-    static makeClockwise(polygon: ArrayLike<number>): void;
+      output: Array<number>,
+    ): boolean
+    static makeClockwise(polygon: ArrayLike<number>): void
   }
 }
 declare module spine {
   class SkeletonData {
-    name: string;
-    bones: BoneData[];
-    slots: SlotData[];
-    skins: Skin[];
-    defaultSkin: Skin;
-    events: EventData[];
-    animations: Animation[];
-    ikConstraints: IkConstraintData[];
-    transformConstraints: TransformConstraintData[];
-    pathConstraints: PathConstraintData[];
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    version: string;
-    hash: string;
-    fps: number;
-    imagesPath: string;
-    audioPath: string;
-    findBone(boneName: string): BoneData;
-    findBoneIndex(boneName: string): number;
-    findSlot(slotName: string): SlotData;
-    findSlotIndex(slotName: string): number;
-    findSkin(skinName: string): Skin;
-    findEvent(eventDataName: string): EventData;
-    findAnimation(animationName: string): Animation;
-    findIkConstraint(constraintName: string): IkConstraintData;
-    findTransformConstraint(constraintName: string): TransformConstraintData;
-    findPathConstraint(constraintName: string): PathConstraintData;
-    findPathConstraintIndex(pathConstraintName: string): number;
+    name: string
+    bones: BoneData[]
+    slots: SlotData[]
+    skins: Skin[]
+    defaultSkin: Skin
+    events: EventData[]
+    animations: Animation[]
+    ikConstraints: IkConstraintData[]
+    transformConstraints: TransformConstraintData[]
+    pathConstraints: PathConstraintData[]
+    x: number
+    y: number
+    width: number
+    height: number
+    version: string
+    hash: string
+    fps: number
+    imagesPath: string
+    audioPath: string
+    findBone(boneName: string): BoneData
+    findBoneIndex(boneName: string): number
+    findSlot(slotName: string): SlotData
+    findSlotIndex(slotName: string): number
+    findSkin(skinName: string): Skin
+    findEvent(eventDataName: string): EventData
+    findAnimation(animationName: string): Animation
+    findIkConstraint(constraintName: string): IkConstraintData
+    findTransformConstraint(constraintName: string): TransformConstraintData
+    findPathConstraint(constraintName: string): PathConstraintData
+    findPathConstraintIndex(pathConstraintName: string): number
   }
 }
 declare module spine {
   class SkeletonJson {
-    attachmentLoader: AttachmentLoader;
-    scale: number;
-    private linkedMeshes;
-    constructor(attachmentLoader: AttachmentLoader);
-    readSkeletonData(json: string | any): SkeletonData;
+    attachmentLoader: AttachmentLoader
+    scale: number
+    private linkedMeshes
+    constructor(attachmentLoader: AttachmentLoader)
+    readSkeletonData(json: string | any): SkeletonData
     readAttachment(
       map: any,
       skin: Skin,
       slotIndex: number,
       name: string,
-      skeletonData: SkeletonData
-    ): Attachment;
-    readVertices(
-      map: any,
-      attachment: VertexAttachment,
-      verticesLength: number
-    ): void;
-    readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
-    readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void;
-    getValue(map: any, prop: string, defaultValue: any): any;
-    static blendModeFromString(str: string): BlendMode;
-    static positionModeFromString(str: string): PositionMode;
-    static spacingModeFromString(str: string): SpacingMode;
-    static rotateModeFromString(str: string): RotateMode;
-    static transformModeFromString(str: string): TransformMode;
+      skeletonData: SkeletonData,
+    ): Attachment
+    readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void
+    readAnimation(map: any, name: string, skeletonData: SkeletonData): void
+    readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void
+    getValue(map: any, prop: string, defaultValue: any): any
+    static blendModeFromString(str: string): BlendMode
+    static positionModeFromString(str: string): PositionMode
+    static spacingModeFromString(str: string): SpacingMode
+    static rotateModeFromString(str: string): RotateMode
+    static transformModeFromString(str: string): TransformMode
   }
 }
 declare module spine {
   class SkinEntry {
-    slotIndex: number;
-    name: string;
-    attachment: Attachment;
-    constructor(slotIndex: number, name: string, attachment: Attachment);
+    slotIndex: number
+    name: string
+    attachment: Attachment
+    constructor(slotIndex: number, name: string, attachment: Attachment)
   }
   class Skin {
-    name: string;
-    attachments: Map<Attachment>[];
-    bones: BoneData[];
-    constraints: ConstraintData[];
-    constructor(name: string);
-    setAttachment(
-      slotIndex: number,
-      name: string,
-      attachment: Attachment
-    ): void;
-    addSkin(skin: Skin): void;
-    copySkin(skin: Skin): void;
-    getAttachment(slotIndex: number, name: string): Attachment;
-    removeAttachment(slotIndex: number, name: string): void;
-    getAttachments(): Array<SkinEntry>;
-    getAttachmentsForSlot(
-      slotIndex: number,
-      attachments: Array<SkinEntry>
-    ): void;
-    clear(): void;
-    attachAll(skeleton: Skeleton, oldSkin: Skin): void;
+    name: string
+    attachments: Map<Attachment>[]
+    bones: BoneData[]
+    constraints: ConstraintData[]
+    constructor(name: string)
+    setAttachment(slotIndex: number, name: string, attachment: Attachment): void
+    addSkin(skin: Skin): void
+    copySkin(skin: Skin): void
+    getAttachment(slotIndex: number, name: string): Attachment
+    removeAttachment(slotIndex: number, name: string): void
+    getAttachments(): Array<SkinEntry>
+    getAttachmentsForSlot(slotIndex: number, attachments: Array<SkinEntry>): void
+    clear(): void
+    attachAll(skeleton: Skeleton, oldSkin: Skin): void
   }
 }
 declare module spine {
   class Slot {
-    data: SlotData;
-    bone: Bone;
-    color: Color;
-    darkColor: Color;
-    private attachment;
-    private attachmentTime;
-    deform: number[];
-    constructor(data: SlotData, bone: Bone);
-    getAttachment(): Attachment;
-    setAttachment(attachment: Attachment): void;
-    setAttachmentTime(time: number): void;
-    getAttachmentTime(): number;
-    setToSetupPose(): void;
+    data: SlotData
+    bone: Bone
+    color: Color
+    darkColor: Color
+    private attachment
+    private attachmentTime
+    deform: number[]
+    constructor(data: SlotData, bone: Bone)
+    getAttachment(): Attachment
+    setAttachment(attachment: Attachment): void
+    setAttachmentTime(time: number): void
+    getAttachmentTime(): number
+    setToSetupPose(): void
   }
 }
 declare module spine {
   class SlotData {
-    index: number;
-    name: string;
-    boneData: BoneData;
-    color: Color;
-    darkColor: Color;
-    attachmentName: string;
-    blendMode: BlendMode;
-    constructor(index: number, name: string, boneData: BoneData);
+    index: number
+    name: string
+    boneData: BoneData
+    color: Color
+    darkColor: Color
+    attachmentName: string
+    blendMode: BlendMode
+    constructor(index: number, name: string, boneData: BoneData)
   }
 }
 declare module spine {
   abstract class Texture {
-    protected _image: HTMLImageElement;
-    constructor(image: HTMLImageElement);
-    getImage(): HTMLImageElement;
-    abstract setFilters(
-      minFilter: TextureFilter,
-      magFilter: TextureFilter
-    ): void;
-    abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-    abstract dispose(): void;
-    static filterFromString(text: string): TextureFilter;
-    static wrapFromString(text: string): TextureWrap;
+    protected _image: HTMLImageElement
+    constructor(image: HTMLImageElement)
+    getImage(): HTMLImageElement
+    abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    abstract dispose(): void
+    static filterFromString(text: string): TextureFilter
+    static wrapFromString(text: string): TextureWrap
   }
   enum TextureFilter {
     Nearest = 9728,
@@ -1309,309 +1215,290 @@ declare module spine {
     Repeat = 10497,
   }
   class TextureRegion {
-    renderObject: any;
-    u: number;
-    v: number;
-    u2: number;
-    v2: number;
-    width: number;
-    height: number;
-    rotate: boolean;
-    offsetX: number;
-    offsetY: number;
-    originalWidth: number;
-    originalHeight: number;
+    renderObject: any
+    u: number
+    v: number
+    u2: number
+    v2: number
+    width: number
+    height: number
+    rotate: boolean
+    offsetX: number
+    offsetY: number
+    originalWidth: number
+    originalHeight: number
   }
   class FakeTexture extends Texture {
-    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-    dispose(): void;
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    dispose(): void
   }
 }
 declare module spine {
   class TextureAtlas implements Disposable {
-    pages: TextureAtlasPage[];
-    regions: TextureAtlasRegion[];
-    constructor(atlasText: string, textureLoader: (path: string) => any);
-    private load;
-    findRegion(name: string): TextureAtlasRegion;
-    dispose(): void;
+    pages: TextureAtlasPage[]
+    regions: TextureAtlasRegion[]
+    constructor(atlasText: string, textureLoader: (path: string) => any)
+    private load
+    findRegion(name: string): TextureAtlasRegion
+    dispose(): void
   }
   class TextureAtlasPage {
-    name: string;
-    minFilter: TextureFilter;
-    magFilter: TextureFilter;
-    uWrap: TextureWrap;
-    vWrap: TextureWrap;
-    texture: Texture;
-    width: number;
-    height: number;
+    name: string
+    minFilter: TextureFilter
+    magFilter: TextureFilter
+    uWrap: TextureWrap
+    vWrap: TextureWrap
+    texture: Texture
+    width: number
+    height: number
   }
   class TextureAtlasRegion extends TextureRegion {
-    page: TextureAtlasPage;
-    name: string;
-    x: number;
-    y: number;
-    index: number;
-    rotate: boolean;
-    degrees: number;
-    texture: Texture;
+    page: TextureAtlasPage
+    name: string
+    x: number
+    y: number
+    index: number
+    rotate: boolean
+    degrees: number
+    texture: Texture
   }
 }
 declare module spine {
   class TransformConstraint implements Updatable {
-    data: TransformConstraintData;
-    bones: Array<Bone>;
-    target: Bone;
-    rotateMix: number;
-    translateMix: number;
-    scaleMix: number;
-    shearMix: number;
-    temp: Vector2;
-    active: boolean;
-    constructor(data: TransformConstraintData, skeleton: Skeleton);
-    isActive(): boolean;
-    apply(): void;
-    update(): void;
-    applyAbsoluteWorld(): void;
-    applyRelativeWorld(): void;
-    applyAbsoluteLocal(): void;
-    applyRelativeLocal(): void;
+    data: TransformConstraintData
+    bones: Array<Bone>
+    target: Bone
+    rotateMix: number
+    translateMix: number
+    scaleMix: number
+    shearMix: number
+    temp: Vector2
+    active: boolean
+    constructor(data: TransformConstraintData, skeleton: Skeleton)
+    isActive(): boolean
+    apply(): void
+    update(): void
+    applyAbsoluteWorld(): void
+    applyRelativeWorld(): void
+    applyAbsoluteLocal(): void
+    applyRelativeLocal(): void
   }
 }
 declare module spine {
   class TransformConstraintData extends ConstraintData {
-    bones: BoneData[];
-    target: BoneData;
-    rotateMix: number;
-    translateMix: number;
-    scaleMix: number;
-    shearMix: number;
-    offsetRotation: number;
-    offsetX: number;
-    offsetY: number;
-    offsetScaleX: number;
-    offsetScaleY: number;
-    offsetShearY: number;
-    relative: boolean;
-    local: boolean;
-    constructor(name: string);
+    bones: BoneData[]
+    target: BoneData
+    rotateMix: number
+    translateMix: number
+    scaleMix: number
+    shearMix: number
+    offsetRotation: number
+    offsetX: number
+    offsetY: number
+    offsetScaleX: number
+    offsetScaleY: number
+    offsetShearY: number
+    relative: boolean
+    local: boolean
+    constructor(name: string)
   }
 }
 declare module spine {
   class Triangulator {
-    private convexPolygons;
-    private convexPolygonsIndices;
-    private indicesArray;
-    private isConcaveArray;
-    private triangles;
-    private polygonPool;
-    private polygonIndicesPool;
-    triangulate(verticesArray: ArrayLike<number>): Array<number>;
-    decompose(
-      verticesArray: Array<number>,
-      triangles: Array<number>
-    ): Array<Array<number>>;
-    private static isConcave;
-    private static positiveArea;
-    private static winding;
+    private convexPolygons
+    private convexPolygonsIndices
+    private indicesArray
+    private isConcaveArray
+    private triangles
+    private polygonPool
+    private polygonIndicesPool
+    triangulate(verticesArray: ArrayLike<number>): Array<number>
+    decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>
+    private static isConcave
+    private static positiveArea
+    private static winding
   }
 }
 declare module spine {
   interface Updatable {
-    update(): void;
-    isActive(): boolean;
+    update(): void
+    isActive(): boolean
   }
 }
 declare module spine {
   interface Map<T> {
-    [key: string]: T;
+    [key: string]: T
   }
   class IntSet {
-    array: number[];
-    add(value: number): boolean;
-    contains(value: number): boolean;
-    remove(value: number): void;
-    clear(): void;
+    array: number[]
+    add(value: number): boolean
+    contains(value: number): boolean
+    remove(value: number): void
+    clear(): void
   }
   interface Disposable {
-    dispose(): void;
+    dispose(): void
   }
   interface Restorable {
-    restore(): void;
+    restore(): void
   }
   class Color {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-    static WHITE: Color;
-    static RED: Color;
-    static GREEN: Color;
-    static BLUE: Color;
-    static MAGENTA: Color;
-    constructor(r?: number, g?: number, b?: number, a?: number);
-    set(r: number, g: number, b: number, a: number): this;
-    setFromColor(c: Color): this;
-    setFromString(hex: string): this;
-    add(r: number, g: number, b: number, a: number): this;
-    clamp(): this;
-    static rgba8888ToColor(color: Color, value: number): void;
-    static rgb888ToColor(color: Color, value: number): void;
+    r: number
+    g: number
+    b: number
+    a: number
+    static WHITE: Color
+    static RED: Color
+    static GREEN: Color
+    static BLUE: Color
+    static MAGENTA: Color
+    constructor(r?: number, g?: number, b?: number, a?: number)
+    set(r: number, g: number, b: number, a: number): this
+    setFromColor(c: Color): this
+    setFromString(hex: string): this
+    add(r: number, g: number, b: number, a: number): this
+    clamp(): this
+    static rgba8888ToColor(color: Color, value: number): void
+    static rgb888ToColor(color: Color, value: number): void
   }
   class MathUtils {
-    static PI: number;
-    static PI2: number;
-    static radiansToDegrees: number;
-    static radDeg: number;
-    static degreesToRadians: number;
-    static degRad: number;
-    static clamp(value: number, min: number, max: number): number;
-    static cosDeg(degrees: number): number;
-    static sinDeg(degrees: number): number;
-    static signum(value: number): number;
-    static toInt(x: number): number;
-    static cbrt(x: number): number;
-    static randomTriangular(min: number, max: number): number;
-    static randomTriangularWith(min: number, max: number, mode: number): number;
+    static PI: number
+    static PI2: number
+    static radiansToDegrees: number
+    static radDeg: number
+    static degreesToRadians: number
+    static degRad: number
+    static clamp(value: number, min: number, max: number): number
+    static cosDeg(degrees: number): number
+    static sinDeg(degrees: number): number
+    static signum(value: number): number
+    static toInt(x: number): number
+    static cbrt(x: number): number
+    static randomTriangular(min: number, max: number): number
+    static randomTriangularWith(min: number, max: number, mode: number): number
   }
   abstract class Interpolation {
-    protected abstract applyInternal(a: number): number;
-    apply(start: number, end: number, a: number): number;
+    protected abstract applyInternal(a: number): number
+    apply(start: number, end: number, a: number): number
   }
   class Pow extends Interpolation {
-    protected power: number;
-    constructor(power: number);
-    applyInternal(a: number): number;
+    protected power: number
+    constructor(power: number)
+    applyInternal(a: number): number
   }
   class PowOut extends Pow {
-    constructor(power: number);
-    applyInternal(a: number): number;
+    constructor(power: number)
+    applyInternal(a: number): number
   }
   class Utils {
-    static SUPPORTS_TYPED_ARRAYS: boolean;
+    static SUPPORTS_TYPED_ARRAYS: boolean
     static arrayCopy<T>(
       source: ArrayLike<T>,
       sourceStart: number,
       dest: ArrayLike<T>,
       destStart: number,
-      numElements: number
-    ): void;
-    static setArraySize<T>(
-      array: Array<T>,
-      size: number,
-      value?: any
-    ): Array<T>;
-    static ensureArrayCapacity<T>(
-      array: Array<T>,
-      size: number,
-      value?: any
-    ): Array<T>;
-    static newArray<T>(size: number, defaultValue: T): Array<T>;
-    static newFloatArray(size: number): ArrayLike<number>;
-    static newShortArray(size: number): ArrayLike<number>;
-    static toFloatArray(array: Array<number>): number[] | Float32Array;
-    static toSinglePrecision(value: number): number;
-    static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
-    static contains<T>(
-      array: Array<T>,
-      element: T,
-      identity?: boolean
-    ): boolean;
+      numElements: number,
+    ): void
+    static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>
+    static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>
+    static newArray<T>(size: number, defaultValue: T): Array<T>
+    static newFloatArray(size: number): ArrayLike<number>
+    static newShortArray(size: number): ArrayLike<number>
+    static toFloatArray(array: Array<number>): number[] | Float32Array
+    static toSinglePrecision(value: number): number
+    static webkit602BugfixHelper(alpha: number, blend: MixBlend): void
+    static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean
   }
   class DebugUtils {
-    static logBones(skeleton: Skeleton): void;
+    static logBones(skeleton: Skeleton): void
   }
   class Pool<T> {
-    private items;
-    private instantiator;
-    constructor(instantiator: () => T);
-    obtain(): T;
-    free(item: T): void;
-    freeAll(items: ArrayLike<T>): void;
-    clear(): void;
+    private items
+    private instantiator
+    constructor(instantiator: () => T)
+    obtain(): T
+    free(item: T): void
+    freeAll(items: ArrayLike<T>): void
+    clear(): void
   }
   class Vector2 {
-    x: number;
-    y: number;
-    constructor(x?: number, y?: number);
-    set(x: number, y: number): Vector2;
-    length(): number;
-    normalize(): this;
+    x: number
+    y: number
+    constructor(x?: number, y?: number)
+    set(x: number, y: number): Vector2
+    length(): number
+    normalize(): this
   }
   class TimeKeeper {
-    maxDelta: number;
-    framesPerSecond: number;
-    delta: number;
-    totalTime: number;
-    private lastTime;
-    private frameCount;
-    private frameTime;
-    update(): void;
+    maxDelta: number
+    framesPerSecond: number
+    delta: number
+    totalTime: number
+    private lastTime
+    private frameCount
+    private frameTime
+    update(): void
   }
   interface ArrayLike<T> {
-    length: number;
-    [n: number]: T;
+    length: number
+    [n: number]: T
   }
   class WindowedMean {
-    values: Array<number>;
-    addedValues: number;
-    lastValue: number;
-    mean: number;
-    dirty: boolean;
-    constructor(windowSize?: number);
-    hasEnoughData(): boolean;
-    addValue(value: number): void;
-    getMean(): number;
+    values: Array<number>
+    addedValues: number
+    lastValue: number
+    mean: number
+    dirty: boolean
+    constructor(windowSize?: number)
+    hasEnoughData(): boolean
+    addValue(value: number): void
+    getMean(): number
   }
 }
 declare module spine {
   interface VertexEffect {
-    begin(skeleton: Skeleton): void;
-    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-    end(): void;
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
   }
 }
 interface Math {
-  fround(n: number): number;
+  fround(n: number): number
 }
 declare module spine {
   abstract class Attachment {
-    name: string;
-    constructor(name: string);
-    abstract copy(): Attachment;
+    name: string
+    constructor(name: string)
+    abstract copy(): Attachment
   }
   abstract class VertexAttachment extends Attachment {
-    private static nextID;
-    id: number;
-    bones: Array<number>;
-    vertices: ArrayLike<number>;
-    worldVerticesLength: number;
-    deformAttachment: VertexAttachment;
-    constructor(name: string);
+    private static nextID
+    id: number
+    bones: Array<number>
+    vertices: ArrayLike<number>
+    worldVerticesLength: number
+    deformAttachment: VertexAttachment
+    constructor(name: string)
     computeWorldVertices(
       slot: Slot,
       start: number,
       count: number,
       worldVertices: ArrayLike<number>,
       offset: number,
-      stride: number
-    ): void;
-    copyTo(attachment: VertexAttachment): void;
+      stride: number,
+    ): void
+    copyTo(attachment: VertexAttachment): void
   }
 }
 declare module spine {
   interface AttachmentLoader {
-    newRegionAttachment(
-      skin: Skin,
-      name: string,
-      path: string
-    ): RegionAttachment;
-    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
-    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
-    newPathAttachment(skin: Skin, name: string): PathAttachment;
-    newPointAttachment(skin: Skin, name: string): PointAttachment;
-    newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
+    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment
+    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment
+    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment
+    newPathAttachment(skin: Skin, name: string): PathAttachment
+    newPointAttachment(skin: Skin, name: string): PointAttachment
+    newClippingAttachment(skin: Skin, name: string): ClippingAttachment
   }
 }
 declare module spine {
@@ -1627,357 +1514,340 @@ declare module spine {
 }
 declare module spine {
   class BoundingBoxAttachment extends VertexAttachment {
-    color: Color;
-    constructor(name: string);
-    copy(): Attachment;
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
   }
 }
 declare module spine {
   class ClippingAttachment extends VertexAttachment {
-    endSlot: SlotData;
-    color: Color;
-    constructor(name: string);
-    copy(): Attachment;
+    endSlot: SlotData
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
   }
 }
 declare module spine {
   class MeshAttachment extends VertexAttachment {
-    region: TextureRegion;
-    path: string;
-    regionUVs: ArrayLike<number>;
-    uvs: ArrayLike<number>;
-    triangles: Array<number>;
-    color: Color;
-    width: number;
-    height: number;
-    hullLength: number;
-    edges: Array<number>;
-    private parentMesh;
-    tempColor: Color;
-    constructor(name: string);
-    updateUVs(): void;
-    getParentMesh(): MeshAttachment;
-    setParentMesh(parentMesh: MeshAttachment): void;
-    copy(): Attachment;
-    newLinkedMesh(): MeshAttachment;
+    region: TextureRegion
+    path: string
+    regionUVs: ArrayLike<number>
+    uvs: ArrayLike<number>
+    triangles: Array<number>
+    color: Color
+    width: number
+    height: number
+    hullLength: number
+    edges: Array<number>
+    private parentMesh
+    tempColor: Color
+    constructor(name: string)
+    updateUVs(): void
+    getParentMesh(): MeshAttachment
+    setParentMesh(parentMesh: MeshAttachment): void
+    copy(): Attachment
+    newLinkedMesh(): MeshAttachment
   }
 }
 declare module spine {
   class PathAttachment extends VertexAttachment {
-    lengths: Array<number>;
-    closed: boolean;
-    constantSpeed: boolean;
-    color: Color;
-    constructor(name: string);
-    copy(): Attachment;
+    lengths: Array<number>
+    closed: boolean
+    constantSpeed: boolean
+    color: Color
+    constructor(name: string)
+    copy(): Attachment
   }
 }
 declare module spine {
   class PointAttachment extends VertexAttachment {
-    x: number;
-    y: number;
-    rotation: number;
-    color: Color;
-    constructor(name: string);
-    computeWorldPosition(bone: Bone, point: Vector2): Vector2;
-    computeWorldRotation(bone: Bone): number;
-    copy(): Attachment;
+    x: number
+    y: number
+    rotation: number
+    color: Color
+    constructor(name: string)
+    computeWorldPosition(bone: Bone, point: Vector2): Vector2
+    computeWorldRotation(bone: Bone): number
+    copy(): Attachment
   }
 }
 declare module spine {
   class RegionAttachment extends Attachment {
-    static OX1: number;
-    static OY1: number;
-    static OX2: number;
-    static OY2: number;
-    static OX3: number;
-    static OY3: number;
-    static OX4: number;
-    static OY4: number;
-    static X1: number;
-    static Y1: number;
-    static C1R: number;
-    static C1G: number;
-    static C1B: number;
-    static C1A: number;
-    static U1: number;
-    static V1: number;
-    static X2: number;
-    static Y2: number;
-    static C2R: number;
-    static C2G: number;
-    static C2B: number;
-    static C2A: number;
-    static U2: number;
-    static V2: number;
-    static X3: number;
-    static Y3: number;
-    static C3R: number;
-    static C3G: number;
-    static C3B: number;
-    static C3A: number;
-    static U3: number;
-    static V3: number;
-    static X4: number;
-    static Y4: number;
-    static C4R: number;
-    static C4G: number;
-    static C4B: number;
-    static C4A: number;
-    static U4: number;
-    static V4: number;
-    x: number;
-    y: number;
-    scaleX: number;
-    scaleY: number;
-    rotation: number;
-    width: number;
-    height: number;
-    color: Color;
-    path: string;
-    rendererObject: any;
-    region: TextureRegion;
-    offset: ArrayLike<number>;
-    uvs: ArrayLike<number>;
-    tempColor: Color;
-    constructor(name: string);
-    updateOffset(): void;
-    setRegion(region: TextureRegion): void;
+    static OX1: number
+    static OY1: number
+    static OX2: number
+    static OY2: number
+    static OX3: number
+    static OY3: number
+    static OX4: number
+    static OY4: number
+    static X1: number
+    static Y1: number
+    static C1R: number
+    static C1G: number
+    static C1B: number
+    static C1A: number
+    static U1: number
+    static V1: number
+    static X2: number
+    static Y2: number
+    static C2R: number
+    static C2G: number
+    static C2B: number
+    static C2A: number
+    static U2: number
+    static V2: number
+    static X3: number
+    static Y3: number
+    static C3R: number
+    static C3G: number
+    static C3B: number
+    static C3A: number
+    static U3: number
+    static V3: number
+    static X4: number
+    static Y4: number
+    static C4R: number
+    static C4G: number
+    static C4B: number
+    static C4A: number
+    static U4: number
+    static V4: number
+    x: number
+    y: number
+    scaleX: number
+    scaleY: number
+    rotation: number
+    width: number
+    height: number
+    color: Color
+    path: string
+    rendererObject: any
+    region: TextureRegion
+    offset: ArrayLike<number>
+    uvs: ArrayLike<number>
+    tempColor: Color
+    constructor(name: string)
+    updateOffset(): void
+    setRegion(region: TextureRegion): void
     computeWorldVertices(
       bone: Bone,
       worldVertices: ArrayLike<number>,
       offset: number,
-      stride: number
-    ): void;
-    copy(): Attachment;
+      stride: number,
+    ): void
+    copy(): Attachment
   }
 }
 declare module spine {
   class JitterEffect implements VertexEffect {
-    jitterX: number;
-    jitterY: number;
-    constructor(jitterX: number, jitterY: number);
-    begin(skeleton: Skeleton): void;
-    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-    end(): void;
+    jitterX: number
+    jitterY: number
+    constructor(jitterX: number, jitterY: number)
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
   }
 }
 declare module spine {
   class SwirlEffect implements VertexEffect {
-    static interpolation: PowOut;
-    centerX: number;
-    centerY: number;
-    radius: number;
-    angle: number;
-    private worldX;
-    private worldY;
-    constructor(radius: number);
-    begin(skeleton: Skeleton): void;
-    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-    end(): void;
+    static interpolation: PowOut
+    centerX: number
+    centerY: number
+    radius: number
+    angle: number
+    private worldX
+    private worldY
+    constructor(radius: number)
+    begin(skeleton: Skeleton): void
+    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void
+    end(): void
   }
 }
 declare module spine.canvas {
   class AssetManager extends spine.AssetManager {
-    constructor(pathPrefix?: string);
+    constructor(pathPrefix?: string)
   }
 }
 declare module spine.canvas {
   class CanvasTexture extends Texture {
-    constructor(image: HTMLImageElement);
-    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-    dispose(): void;
+    constructor(image: HTMLImageElement)
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    dispose(): void
   }
 }
 declare module spine.canvas {
   class SkeletonRenderer {
-    static QUAD_TRIANGLES: number[];
-    static VERTEX_SIZE: number;
-    private ctx;
-    triangleRendering: boolean;
-    debugRendering: boolean;
-    private vertices;
-    private tempColor;
-    constructor(context: CanvasRenderingContext2D);
-    draw(skeleton: Skeleton): void;
-    private drawImages;
-    private drawTriangles;
-    private drawTriangle;
-    private computeRegionVertices;
-    private computeMeshVertices;
+    static QUAD_TRIANGLES: number[]
+    static VERTEX_SIZE: number
+    private ctx
+    triangleRendering: boolean
+    debugRendering: boolean
+    private vertices
+    private tempColor
+    constructor(context: CanvasRenderingContext2D)
+    draw(skeleton: Skeleton): void
+    private drawImages
+    private drawTriangles
+    private drawTriangle
+    private computeRegionVertices
+    private computeMeshVertices
   }
 }
 declare module spine.webgl {
   class AssetManager extends spine.AssetManager {
-    constructor(
-      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
-      pathPrefix?: string
-    );
+    constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix?: string)
   }
 }
 declare module spine.webgl {
   class OrthoCamera {
-    position: Vector3;
-    direction: Vector3;
-    up: Vector3;
-    near: number;
-    far: number;
-    zoom: number;
-    viewportWidth: number;
-    viewportHeight: number;
-    projectionView: Matrix4;
-    inverseProjectionView: Matrix4;
-    projection: Matrix4;
-    view: Matrix4;
-    private tmp;
-    constructor(viewportWidth: number, viewportHeight: number);
-    update(): void;
-    screenToWorld(
-      screenCoords: Vector3,
-      screenWidth: number,
-      screenHeight: number
-    ): Vector3;
-    setViewport(viewportWidth: number, viewportHeight: number): void;
+    position: Vector3
+    direction: Vector3
+    up: Vector3
+    near: number
+    far: number
+    zoom: number
+    viewportWidth: number
+    viewportHeight: number
+    projectionView: Matrix4
+    inverseProjectionView: Matrix4
+    projection: Matrix4
+    view: Matrix4
+    private tmp
+    constructor(viewportWidth: number, viewportHeight: number)
+    update(): void
+    screenToWorld(screenCoords: Vector3, screenWidth: number, screenHeight: number): Vector3
+    setViewport(viewportWidth: number, viewportHeight: number): void
   }
 }
 declare module spine.webgl {
   class GLTexture extends Texture implements Disposable, Restorable {
-    private context;
-    private texture;
-    private boundUnit;
-    private useMipMaps;
+    private context
+    private texture
+    private boundUnit
+    private useMipMaps
     constructor(
       context: ManagedWebGLRenderingContext | WebGLRenderingContext,
       image: HTMLImageElement,
-      useMipMaps?: boolean
-    );
-    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-    update(useMipMaps: boolean): void;
-    restore(): void;
-    bind(unit?: number): void;
-    unbind(): void;
-    dispose(): void;
+      useMipMaps?: boolean,
+    )
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void
+    update(useMipMaps: boolean): void
+    restore(): void
+    bind(unit?: number): void
+    unbind(): void
+    dispose(): void
   }
 }
 declare module spine.webgl {
-  const M00 = 0;
-  const M01 = 4;
-  const M02 = 8;
-  const M03 = 12;
-  const M10 = 1;
-  const M11 = 5;
-  const M12 = 9;
-  const M13 = 13;
-  const M20 = 2;
-  const M21 = 6;
-  const M22 = 10;
-  const M23 = 14;
-  const M30 = 3;
-  const M31 = 7;
-  const M32 = 11;
-  const M33 = 15;
+  const M00 = 0
+  const M01 = 4
+  const M02 = 8
+  const M03 = 12
+  const M10 = 1
+  const M11 = 5
+  const M12 = 9
+  const M13 = 13
+  const M20 = 2
+  const M21 = 6
+  const M22 = 10
+  const M23 = 14
+  const M30 = 3
+  const M31 = 7
+  const M32 = 11
+  const M33 = 15
   class Matrix4 {
-    temp: Float32Array;
-    values: Float32Array;
-    private static xAxis;
-    private static yAxis;
-    private static zAxis;
-    private static tmpMatrix;
-    constructor();
-    set(values: ArrayLike<number>): Matrix4;
-    transpose(): Matrix4;
-    identity(): Matrix4;
-    invert(): Matrix4;
-    determinant(): number;
-    translate(x: number, y: number, z: number): Matrix4;
-    copy(): Matrix4;
-    projection(
-      near: number,
-      far: number,
-      fovy: number,
-      aspectRatio: number
-    ): Matrix4;
-    ortho2d(x: number, y: number, width: number, height: number): Matrix4;
+    temp: Float32Array
+    values: Float32Array
+    private static xAxis
+    private static yAxis
+    private static zAxis
+    private static tmpMatrix
+    constructor()
+    set(values: ArrayLike<number>): Matrix4
+    transpose(): Matrix4
+    identity(): Matrix4
+    invert(): Matrix4
+    determinant(): number
+    translate(x: number, y: number, z: number): Matrix4
+    copy(): Matrix4
+    projection(near: number, far: number, fovy: number, aspectRatio: number): Matrix4
+    ortho2d(x: number, y: number, width: number, height: number): Matrix4
     ortho(
       left: number,
       right: number,
       bottom: number,
       top: number,
       near: number,
-      far: number
-    ): Matrix4;
-    multiply(matrix: Matrix4): Matrix4;
-    multiplyLeft(matrix: Matrix4): Matrix4;
-    lookAt(position: Vector3, direction: Vector3, up: Vector3): this;
-    static initTemps(): void;
+      far: number,
+    ): Matrix4
+    multiply(matrix: Matrix4): Matrix4
+    multiplyLeft(matrix: Matrix4): Matrix4
+    lookAt(position: Vector3, direction: Vector3, up: Vector3): this
+    static initTemps(): void
   }
 }
 declare module spine.webgl {
   class Mesh implements Disposable, Restorable {
-    private attributes;
-    private context;
-    private vertices;
-    private verticesBuffer;
-    private verticesLength;
-    private dirtyVertices;
-    private indices;
-    private indicesBuffer;
-    private indicesLength;
-    private dirtyIndices;
-    private elementsPerVertex;
-    getAttributes(): VertexAttribute[];
-    maxVertices(): number;
-    numVertices(): number;
-    setVerticesLength(length: number): void;
-    getVertices(): Float32Array;
-    maxIndices(): number;
-    numIndices(): number;
-    setIndicesLength(length: number): void;
-    getIndices(): Uint16Array;
-    getVertexSizeInFloats(): number;
+    private attributes
+    private context
+    private vertices
+    private verticesBuffer
+    private verticesLength
+    private dirtyVertices
+    private indices
+    private indicesBuffer
+    private indicesLength
+    private dirtyIndices
+    private elementsPerVertex
+    getAttributes(): VertexAttribute[]
+    maxVertices(): number
+    numVertices(): number
+    setVerticesLength(length: number): void
+    getVertices(): Float32Array
+    maxIndices(): number
+    numIndices(): number
+    setIndicesLength(length: number): void
+    getIndices(): Uint16Array
+    getVertexSizeInFloats(): number
     constructor(
       context: ManagedWebGLRenderingContext | WebGLRenderingContext,
       attributes: VertexAttribute[],
       maxVertices: number,
-      maxIndices: number
-    );
-    setVertices(vertices: Array<number>): void;
-    setIndices(indices: Array<number>): void;
-    draw(shader: Shader, primitiveType: number): void;
-    drawWithOffset(
-      shader: Shader,
-      primitiveType: number,
-      offset: number,
-      count: number
-    ): void;
-    bind(shader: Shader): void;
-    unbind(shader: Shader): void;
-    private update;
-    restore(): void;
-    dispose(): void;
+      maxIndices: number,
+    )
+    setVertices(vertices: Array<number>): void
+    setIndices(indices: Array<number>): void
+    draw(shader: Shader, primitiveType: number): void
+    drawWithOffset(shader: Shader, primitiveType: number, offset: number, count: number): void
+    bind(shader: Shader): void
+    unbind(shader: Shader): void
+    private update
+    restore(): void
+    dispose(): void
   }
   class VertexAttribute {
-    name: string;
-    type: VertexAttributeType;
-    numElements: number;
-    constructor(name: string, type: VertexAttributeType, numElements: number);
+    name: string
+    type: VertexAttributeType
+    numElements: number
+    constructor(name: string, type: VertexAttributeType, numElements: number)
   }
   class Position2Attribute extends VertexAttribute {
-    constructor();
+    constructor()
   }
   class Position3Attribute extends VertexAttribute {
-    constructor();
+    constructor()
   }
   class TexCoordAttribute extends VertexAttribute {
-    constructor(unit?: number);
+    constructor(unit?: number)
   }
   class ColorAttribute extends VertexAttribute {
-    constructor();
+    constructor()
   }
   class Color2Attribute extends VertexAttribute {
-    constructor();
+    constructor()
   }
   enum VertexAttributeType {
     Float = 0,
@@ -1985,75 +1855,71 @@ declare module spine.webgl {
 }
 declare module spine.webgl {
   class PolygonBatcher implements Disposable {
-    private context;
-    private drawCalls;
-    private isDrawing;
-    private mesh;
-    private shader;
-    private lastTexture;
-    private verticesLength;
-    private indicesLength;
-    private srcBlend;
-    private dstBlend;
+    private context
+    private drawCalls
+    private isDrawing
+    private mesh
+    private shader
+    private lastTexture
+    private verticesLength
+    private indicesLength
+    private srcBlend
+    private dstBlend
     constructor(
       context: ManagedWebGLRenderingContext | WebGLRenderingContext,
       twoColorTint?: boolean,
-      maxVertices?: number
-    );
-    begin(shader: Shader): void;
-    setBlendMode(srcBlend: number, dstBlend: number): void;
-    draw(
-      texture: GLTexture,
-      vertices: ArrayLike<number>,
-      indices: Array<number>
-    ): void;
-    private flush;
-    end(): void;
-    getDrawCalls(): number;
-    dispose(): void;
+      maxVertices?: number,
+    )
+    begin(shader: Shader): void
+    setBlendMode(srcBlend: number, dstBlend: number): void
+    draw(texture: GLTexture, vertices: ArrayLike<number>, indices: Array<number>): void
+    private flush
+    end(): void
+    getDrawCalls(): number
+    dispose(): void
   }
 }
 declare module spine.webgl {
   class SceneRenderer implements Disposable {
-    context: ManagedWebGLRenderingContext;
-    canvas: HTMLCanvasElement;
-    camera: OrthoCamera;
-    batcher: PolygonBatcher;
-    private twoColorTint;
-    private batcherShader;
-    private shapes;
-    private shapesShader;
-    private activeRenderer;
-    skeletonRenderer: SkeletonRenderer;
-    skeletonDebugRenderer: SkeletonDebugRenderer;
-    private QUAD;
-    private QUAD_TRIANGLES;
-    private WHITE;
+    context: ManagedWebGLRenderingContext
+    canvas: HTMLCanvasElement
+    camera: OrthoCamera
+    batcher: PolygonBatcher
+    private twoColorTint
+    private batcherShader
+    private shapes
+    private shapesShader
+    private activeRenderer
+    skeletonRenderer: SkeletonRenderer
+    skeletonDebugRenderer: SkeletonDebugRenderer
+    private QUAD
+    private QUAD_TRIANGLES
+    private WHITE
     constructor(
       canvas: HTMLCanvasElement,
       context: ManagedWebGLRenderingContext | WebGLRenderingContext,
-      twoColorTint?: boolean
-    );
-    begin(): void;
+      twoColorTint?: boolean,
+    )
+    begin(): void
     drawSkeleton(
       skeleton: Skeleton,
       premultipliedAlpha?: boolean,
       slotRangeStart?: number,
-      slotRangeEnd?: number
-    ): void;
+      slotRangeEnd?: number,
+    ): void
     drawSkeletonDebug(
       skeleton: Skeleton,
       premultipliedAlpha?: boolean,
-      ignoredBones?: Array<string>
-    ): void;
+      ignoredBones?: Array<string>,
+    ): void
     drawTexture(
       texture: GLTexture,
       x: number,
       y: number,
       width: number,
       height: number,
-      color?: Color
-    ): void;
+      color?: Color,
+    ): void
     drawTextureUV(
       texture: GLTexture,
       x: number,
@@ -2064,8 +1930,8 @@ declare module spine.webgl {
       v: number,
       u2: number,
       v2: number,
-      color?: Color
-    ): void;
+      color?: Color,
+    ): void
     drawTextureRotated(
       texture: GLTexture,
       x: number,
@@ -2076,8 +1942,8 @@ declare module spine.webgl {
       pivotY: number,
       angle: number,
       color?: Color,
-      premultipliedAlpha?: boolean
-    ): void;
+      premultipliedAlpha?: boolean,
+    ): void
     drawRegion(
       region: TextureAtlasRegion,
       x: number,
@@ -2085,16 +1951,9 @@ declare module spine.webgl {
       width: number,
       height: number,
       color?: Color,
-      premultipliedAlpha?: boolean
-    ): void;
-    line(
-      x: number,
-      y: number,
-      x2: number,
-      y2: number,
-      color?: Color,
-      color2?: Color
-    ): void;
+      premultipliedAlpha?: boolean,
+    ): void
+    line(x: number, y: number, x2: number, y2: number, color?: Color, color2?: Color): void
     triangle(
       filled: boolean,
       x: number,
@@ -2105,8 +1964,8 @@ declare module spine.webgl {
       y3: number,
       color?: Color,
       color2?: Color,
-      color3?: Color
-    ): void;
+      color3?: Color,
+    ): void
     quad(
       filled: boolean,
       x: number,
@@ -2120,16 +1979,9 @@ declare module spine.webgl {
       color?: Color,
       color2?: Color,
       color3?: Color,
-      color4?: Color
-    ): void;
-    rect(
-      filled: boolean,
-      x: number,
-      y: number,
-      width: number,
-      height: number,
-      color?: Color
-    ): void;
+      color4?: Color,
+    ): void
+    rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void
     rectLine(
       filled: boolean,
       x1: number,
@@ -2137,22 +1989,17 @@ declare module spine.webgl {
       x2: number,
       y2: number,
       width: number,
-      color?: Color
-    ): void;
-    polygon(
-      polygonVertices: ArrayLike<number>,
-      offset: number,
-      count: number,
-      color?: Color
-    ): void;
+      color?: Color,
+    ): void
+    polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void
     circle(
       filled: boolean,
       x: number,
       y: number,
       radius: number,
       color?: Color,
-      segments?: number
-    ): void;
+      segments?: number,
+    ): void
     curve(
       x1: number,
       y1: number,
@@ -2163,12 +2010,12 @@ declare module spine.webgl {
       x2: number,
       y2: number,
       segments: number,
-      color?: Color
-    ): void;
-    end(): void;
-    resize(resizeMode: ResizeMode): void;
-    private enableRenderer;
-    dispose(): void;
+      color?: Color,
+    ): void
+    end(): void
+    resize(resizeMode: ResizeMode): void
+    private enableRenderer
+    dispose(): void
   }
   enum ResizeMode {
     Stretch = 0,
@@ -2178,94 +2025,82 @@ declare module spine.webgl {
 }
 declare module spine.webgl {
   class Shader implements Disposable, Restorable {
-    private vertexShader;
-    private fragmentShader;
-    static MVP_MATRIX: string;
-    static POSITION: string;
-    static COLOR: string;
-    static COLOR2: string;
-    static TEXCOORDS: string;
-    static SAMPLER: string;
-    private context;
-    private vs;
-    private vsSource;
-    private fs;
-    private fsSource;
-    private program;
-    private tmp2x2;
-    private tmp3x3;
-    private tmp4x4;
-    getProgram(): WebGLProgram;
-    getVertexShader(): string;
-    getFragmentShader(): string;
-    getVertexShaderSource(): string;
-    getFragmentSource(): string;
+    private vertexShader
+    private fragmentShader
+    static MVP_MATRIX: string
+    static POSITION: string
+    static COLOR: string
+    static COLOR2: string
+    static TEXCOORDS: string
+    static SAMPLER: string
+    private context
+    private vs
+    private vsSource
+    private fs
+    private fsSource
+    private program
+    private tmp2x2
+    private tmp3x3
+    private tmp4x4
+    getProgram(): WebGLProgram
+    getVertexShader(): string
+    getFragmentShader(): string
+    getVertexShaderSource(): string
+    getFragmentSource(): string
     constructor(
       context: ManagedWebGLRenderingContext | WebGLRenderingContext,
       vertexShader: string,
-      fragmentShader: string
-    );
-    private compile;
-    private compileShader;
-    private compileProgram;
-    restore(): void;
-    bind(): void;
-    unbind(): void;
-    setUniformi(uniform: string, value: number): void;
-    setUniformf(uniform: string, value: number): void;
-    setUniform2f(uniform: string, value: number, value2: number): void;
-    setUniform3f(
-      uniform: string,
-      value: number,
-      value2: number,
-      value3: number
-    ): void;
+      fragmentShader: string,
+    )
+    private compile
+    private compileShader
+    private compileProgram
+    restore(): void
+    bind(): void
+    unbind(): void
+    setUniformi(uniform: string, value: number): void
+    setUniformf(uniform: string, value: number): void
+    setUniform2f(uniform: string, value: number, value2: number): void
+    setUniform3f(uniform: string, value: number, value2: number, value3: number): void
     setUniform4f(
       uniform: string,
       value: number,
       value2: number,
       value3: number,
-      value4: number
-    ): void;
-    setUniform2x2f(uniform: string, value: ArrayLike<number>): void;
-    setUniform3x3f(uniform: string, value: ArrayLike<number>): void;
-    setUniform4x4f(uniform: string, value: ArrayLike<number>): void;
-    getUniformLocation(uniform: string): WebGLUniformLocation;
-    getAttributeLocation(attribute: string): number;
-    dispose(): void;
-    static newColoredTextured(
-      context: ManagedWebGLRenderingContext | WebGLRenderingContext
-    ): Shader;
+      value4: number,
+    ): void
+    setUniform2x2f(uniform: string, value: ArrayLike<number>): void
+    setUniform3x3f(uniform: string, value: ArrayLike<number>): void
+    setUniform4x4f(uniform: string, value: ArrayLike<number>): void
+    getUniformLocation(uniform: string): WebGLUniformLocation
+    getAttributeLocation(attribute: string): number
+    dispose(): void
+    static newColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader
     static newTwoColoredTextured(
-      context: ManagedWebGLRenderingContext | WebGLRenderingContext
-    ): Shader;
-    static newColored(
-      context: ManagedWebGLRenderingContext | WebGLRenderingContext
-    ): Shader;
+      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
+    ): Shader
+    static newColored(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader
   }
 }
 declare module spine.webgl {
   class ShapeRenderer implements Disposable {
-    private context;
-    private isDrawing;
-    private mesh;
-    private shapeType;
-    private color;
-    private shader;
-    private vertexIndex;
-    private tmp;
-    private srcBlend;
-    private dstBlend;
-    constructor(
-      context: ManagedWebGLRenderingContext | WebGLRenderingContext,
-      maxVertices?: number
-    );
-    begin(shader: Shader): void;
-    setBlendMode(srcBlend: number, dstBlend: number): void;
-    setColor(color: Color): void;
-    setColorWith(r: number, g: number, b: number, a: number): void;
-    point(x: number, y: number, color?: Color): void;
-    line(x: number, y: number, x2: number, y2: number, color?: Color): void;
+    private context
+    private isDrawing
+    private mesh
+    private shapeType
+    private color
+    private shader
+    private vertexIndex
+    private tmp
+    private srcBlend
+    private dstBlend
+    constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, maxVertices?: number)
+    begin(shader: Shader): void
+    setBlendMode(srcBlend: number, dstBlend: number): void
+    setColor(color: Color): void
+    setColorWith(r: number, g: number, b: number, a: number): void
+    point(x: number, y: number, color?: Color): void
+    line(x: number, y: number, x2: number, y2: number, color?: Color): void
     triangle(
       filled: boolean,
       x: number,
@@ -2276,8 +2111,8 @@ declare module spine.webgl {
       y3: number,
       color?: Color,
       color2?: Color,
-      color3?: Color
-    ): void;
+      color3?: Color,
+    ): void
     quad(
       filled: boolean,
       x: number,
@@ -2291,16 +2126,9 @@ declare module spine.webgl {
       color?: Color,
       color2?: Color,
       color3?: Color,
-      color4?: Color
-    ): void;
-    rect(
-      filled: boolean,
-      x: number,
-      y: number,
-      width: number,
-      height: number,
-      color?: Color
-    ): void;
+      color4?: Color,
+    ): void
+    rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void
     rectLine(
       filled: boolean,
       x1: number,
@@ -2308,23 +2136,18 @@ declare module spine.webgl {
       x2: number,
       y2: number,
       width: number,
-      color?: Color
-    ): void;
-    x(x: number, y: number, size: number): void;
-    polygon(
-      polygonVertices: ArrayLike<number>,
-      offset: number,
-      count: number,
-      color?: Color
-    ): void;
+      color?: Color,
+    ): void
+    x(x: number, y: number, size: number): void
+    polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void
     circle(
       filled: boolean,
       x: number,
       y: number,
       radius: number,
       color?: Color,
-      segments?: number
-    ): void;
+      segments?: number,
+    ): void
     curve(
       x1: number,
       y1: number,
@@ -2335,13 +2158,13 @@ declare module spine.webgl {
       x2: number,
       y2: number,
       segments: number,
-      color?: Color
-    ): void;
-    private vertex;
-    end(): void;
-    private flush;
-    private check;
-    dispose(): void;
+      color?: Color,
+    ): void
+    private vertex
+    end(): void
+    private flush
+    private check
+    dispose(): void
   }
   enum ShapeType {
     Point = 0,
@@ -2351,110 +2174,100 @@ declare module spine.webgl {
 }
 declare module spine.webgl {
   class SkeletonDebugRenderer implements Disposable {
-    boneLineColor: Color;
-    boneOriginColor: Color;
-    attachmentLineColor: Color;
-    triangleLineColor: Color;
-    pathColor: Color;
-    clipColor: Color;
-    aabbColor: Color;
-    drawBones: boolean;
-    drawRegionAttachments: boolean;
-    drawBoundingBoxes: boolean;
-    drawMeshHull: boolean;
-    drawMeshTriangles: boolean;
-    drawPaths: boolean;
-    drawSkeletonXY: boolean;
-    drawClipping: boolean;
-    premultipliedAlpha: boolean;
-    scale: number;
-    boneWidth: number;
-    private context;
-    private bounds;
-    private temp;
-    private vertices;
-    private static LIGHT_GRAY;
-    private static GREEN;
-    constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext);
-    draw(
-      shapes: ShapeRenderer,
-      skeleton: Skeleton,
-      ignoredBones?: Array<string>
-    ): void;
-    dispose(): void;
+    boneLineColor: Color
+    boneOriginColor: Color
+    attachmentLineColor: Color
+    triangleLineColor: Color
+    pathColor: Color
+    clipColor: Color
+    aabbColor: Color
+    drawBones: boolean
+    drawRegionAttachments: boolean
+    drawBoundingBoxes: boolean
+    drawMeshHull: boolean
+    drawMeshTriangles: boolean
+    drawPaths: boolean
+    drawSkeletonXY: boolean
+    drawClipping: boolean
+    premultipliedAlpha: boolean
+    scale: number
+    boneWidth: number
+    private context
+    private bounds
+    private temp
+    private vertices
+    private static LIGHT_GRAY
+    private static GREEN
+    constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext)
+    draw(shapes: ShapeRenderer, skeleton: Skeleton, ignoredBones?: Array<string>): void
+    dispose(): void
   }
 }
 declare module spine.webgl {
   class SkeletonRenderer {
-    static QUAD_TRIANGLES: number[];
-    premultipliedAlpha: boolean;
-    vertexEffect: VertexEffect;
-    private tempColor;
-    private tempColor2;
-    private vertices;
-    private vertexSize;
-    private twoColorTint;
-    private renderable;
-    private clipper;
-    private temp;
-    private temp2;
-    private temp3;
-    private temp4;
-    constructor(context: ManagedWebGLRenderingContext, twoColorTint?: boolean);
+    static QUAD_TRIANGLES: number[]
+    premultipliedAlpha: boolean
+    vertexEffect: VertexEffect
+    private tempColor
+    private tempColor2
+    private vertices
+    private vertexSize
+    private twoColorTint
+    private renderable
+    private clipper
+    private temp
+    private temp2
+    private temp3
+    private temp4
+    constructor(context: ManagedWebGLRenderingContext, twoColorTint?: boolean)
     draw(
       batcher: PolygonBatcher,
       skeleton: Skeleton,
       slotRangeStart?: number,
-      slotRangeEnd?: number
-    ): void;
+      slotRangeEnd?: number,
+    ): void
   }
 }
 declare module spine.webgl {
   class Vector3 {
-    x: number;
-    y: number;
-    z: number;
-    constructor(x?: number, y?: number, z?: number);
-    setFrom(v: Vector3): Vector3;
-    set(x: number, y: number, z: number): Vector3;
-    add(v: Vector3): Vector3;
-    sub(v: Vector3): Vector3;
-    scale(s: number): Vector3;
-    normalize(): Vector3;
-    cross(v: Vector3): Vector3;
-    multiply(matrix: Matrix4): Vector3;
-    project(matrix: Matrix4): Vector3;
-    dot(v: Vector3): number;
-    length(): number;
-    distance(v: Vector3): number;
+    x: number
+    y: number
+    z: number
+    constructor(x?: number, y?: number, z?: number)
+    setFrom(v: Vector3): Vector3
+    set(x: number, y: number, z: number): Vector3
+    add(v: Vector3): Vector3
+    sub(v: Vector3): Vector3
+    scale(s: number): Vector3
+    normalize(): Vector3
+    cross(v: Vector3): Vector3
+    multiply(matrix: Matrix4): Vector3
+    project(matrix: Matrix4): Vector3
+    dot(v: Vector3): number
+    length(): number
+    distance(v: Vector3): number
   }
 }
 declare module spine.webgl {
   class ManagedWebGLRenderingContext {
-    canvas: HTMLCanvasElement | OffscreenCanvas;
-    gl: WebGLRenderingContext;
-    private restorables;
-    constructor(
-      canvasOrContext: HTMLCanvasElement | WebGLRenderingContext,
-      contextConfig?: any
-    );
-    addRestorable(restorable: Restorable): void;
-    removeRestorable(restorable: Restorable): void;
+    canvas: HTMLCanvasElement | OffscreenCanvas
+    gl: WebGLRenderingContext
+    private restorables
+    constructor(canvasOrContext: HTMLCanvasElement | WebGLRenderingContext, contextConfig?: any)
+    addRestorable(restorable: Restorable): void
+    removeRestorable(restorable: Restorable): void
   }
   class WebGLBlendModeConverter {
-    static ZERO: number;
-    static ONE: number;
-    static SRC_COLOR: number;
-    static ONE_MINUS_SRC_COLOR: number;
-    static SRC_ALPHA: number;
-    static ONE_MINUS_SRC_ALPHA: number;
-    static DST_ALPHA: number;
-    static ONE_MINUS_DST_ALPHA: number;
-    static DST_COLOR: number;
-    static getDestGLBlendMode(blendMode: BlendMode): number;
-    static getSourceGLBlendMode(
-      blendMode: BlendMode,
-      premultipliedAlpha?: boolean
-    ): number;
+    static ZERO: number
+    static ONE: number
+    static SRC_COLOR: number
+    static ONE_MINUS_SRC_COLOR: number
+    static SRC_ALPHA: number
+    static ONE_MINUS_SRC_ALPHA: number
+    static DST_ALPHA: number
+    static ONE_MINUS_DST_ALPHA: number
+    static DST_COLOR: number
+    static getDestGLBlendMode(blendMode: BlendMode): number
+    static getSourceGLBlendMode(blendMode: BlendMode, premultipliedAlpha?: boolean): number
   }
 }
diff --git a/tsconfig.json b/tsconfig.json
index 6843311..21d0d8f 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,6 +1,12 @@
 {
   "compilerOptions": {
-    "target": "es5",
+    "target": "ES2017",
+    "lib": ["ES2017", "dom"],
+    "module": "commonjs",
     "esModuleInterop": true,
-  }
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "noImplicitAny": true
+  },
+  "include": ["src/**/*"]
 }
diff --git a/webpack.config.js b/webpack.config.js
index a8b7922..31f067e 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -4,7 +4,10 @@ const CopyWebpackPlugin = require("copy-webpack-plugin");
 const package = require("./package.json");
 
 module.exports = {
-  entry: path.resolve(__dirname, "./src/index.ts"),
+  entry: {
+    main: path.resolve(__dirname, "./src/index.ts"),
+    editor: path.resolve(__dirname, "./src/editor/index.ts"),
+  },
   module: {
     rules: [
       {
@@ -54,6 +57,9 @@ module.exports = {
   },
   devServer: {
     static: path.resolve(__dirname, "./dist"),
+    historyApiFallback: {
+      rewrites: [{ from: /^\/editor/, to: "/editor.html" }],
+    },
   },
   plugins: [
     new CopyWebpackPlugin({
@@ -70,6 +76,15 @@ module.exports = {
       title: package.description,
       inject: "body",
       hot: true,
+      chunks: ["main"],
+    }),
+    new HtmlWebpackPlugin({
+      template: path.resolve(__dirname, "./src/editor/index.html"),
+      filename: "editor.html",
+      title: "Spine Editor",
+      inject: "body",
+      hot: true,
+      chunks: ["editor"],
     }),
   ],
 };