├── README.md
├── .gitignore
├── example
    ├── assets
    │   ├── 1000.png
    │   └── test.wav
    ├── tsconfig.json
    ├── src
    │   ├── declarations.d.ts
    │   ├── DrawingScene.ts
    │   ├── UIScene.ts
    │   ├── index.ts
    │   ├── index.html
    │   ├── widgets
    │   │   ├── AnimationWidget.ts
    │   │   └── PathOnGridWidget.ts
    │   ├── DrawingEntity.ts
    │   └── scenes
    │   │   └── GridScene.ts
    ├── package.json
    └── dist
    │   ├── index.html
    │   ├── index.js
    │   ├── index.js.map
    │   └── src.8e541c7a.js
├── src
    ├── assetLoader
    │   ├── assetTypes
    │   │   ├── index.ts
    │   │   ├── ImageAsset.ts
    │   │   └── SoundAsset.ts
    │   ├── index.ts
    │   ├── AssetDefinition.ts
    │   ├── Asset.ts
    │   └── AssetLoader.ts
    ├── widgets
    │   ├── Widget.ts
    │   └── MousePath.ts
    ├── index.ts
    ├── ticker
    │   ├── Ticker.ts
    │   └── AnimationFrameTicker.ts
    ├── entity
    │   ├── TextEntity.ts
    │   └── Entity.ts
    ├── inputManager
    │   ├── InputState.ts
    │   ├── Key.ts
    │   └── InputManager.ts
    ├── scene
    │   └── Scene.ts
    ├── math
    │   └── Vector2.ts
    └── engine
    │   └── Engine.ts
├── test
    └── blah.test.ts
├── .github
    └── workflows
    │   ├── size.yml
    │   └── main.yml
├── tsconfig.json
├── package.json
└── LICENSE


/README.md:
--------------------------------------------------------------------------------
1 | # <center>🚂 `@are/engine`</center>
2 | 
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.log
2 | .DS_Store
3 | node_modules
4 | dist
5 | !example/dist
6 | .cache


--------------------------------------------------------------------------------
/example/assets/1000.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ARE/engine/main/example/assets/1000.png


--------------------------------------------------------------------------------
/example/assets/test.wav:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ARE/engine/main/example/assets/test.wav


--------------------------------------------------------------------------------
/src/assetLoader/assetTypes/index.ts:
--------------------------------------------------------------------------------
1 | export * from './ImageAsset'
2 | export * from './SoundAsset'
3 | 


--------------------------------------------------------------------------------
/src/assetLoader/index.ts:
--------------------------------------------------------------------------------
1 | export * from './Asset'
2 | export * from './AssetDefinition'
3 | export * from './AssetLoader'
4 | export * from './assetTypes'
5 | 


--------------------------------------------------------------------------------
/test/blah.test.ts:
--------------------------------------------------------------------------------
1 | import { sum } from '../src'
2 | 
3 | describe('blah', () => {
4 |   it('works', () => {
5 |     expect(sum(1, 1)).toEqual(2)
6 |   })
7 | })
8 | 


--------------------------------------------------------------------------------
/example/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "compilerOptions": {
3 |     "lib": ["ESNext", "DOM"],
4 |     "target": "ES6",
5 |     "moduleResolution": "node",
6 |     "allowSyntheticDefaultImports": true
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/assetLoader/AssetDefinition.ts:
--------------------------------------------------------------------------------
1 | export enum AssetType {
2 |   image,
3 |   sound,
4 | }
5 | 
6 | export class AssetDefinition {
7 |   constructor(public type: AssetType, public source: string) {}
8 | }
9 | 


--------------------------------------------------------------------------------
/.github/workflows/size.yml:
--------------------------------------------------------------------------------
 1 | name: size
 2 | on: [pull_request]
 3 | jobs:
 4 |   size:
 5 |     runs-on: ubuntu-latest
 6 |     env:
 7 |       CI_JOB_NUMBER: 1
 8 |     steps:
 9 |       - uses: actions/checkout@v1
10 |       - uses: andresz1/size-limit-action@v1
11 |         with:
12 |           github_token: ${{ secrets.GITHUB_TOKEN }}
13 | 


--------------------------------------------------------------------------------
/src/assetLoader/assetTypes/ImageAsset.ts:
--------------------------------------------------------------------------------
 1 | import { Asset } from '../Asset'
 2 | import { AssetDefinition, AssetType } from '../AssetDefinition'
 3 | 
 4 | export class ImageAsset extends Asset {
 5 |   type = AssetType.image
 6 | 
 7 |   constructor(definition: AssetDefinition, public image: HTMLImageElement) {
 8 |     super(definition)
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/assetLoader/assetTypes/SoundAsset.ts:
--------------------------------------------------------------------------------
 1 | import { Asset } from '../Asset'
 2 | import { AssetDefinition, AssetType } from '../AssetDefinition'
 3 | 
 4 | export class SoundAsset extends Asset {
 5 |   type = AssetType.image
 6 | 
 7 |   constructor(definition: AssetDefinition, public audio: HTMLAudioElement) {
 8 |     super(definition)
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/widgets/Widget.ts:
--------------------------------------------------------------------------------
 1 | import { EntityDrawContext, EntityUpdateContext } from '../entity/Entity'
 2 | 
 3 | export abstract class Widget {
 4 |   willUpdate(_context: EntityUpdateContext): void {}
 5 |   didUpdate(_context: EntityUpdateContext): void {}
 6 | 
 7 |   willDraw(_context: EntityDrawContext): void {}
 8 |   didDraw(_context: EntityDrawContext): void {}
 9 | }
10 | 


--------------------------------------------------------------------------------
/example/src/declarations.d.ts:
--------------------------------------------------------------------------------
 1 | declare module '*.png'
 2 | declare module '*.wav'
 3 | 
 4 | declare module 'simplify-js' {
 5 |   interface Point {
 6 |     x: number
 7 |     y: number
 8 |   }
 9 | 
10 |   function simplify<T extends Point>(
11 |     points: T[],
12 |     tolerance?: number,
13 |     highQuality?: boolean
14 |   ): T[]
15 |   namespace simplify {}
16 | 
17 |   export = simplify
18 | }
19 | 


--------------------------------------------------------------------------------
/example/src/DrawingScene.ts:
--------------------------------------------------------------------------------
 1 | import { EntityDrawContext } from '../../src/entity/Entity'
 2 | import { Scene } from '../../src/scene/Scene'
 3 | import { DrawingEntity } from './DrawingEntity'
 4 | 
 5 | export class DrawingScene extends Scene {
 6 |   willMount() {
 7 |     this.add(new DrawingEntity())
 8 |   }
 9 | 
10 |   willDraw({ ctx }: EntityDrawContext) {
11 |     ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height)
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/example/src/UIScene.ts:
--------------------------------------------------------------------------------
 1 | import { Scene } from '../../src/scene/Scene'
 2 | import { TextEntity } from '../../src/entity/TextEntity'
 3 | import { vec2 } from '../../src/math/Vector2'
 4 | 
 5 | export class UIScene extends Scene {
 6 |   willMount() {
 7 |     this.add(
 8 |       new TextEntity({
 9 |         text: 'Hello world!',
10 |         position: vec2(100, 100),
11 |         style: 'black',
12 |         font: '16px monospace',
13 |       })
14 |     )
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/example/src/index.ts:
--------------------------------------------------------------------------------
 1 | import { AnimationFrameTicker, Engine, vec2 } from '../../src'
 2 | import { GridScene } from './scenes/GridScene'
 3 | 
 4 | const canvas = document.querySelector<HTMLCanvasElement>('#app')
 5 | 
 6 | const engine = new Engine({
 7 |   canvas: canvas,
 8 |   size: vec2(window.innerWidth, window.innerHeight),
 9 |   ticker: new AnimationFrameTicker(),
10 | })
11 | 
12 | engine.registerScene('grid', GridScene)
13 | 
14 | engine.start()
15 | 
16 | engine.pushScene('grid')
17 | 


--------------------------------------------------------------------------------
/src/assetLoader/Asset.ts:
--------------------------------------------------------------------------------
 1 | import { AssetDefinition, AssetType } from './AssetDefinition'
 2 | 
 3 | export abstract class Asset {
 4 |   abstract type: AssetType
 5 | 
 6 |   constructor(public definition: AssetDefinition) {}
 7 | 
 8 |   static image(source: string): AssetDefinition {
 9 |     return new AssetDefinition(AssetType.image, source)
10 |   }
11 | 
12 |   static sound(source: string): AssetDefinition {
13 |     return new AssetDefinition(AssetType.sound, source)
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/example/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "example",
 3 |   "private": true,
 4 |   "version": "1.0.0",
 5 |   "browserslist": [
 6 |     "last 1 Chrome version"
 7 |   ],
 8 |   "scripts": {
 9 |     "start": "parcel src/index.html",
10 |     "build": "parcel build src/index.html"
11 |   },
12 |   "devDependencies": {
13 |     "parcel-bundler": "^1.12.4",
14 |     "typescript": "^4.1.2"
15 |   },
16 |   "dependencies": {
17 |     "@tweenjs/tween.js": "^18.6.4",
18 |     "simplify-js": "^1.2.4"
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
 1 | export * from './assetLoader/index'
 2 | export * from './engine/Engine'
 3 | export * from './entity/Entity'
 4 | export * from './entity/TextEntity'
 5 | export * from './inputManager/InputManager'
 6 | export * from './inputManager/InputState'
 7 | export * from './inputManager/Key'
 8 | export * from './math/Vector2'
 9 | export * from './scene/Scene'
10 | export * from './ticker/Ticker'
11 | export * from './ticker/AnimationFrameTicker'
12 | export * from './widgets/Widget'
13 | export * from './widgets/MousePath'
14 | 


--------------------------------------------------------------------------------
/src/ticker/Ticker.ts:
--------------------------------------------------------------------------------
 1 | export type TickerState = {
 2 |   frameNumber: number
 3 | 
 4 |   startTimestamp: number
 5 |   lastTimestamp: number
 6 |   currentTimestamp: number
 7 | 
 8 |   delta: number
 9 | }
10 | 
11 | export type TickerListener = (state: TickerState) => void
12 | 
13 | export type CancelTickerListener = () => void
14 | 
15 | export abstract class Ticker {
16 |   abstract start(): void
17 |   abstract stop(): void
18 | 
19 |   abstract get isRunning(): boolean
20 | 
21 |   abstract listen(listener: TickerListener): CancelTickerListener
22 | }
23 | 


--------------------------------------------------------------------------------
/example/dist/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>Document</title>
 7 | 
 8 |     <style>* {
 9 |         padding: 0;
10 |         margin: 0;
11 | 
12 |         box-sizing: border-box;
13 |       }
14 | 
15 |       body {
16 |         overflow: hidden;
17 |       }</style>
18 |   </head>
19 |   <body>
20 |     <canvas id="app"></canvas>
21 | 
22 |     <script src="/engine/example/dist/src.8e541c7a.js"></script>
23 |   </body>
24 | </html>
25 | 


--------------------------------------------------------------------------------
/example/src/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 6 |     <title>Document</title>
 7 | 
 8 |     <style>
 9 |       * {
10 |         padding: 0;
11 |         margin: 0;
12 | 
13 |         box-sizing: border-box;
14 |       }
15 | 
16 |       body {
17 |         overflow: hidden;
18 |       }
19 |     </style>
20 |   </head>
21 |   <body>
22 |     <canvas id="app"></canvas>
23 | 
24 |     <script src="./index.ts"></script>
25 |   </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "include": ["src", "types"],
 3 |   "compilerOptions": {
 4 |     "module": "esnext",
 5 |     "lib": ["dom", "esnext"],
 6 |     "target": "ESNext",
 7 |     "importHelpers": true,
 8 |     "declaration": true,
 9 |     "sourceMap": true,
10 |     "rootDir": "./src",
11 |     "strict": true,
12 |     "strictNullChecks": true,
13 |     "noImplicitReturns": true,
14 |     "noFallthroughCasesInSwitch": true,
15 |     "noUnusedLocals": true,
16 |     "noUnusedParameters": true,
17 |     "moduleResolution": "node",
18 |     "esModuleInterop": true,
19 |     "skipLibCheck": true,
20 |     "forceConsistentCasingInFileNames": true,
21 |     "noEmit": true,
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/.github/workflows/main.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | on: [push]
 3 | jobs:
 4 |   build:
 5 |     name: Build, lint, and test on Node ${{ matrix.node }} and ${{ matrix.os }}
 6 | 
 7 |     runs-on: ${{ matrix.os }}
 8 |     strategy:
 9 |       matrix:
10 |         node: ['10.x', '12.x', '14.x']
11 |         os: [ubuntu-latest, windows-latest, macOS-latest]
12 | 
13 |     steps:
14 |       - name: Checkout repo
15 |         uses: actions/checkout@v2
16 | 
17 |       - name: Use Node ${{ matrix.node }}
18 |         uses: actions/setup-node@v1
19 |         with:
20 |           node-version: ${{ matrix.node }}
21 | 
22 |       - name: Install deps and build (with cache)
23 |         uses: bahmutov/npm-install@v1
24 | 
25 |       - name: Lint
26 |         run: yarn lint
27 | 
28 |       - name: Test
29 |         run: yarn test --ci --coverage --maxWorkers=2
30 | 
31 |       - name: Build
32 |         run: yarn build
33 | 


--------------------------------------------------------------------------------
/src/entity/TextEntity.ts:
--------------------------------------------------------------------------------
 1 | import { Entity, EntityDrawContext } from '../../src/entity/Entity'
 2 | import { Vector2 } from '../../src/math/Vector2'
 3 | 
 4 | interface TextOptions {
 5 |   text: string
 6 |   font: string
 7 |   style: string
 8 |   position: Vector2
 9 | 
10 |   vertical?: CanvasTextBaseline
11 |   horizontal?: CanvasTextAlign
12 | }
13 | 
14 | export class TextEntity extends Entity {
15 |   constructor(private options: TextOptions) {
16 |     super()
17 |   }
18 | 
19 |   update() {}
20 | 
21 |   draw({ ctx }: EntityDrawContext): void {
22 |     const { font, style, horizontal, vertical, position, text } = this.options
23 | 
24 |     ctx.save()
25 |     ctx.font = font
26 |     ctx.fillStyle = style
27 | 
28 |     ctx.textAlign = horizontal ?? 'center'
29 |     ctx.textBaseline = vertical ?? 'middle'
30 | 
31 |     ctx.fillText(text, position.x, position.y)
32 | 
33 |     ctx.restore()
34 |   }
35 | 
36 |   widgets = []
37 | }
38 | 


--------------------------------------------------------------------------------
/src/inputManager/InputState.ts:
--------------------------------------------------------------------------------
 1 | import { Key } from './Key'
 2 | import { Vector2 } from '../math/Vector2'
 3 | 
 4 | export interface KeyState {
 5 |   re: boolean
 6 |   fe: boolean
 7 | 
 8 |   pressed: boolean
 9 | }
10 | 
11 | const emptyKeyState: KeyState = { re: false, fe: false, pressed: false }
12 | 
13 | export class InputState {
14 |   constructor(
15 |     private keyState: Map<Key, KeyState>,
16 |     private mousePosition: Vector2
17 |   ) {}
18 | 
19 |   private getKeyState(keyCode: Key): KeyState {
20 |     return this.keyState.get(keyCode) ?? emptyKeyState
21 |   }
22 | 
23 |   isPressed(keyCode: Key): boolean {
24 |     return this.getKeyState(keyCode).pressed
25 |   }
26 | 
27 |   isReleased(keyCode: Key): boolean {
28 |     return !this.getKeyState(keyCode).pressed
29 |   }
30 | 
31 |   isJustPressed(keyCode: Key): boolean {
32 |     return this.getKeyState(keyCode).re
33 |   }
34 | 
35 |   isJustReleased(keyCode: Key): boolean {
36 |     return this.getKeyState(keyCode).fe
37 |   }
38 | 
39 |   get mouse(): Vector2 {
40 |     return this.mousePosition
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@are/engine",
 3 |   "author": "Artur Wojciechowski <me@iama.re>",
 4 |   "version": "0.1.0",
 5 |   "license": "Hippocratic-2.1",
 6 |   "engines": {
 7 |     "node": ">=10"
 8 |   },
 9 |   "main": "dist/index.js",
10 |   "typings": "dist/index.d.ts",
11 |   "module": "dist/engine.esm.js",
12 |   "files": [
13 |     "dist",
14 |     "src"
15 |   ],
16 |   "scripts": {
17 |     "start": "tsdx watch",
18 |     "build": "tsdx build",
19 |     "test": "tsdx test",
20 |     "lint": "tsdx lint",
21 |     "size": "size-limit",
22 |     "analyze": "size-limit --why"
23 |   },
24 |   "devDependencies": {
25 |     "@size-limit/preset-small-lib": "^4.9.0",
26 |     "husky": "^4.3.0",
27 |     "size-limit": "^4.9.0",
28 |     "tsdx": "^0.14.1",
29 |     "tslib": "^2.0.3",
30 |     "typescript": "^4.1.2"
31 |   },
32 |   "peerDependencies": {},
33 |   "husky": {
34 |     "hooks": {
35 |       "pre-commit": "tsdx lint"
36 |     }
37 |   },
38 |   "prettier": {
39 |     "printWidth": 80,
40 |     "semi": false,
41 |     "singleQuote": true,
42 |     "trailingComma": "es5"
43 |   },
44 |   "size-limit": [
45 |     {
46 |       "path": "dist/engine.cjs.production.min.js",
47 |       "limit": "10 KB"
48 |     },
49 |     {
50 |       "path": "dist/engine.esm.js",
51 |       "limit": "10 KB"
52 |     }
53 |   ]
54 | }
55 | 


--------------------------------------------------------------------------------
/example/src/widgets/AnimationWidget.ts:
--------------------------------------------------------------------------------
 1 | import { EntityUpdateContext, Widget } from '../../../src'
 2 | 
 3 | import { Tween, Group, Easing } from '@tweenjs/tween.js'
 4 | 
 5 | export class AnimatedValueWidget<T> extends Widget {
 6 |   private group: Group = new Group()
 7 | 
 8 |   private tween: Tween<T>
 9 | 
10 |   constructor(public state: T) {
11 |     super()
12 |     this.state = state
13 |   }
14 | 
15 |   set(newState: T) {
16 |     this.group.removeAll()
17 |     for (let tween of this.group.getAll()) {
18 |       tween.stop().stopChainedTweens()
19 |     }
20 | 
21 |     this.state = newState
22 |   }
23 | 
24 |   update(newState: T, time: number) {
25 |     this.group.removeAll()
26 |     for (let tween of this.group.getAll()) {
27 |       tween.stop().stopChainedTweens()
28 |     }
29 | 
30 |     this.tween = new Tween(this.state, this.group)
31 |       .easing(Easing.Quadratic.Out)
32 |       .to(newState, time)
33 |       .start()
34 |       .onComplete(result => {
35 |         this.state = result
36 |         this.tween = null
37 |       })
38 |       .onStop(result => {
39 |         this.state = newState
40 |         this.tween = null
41 |       })
42 | 
43 |     return this.tween
44 |   }
45 | 
46 |   willUpdate({ tickerState }: EntityUpdateContext) {
47 |     this.group.update(tickerState.currentTimestamp)
48 |   }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/entity/Entity.ts:
--------------------------------------------------------------------------------
 1 | import { InputState } from '../inputManager/InputState'
 2 | import { Vector2 } from '../math/Vector2'
 3 | import { Scene } from '../scene/Scene'
 4 | import { TickerState } from '../ticker/Ticker'
 5 | import { Widget } from '../widgets/Widget'
 6 | 
 7 | export type EntityUpdateContext = {
 8 |   matrix: DOMMatrix
 9 |   inputState: InputState
10 |   tickerState: TickerState
11 |   canvasSize: Vector2
12 | }
13 | export type EntityDrawContext = {
14 |   ctx: CanvasRenderingContext2D
15 |   tickerState: TickerState
16 |   canvasSize: Vector2
17 | }
18 | 
19 | export abstract class Entity {
20 |   abstract widgets: Widget[]
21 | 
22 |   protected scene: Scene | null = null
23 | 
24 |   _mount(scene: Scene) {
25 |     this.scene = scene
26 |   }
27 | 
28 |   _unmount() {
29 |     this.scene = null
30 |   }
31 | 
32 |   _update(context: EntityUpdateContext) {
33 |     for (let widget of Object.values(this.widgets)) {
34 |       widget.willUpdate(context)
35 |     }
36 | 
37 |     this.update(context)
38 | 
39 |     for (let widget of Object.values(this.widgets)) {
40 |       widget.didUpdate(context)
41 |     }
42 |   }
43 | 
44 |   _draw(context: EntityDrawContext) {
45 |     for (let widget of Object.values(this.widgets)) {
46 |       widget.willDraw(context)
47 |     }
48 | 
49 |     this.draw(context)
50 | 
51 |     for (let widget of Object.values(this.widgets)) {
52 |       widget.didDraw(context)
53 |     }
54 |   }
55 | 
56 |   abstract update(context: EntityUpdateContext): void
57 |   abstract draw(context: EntityDrawContext): void
58 | }
59 | 


--------------------------------------------------------------------------------
/src/ticker/AnimationFrameTicker.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |   CancelTickerListener,
 3 |   Ticker,
 4 |   TickerListener,
 5 |   TickerState,
 6 | } from './Ticker'
 7 | 
 8 | export class AnimationFrameTicker extends Ticker {
 9 |   private listeners: Set<TickerListener> = new Set()
10 | 
11 |   private afId: number | null = null
12 | 
13 |   private frameNumber: number = 0
14 |   private startTimestamp: number = 0
15 |   private lastTimestamp: number = 0
16 | 
17 |   get isRunning(): boolean {
18 |     return this.afId !== null
19 |   }
20 | 
21 |   start(): void {
22 |     if (this.afId === null) {
23 |       this.frameNumber = 0
24 | 
25 |       this.scheduleNextAnimationFrame()
26 |     }
27 |   }
28 | 
29 |   stop(): void {
30 |     if (this.afId !== null) {
31 |       cancelAnimationFrame(this.afId)
32 |       this.afId = null
33 |     }
34 |   }
35 | 
36 |   private scheduleNextAnimationFrame(): void {
37 |     this.afId = requestAnimationFrame(this.tick.bind(this))
38 |   }
39 | 
40 |   private tick(currentTimestamp: number): void {
41 |     this.scheduleNextAnimationFrame()
42 | 
43 |     if (this.frameNumber === 0) {
44 |       this.startTimestamp = currentTimestamp
45 |       this.lastTimestamp = currentTimestamp
46 |     }
47 | 
48 |     const tickerState: TickerState = {
49 |       frameNumber: this.frameNumber,
50 |       startTimestamp: this.startTimestamp,
51 |       lastTimestamp: this.lastTimestamp,
52 |       currentTimestamp: currentTimestamp,
53 |       delta: currentTimestamp - this.lastTimestamp,
54 |     }
55 | 
56 |     for (let listener of this.listeners) {
57 |       listener(tickerState)
58 |     }
59 | 
60 |     this.lastTimestamp = currentTimestamp
61 |     this.frameNumber += 1
62 |   }
63 | 
64 |   listen(listener: TickerListener): CancelTickerListener {
65 |     this.listeners.add(listener)
66 | 
67 |     return () => {
68 |       this.listeners.delete(listener)
69 |     }
70 |   }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/scene/Scene.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |   Entity,
 3 |   EntityDrawContext,
 4 |   EntityUpdateContext,
 5 | } from '../entity/Entity'
 6 | 
 7 | export abstract class Scene {
 8 |   private entities: Set<Entity> = new Set()
 9 | 
10 |   protected add(entity: Entity) {
11 |     this.entities.add(entity)
12 |   }
13 | 
14 |   protected addAll(entities: Entity[]) {
15 |     for (let entity of entities) {
16 |       this.entities.add(entity)
17 |     }
18 |   }
19 | 
20 |   protected remove(entity: Entity) {
21 |     this.entities.delete(entity)
22 |   }
23 | 
24 |   willMount(): void {}
25 |   didUnmount(): void {}
26 | 
27 |   prepare(
28 |     _updateContext: EntityUpdateContext,
29 |     _drawContext: EntityDrawContext
30 |   ): void {}
31 | 
32 |   cleanup(
33 |     _updateContext: EntityUpdateContext,
34 |     _drawContext: EntityDrawContext
35 |   ): void {}
36 | 
37 |   willUpdate(_context: EntityUpdateContext): void {}
38 |   didUpdate(_context: EntityUpdateContext): void {}
39 |   willDraw(_context: EntityDrawContext): void {}
40 |   didDraw(_context: EntityDrawContext): void {}
41 | 
42 |   update(context: EntityUpdateContext) {
43 |     this.willUpdate(context)
44 | 
45 |     for (let entity of this.entities) {
46 |       entity._update(context)
47 |     }
48 | 
49 |     this.didUpdate(context)
50 |   }
51 | 
52 |   draw(context: EntityDrawContext) {
53 |     this.willDraw(context)
54 | 
55 |     for (let entity of this.entities) {
56 |       context.ctx.save()
57 |       entity._draw(context)
58 |       context.ctx.restore()
59 |     }
60 | 
61 |     this.didDraw(context)
62 |   }
63 | 
64 |   mount(): void {
65 |     this.willMount()
66 | 
67 |     for (let entity of this.entities) {
68 |       entity._mount(this)
69 |     }
70 |   }
71 | 
72 |   unmount(): void {
73 |     for (let entity of this.entities) {
74 |       entity._unmount()
75 |     }
76 | 
77 |     this.entities.clear()
78 | 
79 |     this.didUnmount()
80 |   }
81 | }
82 | 


--------------------------------------------------------------------------------
/src/widgets/MousePath.ts:
--------------------------------------------------------------------------------
 1 | import { EntityUpdateContext } from '../entity/Entity'
 2 | import { Key } from '../inputManager/Key'
 3 | import { Vector2 } from '../math/Vector2'
 4 | import { Widget } from './Widget'
 5 | 
 6 | export type PathStartedCallback = (start: Vector2, key: Key) => void
 7 | export type PathEndedCallback = (path: Array<Vector2>, key: Key) => void
 8 | 
 9 | export class MousePathWidget extends Widget {
10 |   public isTracking = false
11 |   public state: Array<Vector2> = []
12 | 
13 |   constructor(public keys: Key[]) {
14 |     super()
15 |   }
16 | 
17 |   private shouldNotifyPathStarted: boolean = false
18 |   private shouldNotifyPathEnded: boolean = false
19 |   private key: Key | null = null
20 | 
21 |   willUpdate({ inputState }: EntityUpdateContext) {
22 |     if (this.isTracking === false) {
23 |       const key = this.keys.find(inputState.isJustPressed.bind(inputState))
24 | 
25 |       if (key) {
26 |         this.state = []
27 |         this.isTracking = true
28 | 
29 |         this.key = key
30 |         this.shouldNotifyPathStarted = true
31 |       }
32 |     }
33 | 
34 |     if (
35 |       this.isTracking === true &&
36 |       this.key &&
37 |       inputState.isPressed(this.key)
38 |     ) {
39 |       this.state.push(inputState.mouse.clone())
40 |     }
41 | 
42 |     if (
43 |       this.isTracking === true &&
44 |       this.key &&
45 |       inputState.isJustReleased(this.key)
46 |     ) {
47 |       this.isTracking = false
48 |       this.shouldNotifyPathEnded = true
49 |     }
50 |   }
51 | 
52 |   onPathStarted(callback: PathStartedCallback) {
53 |     if (this.shouldNotifyPathStarted) {
54 |       this.shouldNotifyPathStarted = false
55 | 
56 |       callback(this.state[0], this.key!)
57 |     }
58 |   }
59 | 
60 |   onPathEnded(callback: PathEndedCallback) {
61 |     if (this.shouldNotifyPathEnded) {
62 |       this.shouldNotifyPathEnded = false
63 | 
64 |       const state = this.state
65 |       this.state = []
66 | 
67 |       callback(state, this.key!)
68 |     }
69 |   }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/math/Vector2.ts:
--------------------------------------------------------------------------------
 1 | export class Vector2 {
 2 |   constructor(private _x: number = 0, private _y: number = 0) {}
 3 | 
 4 |   get x(): number {
 5 |     return this._x
 6 |   }
 7 | 
 8 |   get y(): number {
 9 |     return this._y
10 |   }
11 | 
12 |   get e(): [number, number] {
13 |     return [this._x, this._y]
14 |   }
15 | 
16 |   get o(): { x: number; y: number } {
17 |     return { x: this._x, y: this._y }
18 |   }
19 | 
20 |   static from({ x, y }: { x: number; y: number }) {
21 |     return Vector2.of(x, y)
22 |   }
23 | 
24 |   clone = () => Vector2.of(this.x, this.y)
25 |   simpleProduct = () => this.x * this.y
26 |   asStride = (index: number) =>
27 |     Vector2.of(index % this.x, (index - (index % this.x)) / this.x)
28 | 
29 |   add(other: Vector2): Vector2
30 |   add(x: number, y?: number): Vector2
31 |   add(x: number | Vector2, y?: number): Vector2 {
32 |     if (x instanceof Vector2) {
33 |       return Vector2.of(this._x + x._x, this._y + x._y)
34 |     }
35 | 
36 |     return Vector2.of(this._x + x, this._y + (y ?? x))
37 |   }
38 | 
39 |   mul = (x: number, y?: number) => Vector2.of(this.x * x, this.y * (y ?? x))
40 | 
41 |   div(other: Vector2): Vector2
42 |   div(x: number, y?: number): Vector2
43 |   div(x: number | Vector2, y?: number): Vector2 {
44 |     if (x instanceof Vector2) {
45 |       return Vector2.of(this._x / x._x, this._y / x._y)
46 |     }
47 | 
48 |     return Vector2.of(this._x / x, this._y / (y ?? x))
49 |   }
50 | 
51 |   pipe = (fn: (value: Vector2) => Vector2) => fn(this)
52 | 
53 |   equals = (other: Vector2) => this.x === other.x && this.y === other.y
54 | 
55 |   distance = (other: Vector2) =>
56 |     Math.sqrt(Math.pow(other.x - this.x, 2) + Math.pow(other.y - this.y, 2))
57 | 
58 |   snapToGrid = (size: Vector2) =>
59 |     Vector2.of(
60 |       Math.round(this.x / size.x) * size.x,
61 |       Math.round(this.y / size.y) * size.y
62 |     )
63 | 
64 |   transform = (matrix: DOMMatrix) =>
65 |     Vector2.fromDOMPoint(matrix.transformPoint({ x: this._x, y: this._y }))
66 | 
67 |   floor = () => Vector2.of(Math.floor(this._x), Math.floor(this._y))
68 | 
69 |   static fromDOMPoint(point: DOMPoint) {
70 |     return new Vector2(point.x, point.y)
71 |   }
72 | 
73 |   static zero(): Vector2 {
74 |     return new Vector2(0, 0)
75 |   }
76 | 
77 |   static of(x: number, y?: number) {
78 |     return new Vector2(x, y ?? x)
79 |   }
80 | }
81 | 
82 | export const vec2 = (x: number, y?: number) => Vector2.of(x, y ?? x)
83 | 


--------------------------------------------------------------------------------
/src/inputManager/Key.ts:
--------------------------------------------------------------------------------
  1 | export enum Key {
  2 |   LMB = 0,
  3 |   MMB = 1,
  4 |   RMB = 2,
  5 |   MB3 = 3,
  6 |   MB4 = 4,
  7 | 
  8 |   Backspace = 8,
  9 |   Tab = 9,
 10 |   Enter = 13,
 11 |   Shift = 16,
 12 |   Ctrl = 17,
 13 |   Alt = 18,
 14 |   PauseBreak = 19,
 15 |   CapsLock = 20,
 16 |   Escape = 27,
 17 |   Space = 32,
 18 |   PageUp = 33,
 19 |   PageDown = 34,
 20 |   End = 35,
 21 |   Home = 36,
 22 | 
 23 |   LeftArrow = 37,
 24 |   UpArrow = 38,
 25 |   RightArrow = 39,
 26 |   DownArrow = 40,
 27 | 
 28 |   Insert = 45,
 29 |   Delete = 46,
 30 | 
 31 |   Zero = 48,
 32 |   ClosedParen = Zero,
 33 |   One = 49,
 34 |   ExclamationMark = One,
 35 |   Two = 50,
 36 |   AtSign = Two,
 37 |   Three = 51,
 38 |   PoundSign = Three,
 39 |   Hash = PoundSign,
 40 |   Four = 52,
 41 |   DollarSign = Four,
 42 |   Five = 53,
 43 |   PercentSign = Five,
 44 |   Six = 54,
 45 |   Caret = Six,
 46 |   Hat = Caret,
 47 |   Seven = 55,
 48 |   Ampersand = Seven,
 49 |   Eight = 56,
 50 |   Star = Eight,
 51 |   Asterik = Star,
 52 |   Nine = 57,
 53 |   OpenParen = Nine,
 54 | 
 55 |   A = 65,
 56 |   B = 66,
 57 |   C = 67,
 58 |   D = 68,
 59 |   E = 69,
 60 |   F = 70,
 61 |   G = 71,
 62 |   H = 72,
 63 |   I = 73,
 64 |   J = 74,
 65 |   K = 75,
 66 |   L = 76,
 67 |   M = 77,
 68 |   N = 78,
 69 |   O = 79,
 70 |   P = 80,
 71 |   Q = 81,
 72 |   R = 82,
 73 |   S = 83,
 74 |   T = 84,
 75 |   U = 85,
 76 |   V = 86,
 77 |   W = 87,
 78 |   X = 88,
 79 |   Y = 89,
 80 |   Z = 90,
 81 | 
 82 |   LeftWindowKey = 91,
 83 |   RightWindowKey = 92,
 84 |   SelectKey = 93,
 85 | 
 86 |   Numpad0 = 96,
 87 |   Numpad1 = 97,
 88 |   Numpad2 = 98,
 89 |   Numpad3 = 99,
 90 |   Numpad4 = 100,
 91 |   Numpad5 = 101,
 92 |   Numpad6 = 102,
 93 |   Numpad7 = 103,
 94 |   Numpad8 = 104,
 95 |   Numpad9 = 105,
 96 | 
 97 |   Multiply = 106,
 98 |   Add = 107,
 99 |   Subtract = 109,
100 |   DecimalPoint = 110,
101 |   Divide = 111,
102 | 
103 |   F1 = 112,
104 |   F2 = 113,
105 |   F3 = 114,
106 |   F4 = 115,
107 |   F5 = 116,
108 |   F6 = 117,
109 |   F7 = 118,
110 |   F8 = 119,
111 |   F9 = 120,
112 |   F10 = 121,
113 |   F11 = 122,
114 |   F12 = 123,
115 | 
116 |   NumLock = 144,
117 |   ScrollLock = 145,
118 | 
119 |   SemiColon = 186,
120 |   Equals = 187,
121 |   Comma = 188,
122 |   Dash = 189,
123 |   Period = 190,
124 |   UnderScore = Dash,
125 |   PlusSign = Equals,
126 |   ForwardSlash = 191,
127 |   Tilde = 192,
128 |   GraveAccent = Tilde,
129 | 
130 |   OpenBracket = 219,
131 |   ClosedBracket = 221,
132 |   Quote = 222,
133 | }
134 | 
135 | export function isKey(keyCode: number): keyCode is Key {
136 |   return keyCode <= Key.Backspace && keyCode >= Key.Quote
137 | }
138 | 


--------------------------------------------------------------------------------
/src/inputManager/InputManager.ts:
--------------------------------------------------------------------------------
 1 | import { InputState, KeyState } from './InputState'
 2 | import { Key } from './Key'
 3 | import { vec2, Vector2 } from '../math/Vector2'
 4 | 
 5 | export class InputManager {
 6 |   private state: Map<Key, KeyState> = new Map()
 7 |   private mousePosition: Vector2 = vec2(0, 0)
 8 | 
 9 |   private element: HTMLElement | null = null
10 | 
11 |   getState(): InputState {
12 |     return new InputState(
13 |       new Map(this.state.entries()),
14 |       this.mousePosition.clone()
15 |     )
16 |   }
17 | 
18 |   processTick(): void {
19 |     for (let key of this.state.keys()) {
20 |       const state = this.state.get(key)!
21 | 
22 |       this.state.set(key, {
23 |         pressed: state.pressed,
24 |         fe: false,
25 |         re: false,
26 |       })
27 |     }
28 |   }
29 | 
30 |   mount(element: HTMLElement): void {
31 |     this.element = element
32 |     window.addEventListener('keydown', this.handleKeydown)
33 |     window.addEventListener('keyup', this.handleKeyup)
34 |     window.addEventListener('mousedown', this.handleMousedown)
35 |     window.addEventListener('mouseup', this.handleMouseup)
36 |     window.addEventListener('mousemove', this.handleMousemove)
37 |   }
38 | 
39 |   unmount(): void {
40 |     this.element = null
41 |     window.removeEventListener('keydown', this.handleKeydown)
42 |     window.removeEventListener('keyup', this.handleKeyup)
43 |     window.removeEventListener('mousedown', this.handleMousedown)
44 |     window.removeEventListener('mouseup', this.handleMouseup)
45 |     window.removeEventListener('mousemove', this.handleMousemove)
46 |   }
47 | 
48 |   private handleKeydown = (event: KeyboardEvent) => {
49 |     const state = this.state.get(event.keyCode)
50 | 
51 |     if (!state?.pressed) {
52 |       this.state.set(event.keyCode, {
53 |         re: true,
54 |         fe: false,
55 |         pressed: true,
56 |       })
57 |     }
58 |   }
59 | 
60 |   private handleKeyup = (event: KeyboardEvent) => {
61 |     this.state.set(event.keyCode, {
62 |       re: false,
63 |       fe: true,
64 |       pressed: false,
65 |     })
66 |   }
67 | 
68 |   private handleMousedown = (event: MouseEvent) => {
69 |     const state = this.state.get(event.button)
70 | 
71 |     if (!state?.pressed) {
72 |       this.state.set(event.button, {
73 |         re: true,
74 |         fe: false,
75 |         pressed: true,
76 |       })
77 |     }
78 |   }
79 |   private handleMouseup = (event: MouseEvent) => {
80 |     this.state.set(event.button, {
81 |       re: false,
82 |       fe: true,
83 |       pressed: false,
84 |     })
85 |   }
86 |   private handleMousemove = (event: MouseEvent) => {
87 |     const boundingRect = this.element?.getBoundingClientRect()
88 | 
89 |     this.mousePosition = vec2(
90 |       event.clientX - (boundingRect?.left ?? 0),
91 |       event.clientY - (boundingRect?.top ?? 0)
92 |     )
93 |   }
94 | }
95 | 


--------------------------------------------------------------------------------
/src/engine/Engine.ts:
--------------------------------------------------------------------------------
  1 | import { vec2, Vector2 } from '../math/Vector2'
  2 | import { Scene } from '../scene/Scene'
  3 | import { Ticker, TickerState } from '../ticker/Ticker'
  4 | import { InputManager } from '../inputManager/InputManager'
  5 | import { EntityDrawContext, EntityUpdateContext } from '../entity/Entity'
  6 | 
  7 | type SceneConstructor = { new (): Scene }
  8 | 
  9 | type EngineOptions = {
 10 |   canvas: HTMLCanvasElement
 11 |   size: Vector2
 12 |   ticker: Ticker
 13 | }
 14 | 
 15 | export class Engine {
 16 |   public ticker: Ticker
 17 | 
 18 |   private canvas: HTMLCanvasElement
 19 |   private context: CanvasRenderingContext2D
 20 | 
 21 |   private canvasSize!: Vector2
 22 |   private input = new InputManager()
 23 | 
 24 |   private scenes: Map<string, SceneConstructor> = new Map()
 25 |   private stack: Scene[] = []
 26 | 
 27 |   constructor({ canvas, size, ticker }: EngineOptions) {
 28 |     this.ticker = ticker
 29 | 
 30 |     this.canvas = canvas
 31 |     this.context = this.canvas.getContext('2d')!
 32 |     this.resize(size)
 33 | 
 34 |     this.input.mount(canvas)
 35 |     ticker.listen(this.tick.bind(this))
 36 | 
 37 |     window.addEventListener('resize', () => {
 38 |       this.resize(vec2(window.innerWidth, window.innerHeight))
 39 |     })
 40 |   }
 41 | 
 42 |   registerScene(name: string, Constructor: SceneConstructor) {
 43 |     this.scenes.set(name, Constructor)
 44 |   }
 45 | 
 46 |   getScene(name: string) {
 47 |     const Scene = this.scenes.get(name)
 48 | 
 49 |     if (!Scene) {
 50 |       throw new Error(`Requested to mount unregistered scene '${name}'`)
 51 |     }
 52 | 
 53 |     return new Scene()
 54 |   }
 55 | 
 56 |   pushScene(name: string) {
 57 |     const scene = this.getScene(name)
 58 | 
 59 |     this.stack.unshift(scene)
 60 | 
 61 |     scene.mount()
 62 |   }
 63 | 
 64 |   resize(newSize: Vector2) {
 65 |     this.canvasSize = newSize
 66 | 
 67 |     this.canvas.width = newSize.x
 68 |     this.canvas.height = newSize.y
 69 |   }
 70 | 
 71 |   private tick(tickerState: TickerState): void {
 72 |     this.context.clearRect(0, 0, this.canvasSize.x, this.canvasSize.y)
 73 | 
 74 |     const inputState = this.input.getState()
 75 | 
 76 |     let updateContext: EntityUpdateContext = {
 77 |       matrix: this.context.getTransform(),
 78 |       inputState: inputState,
 79 |       tickerState: tickerState,
 80 |       canvasSize: this.canvasSize,
 81 |     }
 82 | 
 83 |     let drawContext: EntityDrawContext = {
 84 |       ctx: this.context,
 85 |       tickerState: tickerState,
 86 |       canvasSize: this.canvasSize,
 87 |     }
 88 | 
 89 |     for (let scene of this.stack) {
 90 |       scene.prepare(updateContext, drawContext)
 91 |     }
 92 | 
 93 |     for (let scene of this.stack) {
 94 |       scene.update(updateContext)
 95 |     }
 96 | 
 97 |     for (let scene of this.stack) {
 98 |       scene.draw(drawContext)
 99 |     }
100 | 
101 |     for (let scene of this.stack) {
102 |       scene.cleanup(updateContext, drawContext)
103 |     }
104 | 
105 |     this.input.processTick()
106 |   }
107 | 
108 |   start(): void {
109 |     this.ticker.start()
110 |   }
111 | 
112 |   stop(): void {
113 |     this.ticker.stop()
114 |   }
115 | }
116 | 


--------------------------------------------------------------------------------
/example/src/DrawingEntity.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   Entity,
  3 |   EntityDrawContext,
  4 |   EntityUpdateContext,
  5 | } from '../../src/entity/Entity'
  6 | import { Key } from '../../src/inputManager/Key'
  7 | import { vec2, Vector2 } from '../../src/math/Vector2'
  8 | import { MousePathWidget } from '../../src/widgets/MousePath'
  9 | 
 10 | import simplify from 'simplify-js'
 11 | 
 12 | function shakey(path: Vector2[], amount: number = 2): Vector2[] {
 13 |   return path.map(point =>
 14 |     vec2(
 15 |       point.x + (Math.random() - 0.5) * amount,
 16 |       point.y + (Math.random() - 0.5) * amount
 17 |     )
 18 |   )
 19 | }
 20 | 
 21 | function distance(a: Vector2, b: Vector2): number {
 22 |   return Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2)
 23 | }
 24 | 
 25 | export class DrawingEntity extends Entity {
 26 |   path = new MousePathWidget([Key.Q, Key.W, Key.E])
 27 | 
 28 |   paths: { color: string; path: Vector2[]; closed: boolean }[] = []
 29 | 
 30 |   point: [string, Vector2] | null
 31 | 
 32 |   getColor(key: Key): string {
 33 |     let color: string
 34 |     switch (key) {
 35 |       case Key.Q:
 36 |         color = 'black'
 37 |         break
 38 |       case Key.W:
 39 |         color = 'darkgreen'
 40 |         break
 41 |       case Key.E:
 42 |         color = 'blue'
 43 |         break
 44 |     }
 45 |     return color
 46 |   }
 47 | 
 48 |   update(_context: EntityUpdateContext): void {
 49 |     this.path.onPathStarted((point, key) => {
 50 |       const color = this.getColor(key)
 51 |       this.point = [color, point]
 52 |     })
 53 | 
 54 |     this.path.onPathEnded((path, key) => {
 55 |       this.point = null
 56 | 
 57 |       const color = this.getColor(key)
 58 | 
 59 |       this.paths.push({
 60 |         color: color,
 61 |         path: simplify(path, 2).map(point => vec2(point.x, point.y)),
 62 |         closed: distance(path[path.length - 1], path[0]) < 10,
 63 |       })
 64 |     })
 65 |   }
 66 | 
 67 |   draw({ ctx }: EntityDrawContext): void {
 68 |     ctx.lineWidth = 2
 69 | 
 70 |     for (let { path, color, closed } of this.paths) {
 71 |       ctx.strokeStyle = color
 72 |       ctx.fillStyle = color
 73 |       ctx.beginPath()
 74 |       ctx.moveTo(path[0].x, path[0].y)
 75 | 
 76 |       for (let point of shakey(path.slice(1) as Vector2[], 2)) {
 77 |         ctx.lineTo(point.x, point.y)
 78 |       }
 79 | 
 80 |       if (closed) {
 81 |         ctx.closePath()
 82 |         ctx.fill()
 83 |       } else {
 84 |         ctx.stroke()
 85 |       }
 86 |     }
 87 | 
 88 |     if (this.point) {
 89 |       ctx.save()
 90 |       ctx.globalAlpha = 0.4
 91 |       ctx.beginPath()
 92 |       ctx.fillStyle = this.point[0]
 93 |       ctx.arc(this.point[1].x, this.point[1].y, 10, 0, Math.PI * 2)
 94 | 
 95 |       ctx.closePath()
 96 |       ctx.fill()
 97 |       ctx.restore()
 98 |     }
 99 | 
100 |     if (this.path.isTracking) {
101 |       ctx.strokeStyle = 'red'
102 | 
103 |       ctx.beginPath()
104 |       ctx.moveTo(this.path.state[0].x, this.path.state[0].y)
105 | 
106 |       for (let point of shakey(simplify(this.path.state.slice(1), 2), 2)) {
107 |         ctx.lineTo(point.x, point.y)
108 |       }
109 | 
110 |       ctx.stroke()
111 |     }
112 |   }
113 | 
114 |   widgets = [this.path]
115 | }
116 | 


--------------------------------------------------------------------------------
/src/assetLoader/AssetLoader.ts:
--------------------------------------------------------------------------------
  1 | import { Asset } from './Asset'
  2 | import { AssetDefinition, AssetType } from './AssetDefinition'
  3 | 
  4 | import { ImageAsset, SoundAsset } from './assetTypes'
  5 | 
  6 | export class AssetMap {
  7 |   constructor(private map: Record<string, Asset>) {}
  8 | 
  9 |   get<T extends Asset>(name: string) {
 10 |     return this.map[name] as T
 11 |   }
 12 | }
 13 | 
 14 | export class AssetLoader {
 15 |   private cache: Map<string, Map<AssetType, Asset>> = new Map()
 16 | 
 17 |   async loadAssetMap(
 18 |     assetMap: Record<string, AssetDefinition>,
 19 |     onProgress: (percentageLoaded: number) => void = () => {}
 20 |   ): Promise<AssetMap> {
 21 |     const totalAmount = Object.keys(assetMap).length
 22 |     let currentAmount = 0
 23 | 
 24 |     const updateProgress = () => {
 25 |       currentAmount += 1
 26 | 
 27 |       onProgress(currentAmount / totalAmount)
 28 |     }
 29 | 
 30 |     onProgress(0)
 31 | 
 32 |     return new AssetMap(
 33 |       Object.fromEntries(
 34 |         await Promise.all(
 35 |           Object.entries(assetMap).map(([name, assetDef]) => {
 36 |             return this.loadAsset(assetDef).then(asset => {
 37 |               updateProgress()
 38 | 
 39 |               return [name, asset]
 40 |             })
 41 |           })
 42 |         )
 43 |       )
 44 |     )
 45 |   }
 46 | 
 47 |   async loadAsset<T extends Asset>(
 48 |     assetDefinition: AssetDefinition
 49 |   ): Promise<T> {
 50 |     let asset: Asset | null = null
 51 | 
 52 |     const assetMap = this.cache.get(assetDefinition.source) ?? new Map()
 53 | 
 54 |     if (assetMap.has(assetDefinition.type)) {
 55 |       asset = assetMap.get(assetDefinition.type)
 56 |     }
 57 | 
 58 |     if (asset !== null) {
 59 |       return (asset as unknown) as T
 60 |     }
 61 | 
 62 |     switch (assetDefinition.type) {
 63 |       case AssetType.image:
 64 |         asset = await this.loadImageAsset(assetDefinition)
 65 |         break
 66 |       case AssetType.sound:
 67 |         asset = await this.loadSoundAsset(assetDefinition)
 68 |         break
 69 |       default:
 70 |         throw new Error(`Unknown asset type: '${assetDefinition.type}'`)
 71 |     }
 72 | 
 73 |     assetMap.set(assetDefinition.type, asset)
 74 |     this.cache.set(assetDefinition.source, assetMap)
 75 | 
 76 |     return (asset as unknown) as T
 77 |   }
 78 | 
 79 |   private loadImageAsset(
 80 |     assetDefinition: AssetDefinition
 81 |   ): Promise<ImageAsset> {
 82 |     const imageElement = new Image()
 83 | 
 84 |     return new Promise((resolve, reject) => {
 85 |       imageElement.addEventListener('error', reject, { once: true })
 86 |       imageElement.addEventListener(
 87 |         'load',
 88 |         () => {
 89 |           resolve(new ImageAsset(assetDefinition, imageElement))
 90 |         },
 91 |         { once: true }
 92 |       )
 93 | 
 94 |       imageElement.src = assetDefinition.source
 95 |     })
 96 |   }
 97 | 
 98 |   private loadSoundAsset(
 99 |     assetDefinition: AssetDefinition
100 |   ): Promise<SoundAsset> {
101 |     const soundElement = new Audio()
102 | 
103 |     return new Promise((resolve, reject) => {
104 |       soundElement.addEventListener('error', reject, { once: true })
105 |       soundElement.addEventListener(
106 |         'canplaythrough',
107 |         () => {
108 |           resolve(new SoundAsset(assetDefinition, soundElement))
109 |         },
110 |         { once: true }
111 |       )
112 | 
113 |       soundElement.src = assetDefinition.source
114 |     })
115 |   }
116 | }
117 | 


--------------------------------------------------------------------------------
/example/src/widgets/PathOnGridWidget.ts:
--------------------------------------------------------------------------------
  1 | import { Entity, EntityUpdateContext, Key, Vector2, Widget } from '../../../src'
  2 | 
  3 | export class TrackingPathOnGridWidget extends Widget {
  4 |   public isTracking = false
  5 | 
  6 |   constructor(public gridSize: Vector2, public tileSize: Vector2) {
  7 |     super()
  8 |   }
  9 | 
 10 |   public startPoint: Vector2 | null = null
 11 |   public endPoint: Vector2 | null = null
 12 | 
 13 |   public path: Vector2[] = []
 14 | 
 15 |   private shouldNotifyPathStart = false
 16 |   private shouldNotifyPathUpdated = false
 17 |   private shouldNotifyPathEnd = false
 18 | 
 19 |   willUpdate(context: EntityUpdateContext) {
 20 |     const { inputState } = context
 21 | 
 22 |     if (this.isTracking === false && inputState.isJustPressed(Key.LMB)) {
 23 |       return this.handlePathStart(context)
 24 |     } else if (this.isTracking === true && inputState.isPressed(Key.LMB)) {
 25 |       return this.handlePath(context)
 26 |     } else if (this.isTracking === true && inputState.isJustReleased(Key.LMB)) {
 27 |       return this.handlePathEnd(context)
 28 |     }
 29 |   }
 30 | 
 31 |   whenPathStarts(callback: () => void): void {
 32 |     if (this.shouldNotifyPathStart) {
 33 |       this.shouldNotifyPathStart = false
 34 |       callback()
 35 |     }
 36 |   }
 37 | 
 38 |   whenPathEnds(callback: () => void): void {
 39 |     if (this.shouldNotifyPathEnd) {
 40 |       this.shouldNotifyPathEnd = false
 41 |       callback()
 42 |     }
 43 |   }
 44 | 
 45 |   whenPathUpdates(callback: () => void): void {
 46 |     if (this.shouldNotifyPathUpdated) {
 47 |       this.shouldNotifyPathUpdated = false
 48 |       callback()
 49 |     }
 50 |   }
 51 | 
 52 |   clear(): void {
 53 |     this.isTracking = false
 54 |     this.path = []
 55 |     this.startPoint = null
 56 |     this.endPoint = null
 57 |   }
 58 | 
 59 |   private handlePathStart({ inputState, matrix }: EntityUpdateContext) {
 60 |     const candidate = this.transformMousePosition(inputState.mouse, matrix)
 61 | 
 62 |     if (this.isPointContainedInTheGrid(candidate)) {
 63 |       this.isTracking = true
 64 |       this.path = [candidate]
 65 |       this.startPoint = candidate
 66 |       this.shouldNotifyPathStart = true
 67 |     }
 68 |   }
 69 | 
 70 |   private handlePath({ inputState, matrix }: EntityUpdateContext) {
 71 |     const candidate = this.transformMousePosition(inputState.mouse, matrix)
 72 | 
 73 |     if (
 74 |       this.isPointContainedInTheGrid(candidate) &&
 75 |       !this.lastPathPoint.equals(candidate) &&
 76 |       this.lastPathPoint.distance(candidate) === 1
 77 |     ) {
 78 |       const index = this.path.findIndex(candidate.equals, candidate)
 79 | 
 80 |       const isPenultimate = index === this.path.length - 2
 81 | 
 82 |       if (isPenultimate && index !== -1) {
 83 |         this.path = this.path.slice(0, index)
 84 |       }
 85 | 
 86 |       if (index === -1 || isPenultimate) {
 87 |         this.endPoint = candidate
 88 |         this.path.push(candidate)
 89 |         this.shouldNotifyPathUpdated = true
 90 |       }
 91 |     }
 92 |   }
 93 | 
 94 |   private handlePathEnd(_context: EntityUpdateContext) {
 95 |     this.isTracking = false
 96 |     this.shouldNotifyPathEnd = true
 97 |   }
 98 | 
 99 |   private get lastPathPoint(): Vector2 {
100 |     return this.path[this.path.length - 1]
101 |   }
102 | 
103 |   private isPointContainedInTheGrid(point: Vector2) {
104 |     return (
105 |       point.x >= 0 &&
106 |       point.x < this.gridSize.x &&
107 |       point.y >= 0 &&
108 |       point.y < this.gridSize.y
109 |     )
110 |   }
111 | 
112 |   private transformMousePosition(initial: Vector2, matrix: DOMMatrix) {
113 |     return initial
114 |       .transform(matrix.inverse())
115 |       .snapToGrid(this.tileSize)
116 |       .div(this.tileSize)
117 |       .add(this.gridSize.div(2).floor())
118 |   }
119 | }
120 | 


--------------------------------------------------------------------------------
/example/src/scenes/GridScene.ts:
--------------------------------------------------------------------------------
  1 | import { Easing } from '@tweenjs/tween.js'
  2 | import {
  3 |   Entity,
  4 |   EntityDrawContext,
  5 |   EntityUpdateContext,
  6 |   Key,
  7 |   Scene,
  8 |   vec2,
  9 |   Vector2,
 10 | } from '../../../src'
 11 | import { AnimatedValueWidget } from '../widgets/AnimationWidget'
 12 | import { TrackingPathOnGridWidget } from '../widgets/PathOnGridWidget'
 13 | 
 14 | export class GridEntity extends Entity {
 15 |   widgets = []
 16 | 
 17 |   constructor(private position: Vector2) {
 18 |     super()
 19 |   }
 20 | 
 21 |   update() {}
 22 | 
 23 |   draw({ ctx }: EntityDrawContext) {
 24 |     ctx.fillStyle = 'rgba(0, 0, 0, 0.1)'
 25 |     ctx.beginPath()
 26 |     ctx.arc(this.position.x, this.position.y, 5, 0, Math.PI * 2)
 27 |     ctx.closePath()
 28 |     ctx.fill()
 29 |   }
 30 | }
 31 | 
 32 | const prepare = (v: Vector2) => v.add(-6, -4).mul(100)
 33 | 
 34 | class CreateTrackEntity extends Entity {
 35 |   trackWidget = new TrackingPathOnGridWidget(vec2(13, 9), vec2(100))
 36 | 
 37 |   tween = new AnimatedValueWidget({ size: 0 })
 38 |   lastPoint = new AnimatedValueWidget({ x: 0, y: 0 })
 39 | 
 40 |   widgets = [this.trackWidget, this.tween, this.lastPoint]
 41 | 
 42 |   path: Vector2[] = []
 43 | 
 44 |   update({ inputState, matrix }: EntityUpdateContext) {
 45 |     this.trackWidget.whenPathStarts(() => {
 46 |       console.log('tarl')
 47 |       this.lastPoint.set(this.trackWidget.path[0].o)
 48 |     })
 49 | 
 50 |     this.trackWidget.whenPathUpdates(() => {
 51 |       const oldPath = this.path
 52 |       const newPath = this.trackWidget.path.slice(0)
 53 |       if (newPath.length > 1) {
 54 |         this.tween.update({ size: 26 }, 250)
 55 | 
 56 |         if (oldPath.length > newPath.length) {
 57 |           this.lastPoint.set(oldPath[oldPath.length - 1].o)
 58 |           this.lastPoint
 59 |             .update(newPath[newPath.length - 1].o, 50)
 60 |             .onComplete(() => {
 61 |               this.path = newPath
 62 |             })
 63 |             .onStop(() => {
 64 |               this.path = newPath
 65 |             })
 66 |         } else if (oldPath.length < newPath.length) {
 67 |           this.path = newPath
 68 |           this.lastPoint.set(newPath[newPath.length - 2].o)
 69 |           this.lastPoint.update(newPath[newPath.length - 1].o, 150)
 70 |         }
 71 |       }
 72 |     })
 73 | 
 74 |     this.trackWidget.whenPathEnds(() => {
 75 |       this.tween.update({ size: 0 }, 150).onComplete(() => {
 76 |         this.trackWidget.clear()
 77 |         this.path = []
 78 |       })
 79 |     })
 80 |   }
 81 |   draw({ ctx }: EntityDrawContext) {
 82 |     if (this.path.length > 1) {
 83 |       const path = this.path.slice(0, this.path.length - 1)
 84 |       ctx.beginPath()
 85 |       ctx.strokeStyle = 'black'
 86 |       ctx.lineWidth = this.tween.state.size * 2
 87 |       ctx.lineJoin = 'round'
 88 |       ctx.lineCap = 'round'
 89 | 
 90 |       ctx.moveTo(...path[0].pipe(prepare).e)
 91 | 
 92 |       for (let point of path.slice(1)) {
 93 |         ctx.lineTo(...point.pipe(prepare).e)
 94 |       }
 95 | 
 96 |       const lastPoint = Vector2.from(this.lastPoint.state).pipe(prepare)
 97 | 
 98 |       ctx.lineTo(...lastPoint.e)
 99 | 
100 |       ctx.stroke()
101 |     }
102 |   }
103 | }
104 | 
105 | export class GridScene extends Scene {
106 |   gridSize = 100
107 |   grid: GridEntity[] = []
108 |   size: Vector2 = vec2(13, 9)
109 | 
110 |   willMount() {
111 |     for (let i = 0; i < this.size.simpleProduct(); i++) {
112 |       const position = this.size.asStride(i).pipe(prepare)
113 | 
114 |       const entity = new GridEntity(position)
115 | 
116 |       this.grid.push(entity)
117 |     }
118 | 
119 |     this.addAll(this.grid)
120 | 
121 |     this.add(new CreateTrackEntity())
122 |   }
123 | 
124 |   prepare(
125 |     updateContext: EntityUpdateContext,
126 |     { ctx, canvasSize }: EntityDrawContext
127 |   ) {
128 |     ctx.save()
129 |     const half = canvasSize.div(2)
130 | 
131 |     ctx.translate(half.x, half.y)
132 | 
133 |     updateContext.matrix = ctx.getTransform()
134 |   }
135 | 
136 |   cleanup(updateContext: EntityUpdateContext, { ctx }: EntityDrawContext) {
137 |     ctx.restore()
138 | 
139 |     updateContext.matrix = ctx.getTransform()
140 |   }
141 | }
142 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | @are/engine Copyright 2020 Artur Wojciechowski (“Licensor”)
 2 | 
 3 | Hippocratic License Version Number: 2.1.
 4 | 
 5 | Purpose. The purpose of this License is for the Licensor named above to permit the Licensee (as defined below) broad permission, if consistent with Human Rights Laws and Human Rights Principles (as each is defined below), to use and work with the Software (as defined below) within the full scope of Licensor’s copyright and patent rights, if any, in the Software, while ensuring attribution and protecting the Licensor from liability.
 6 | 
 7 | Permission and Conditions. The Licensor grants permission by this license (“License”), free of charge, to the extent of Licensor’s rights under applicable copyright and patent law, to any person or entity (the “Licensee”) obtaining a copy of this software and associated documentation files (the “Software”), to do everything with the Software that would otherwise infringe (i) the Licensor’s copyright in the Software or (ii) any patent claims to the Software that the Licensor can license or becomes able to license, subject to all of the following terms and conditions:
 8 | 
 9 | * Acceptance. This License is automatically offered to every person and entity subject to its terms and conditions. Licensee accepts this License and agrees to its terms and conditions by taking any action with the Software that, absent this License, would infringe any intellectual property right held by Licensor.
10 | 
11 | * Notice. Licensee must ensure that everyone who gets a copy of any part of this Software from Licensee, with or without changes, also receives the License and the above copyright notice (and if included by the Licensor, patent, trademark and attribution notice). Licensee must cause any modified versions of the Software to carry prominent notices stating that Licensee changed the Software. For clarity, although Licensee is free to create modifications of the Software and distribute only the modified portion created by Licensee with additional or different terms, the portion of the Software not modified must be distributed pursuant to this License. If anyone notifies Licensee in writing that Licensee has not complied with this Notice section, Licensee can keep this License by taking all practical steps to comply within 30 days after the notice. If Licensee does not do so, Licensee’s License (and all rights licensed hereunder) shall end immediately.
12 | 
13 | * Compliance with Human Rights Principles and Human Rights Laws.
14 | 
15 |     1. Human Rights Principles.
16 | 
17 |         (a) Licensee is advised to consult the articles of the United Nations Universal Declaration of Human Rights and the United Nations Global Compact that define recognized principles of international human rights (the “Human Rights Principles”). Licensee shall use the Software in a manner consistent with Human Rights Principles.
18 | 
19 |         (b) Unless the Licensor and Licensee agree otherwise, any dispute, controversy, or claim arising out of or relating to (i) Section 1(a) regarding Human Rights Principles, including the breach of Section 1(a), termination of this License for breach of the Human Rights Principles, or invalidity of Section 1(a) or (ii) a determination of whether any Law is consistent or in conflict with Human Rights Principles pursuant to Section 2, below, shall be settled by arbitration in accordance with the Hague Rules on Business and Human Rights Arbitration (the “Rules”); provided, however, that Licensee may elect not to participate in such arbitration, in which event this License (and all rights licensed hereunder) shall end immediately. The number of arbitrators shall be one unless the Rules require otherwise.
20 | 
21 |         Unless both the Licensor and Licensee agree to the contrary: (1) All documents and information concerning the arbitration shall be public and may be disclosed by any party; (2) The repository referred to under Article 43 of the Rules shall make available to the public in a timely manner all documents concerning the arbitration which are communicated to it, including all submissions of the parties, all evidence admitted into the record of the proceedings, all transcripts or other recordings of hearings and all orders, decisions and awards of the arbitral tribunal, subject only to the arbitral tribunal's powers to take such measures as may be necessary to safeguard the integrity of the arbitral process pursuant to Articles 18, 33, 41 and 42 of the Rules; and (3) Article 26(6) of the Rules shall not apply.
22 | 
23 |     2. Human Rights Laws. The Software shall not be used by any person or entity for any systems, activities, or other uses that violate any Human Rights Laws.  “Human Rights Laws” means any applicable laws, regulations, or rules (collectively, “Laws”) that protect human, civil, labor, privacy, political, environmental, security, economic, due process, or similar rights; provided, however, that such Laws are consistent and not in conflict with Human Rights Principles (a dispute over the consistency or a conflict between Laws and Human Rights Principles shall be determined by arbitration as stated above).  Where the Human Rights Laws of more than one jurisdiction are applicable or in conflict with respect to the use of the Software, the Human Rights Laws that are most protective of the individuals or groups harmed shall apply.
24 | 
25 |     3. Indemnity. Licensee shall hold harmless and indemnify Licensor (and any other contributor) against all losses, damages, liabilities, deficiencies, claims, actions, judgments, settlements, interest, awards, penalties, fines, costs, or expenses of whatever kind, including Licensor’s reasonable attorneys’ fees, arising out of or relating to Licensee’s use of the Software in violation of Human Rights Laws or Human Rights Principles.
26 | 
27 | * Failure to Comply. Any failure of Licensee to act according to the terms and conditions of this License is both a breach of the License and an infringement of the intellectual property rights of the Licensor (subject to exceptions under Laws, e.g., fair use). In the event of a breach or infringement, the terms and conditions of this License may be enforced by Licensor under the Laws of any jurisdiction to which Licensee is subject. Licensee also agrees that the Licensor may enforce the terms and conditions of this License against Licensee through specific performance (or similar remedy under Laws) to the extent permitted by Laws. For clarity, except in the event of a breach of this License, infringement, or as otherwise stated in this License, Licensor may not terminate this License with Licensee.
28 | 
29 | * Enforceability and Interpretation. If any term or provision of this License is determined to be invalid, illegal, or unenforceable by a court of competent jurisdiction, then such invalidity, illegality, or unenforceability shall not affect any other term or provision of this License or invalidate or render unenforceable such term or provision in any other jurisdiction; provided, however, subject to a court modification pursuant to the immediately following sentence, if any term or provision of this License pertaining to Human Rights Laws or Human Rights Principles is deemed invalid, illegal, or unenforceable against Licensee by a court of competent jurisdiction, all rights in the Software granted to Licensee shall be deemed null and void as between Licensor and Licensee. Upon a determination that any term or provision is invalid, illegal, or unenforceable, to the extent permitted by Laws, the court may modify this License to affect the original purpose that the Software be used in compliance with Human Rights Principles and Human Rights Laws as closely as possible. The language in this License shall be interpreted as to its fair meaning and not strictly for or against any party.
30 | 
31 | * Disclaimer. TO THE FULL EXTENT ALLOWED BY LAW, THIS SOFTWARE COMES “AS IS,” WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED, AND LICENSOR AND ANY OTHER CONTRIBUTOR SHALL NOT BE LIABLE TO ANYONE FOR ANY DAMAGES OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THIS LICENSE, UNDER ANY KIND OF LEGAL CLAIM.
32 | 
33 | This Hippocratic License is an Ethical Source license (https://ethicalsource.dev) and is offered for use by licensors and licensees at their own risk, on an “AS IS” basis, and with no warranties express or implied, to the maximum extent permitted by Laws.
34 | 


--------------------------------------------------------------------------------
/example/dist/index.js:
--------------------------------------------------------------------------------
  1 | // modules are defined as an array
  2 | // [ module function, map of requires ]
  3 | //
  4 | // map of requires is short require name -> numeric require
  5 | //
  6 | // anything defined in a previous bundle is accessed via the
  7 | // orig method which is the require for previous bundles
  8 | parcelRequire = (function (modules, cache, entry, globalName) {
  9 |   // Save the require from previous bundle to this closure if any
 10 |   var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
 11 |   var nodeRequire = typeof require === 'function' && require;
 12 | 
 13 |   function newRequire(name, jumped) {
 14 |     if (!cache[name]) {
 15 |       if (!modules[name]) {
 16 |         // if we cannot find the module within our internal map or
 17 |         // cache jump to the current global require ie. the last bundle
 18 |         // that was added to the page.
 19 |         var currentRequire = typeof parcelRequire === 'function' && parcelRequire;
 20 |         if (!jumped && currentRequire) {
 21 |           return currentRequire(name, true);
 22 |         }
 23 | 
 24 |         // If there are other bundles on this page the require from the
 25 |         // previous one is saved to 'previousRequire'. Repeat this as
 26 |         // many times as there are bundles until the module is found or
 27 |         // we exhaust the require chain.
 28 |         if (previousRequire) {
 29 |           return previousRequire(name, true);
 30 |         }
 31 | 
 32 |         // Try the node require function if it exists.
 33 |         if (nodeRequire && typeof name === 'string') {
 34 |           return nodeRequire(name);
 35 |         }
 36 | 
 37 |         var err = new Error('Cannot find module \'' + name + '\'');
 38 |         err.code = 'MODULE_NOT_FOUND';
 39 |         throw err;
 40 |       }
 41 | 
 42 |       localRequire.resolve = resolve;
 43 |       localRequire.cache = {};
 44 | 
 45 |       var module = cache[name] = new newRequire.Module(name);
 46 | 
 47 |       modules[name][0].call(module.exports, localRequire, module, module.exports, this);
 48 |     }
 49 | 
 50 |     return cache[name].exports;
 51 | 
 52 |     function localRequire(x){
 53 |       return newRequire(localRequire.resolve(x));
 54 |     }
 55 | 
 56 |     function resolve(x){
 57 |       return modules[name][1][x] || x;
 58 |     }
 59 |   }
 60 | 
 61 |   function Module(moduleName) {
 62 |     this.id = moduleName;
 63 |     this.bundle = newRequire;
 64 |     this.exports = {};
 65 |   }
 66 | 
 67 |   newRequire.isParcelRequire = true;
 68 |   newRequire.Module = Module;
 69 |   newRequire.modules = modules;
 70 |   newRequire.cache = cache;
 71 |   newRequire.parent = previousRequire;
 72 |   newRequire.register = function (id, exports) {
 73 |     modules[id] = [function (require, module) {
 74 |       module.exports = exports;
 75 |     }, {}];
 76 |   };
 77 | 
 78 |   var error;
 79 |   for (var i = 0; i < entry.length; i++) {
 80 |     try {
 81 |       newRequire(entry[i]);
 82 |     } catch (e) {
 83 |       // Save first error but execute all entries
 84 |       if (!error) {
 85 |         error = e;
 86 |       }
 87 |     }
 88 |   }
 89 | 
 90 |   if (entry.length) {
 91 |     // Expose entry point to Node, AMD or browser globals
 92 |     // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
 93 |     var mainExports = newRequire(entry[entry.length - 1]);
 94 | 
 95 |     // CommonJS
 96 |     if (typeof exports === "object" && typeof module !== "undefined") {
 97 |       module.exports = mainExports;
 98 | 
 99 |     // RequireJS
100 |     } else if (typeof define === "function" && define.amd) {
101 |      define(function () {
102 |        return mainExports;
103 |      });
104 | 
105 |     // <script>
106 |     } else if (globalName) {
107 |       this[globalName] = mainExports;
108 |     }
109 |   }
110 | 
111 |   // Override the current require with this new one
112 |   parcelRequire = newRequire;
113 | 
114 |   if (error) {
115 |     // throw error from earlier, _after updating parcelRequire_
116 |     throw error;
117 |   }
118 | 
119 |   return newRequire;
120 | })({"../node_modules/parcel-bundler/src/builtins/bundle-url.js":[function(require,module,exports) {
121 | var bundleURL = null;
122 | 
123 | function getBundleURLCached() {
124 |   if (!bundleURL) {
125 |     bundleURL = getBundleURL();
126 |   }
127 | 
128 |   return bundleURL;
129 | }
130 | 
131 | function getBundleURL() {
132 |   // Attempt to find the URL of the current script and use that as the base URL
133 |   try {
134 |     throw new Error();
135 |   } catch (err) {
136 |     var matches = ('' + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^)\n]+/g);
137 | 
138 |     if (matches) {
139 |       return getBaseURL(matches[0]);
140 |     }
141 |   }
142 | 
143 |   return '/';
144 | }
145 | 
146 | function getBaseURL(url) {
147 |   return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)\/[^/]+$/, '$1') + '/';
148 | }
149 | 
150 | exports.getBundleURL = getBundleURLCached;
151 | exports.getBaseURL = getBaseURL;
152 | },{}],"../node_modules/parcel-bundler/src/builtins/css-loader.js":[function(require,module,exports) {
153 | var bundle = require('./bundle-url');
154 | 
155 | function updateLink(link) {
156 |   var newLink = link.cloneNode();
157 | 
158 |   newLink.onload = function () {
159 |     link.remove();
160 |   };
161 | 
162 |   newLink.href = link.href.split('?')[0] + '?' + Date.now();
163 |   link.parentNode.insertBefore(newLink, link.nextSibling);
164 | }
165 | 
166 | var cssTimeout = null;
167 | 
168 | function reloadCSS() {
169 |   if (cssTimeout) {
170 |     return;
171 |   }
172 | 
173 |   cssTimeout = setTimeout(function () {
174 |     var links = document.querySelectorAll('link[rel="stylesheet"]');
175 | 
176 |     for (var i = 0; i < links.length; i++) {
177 |       if (bundle.getBaseURL(links[i].href) === bundle.getBundleURL()) {
178 |         updateLink(links[i]);
179 |       }
180 |     }
181 | 
182 |     cssTimeout = null;
183 |   }, 50);
184 | }
185 | 
186 | module.exports = reloadCSS;
187 | },{"./bundle-url":"../node_modules/parcel-bundler/src/builtins/bundle-url.js"}],"../node_modules/parcel-bundler/src/builtins/hmr-runtime.js":[function(require,module,exports) {
188 | var global = arguments[3];
189 | var OVERLAY_ID = '__parcel__error__overlay__';
190 | var OldModule = module.bundle.Module;
191 | 
192 | function Module(moduleName) {
193 |   OldModule.call(this, moduleName);
194 |   this.hot = {
195 |     data: module.bundle.hotData,
196 |     _acceptCallbacks: [],
197 |     _disposeCallbacks: [],
198 |     accept: function (fn) {
199 |       this._acceptCallbacks.push(fn || function () {});
200 |     },
201 |     dispose: function (fn) {
202 |       this._disposeCallbacks.push(fn);
203 |     }
204 |   };
205 |   module.bundle.hotData = null;
206 | }
207 | 
208 | module.bundle.Module = Module;
209 | var checkedAssets, assetsToAccept;
210 | var parent = module.bundle.parent;
211 | 
212 | if ((!parent || !parent.isParcelRequire) && typeof WebSocket !== 'undefined') {
213 |   var hostname = "" || location.hostname;
214 |   var protocol = location.protocol === 'https:' ? 'wss' : 'ws';
215 |   var ws = new WebSocket(protocol + '://' + hostname + ':' + "61931" + '/');
216 | 
217 |   ws.onmessage = function (event) {
218 |     checkedAssets = {};
219 |     assetsToAccept = [];
220 |     var data = JSON.parse(event.data);
221 | 
222 |     if (data.type === 'update') {
223 |       var handled = false;
224 |       data.assets.forEach(function (asset) {
225 |         if (!asset.isNew) {
226 |           var didAccept = hmrAcceptCheck(global.parcelRequire, asset.id);
227 | 
228 |           if (didAccept) {
229 |             handled = true;
230 |           }
231 |         }
232 |       }); // Enable HMR for CSS by default.
233 | 
234 |       handled = handled || data.assets.every(function (asset) {
235 |         return asset.type === 'css' && asset.generated.js;
236 |       });
237 | 
238 |       if (handled) {
239 |         console.clear();
240 |         data.assets.forEach(function (asset) {
241 |           hmrApply(global.parcelRequire, asset);
242 |         });
243 |         assetsToAccept.forEach(function (v) {
244 |           hmrAcceptRun(v[0], v[1]);
245 |         });
246 |       } else if (location.reload) {
247 |         // `location` global exists in a web worker context but lacks `.reload()` function.
248 |         location.reload();
249 |       }
250 |     }
251 | 
252 |     if (data.type === 'reload') {
253 |       ws.close();
254 | 
255 |       ws.onclose = function () {
256 |         location.reload();
257 |       };
258 |     }
259 | 
260 |     if (data.type === 'error-resolved') {
261 |       console.log('[parcel] ✨ Error resolved');
262 |       removeErrorOverlay();
263 |     }
264 | 
265 |     if (data.type === 'error') {
266 |       console.error('[parcel] 🚨  ' + data.error.message + '\n' + data.error.stack);
267 |       removeErrorOverlay();
268 |       var overlay = createErrorOverlay(data);
269 |       document.body.appendChild(overlay);
270 |     }
271 |   };
272 | }
273 | 
274 | function removeErrorOverlay() {
275 |   var overlay = document.getElementById(OVERLAY_ID);
276 | 
277 |   if (overlay) {
278 |     overlay.remove();
279 |   }
280 | }
281 | 
282 | function createErrorOverlay(data) {
283 |   var overlay = document.createElement('div');
284 |   overlay.id = OVERLAY_ID; // html encode message and stack trace
285 | 
286 |   var message = document.createElement('div');
287 |   var stackTrace = document.createElement('pre');
288 |   message.innerText = data.error.message;
289 |   stackTrace.innerText = data.error.stack;
290 |   overlay.innerHTML = '<div style="background: black; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; opacity: 0.85; font-family: Menlo, Consolas, monospace; z-index: 9999;">' + '<span style="background: red; padding: 2px 4px; border-radius: 2px;">ERROR</span>' + '<span style="top: 2px; margin-left: 5px; position: relative;">🚨</span>' + '<div style="font-size: 18px; font-weight: bold; margin-top: 20px;">' + message.innerHTML + '</div>' + '<pre>' + stackTrace.innerHTML + '</pre>' + '</div>';
291 |   return overlay;
292 | }
293 | 
294 | function getParents(bundle, id) {
295 |   var modules = bundle.modules;
296 | 
297 |   if (!modules) {
298 |     return [];
299 |   }
300 | 
301 |   var parents = [];
302 |   var k, d, dep;
303 | 
304 |   for (k in modules) {
305 |     for (d in modules[k][1]) {
306 |       dep = modules[k][1][d];
307 | 
308 |       if (dep === id || Array.isArray(dep) && dep[dep.length - 1] === id) {
309 |         parents.push(k);
310 |       }
311 |     }
312 |   }
313 | 
314 |   if (bundle.parent) {
315 |     parents = parents.concat(getParents(bundle.parent, id));
316 |   }
317 | 
318 |   return parents;
319 | }
320 | 
321 | function hmrApply(bundle, asset) {
322 |   var modules = bundle.modules;
323 | 
324 |   if (!modules) {
325 |     return;
326 |   }
327 | 
328 |   if (modules[asset.id] || !bundle.parent) {
329 |     var fn = new Function('require', 'module', 'exports', asset.generated.js);
330 |     asset.isNew = !modules[asset.id];
331 |     modules[asset.id] = [fn, asset.deps];
332 |   } else if (bundle.parent) {
333 |     hmrApply(bundle.parent, asset);
334 |   }
335 | }
336 | 
337 | function hmrAcceptCheck(bundle, id) {
338 |   var modules = bundle.modules;
339 | 
340 |   if (!modules) {
341 |     return;
342 |   }
343 | 
344 |   if (!modules[id] && bundle.parent) {
345 |     return hmrAcceptCheck(bundle.parent, id);
346 |   }
347 | 
348 |   if (checkedAssets[id]) {
349 |     return;
350 |   }
351 | 
352 |   checkedAssets[id] = true;
353 |   var cached = bundle.cache[id];
354 |   assetsToAccept.push([bundle, id]);
355 | 
356 |   if (cached && cached.hot && cached.hot._acceptCallbacks.length) {
357 |     return true;
358 |   }
359 | 
360 |   return getParents(global.parcelRequire, id).some(function (id) {
361 |     return hmrAcceptCheck(global.parcelRequire, id);
362 |   });
363 | }
364 | 
365 | function hmrAcceptRun(bundle, id) {
366 |   var cached = bundle.cache[id];
367 |   bundle.hotData = {};
368 | 
369 |   if (cached) {
370 |     cached.hot.data = bundle.hotData;
371 |   }
372 | 
373 |   if (cached && cached.hot && cached.hot._disposeCallbacks.length) {
374 |     cached.hot._disposeCallbacks.forEach(function (cb) {
375 |       cb(bundle.hotData);
376 |     });
377 |   }
378 | 
379 |   delete bundle.cache[id];
380 |   bundle(id);
381 |   cached = bundle.cache[id];
382 | 
383 |   if (cached && cached.hot && cached.hot._acceptCallbacks.length) {
384 |     cached.hot._acceptCallbacks.forEach(function (cb) {
385 |       cb();
386 |     });
387 | 
388 |     return true;
389 |   }
390 | }
391 | },{}]},{},["../node_modules/parcel-bundler/src/builtins/hmr-runtime.js"], null)
392 | //# sourceMappingURL=/index.js.map


--------------------------------------------------------------------------------
/example/dist/index.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"sources":["../node_modules/parcel-bundler/src/builtins/bundle-url.js","../node_modules/parcel-bundler/src/builtins/css-loader.js","../node_modules/parcel-bundler/src/builtins/hmr-runtime.js"],"names":["bundleURL","getBundleURLCached","getBundleURL","Error","err","matches","stack","match","getBaseURL","url","replace","exports","bundle","require","updateLink","link","newLink","cloneNode","onload","remove","href","split","Date","now","parentNode","insertBefore","nextSibling","cssTimeout","reloadCSS","setTimeout","links","document","querySelectorAll","i","length","module","OVERLAY_ID","OldModule","Module","moduleName","call","hot","data","hotData","_acceptCallbacks","_disposeCallbacks","accept","fn","push","dispose","checkedAssets","assetsToAccept","parent","isParcelRequire","WebSocket","hostname","location","protocol","ws","onmessage","event","JSON","parse","type","handled","assets","forEach","asset","isNew","didAccept","hmrAcceptCheck","global","parcelRequire","id","every","generated","js","console","clear","hmrApply","v","hmrAcceptRun","reload","close","onclose","log","removeErrorOverlay","error","message","overlay","createErrorOverlay","body","appendChild","getElementById","createElement","stackTrace","innerText","innerHTML","getParents","modules","parents","k","d","dep","Array","isArray","concat","Function","deps","cached","cache","some","cb"],"mappings":"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","file":"index.js","sourceRoot":"../src","sourcesContent":["var bundleURL = null;\nfunction getBundleURLCached() {\n  if (!bundleURL) {\n    bundleURL = getBundleURL();\n  }\n\n  return bundleURL;\n}\n\nfunction getBundleURL() {\n  // Attempt to find the URL of the current script and use that as the base URL\n  try {\n    throw new Error;\n  } catch (err) {\n    var matches = ('' + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\\/\\/[^)\\n]+/g);\n    if (matches) {\n      return getBaseURL(matches[0]);\n    }\n  }\n\n  return '/';\n}\n\nfunction getBaseURL(url) {\n  return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\\/\\/.+)\\/[^/]+$/, '$1') + '/';\n}\n\nexports.getBundleURL = getBundleURLCached;\nexports.getBaseURL = getBaseURL;\n","var bundle = require('./bundle-url');\n\nfunction updateLink(link) {\n  var newLink = link.cloneNode();\n  newLink.onload = function () {\n    link.remove();\n  };\n  newLink.href = link.href.split('?')[0] + '?' + Date.now();\n  link.parentNode.insertBefore(newLink, link.nextSibling);\n}\n\nvar cssTimeout = null;\nfunction reloadCSS() {\n  if (cssTimeout) {\n    return;\n  }\n\n  cssTimeout = setTimeout(function () {\n    var links = document.querySelectorAll('link[rel=\"stylesheet\"]');\n    for (var i = 0; i < links.length; i++) {\n      if (bundle.getBaseURL(links[i].href) === bundle.getBundleURL()) {\n        updateLink(links[i]);\n      }\n    }\n\n    cssTimeout = null;\n  }, 50);\n}\n\nmodule.exports = reloadCSS;\n","var OVERLAY_ID = '__parcel__error__overlay__';\n\nvar OldModule = module.bundle.Module;\n\nfunction Module(moduleName) {\n  OldModule.call(this, moduleName);\n  this.hot = {\n    data: module.bundle.hotData,\n    _acceptCallbacks: [],\n    _disposeCallbacks: [],\n    accept: function (fn) {\n      this._acceptCallbacks.push(fn || function () {});\n    },\n    dispose: function (fn) {\n      this._disposeCallbacks.push(fn);\n    }\n  };\n\n  module.bundle.hotData = null;\n}\n\nmodule.bundle.Module = Module;\nvar checkedAssets, assetsToAccept;\n\nvar parent = module.bundle.parent;\nif ((!parent || !parent.isParcelRequire) && typeof WebSocket !== 'undefined') {\n  var hostname = process.env.HMR_HOSTNAME || location.hostname;\n  var protocol = location.protocol === 'https:' ? 'wss' : 'ws';\n  var ws = new WebSocket(protocol + '://' + hostname + ':' + process.env.HMR_PORT + '/');\n  ws.onmessage = function(event) {\n    checkedAssets = {};\n    assetsToAccept = [];\n\n    var data = JSON.parse(event.data);\n\n    if (data.type === 'update') {\n      var handled = false;\n      data.assets.forEach(function(asset) {\n        if (!asset.isNew) {\n          var didAccept = hmrAcceptCheck(global.parcelRequire, asset.id);\n          if (didAccept) {\n            handled = true;\n          }\n        }\n      });\n\n      // Enable HMR for CSS by default.\n      handled = handled || data.assets.every(function(asset) {\n        return asset.type === 'css' && asset.generated.js;\n      });\n\n      if (handled) {\n        console.clear();\n\n        data.assets.forEach(function (asset) {\n          hmrApply(global.parcelRequire, asset);\n        });\n\n        assetsToAccept.forEach(function (v) {\n          hmrAcceptRun(v[0], v[1]);\n        });\n      } else if (location.reload) { // `location` global exists in a web worker context but lacks `.reload()` function.\n        location.reload();\n      }\n    }\n\n    if (data.type === 'reload') {\n      ws.close();\n      ws.onclose = function () {\n        location.reload();\n      }\n    }\n\n    if (data.type === 'error-resolved') {\n      console.log('[parcel] ✨ Error resolved');\n\n      removeErrorOverlay();\n    }\n\n    if (data.type === 'error') {\n      console.error('[parcel] 🚨  ' + data.error.message + '\\n' + data.error.stack);\n\n      removeErrorOverlay();\n\n      var overlay = createErrorOverlay(data);\n      document.body.appendChild(overlay);\n    }\n  };\n}\n\nfunction removeErrorOverlay() {\n  var overlay = document.getElementById(OVERLAY_ID);\n  if (overlay) {\n    overlay.remove();\n  }\n}\n\nfunction createErrorOverlay(data) {\n  var overlay = document.createElement('div');\n  overlay.id = OVERLAY_ID;\n\n  // html encode message and stack trace\n  var message = document.createElement('div');\n  var stackTrace = document.createElement('pre');\n  message.innerText = data.error.message;\n  stackTrace.innerText = data.error.stack;\n\n  overlay.innerHTML = (\n    '<div style=\"background: black; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; opacity: 0.85; font-family: Menlo, Consolas, monospace; z-index: 9999;\">' +\n      '<span style=\"background: red; padding: 2px 4px; border-radius: 2px;\">ERROR</span>' +\n      '<span style=\"top: 2px; margin-left: 5px; position: relative;\">🚨</span>' +\n      '<div style=\"font-size: 18px; font-weight: bold; margin-top: 20px;\">' + message.innerHTML + '</div>' +\n      '<pre>' + stackTrace.innerHTML + '</pre>' +\n    '</div>'\n  );\n\n  return overlay;\n\n}\n\nfunction getParents(bundle, id) {\n  var modules = bundle.modules;\n  if (!modules) {\n    return [];\n  }\n\n  var parents = [];\n  var k, d, dep;\n\n  for (k in modules) {\n    for (d in modules[k][1]) {\n      dep = modules[k][1][d];\n      if (dep === id || (Array.isArray(dep) && dep[dep.length - 1] === id)) {\n        parents.push(k);\n      }\n    }\n  }\n\n  if (bundle.parent) {\n    parents = parents.concat(getParents(bundle.parent, id));\n  }\n\n  return parents;\n}\n\nfunction hmrApply(bundle, asset) {\n  var modules = bundle.modules;\n  if (!modules) {\n    return;\n  }\n\n  if (modules[asset.id] || !bundle.parent) {\n    var fn = new Function('require', 'module', 'exports', asset.generated.js);\n    asset.isNew = !modules[asset.id];\n    modules[asset.id] = [fn, asset.deps];\n  } else if (bundle.parent) {\n    hmrApply(bundle.parent, asset);\n  }\n}\n\nfunction hmrAcceptCheck(bundle, id) {\n  var modules = bundle.modules;\n  if (!modules) {\n    return;\n  }\n\n  if (!modules[id] && bundle.parent) {\n    return hmrAcceptCheck(bundle.parent, id);\n  }\n\n  if (checkedAssets[id]) {\n    return;\n  }\n  checkedAssets[id] = true;\n\n  var cached = bundle.cache[id];\n\n  assetsToAccept.push([bundle, id]);\n\n  if (cached && cached.hot && cached.hot._acceptCallbacks.length) {\n    return true;\n  }\n\n  return getParents(global.parcelRequire, id).some(function (id) {\n    return hmrAcceptCheck(global.parcelRequire, id)\n  });\n}\n\nfunction hmrAcceptRun(bundle, id) {\n  var cached = bundle.cache[id];\n  bundle.hotData = {};\n  if (cached) {\n    cached.hot.data = bundle.hotData;\n  }\n\n  if (cached && cached.hot && cached.hot._disposeCallbacks.length) {\n    cached.hot._disposeCallbacks.forEach(function (cb) {\n      cb(bundle.hotData);\n    });\n  }\n\n  delete bundle.cache[id];\n  bundle(id);\n\n  cached = bundle.cache[id];\n  if (cached && cached.hot && cached.hot._acceptCallbacks.length) {\n    cached.hot._acceptCallbacks.forEach(function (cb) {\n      cb();\n    });\n    return true;\n  }\n}\n"]}


--------------------------------------------------------------------------------
/example/dist/src.8e541c7a.js:
--------------------------------------------------------------------------------
   1 | // modules are defined as an array
   2 | // [ module function, map of requires ]
   3 | //
   4 | // map of requires is short require name -> numeric require
   5 | //
   6 | // anything defined in a previous bundle is accessed via the
   7 | // orig method which is the require for previous bundles
   8 | parcelRequire = (function (modules, cache, entry, globalName) {
   9 |   // Save the require from previous bundle to this closure if any
  10 |   var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
  11 |   var nodeRequire = typeof require === 'function' && require;
  12 | 
  13 |   function newRequire(name, jumped) {
  14 |     if (!cache[name]) {
  15 |       if (!modules[name]) {
  16 |         // if we cannot find the module within our internal map or
  17 |         // cache jump to the current global require ie. the last bundle
  18 |         // that was added to the page.
  19 |         var currentRequire = typeof parcelRequire === 'function' && parcelRequire;
  20 |         if (!jumped && currentRequire) {
  21 |           return currentRequire(name, true);
  22 |         }
  23 | 
  24 |         // If there are other bundles on this page the require from the
  25 |         // previous one is saved to 'previousRequire'. Repeat this as
  26 |         // many times as there are bundles until the module is found or
  27 |         // we exhaust the require chain.
  28 |         if (previousRequire) {
  29 |           return previousRequire(name, true);
  30 |         }
  31 | 
  32 |         // Try the node require function if it exists.
  33 |         if (nodeRequire && typeof name === 'string') {
  34 |           return nodeRequire(name);
  35 |         }
  36 | 
  37 |         var err = new Error('Cannot find module \'' + name + '\'');
  38 |         err.code = 'MODULE_NOT_FOUND';
  39 |         throw err;
  40 |       }
  41 | 
  42 |       localRequire.resolve = resolve;
  43 |       localRequire.cache = {};
  44 | 
  45 |       var module = cache[name] = new newRequire.Module(name);
  46 | 
  47 |       modules[name][0].call(module.exports, localRequire, module, module.exports, this);
  48 |     }
  49 | 
  50 |     return cache[name].exports;
  51 | 
  52 |     function localRequire(x){
  53 |       return newRequire(localRequire.resolve(x));
  54 |     }
  55 | 
  56 |     function resolve(x){
  57 |       return modules[name][1][x] || x;
  58 |     }
  59 |   }
  60 | 
  61 |   function Module(moduleName) {
  62 |     this.id = moduleName;
  63 |     this.bundle = newRequire;
  64 |     this.exports = {};
  65 |   }
  66 | 
  67 |   newRequire.isParcelRequire = true;
  68 |   newRequire.Module = Module;
  69 |   newRequire.modules = modules;
  70 |   newRequire.cache = cache;
  71 |   newRequire.parent = previousRequire;
  72 |   newRequire.register = function (id, exports) {
  73 |     modules[id] = [function (require, module) {
  74 |       module.exports = exports;
  75 |     }, {}];
  76 |   };
  77 | 
  78 |   var error;
  79 |   for (var i = 0; i < entry.length; i++) {
  80 |     try {
  81 |       newRequire(entry[i]);
  82 |     } catch (e) {
  83 |       // Save first error but execute all entries
  84 |       if (!error) {
  85 |         error = e;
  86 |       }
  87 |     }
  88 |   }
  89 | 
  90 |   if (entry.length) {
  91 |     // Expose entry point to Node, AMD or browser globals
  92 |     // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
  93 |     var mainExports = newRequire(entry[entry.length - 1]);
  94 | 
  95 |     // CommonJS
  96 |     if (typeof exports === "object" && typeof module !== "undefined") {
  97 |       module.exports = mainExports;
  98 | 
  99 |     // RequireJS
 100 |     } else if (typeof define === "function" && define.amd) {
 101 |      define(function () {
 102 |        return mainExports;
 103 |      });
 104 | 
 105 |     // <script>
 106 |     } else if (globalName) {
 107 |       this[globalName] = mainExports;
 108 |     }
 109 |   }
 110 | 
 111 |   // Override the current require with this new one
 112 |   parcelRequire = newRequire;
 113 | 
 114 |   if (error) {
 115 |     // throw error from earlier, _after updating parcelRequire_
 116 |     throw error;
 117 |   }
 118 | 
 119 |   return newRequire;
 120 | })({"hnz3":[function(require,module,exports) {
 121 | "use strict";
 122 | 
 123 | Object.defineProperty(exports, "__esModule", {
 124 |   value: true
 125 | });
 126 | exports.AssetDefinition = exports.AssetType = void 0;
 127 | var AssetType;
 128 | exports.AssetType = AssetType;
 129 | 
 130 | (function (AssetType) {
 131 |   AssetType[AssetType["image"] = 0] = "image";
 132 |   AssetType[AssetType["sound"] = 1] = "sound";
 133 | })(AssetType || (exports.AssetType = AssetType = {}));
 134 | 
 135 | class AssetDefinition {
 136 |   constructor(type, source) {
 137 |     this.type = type;
 138 |     this.source = source;
 139 |   }
 140 | 
 141 | }
 142 | 
 143 | exports.AssetDefinition = AssetDefinition;
 144 | },{}],"MAfq":[function(require,module,exports) {
 145 | "use strict";
 146 | 
 147 | Object.defineProperty(exports, "__esModule", {
 148 |   value: true
 149 | });
 150 | exports.Asset = void 0;
 151 | 
 152 | var _AssetDefinition = require("./AssetDefinition");
 153 | 
 154 | class Asset {
 155 |   constructor(definition) {
 156 |     this.definition = definition;
 157 |   }
 158 | 
 159 |   static image(source) {
 160 |     return new _AssetDefinition.AssetDefinition(_AssetDefinition.AssetType.image, source);
 161 |   }
 162 | 
 163 |   static sound(source) {
 164 |     return new _AssetDefinition.AssetDefinition(_AssetDefinition.AssetType.sound, source);
 165 |   }
 166 | 
 167 | }
 168 | 
 169 | exports.Asset = Asset;
 170 | },{"./AssetDefinition":"hnz3"}],"Book":[function(require,module,exports) {
 171 | "use strict";
 172 | 
 173 | Object.defineProperty(exports, "__esModule", {
 174 |   value: true
 175 | });
 176 | exports.ImageAsset = void 0;
 177 | 
 178 | var _Asset = require("../Asset");
 179 | 
 180 | var _AssetDefinition = require("../AssetDefinition");
 181 | 
 182 | class ImageAsset extends _Asset.Asset {
 183 |   constructor(definition, image) {
 184 |     super(definition);
 185 |     this.image = image;
 186 |     this.type = _AssetDefinition.AssetType.image;
 187 |   }
 188 | 
 189 | }
 190 | 
 191 | exports.ImageAsset = ImageAsset;
 192 | },{"../Asset":"MAfq","../AssetDefinition":"hnz3"}],"nMdM":[function(require,module,exports) {
 193 | "use strict";
 194 | 
 195 | Object.defineProperty(exports, "__esModule", {
 196 |   value: true
 197 | });
 198 | exports.SoundAsset = void 0;
 199 | 
 200 | var _Asset = require("../Asset");
 201 | 
 202 | var _AssetDefinition = require("../AssetDefinition");
 203 | 
 204 | class SoundAsset extends _Asset.Asset {
 205 |   constructor(definition, audio) {
 206 |     super(definition);
 207 |     this.audio = audio;
 208 |     this.type = _AssetDefinition.AssetType.image;
 209 |   }
 210 | 
 211 | }
 212 | 
 213 | exports.SoundAsset = SoundAsset;
 214 | },{"../Asset":"MAfq","../AssetDefinition":"hnz3"}],"Vdsx":[function(require,module,exports) {
 215 | "use strict";
 216 | 
 217 | Object.defineProperty(exports, "__esModule", {
 218 |   value: true
 219 | });
 220 | 
 221 | var _ImageAsset = require("./ImageAsset");
 222 | 
 223 | Object.keys(_ImageAsset).forEach(function (key) {
 224 |   if (key === "default" || key === "__esModule") return;
 225 |   if (key in exports && exports[key] === _ImageAsset[key]) return;
 226 |   Object.defineProperty(exports, key, {
 227 |     enumerable: true,
 228 |     get: function () {
 229 |       return _ImageAsset[key];
 230 |     }
 231 |   });
 232 | });
 233 | 
 234 | var _SoundAsset = require("./SoundAsset");
 235 | 
 236 | Object.keys(_SoundAsset).forEach(function (key) {
 237 |   if (key === "default" || key === "__esModule") return;
 238 |   if (key in exports && exports[key] === _SoundAsset[key]) return;
 239 |   Object.defineProperty(exports, key, {
 240 |     enumerable: true,
 241 |     get: function () {
 242 |       return _SoundAsset[key];
 243 |     }
 244 |   });
 245 | });
 246 | },{"./ImageAsset":"Book","./SoundAsset":"nMdM"}],"lA61":[function(require,module,exports) {
 247 | "use strict";
 248 | 
 249 | Object.defineProperty(exports, "__esModule", {
 250 |   value: true
 251 | });
 252 | exports.AssetLoader = exports.AssetMap = void 0;
 253 | 
 254 | var _AssetDefinition = require("./AssetDefinition");
 255 | 
 256 | var _assetTypes = require("./assetTypes");
 257 | 
 258 | class AssetMap {
 259 |   constructor(map) {
 260 |     this.map = map;
 261 |   }
 262 | 
 263 |   get(name) {
 264 |     return this.map[name];
 265 |   }
 266 | 
 267 | }
 268 | 
 269 | exports.AssetMap = AssetMap;
 270 | 
 271 | class AssetLoader {
 272 |   constructor() {
 273 |     this.cache = new Map();
 274 |   }
 275 | 
 276 |   async loadAssetMap(assetMap, onProgress = () => {}) {
 277 |     const totalAmount = Object.keys(assetMap).length;
 278 |     let currentAmount = 0;
 279 | 
 280 |     const updateProgress = () => {
 281 |       currentAmount += 1;
 282 |       onProgress(currentAmount / totalAmount);
 283 |     };
 284 | 
 285 |     onProgress(0);
 286 |     return new AssetMap(Object.fromEntries(await Promise.all(Object.entries(assetMap).map(([name, assetDef]) => {
 287 |       return this.loadAsset(assetDef).then(asset => {
 288 |         updateProgress();
 289 |         return [name, asset];
 290 |       });
 291 |     }))));
 292 |   }
 293 | 
 294 |   async loadAsset(assetDefinition) {
 295 |     let asset = null;
 296 |     const assetMap = this.cache.get(assetDefinition.source) ?? new Map();
 297 | 
 298 |     if (assetMap.has(assetDefinition.type)) {
 299 |       asset = assetMap.get(assetDefinition.type);
 300 |     }
 301 | 
 302 |     if (asset !== null) {
 303 |       return asset;
 304 |     }
 305 | 
 306 |     switch (assetDefinition.type) {
 307 |       case _AssetDefinition.AssetType.image:
 308 |         asset = await this.loadImageAsset(assetDefinition);
 309 |         break;
 310 | 
 311 |       case _AssetDefinition.AssetType.sound:
 312 |         asset = await this.loadSoundAsset(assetDefinition);
 313 |         break;
 314 | 
 315 |       default:
 316 |         throw new Error(`Unknown asset type: '${assetDefinition.type}'`);
 317 |     }
 318 | 
 319 |     assetMap.set(assetDefinition.type, asset);
 320 |     this.cache.set(assetDefinition.source, assetMap);
 321 |     return asset;
 322 |   }
 323 | 
 324 |   loadImageAsset(assetDefinition) {
 325 |     const imageElement = new Image();
 326 |     return new Promise((resolve, reject) => {
 327 |       imageElement.addEventListener('error', reject, {
 328 |         once: true
 329 |       });
 330 |       imageElement.addEventListener('load', () => {
 331 |         resolve(new _assetTypes.ImageAsset(assetDefinition, imageElement));
 332 |       }, {
 333 |         once: true
 334 |       });
 335 |       imageElement.src = assetDefinition.source;
 336 |     });
 337 |   }
 338 | 
 339 |   loadSoundAsset(assetDefinition) {
 340 |     const soundElement = new Audio();
 341 |     return new Promise((resolve, reject) => {
 342 |       soundElement.addEventListener('error', reject, {
 343 |         once: true
 344 |       });
 345 |       soundElement.addEventListener('canplaythrough', () => {
 346 |         resolve(new _assetTypes.SoundAsset(assetDefinition, soundElement));
 347 |       }, {
 348 |         once: true
 349 |       });
 350 |       soundElement.src = assetDefinition.source;
 351 |     });
 352 |   }
 353 | 
 354 | }
 355 | 
 356 | exports.AssetLoader = AssetLoader;
 357 | },{"./AssetDefinition":"hnz3","./assetTypes":"Vdsx"}],"VSoi":[function(require,module,exports) {
 358 | "use strict";
 359 | 
 360 | Object.defineProperty(exports, "__esModule", {
 361 |   value: true
 362 | });
 363 | 
 364 | var _Asset = require("./Asset");
 365 | 
 366 | Object.keys(_Asset).forEach(function (key) {
 367 |   if (key === "default" || key === "__esModule") return;
 368 |   if (key in exports && exports[key] === _Asset[key]) return;
 369 |   Object.defineProperty(exports, key, {
 370 |     enumerable: true,
 371 |     get: function () {
 372 |       return _Asset[key];
 373 |     }
 374 |   });
 375 | });
 376 | 
 377 | var _AssetDefinition = require("./AssetDefinition");
 378 | 
 379 | Object.keys(_AssetDefinition).forEach(function (key) {
 380 |   if (key === "default" || key === "__esModule") return;
 381 |   if (key in exports && exports[key] === _AssetDefinition[key]) return;
 382 |   Object.defineProperty(exports, key, {
 383 |     enumerable: true,
 384 |     get: function () {
 385 |       return _AssetDefinition[key];
 386 |     }
 387 |   });
 388 | });
 389 | 
 390 | var _AssetLoader = require("./AssetLoader");
 391 | 
 392 | Object.keys(_AssetLoader).forEach(function (key) {
 393 |   if (key === "default" || key === "__esModule") return;
 394 |   if (key in exports && exports[key] === _AssetLoader[key]) return;
 395 |   Object.defineProperty(exports, key, {
 396 |     enumerable: true,
 397 |     get: function () {
 398 |       return _AssetLoader[key];
 399 |     }
 400 |   });
 401 | });
 402 | 
 403 | var _assetTypes = require("./assetTypes");
 404 | 
 405 | Object.keys(_assetTypes).forEach(function (key) {
 406 |   if (key === "default" || key === "__esModule") return;
 407 |   if (key in exports && exports[key] === _assetTypes[key]) return;
 408 |   Object.defineProperty(exports, key, {
 409 |     enumerable: true,
 410 |     get: function () {
 411 |       return _assetTypes[key];
 412 |     }
 413 |   });
 414 | });
 415 | },{"./Asset":"MAfq","./AssetDefinition":"hnz3","./AssetLoader":"lA61","./assetTypes":"Vdsx"}],"huun":[function(require,module,exports) {
 416 | "use strict";
 417 | 
 418 | Object.defineProperty(exports, "__esModule", {
 419 |   value: true
 420 | });
 421 | exports.vec2 = exports.Vector2 = void 0;
 422 | 
 423 | class Vector2 {
 424 |   constructor(_x = 0, _y = 0) {
 425 |     this._x = _x;
 426 |     this._y = _y;
 427 | 
 428 |     this.clone = () => Vector2.of(this.x, this.y);
 429 | 
 430 |     this.simpleProduct = () => this.x * this.y;
 431 | 
 432 |     this.asStride = index => Vector2.of(index % this.x, (index - index % this.x) / this.x);
 433 | 
 434 |     this.mul = (x, y) => Vector2.of(this.x * x, this.y * (y ?? x));
 435 | 
 436 |     this.pipe = fn => fn(this);
 437 | 
 438 |     this.equals = other => this.x === other.x && this.y === other.y;
 439 | 
 440 |     this.distance = other => Math.sqrt(Math.pow(other.x - this.x, 2) + Math.pow(other.y - this.y, 2));
 441 | 
 442 |     this.snapToGrid = size => Vector2.of(Math.round(this.x / size.x) * size.x, Math.round(this.y / size.y) * size.y);
 443 | 
 444 |     this.transform = matrix => Vector2.fromDOMPoint(matrix.transformPoint({
 445 |       x: this._x,
 446 |       y: this._y
 447 |     }));
 448 | 
 449 |     this.floor = () => Vector2.of(Math.floor(this._x), Math.floor(this._y));
 450 |   }
 451 | 
 452 |   get x() {
 453 |     return this._x;
 454 |   }
 455 | 
 456 |   get y() {
 457 |     return this._y;
 458 |   }
 459 | 
 460 |   get e() {
 461 |     return [this._x, this._y];
 462 |   }
 463 | 
 464 |   get o() {
 465 |     return {
 466 |       x: this._x,
 467 |       y: this._y
 468 |     };
 469 |   }
 470 | 
 471 |   static from({
 472 |     x,
 473 |     y
 474 |   }) {
 475 |     return Vector2.of(x, y);
 476 |   }
 477 | 
 478 |   add(x, y) {
 479 |     if (x instanceof Vector2) {
 480 |       return Vector2.of(this._x + x._x, this._y + x._y);
 481 |     }
 482 | 
 483 |     return Vector2.of(this._x + x, this._y + (y ?? x));
 484 |   }
 485 | 
 486 |   div(x, y) {
 487 |     if (x instanceof Vector2) {
 488 |       return Vector2.of(this._x / x._x, this._y / x._y);
 489 |     }
 490 | 
 491 |     return Vector2.of(this._x / x, this._y / (y ?? x));
 492 |   }
 493 | 
 494 |   static fromDOMPoint(point) {
 495 |     return new Vector2(point.x, point.y);
 496 |   }
 497 | 
 498 |   static zero() {
 499 |     return new Vector2(0, 0);
 500 |   }
 501 | 
 502 |   static of(x, y) {
 503 |     return new Vector2(x, y ?? x);
 504 |   }
 505 | 
 506 | }
 507 | 
 508 | exports.Vector2 = Vector2;
 509 | 
 510 | const vec2 = (x, y) => Vector2.of(x, y ?? x);
 511 | 
 512 | exports.vec2 = vec2;
 513 | },{}],"CA2L":[function(require,module,exports) {
 514 | "use strict";
 515 | 
 516 | Object.defineProperty(exports, "__esModule", {
 517 |   value: true
 518 | });
 519 | exports.InputState = void 0;
 520 | const emptyKeyState = {
 521 |   re: false,
 522 |   fe: false,
 523 |   pressed: false
 524 | };
 525 | 
 526 | class InputState {
 527 |   constructor(keyState, mousePosition) {
 528 |     this.keyState = keyState;
 529 |     this.mousePosition = mousePosition;
 530 |   }
 531 | 
 532 |   getKeyState(keyCode) {
 533 |     return this.keyState.get(keyCode) ?? emptyKeyState;
 534 |   }
 535 | 
 536 |   isPressed(keyCode) {
 537 |     return this.getKeyState(keyCode).pressed;
 538 |   }
 539 | 
 540 |   isReleased(keyCode) {
 541 |     return !this.getKeyState(keyCode).pressed;
 542 |   }
 543 | 
 544 |   isJustPressed(keyCode) {
 545 |     return this.getKeyState(keyCode).re;
 546 |   }
 547 | 
 548 |   isJustReleased(keyCode) {
 549 |     return this.getKeyState(keyCode).fe;
 550 |   }
 551 | 
 552 |   get mouse() {
 553 |     return this.mousePosition;
 554 |   }
 555 | 
 556 | }
 557 | 
 558 | exports.InputState = InputState;
 559 | },{}],"cx2N":[function(require,module,exports) {
 560 | "use strict";
 561 | 
 562 | Object.defineProperty(exports, "__esModule", {
 563 |   value: true
 564 | });
 565 | exports.InputManager = void 0;
 566 | 
 567 | var _InputState = require("./InputState");
 568 | 
 569 | var _Vector = require("../math/Vector2");
 570 | 
 571 | class InputManager {
 572 |   constructor() {
 573 |     this.state = new Map();
 574 |     this.mousePosition = (0, _Vector.vec2)(0, 0);
 575 |     this.element = null;
 576 | 
 577 |     this.handleKeydown = event => {
 578 |       const state = this.state.get(event.keyCode);
 579 | 
 580 |       if (!state?.pressed) {
 581 |         this.state.set(event.keyCode, {
 582 |           re: true,
 583 |           fe: false,
 584 |           pressed: true
 585 |         });
 586 |       }
 587 |     };
 588 | 
 589 |     this.handleKeyup = event => {
 590 |       this.state.set(event.keyCode, {
 591 |         re: false,
 592 |         fe: true,
 593 |         pressed: false
 594 |       });
 595 |     };
 596 | 
 597 |     this.handleMousedown = event => {
 598 |       const state = this.state.get(event.button);
 599 | 
 600 |       if (!state?.pressed) {
 601 |         this.state.set(event.button, {
 602 |           re: true,
 603 |           fe: false,
 604 |           pressed: true
 605 |         });
 606 |       }
 607 |     };
 608 | 
 609 |     this.handleMouseup = event => {
 610 |       this.state.set(event.button, {
 611 |         re: false,
 612 |         fe: true,
 613 |         pressed: false
 614 |       });
 615 |     };
 616 | 
 617 |     this.handleMousemove = event => {
 618 |       const boundingRect = this.element?.getBoundingClientRect();
 619 |       this.mousePosition = (0, _Vector.vec2)(event.clientX - (boundingRect?.left ?? 0), event.clientY - (boundingRect?.top ?? 0));
 620 |     };
 621 |   }
 622 | 
 623 |   getState() {
 624 |     return new _InputState.InputState(new Map(this.state.entries()), this.mousePosition.clone());
 625 |   }
 626 | 
 627 |   processTick() {
 628 |     for (let key of this.state.keys()) {
 629 |       const state = this.state.get(key);
 630 |       this.state.set(key, {
 631 |         pressed: state.pressed,
 632 |         fe: false,
 633 |         re: false
 634 |       });
 635 |     }
 636 |   }
 637 | 
 638 |   mount(element) {
 639 |     this.element = element;
 640 |     window.addEventListener('keydown', this.handleKeydown);
 641 |     window.addEventListener('keyup', this.handleKeyup);
 642 |     window.addEventListener('mousedown', this.handleMousedown);
 643 |     window.addEventListener('mouseup', this.handleMouseup);
 644 |     window.addEventListener('mousemove', this.handleMousemove);
 645 |   }
 646 | 
 647 |   unmount() {
 648 |     this.element = null;
 649 |     window.removeEventListener('keydown', this.handleKeydown);
 650 |     window.removeEventListener('keyup', this.handleKeyup);
 651 |     window.removeEventListener('mousedown', this.handleMousedown);
 652 |     window.removeEventListener('mouseup', this.handleMouseup);
 653 |     window.removeEventListener('mousemove', this.handleMousemove);
 654 |   }
 655 | 
 656 | }
 657 | 
 658 | exports.InputManager = InputManager;
 659 | },{"./InputState":"CA2L","../math/Vector2":"huun"}],"mnx3":[function(require,module,exports) {
 660 | "use strict";
 661 | 
 662 | Object.defineProperty(exports, "__esModule", {
 663 |   value: true
 664 | });
 665 | exports.Engine = void 0;
 666 | 
 667 | var _Vector = require("../math/Vector2");
 668 | 
 669 | var _InputManager = require("../inputManager/InputManager");
 670 | 
 671 | class Engine {
 672 |   constructor({
 673 |     canvas,
 674 |     size,
 675 |     ticker
 676 |   }) {
 677 |     this.input = new _InputManager.InputManager();
 678 |     this.scenes = new Map();
 679 |     this.stack = [];
 680 |     this.ticker = ticker;
 681 |     this.canvas = canvas;
 682 |     this.context = this.canvas.getContext('2d');
 683 |     this.resize(size);
 684 |     this.input.mount(canvas);
 685 |     ticker.listen(this.tick.bind(this));
 686 |     window.addEventListener('resize', () => {
 687 |       this.resize((0, _Vector.vec2)(window.innerWidth, window.innerHeight));
 688 |     });
 689 |   }
 690 | 
 691 |   registerScene(name, Constructor) {
 692 |     this.scenes.set(name, Constructor);
 693 |   }
 694 | 
 695 |   getScene(name) {
 696 |     const Scene = this.scenes.get(name);
 697 | 
 698 |     if (!Scene) {
 699 |       throw new Error(`Requested to mount unregistered scene '${name}'`);
 700 |     }
 701 | 
 702 |     return new Scene();
 703 |   }
 704 | 
 705 |   pushScene(name) {
 706 |     const scene = this.getScene(name);
 707 |     this.stack.unshift(scene);
 708 |     scene.mount();
 709 |   }
 710 | 
 711 |   resize(newSize) {
 712 |     this.canvasSize = newSize;
 713 |     this.canvas.width = newSize.x;
 714 |     this.canvas.height = newSize.y;
 715 |   }
 716 | 
 717 |   tick(tickerState) {
 718 |     this.context.clearRect(0, 0, this.canvasSize.x, this.canvasSize.y);
 719 |     const inputState = this.input.getState();
 720 |     let updateContext = {
 721 |       matrix: this.context.getTransform(),
 722 |       inputState: inputState,
 723 |       tickerState: tickerState,
 724 |       canvasSize: this.canvasSize
 725 |     };
 726 |     let drawContext = {
 727 |       ctx: this.context,
 728 |       tickerState: tickerState,
 729 |       canvasSize: this.canvasSize
 730 |     };
 731 | 
 732 |     for (let scene of this.stack) {
 733 |       scene.prepare(updateContext, drawContext);
 734 |     }
 735 | 
 736 |     for (let scene of this.stack) {
 737 |       scene.update(updateContext);
 738 |     }
 739 | 
 740 |     for (let scene of this.stack) {
 741 |       scene.draw(drawContext);
 742 |     }
 743 | 
 744 |     for (let scene of this.stack) {
 745 |       scene.cleanup(updateContext, drawContext);
 746 |     }
 747 | 
 748 |     this.input.processTick();
 749 |   }
 750 | 
 751 |   start() {
 752 |     this.ticker.start();
 753 |   }
 754 | 
 755 |   stop() {
 756 |     this.ticker.stop();
 757 |   }
 758 | 
 759 | }
 760 | 
 761 | exports.Engine = Engine;
 762 | },{"../math/Vector2":"huun","../inputManager/InputManager":"cx2N"}],"H2cD":[function(require,module,exports) {
 763 | "use strict";
 764 | 
 765 | Object.defineProperty(exports, "__esModule", {
 766 |   value: true
 767 | });
 768 | exports.Entity = void 0;
 769 | 
 770 | class Entity {
 771 |   constructor() {
 772 |     this.scene = null;
 773 |   }
 774 | 
 775 |   _mount(scene) {
 776 |     this.scene = scene;
 777 |   }
 778 | 
 779 |   _unmount() {
 780 |     this.scene = null;
 781 |   }
 782 | 
 783 |   _update(context) {
 784 |     for (let widget of Object.values(this.widgets)) {
 785 |       widget.willUpdate(context);
 786 |     }
 787 | 
 788 |     this.update(context);
 789 | 
 790 |     for (let widget of Object.values(this.widgets)) {
 791 |       widget.didUpdate(context);
 792 |     }
 793 |   }
 794 | 
 795 |   _draw(context) {
 796 |     for (let widget of Object.values(this.widgets)) {
 797 |       widget.willDraw(context);
 798 |     }
 799 | 
 800 |     this.draw(context);
 801 | 
 802 |     for (let widget of Object.values(this.widgets)) {
 803 |       widget.didDraw(context);
 804 |     }
 805 |   }
 806 | 
 807 | }
 808 | 
 809 | exports.Entity = Entity;
 810 | },{}],"m6zO":[function(require,module,exports) {
 811 | "use strict";
 812 | 
 813 | Object.defineProperty(exports, "__esModule", {
 814 |   value: true
 815 | });
 816 | exports.TextEntity = void 0;
 817 | 
 818 | var _Entity = require("../../src/entity/Entity");
 819 | 
 820 | class TextEntity extends _Entity.Entity {
 821 |   constructor(options) {
 822 |     super();
 823 |     this.options = options;
 824 |     this.widgets = [];
 825 |   }
 826 | 
 827 |   update() {}
 828 | 
 829 |   draw({
 830 |     ctx
 831 |   }) {
 832 |     const {
 833 |       font,
 834 |       style,
 835 |       horizontal,
 836 |       vertical,
 837 |       position,
 838 |       text
 839 |     } = this.options;
 840 |     ctx.save();
 841 |     ctx.font = font;
 842 |     ctx.fillStyle = style;
 843 |     ctx.textAlign = horizontal ?? 'center';
 844 |     ctx.textBaseline = vertical ?? 'middle';
 845 |     ctx.fillText(text, position.x, position.y);
 846 |     ctx.restore();
 847 |   }
 848 | 
 849 | }
 850 | 
 851 | exports.TextEntity = TextEntity;
 852 | },{"../../src/entity/Entity":"H2cD"}],"oaWb":[function(require,module,exports) {
 853 | "use strict";
 854 | 
 855 | Object.defineProperty(exports, "__esModule", {
 856 |   value: true
 857 | });
 858 | exports.isKey = isKey;
 859 | exports.Key = void 0;
 860 | var Key;
 861 | exports.Key = Key;
 862 | 
 863 | (function (Key) {
 864 |   Key[Key["LMB"] = 0] = "LMB";
 865 |   Key[Key["MMB"] = 1] = "MMB";
 866 |   Key[Key["RMB"] = 2] = "RMB";
 867 |   Key[Key["MB3"] = 3] = "MB3";
 868 |   Key[Key["MB4"] = 4] = "MB4";
 869 |   Key[Key["Backspace"] = 8] = "Backspace";
 870 |   Key[Key["Tab"] = 9] = "Tab";
 871 |   Key[Key["Enter"] = 13] = "Enter";
 872 |   Key[Key["Shift"] = 16] = "Shift";
 873 |   Key[Key["Ctrl"] = 17] = "Ctrl";
 874 |   Key[Key["Alt"] = 18] = "Alt";
 875 |   Key[Key["PauseBreak"] = 19] = "PauseBreak";
 876 |   Key[Key["CapsLock"] = 20] = "CapsLock";
 877 |   Key[Key["Escape"] = 27] = "Escape";
 878 |   Key[Key["Space"] = 32] = "Space";
 879 |   Key[Key["PageUp"] = 33] = "PageUp";
 880 |   Key[Key["PageDown"] = 34] = "PageDown";
 881 |   Key[Key["End"] = 35] = "End";
 882 |   Key[Key["Home"] = 36] = "Home";
 883 |   Key[Key["LeftArrow"] = 37] = "LeftArrow";
 884 |   Key[Key["UpArrow"] = 38] = "UpArrow";
 885 |   Key[Key["RightArrow"] = 39] = "RightArrow";
 886 |   Key[Key["DownArrow"] = 40] = "DownArrow";
 887 |   Key[Key["Insert"] = 45] = "Insert";
 888 |   Key[Key["Delete"] = 46] = "Delete";
 889 |   Key[Key["Zero"] = 48] = "Zero";
 890 |   Key[Key["ClosedParen"] = 48] = "ClosedParen";
 891 |   Key[Key["One"] = 49] = "One";
 892 |   Key[Key["ExclamationMark"] = 49] = "ExclamationMark";
 893 |   Key[Key["Two"] = 50] = "Two";
 894 |   Key[Key["AtSign"] = 50] = "AtSign";
 895 |   Key[Key["Three"] = 51] = "Three";
 896 |   Key[Key["PoundSign"] = 51] = "PoundSign";
 897 |   Key[Key["Hash"] = 51] = "Hash";
 898 |   Key[Key["Four"] = 52] = "Four";
 899 |   Key[Key["DollarSign"] = 52] = "DollarSign";
 900 |   Key[Key["Five"] = 53] = "Five";
 901 |   Key[Key["PercentSign"] = 53] = "PercentSign";
 902 |   Key[Key["Six"] = 54] = "Six";
 903 |   Key[Key["Caret"] = 54] = "Caret";
 904 |   Key[Key["Hat"] = 54] = "Hat";
 905 |   Key[Key["Seven"] = 55] = "Seven";
 906 |   Key[Key["Ampersand"] = 55] = "Ampersand";
 907 |   Key[Key["Eight"] = 56] = "Eight";
 908 |   Key[Key["Star"] = 56] = "Star";
 909 |   Key[Key["Asterik"] = 56] = "Asterik";
 910 |   Key[Key["Nine"] = 57] = "Nine";
 911 |   Key[Key["OpenParen"] = 57] = "OpenParen";
 912 |   Key[Key["A"] = 65] = "A";
 913 |   Key[Key["B"] = 66] = "B";
 914 |   Key[Key["C"] = 67] = "C";
 915 |   Key[Key["D"] = 68] = "D";
 916 |   Key[Key["E"] = 69] = "E";
 917 |   Key[Key["F"] = 70] = "F";
 918 |   Key[Key["G"] = 71] = "G";
 919 |   Key[Key["H"] = 72] = "H";
 920 |   Key[Key["I"] = 73] = "I";
 921 |   Key[Key["J"] = 74] = "J";
 922 |   Key[Key["K"] = 75] = "K";
 923 |   Key[Key["L"] = 76] = "L";
 924 |   Key[Key["M"] = 77] = "M";
 925 |   Key[Key["N"] = 78] = "N";
 926 |   Key[Key["O"] = 79] = "O";
 927 |   Key[Key["P"] = 80] = "P";
 928 |   Key[Key["Q"] = 81] = "Q";
 929 |   Key[Key["R"] = 82] = "R";
 930 |   Key[Key["S"] = 83] = "S";
 931 |   Key[Key["T"] = 84] = "T";
 932 |   Key[Key["U"] = 85] = "U";
 933 |   Key[Key["V"] = 86] = "V";
 934 |   Key[Key["W"] = 87] = "W";
 935 |   Key[Key["X"] = 88] = "X";
 936 |   Key[Key["Y"] = 89] = "Y";
 937 |   Key[Key["Z"] = 90] = "Z";
 938 |   Key[Key["LeftWindowKey"] = 91] = "LeftWindowKey";
 939 |   Key[Key["RightWindowKey"] = 92] = "RightWindowKey";
 940 |   Key[Key["SelectKey"] = 93] = "SelectKey";
 941 |   Key[Key["Numpad0"] = 96] = "Numpad0";
 942 |   Key[Key["Numpad1"] = 97] = "Numpad1";
 943 |   Key[Key["Numpad2"] = 98] = "Numpad2";
 944 |   Key[Key["Numpad3"] = 99] = "Numpad3";
 945 |   Key[Key["Numpad4"] = 100] = "Numpad4";
 946 |   Key[Key["Numpad5"] = 101] = "Numpad5";
 947 |   Key[Key["Numpad6"] = 102] = "Numpad6";
 948 |   Key[Key["Numpad7"] = 103] = "Numpad7";
 949 |   Key[Key["Numpad8"] = 104] = "Numpad8";
 950 |   Key[Key["Numpad9"] = 105] = "Numpad9";
 951 |   Key[Key["Multiply"] = 106] = "Multiply";
 952 |   Key[Key["Add"] = 107] = "Add";
 953 |   Key[Key["Subtract"] = 109] = "Subtract";
 954 |   Key[Key["DecimalPoint"] = 110] = "DecimalPoint";
 955 |   Key[Key["Divide"] = 111] = "Divide";
 956 |   Key[Key["F1"] = 112] = "F1";
 957 |   Key[Key["F2"] = 113] = "F2";
 958 |   Key[Key["F3"] = 114] = "F3";
 959 |   Key[Key["F4"] = 115] = "F4";
 960 |   Key[Key["F5"] = 116] = "F5";
 961 |   Key[Key["F6"] = 117] = "F6";
 962 |   Key[Key["F7"] = 118] = "F7";
 963 |   Key[Key["F8"] = 119] = "F8";
 964 |   Key[Key["F9"] = 120] = "F9";
 965 |   Key[Key["F10"] = 121] = "F10";
 966 |   Key[Key["F11"] = 122] = "F11";
 967 |   Key[Key["F12"] = 123] = "F12";
 968 |   Key[Key["NumLock"] = 144] = "NumLock";
 969 |   Key[Key["ScrollLock"] = 145] = "ScrollLock";
 970 |   Key[Key["SemiColon"] = 186] = "SemiColon";
 971 |   Key[Key["Equals"] = 187] = "Equals";
 972 |   Key[Key["Comma"] = 188] = "Comma";
 973 |   Key[Key["Dash"] = 189] = "Dash";
 974 |   Key[Key["Period"] = 190] = "Period";
 975 |   Key[Key["UnderScore"] = 189] = "UnderScore";
 976 |   Key[Key["PlusSign"] = 187] = "PlusSign";
 977 |   Key[Key["ForwardSlash"] = 191] = "ForwardSlash";
 978 |   Key[Key["Tilde"] = 192] = "Tilde";
 979 |   Key[Key["GraveAccent"] = 192] = "GraveAccent";
 980 |   Key[Key["OpenBracket"] = 219] = "OpenBracket";
 981 |   Key[Key["ClosedBracket"] = 221] = "ClosedBracket";
 982 |   Key[Key["Quote"] = 222] = "Quote";
 983 | })(Key || (exports.Key = Key = {}));
 984 | 
 985 | function isKey(keyCode) {
 986 |   return keyCode <= Key.Backspace && keyCode >= Key.Quote;
 987 | }
 988 | },{}],"mohF":[function(require,module,exports) {
 989 | "use strict";
 990 | 
 991 | Object.defineProperty(exports, "__esModule", {
 992 |   value: true
 993 | });
 994 | exports.Scene = void 0;
 995 | 
 996 | class Scene {
 997 |   constructor() {
 998 |     this.entities = new Set();
 999 |   }
1000 | 
1001 |   add(entity) {
1002 |     this.entities.add(entity);
1003 |   }
1004 | 
1005 |   addAll(entities) {
1006 |     for (let entity of entities) {
1007 |       this.entities.add(entity);
1008 |     }
1009 |   }
1010 | 
1011 |   remove(entity) {
1012 |     this.entities.delete(entity);
1013 |   }
1014 | 
1015 |   willMount() {}
1016 | 
1017 |   didUnmount() {}
1018 | 
1019 |   prepare(_updateContext, _drawContext) {}
1020 | 
1021 |   cleanup(_updateContext, _drawContext) {}
1022 | 
1023 |   willUpdate(_context) {}
1024 | 
1025 |   didUpdate(_context) {}
1026 | 
1027 |   willDraw(_context) {}
1028 | 
1029 |   didDraw(_context) {}
1030 | 
1031 |   update(context) {
1032 |     this.willUpdate(context);
1033 | 
1034 |     for (let entity of this.entities) {
1035 |       entity._update(context);
1036 |     }
1037 | 
1038 |     this.didUpdate(context);
1039 |   }
1040 | 
1041 |   draw(context) {
1042 |     this.willDraw(context);
1043 | 
1044 |     for (let entity of this.entities) {
1045 |       context.ctx.save();
1046 | 
1047 |       entity._draw(context);
1048 | 
1049 |       context.ctx.restore();
1050 |     }
1051 | 
1052 |     this.didDraw(context);
1053 |   }
1054 | 
1055 |   mount() {
1056 |     this.willMount();
1057 | 
1058 |     for (let entity of this.entities) {
1059 |       entity._mount(this);
1060 |     }
1061 |   }
1062 | 
1063 |   unmount() {
1064 |     for (let entity of this.entities) {
1065 |       entity._unmount();
1066 |     }
1067 | 
1068 |     this.entities.clear();
1069 |     this.didUnmount();
1070 |   }
1071 | 
1072 | }
1073 | 
1074 | exports.Scene = Scene;
1075 | },{}],"PcY8":[function(require,module,exports) {
1076 | "use strict";
1077 | 
1078 | Object.defineProperty(exports, "__esModule", {
1079 |   value: true
1080 | });
1081 | exports.Ticker = void 0;
1082 | 
1083 | class Ticker {}
1084 | 
1085 | exports.Ticker = Ticker;
1086 | },{}],"dBYq":[function(require,module,exports) {
1087 | "use strict";
1088 | 
1089 | Object.defineProperty(exports, "__esModule", {
1090 |   value: true
1091 | });
1092 | exports.AnimationFrameTicker = void 0;
1093 | 
1094 | var _Ticker = require("./Ticker");
1095 | 
1096 | class AnimationFrameTicker extends _Ticker.Ticker {
1097 |   constructor() {
1098 |     super(...arguments);
1099 |     this.listeners = new Set();
1100 |     this.afId = null;
1101 |     this.frameNumber = 0;
1102 |     this.startTimestamp = 0;
1103 |     this.lastTimestamp = 0;
1104 |   }
1105 | 
1106 |   get isRunning() {
1107 |     return this.afId !== null;
1108 |   }
1109 | 
1110 |   start() {
1111 |     if (this.afId === null) {
1112 |       this.frameNumber = 0;
1113 |       this.scheduleNextAnimationFrame();
1114 |     }
1115 |   }
1116 | 
1117 |   stop() {
1118 |     if (this.afId !== null) {
1119 |       cancelAnimationFrame(this.afId);
1120 |       this.afId = null;
1121 |     }
1122 |   }
1123 | 
1124 |   scheduleNextAnimationFrame() {
1125 |     this.afId = requestAnimationFrame(this.tick.bind(this));
1126 |   }
1127 | 
1128 |   tick(currentTimestamp) {
1129 |     this.scheduleNextAnimationFrame();
1130 | 
1131 |     if (this.frameNumber === 0) {
1132 |       this.startTimestamp = currentTimestamp;
1133 |       this.lastTimestamp = currentTimestamp;
1134 |     }
1135 | 
1136 |     const tickerState = {
1137 |       frameNumber: this.frameNumber,
1138 |       startTimestamp: this.startTimestamp,
1139 |       lastTimestamp: this.lastTimestamp,
1140 |       currentTimestamp: currentTimestamp,
1141 |       delta: currentTimestamp - this.lastTimestamp
1142 |     };
1143 | 
1144 |     for (let listener of this.listeners) {
1145 |       listener(tickerState);
1146 |     }
1147 | 
1148 |     this.lastTimestamp = currentTimestamp;
1149 |     this.frameNumber += 1;
1150 |   }
1151 | 
1152 |   listen(listener) {
1153 |     this.listeners.add(listener);
1154 |     return () => {
1155 |       this.listeners.delete(listener);
1156 |     };
1157 |   }
1158 | 
1159 | }
1160 | 
1161 | exports.AnimationFrameTicker = AnimationFrameTicker;
1162 | },{"./Ticker":"PcY8"}],"ur7p":[function(require,module,exports) {
1163 | "use strict";
1164 | 
1165 | Object.defineProperty(exports, "__esModule", {
1166 |   value: true
1167 | });
1168 | exports.Widget = void 0;
1169 | 
1170 | class Widget {
1171 |   willUpdate(_context) {}
1172 | 
1173 |   didUpdate(_context) {}
1174 | 
1175 |   willDraw(_context) {}
1176 | 
1177 |   didDraw(_context) {}
1178 | 
1179 | }
1180 | 
1181 | exports.Widget = Widget;
1182 | },{}],"NTlZ":[function(require,module,exports) {
1183 | "use strict";
1184 | 
1185 | Object.defineProperty(exports, "__esModule", {
1186 |   value: true
1187 | });
1188 | exports.MousePathWidget = void 0;
1189 | 
1190 | var _Widget = require("./Widget");
1191 | 
1192 | class MousePathWidget extends _Widget.Widget {
1193 |   constructor(keys) {
1194 |     super();
1195 |     this.keys = keys;
1196 |     this.isTracking = false;
1197 |     this.state = [];
1198 |     this.shouldNotifyPathStarted = false;
1199 |     this.shouldNotifyPathEnded = false;
1200 |     this.key = null;
1201 |   }
1202 | 
1203 |   willUpdate({
1204 |     inputState
1205 |   }) {
1206 |     if (this.isTracking === false) {
1207 |       const key = this.keys.find(inputState.isJustPressed.bind(inputState));
1208 | 
1209 |       if (key) {
1210 |         this.state = [];
1211 |         this.isTracking = true;
1212 |         this.key = key;
1213 |         this.shouldNotifyPathStarted = true;
1214 |       }
1215 |     }
1216 | 
1217 |     if (this.isTracking === true && this.key && inputState.isPressed(this.key)) {
1218 |       this.state.push(inputState.mouse.clone());
1219 |     }
1220 | 
1221 |     if (this.isTracking === true && this.key && inputState.isJustReleased(this.key)) {
1222 |       this.isTracking = false;
1223 |       this.shouldNotifyPathEnded = true;
1224 |     }
1225 |   }
1226 | 
1227 |   onPathStarted(callback) {
1228 |     if (this.shouldNotifyPathStarted) {
1229 |       this.shouldNotifyPathStarted = false;
1230 |       callback(this.state[0], this.key);
1231 |     }
1232 |   }
1233 | 
1234 |   onPathEnded(callback) {
1235 |     if (this.shouldNotifyPathEnded) {
1236 |       this.shouldNotifyPathEnded = false;
1237 |       const state = this.state;
1238 |       this.state = [];
1239 |       callback(state, this.key);
1240 |     }
1241 |   }
1242 | 
1243 | }
1244 | 
1245 | exports.MousePathWidget = MousePathWidget;
1246 | },{"./Widget":"ur7p"}],"WdSo":[function(require,module,exports) {
1247 | "use strict";
1248 | 
1249 | Object.defineProperty(exports, "__esModule", {
1250 |   value: true
1251 | });
1252 | 
1253 | var _index = require("./assetLoader/index");
1254 | 
1255 | Object.keys(_index).forEach(function (key) {
1256 |   if (key === "default" || key === "__esModule") return;
1257 |   if (key in exports && exports[key] === _index[key]) return;
1258 |   Object.defineProperty(exports, key, {
1259 |     enumerable: true,
1260 |     get: function () {
1261 |       return _index[key];
1262 |     }
1263 |   });
1264 | });
1265 | 
1266 | var _Engine = require("./engine/Engine");
1267 | 
1268 | Object.keys(_Engine).forEach(function (key) {
1269 |   if (key === "default" || key === "__esModule") return;
1270 |   if (key in exports && exports[key] === _Engine[key]) return;
1271 |   Object.defineProperty(exports, key, {
1272 |     enumerable: true,
1273 |     get: function () {
1274 |       return _Engine[key];
1275 |     }
1276 |   });
1277 | });
1278 | 
1279 | var _Entity = require("./entity/Entity");
1280 | 
1281 | Object.keys(_Entity).forEach(function (key) {
1282 |   if (key === "default" || key === "__esModule") return;
1283 |   if (key in exports && exports[key] === _Entity[key]) return;
1284 |   Object.defineProperty(exports, key, {
1285 |     enumerable: true,
1286 |     get: function () {
1287 |       return _Entity[key];
1288 |     }
1289 |   });
1290 | });
1291 | 
1292 | var _TextEntity = require("./entity/TextEntity");
1293 | 
1294 | Object.keys(_TextEntity).forEach(function (key) {
1295 |   if (key === "default" || key === "__esModule") return;
1296 |   if (key in exports && exports[key] === _TextEntity[key]) return;
1297 |   Object.defineProperty(exports, key, {
1298 |     enumerable: true,
1299 |     get: function () {
1300 |       return _TextEntity[key];
1301 |     }
1302 |   });
1303 | });
1304 | 
1305 | var _InputManager = require("./inputManager/InputManager");
1306 | 
1307 | Object.keys(_InputManager).forEach(function (key) {
1308 |   if (key === "default" || key === "__esModule") return;
1309 |   if (key in exports && exports[key] === _InputManager[key]) return;
1310 |   Object.defineProperty(exports, key, {
1311 |     enumerable: true,
1312 |     get: function () {
1313 |       return _InputManager[key];
1314 |     }
1315 |   });
1316 | });
1317 | 
1318 | var _InputState = require("./inputManager/InputState");
1319 | 
1320 | Object.keys(_InputState).forEach(function (key) {
1321 |   if (key === "default" || key === "__esModule") return;
1322 |   if (key in exports && exports[key] === _InputState[key]) return;
1323 |   Object.defineProperty(exports, key, {
1324 |     enumerable: true,
1325 |     get: function () {
1326 |       return _InputState[key];
1327 |     }
1328 |   });
1329 | });
1330 | 
1331 | var _Key = require("./inputManager/Key");
1332 | 
1333 | Object.keys(_Key).forEach(function (key) {
1334 |   if (key === "default" || key === "__esModule") return;
1335 |   if (key in exports && exports[key] === _Key[key]) return;
1336 |   Object.defineProperty(exports, key, {
1337 |     enumerable: true,
1338 |     get: function () {
1339 |       return _Key[key];
1340 |     }
1341 |   });
1342 | });
1343 | 
1344 | var _Vector = require("./math/Vector2");
1345 | 
1346 | Object.keys(_Vector).forEach(function (key) {
1347 |   if (key === "default" || key === "__esModule") return;
1348 |   if (key in exports && exports[key] === _Vector[key]) return;
1349 |   Object.defineProperty(exports, key, {
1350 |     enumerable: true,
1351 |     get: function () {
1352 |       return _Vector[key];
1353 |     }
1354 |   });
1355 | });
1356 | 
1357 | var _Scene = require("./scene/Scene");
1358 | 
1359 | Object.keys(_Scene).forEach(function (key) {
1360 |   if (key === "default" || key === "__esModule") return;
1361 |   if (key in exports && exports[key] === _Scene[key]) return;
1362 |   Object.defineProperty(exports, key, {
1363 |     enumerable: true,
1364 |     get: function () {
1365 |       return _Scene[key];
1366 |     }
1367 |   });
1368 | });
1369 | 
1370 | var _Ticker = require("./ticker/Ticker");
1371 | 
1372 | Object.keys(_Ticker).forEach(function (key) {
1373 |   if (key === "default" || key === "__esModule") return;
1374 |   if (key in exports && exports[key] === _Ticker[key]) return;
1375 |   Object.defineProperty(exports, key, {
1376 |     enumerable: true,
1377 |     get: function () {
1378 |       return _Ticker[key];
1379 |     }
1380 |   });
1381 | });
1382 | 
1383 | var _AnimationFrameTicker = require("./ticker/AnimationFrameTicker");
1384 | 
1385 | Object.keys(_AnimationFrameTicker).forEach(function (key) {
1386 |   if (key === "default" || key === "__esModule") return;
1387 |   if (key in exports && exports[key] === _AnimationFrameTicker[key]) return;
1388 |   Object.defineProperty(exports, key, {
1389 |     enumerable: true,
1390 |     get: function () {
1391 |       return _AnimationFrameTicker[key];
1392 |     }
1393 |   });
1394 | });
1395 | 
1396 | var _Widget = require("./widgets/Widget");
1397 | 
1398 | Object.keys(_Widget).forEach(function (key) {
1399 |   if (key === "default" || key === "__esModule") return;
1400 |   if (key in exports && exports[key] === _Widget[key]) return;
1401 |   Object.defineProperty(exports, key, {
1402 |     enumerable: true,
1403 |     get: function () {
1404 |       return _Widget[key];
1405 |     }
1406 |   });
1407 | });
1408 | 
1409 | var _MousePath = require("./widgets/MousePath");
1410 | 
1411 | Object.keys(_MousePath).forEach(function (key) {
1412 |   if (key === "default" || key === "__esModule") return;
1413 |   if (key in exports && exports[key] === _MousePath[key]) return;
1414 |   Object.defineProperty(exports, key, {
1415 |     enumerable: true,
1416 |     get: function () {
1417 |       return _MousePath[key];
1418 |     }
1419 |   });
1420 | });
1421 | },{"./assetLoader/index":"VSoi","./engine/Engine":"mnx3","./entity/Entity":"H2cD","./entity/TextEntity":"m6zO","./inputManager/InputManager":"cx2N","./inputManager/InputState":"CA2L","./inputManager/Key":"oaWb","./math/Vector2":"huun","./scene/Scene":"mohF","./ticker/Ticker":"PcY8","./ticker/AnimationFrameTicker":"dBYq","./widgets/Widget":"ur7p","./widgets/MousePath":"NTlZ"}],"pBGv":[function(require,module,exports) {
1422 | 
1423 | // shim for using process in browser
1424 | var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it
1425 | // don't break things.  But we need to wrap it in a try catch in case it is
1426 | // wrapped in strict mode code which doesn't define any globals.  It's inside a
1427 | // function because try/catches deoptimize in certain engines.
1428 | 
1429 | var cachedSetTimeout;
1430 | var cachedClearTimeout;
1431 | 
1432 | function defaultSetTimout() {
1433 |   throw new Error('setTimeout has not been defined');
1434 | }
1435 | 
1436 | function defaultClearTimeout() {
1437 |   throw new Error('clearTimeout has not been defined');
1438 | }
1439 | 
1440 | (function () {
1441 |   try {
1442 |     if (typeof setTimeout === 'function') {
1443 |       cachedSetTimeout = setTimeout;
1444 |     } else {
1445 |       cachedSetTimeout = defaultSetTimout;
1446 |     }
1447 |   } catch (e) {
1448 |     cachedSetTimeout = defaultSetTimout;
1449 |   }
1450 | 
1451 |   try {
1452 |     if (typeof clearTimeout === 'function') {
1453 |       cachedClearTimeout = clearTimeout;
1454 |     } else {
1455 |       cachedClearTimeout = defaultClearTimeout;
1456 |     }
1457 |   } catch (e) {
1458 |     cachedClearTimeout = defaultClearTimeout;
1459 |   }
1460 | })();
1461 | 
1462 | function runTimeout(fun) {
1463 |   if (cachedSetTimeout === setTimeout) {
1464 |     //normal enviroments in sane situations
1465 |     return setTimeout(fun, 0);
1466 |   } // if setTimeout wasn't available but was latter defined
1467 | 
1468 | 
1469 |   if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
1470 |     cachedSetTimeout = setTimeout;
1471 |     return setTimeout(fun, 0);
1472 |   }
1473 | 
1474 |   try {
1475 |     // when when somebody has screwed with setTimeout but no I.E. maddness
1476 |     return cachedSetTimeout(fun, 0);
1477 |   } catch (e) {
1478 |     try {
1479 |       // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
1480 |       return cachedSetTimeout.call(null, fun, 0);
1481 |     } catch (e) {
1482 |       // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
1483 |       return cachedSetTimeout.call(this, fun, 0);
1484 |     }
1485 |   }
1486 | }
1487 | 
1488 | function runClearTimeout(marker) {
1489 |   if (cachedClearTimeout === clearTimeout) {
1490 |     //normal enviroments in sane situations
1491 |     return clearTimeout(marker);
1492 |   } // if clearTimeout wasn't available but was latter defined
1493 | 
1494 | 
1495 |   if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
1496 |     cachedClearTimeout = clearTimeout;
1497 |     return clearTimeout(marker);
1498 |   }
1499 | 
1500 |   try {
1501 |     // when when somebody has screwed with setTimeout but no I.E. maddness
1502 |     return cachedClearTimeout(marker);
1503 |   } catch (e) {
1504 |     try {
1505 |       // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
1506 |       return cachedClearTimeout.call(null, marker);
1507 |     } catch (e) {
1508 |       // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
1509 |       // Some versions of I.E. have different rules for clearTimeout vs setTimeout
1510 |       return cachedClearTimeout.call(this, marker);
1511 |     }
1512 |   }
1513 | }
1514 | 
1515 | var queue = [];
1516 | var draining = false;
1517 | var currentQueue;
1518 | var queueIndex = -1;
1519 | 
1520 | function cleanUpNextTick() {
1521 |   if (!draining || !currentQueue) {
1522 |     return;
1523 |   }
1524 | 
1525 |   draining = false;
1526 | 
1527 |   if (currentQueue.length) {
1528 |     queue = currentQueue.concat(queue);
1529 |   } else {
1530 |     queueIndex = -1;
1531 |   }
1532 | 
1533 |   if (queue.length) {
1534 |     drainQueue();
1535 |   }
1536 | }
1537 | 
1538 | function drainQueue() {
1539 |   if (draining) {
1540 |     return;
1541 |   }
1542 | 
1543 |   var timeout = runTimeout(cleanUpNextTick);
1544 |   draining = true;
1545 |   var len = queue.length;
1546 | 
1547 |   while (len) {
1548 |     currentQueue = queue;
1549 |     queue = [];
1550 | 
1551 |     while (++queueIndex < len) {
1552 |       if (currentQueue) {
1553 |         currentQueue[queueIndex].run();
1554 |       }
1555 |     }
1556 | 
1557 |     queueIndex = -1;
1558 |     len = queue.length;
1559 |   }
1560 | 
1561 |   currentQueue = null;
1562 |   draining = false;
1563 |   runClearTimeout(timeout);
1564 | }
1565 | 
1566 | process.nextTick = function (fun) {
1567 |   var args = new Array(arguments.length - 1);
1568 | 
1569 |   if (arguments.length > 1) {
1570 |     for (var i = 1; i < arguments.length; i++) {
1571 |       args[i - 1] = arguments[i];
1572 |     }
1573 |   }
1574 | 
1575 |   queue.push(new Item(fun, args));
1576 | 
1577 |   if (queue.length === 1 && !draining) {
1578 |     runTimeout(drainQueue);
1579 |   }
1580 | }; // v8 likes predictible objects
1581 | 
1582 | 
1583 | function Item(fun, array) {
1584 |   this.fun = fun;
1585 |   this.array = array;
1586 | }
1587 | 
1588 | Item.prototype.run = function () {
1589 |   this.fun.apply(null, this.array);
1590 | };
1591 | 
1592 | process.title = 'browser';
1593 | process.env = {};
1594 | process.argv = [];
1595 | process.version = ''; // empty string to avoid regexp issues
1596 | 
1597 | process.versions = {};
1598 | 
1599 | function noop() {}
1600 | 
1601 | process.on = noop;
1602 | process.addListener = noop;
1603 | process.once = noop;
1604 | process.off = noop;
1605 | process.removeListener = noop;
1606 | process.removeAllListeners = noop;
1607 | process.emit = noop;
1608 | process.prependListener = noop;
1609 | process.prependOnceListener = noop;
1610 | 
1611 | process.listeners = function (name) {
1612 |   return [];
1613 | };
1614 | 
1615 | process.binding = function (name) {
1616 |   throw new Error('process.binding is not supported');
1617 | };
1618 | 
1619 | process.cwd = function () {
1620 |   return '/';
1621 | };
1622 | 
1623 | process.chdir = function (dir) {
1624 |   throw new Error('process.chdir is not supported');
1625 | };
1626 | 
1627 | process.umask = function () {
1628 |   return 0;
1629 | };
1630 | },{}],"MxHY":[function(require,module,exports) {
1631 | var process = require("process");
1632 | "use strict";
1633 | 
1634 | Object.defineProperty(exports, "__esModule", {
1635 |   value: true
1636 | });
1637 | exports.update = exports.removeAll = exports.remove = exports.now = exports.nextId = exports.getAll = exports.add = exports.VERSION = exports.Tween = exports.Sequence = exports.Interpolation = exports.Group = exports.Easing = exports.default = void 0;
1638 | 
1639 | /**
1640 |  * The Ease class provides a collection of easing functions for use with tween.js.
1641 |  */
1642 | var Easing = {
1643 |   Linear: {
1644 |     None: function (amount) {
1645 |       return amount;
1646 |     }
1647 |   },
1648 |   Quadratic: {
1649 |     In: function (amount) {
1650 |       return amount * amount;
1651 |     },
1652 |     Out: function (amount) {
1653 |       return amount * (2 - amount);
1654 |     },
1655 |     InOut: function (amount) {
1656 |       if ((amount *= 2) < 1) {
1657 |         return 0.5 * amount * amount;
1658 |       }
1659 | 
1660 |       return -0.5 * (--amount * (amount - 2) - 1);
1661 |     }
1662 |   },
1663 |   Cubic: {
1664 |     In: function (amount) {
1665 |       return amount * amount * amount;
1666 |     },
1667 |     Out: function (amount) {
1668 |       return --amount * amount * amount + 1;
1669 |     },
1670 |     InOut: function (amount) {
1671 |       if ((amount *= 2) < 1) {
1672 |         return 0.5 * amount * amount * amount;
1673 |       }
1674 | 
1675 |       return 0.5 * ((amount -= 2) * amount * amount + 2);
1676 |     }
1677 |   },
1678 |   Quartic: {
1679 |     In: function (amount) {
1680 |       return amount * amount * amount * amount;
1681 |     },
1682 |     Out: function (amount) {
1683 |       return 1 - --amount * amount * amount * amount;
1684 |     },
1685 |     InOut: function (amount) {
1686 |       if ((amount *= 2) < 1) {
1687 |         return 0.5 * amount * amount * amount * amount;
1688 |       }
1689 | 
1690 |       return -0.5 * ((amount -= 2) * amount * amount * amount - 2);
1691 |     }
1692 |   },
1693 |   Quintic: {
1694 |     In: function (amount) {
1695 |       return amount * amount * amount * amount * amount;
1696 |     },
1697 |     Out: function (amount) {
1698 |       return --amount * amount * amount * amount * amount + 1;
1699 |     },
1700 |     InOut: function (amount) {
1701 |       if ((amount *= 2) < 1) {
1702 |         return 0.5 * amount * amount * amount * amount * amount;
1703 |       }
1704 | 
1705 |       return 0.5 * ((amount -= 2) * amount * amount * amount * amount + 2);
1706 |     }
1707 |   },
1708 |   Sinusoidal: {
1709 |     In: function (amount) {
1710 |       return 1 - Math.cos(amount * Math.PI / 2);
1711 |     },
1712 |     Out: function (amount) {
1713 |       return Math.sin(amount * Math.PI / 2);
1714 |     },
1715 |     InOut: function (amount) {
1716 |       return 0.5 * (1 - Math.cos(Math.PI * amount));
1717 |     }
1718 |   },
1719 |   Exponential: {
1720 |     In: function (amount) {
1721 |       return amount === 0 ? 0 : Math.pow(1024, amount - 1);
1722 |     },
1723 |     Out: function (amount) {
1724 |       return amount === 1 ? 1 : 1 - Math.pow(2, -10 * amount);
1725 |     },
1726 |     InOut: function (amount) {
1727 |       if (amount === 0) {
1728 |         return 0;
1729 |       }
1730 | 
1731 |       if (amount === 1) {
1732 |         return 1;
1733 |       }
1734 | 
1735 |       if ((amount *= 2) < 1) {
1736 |         return 0.5 * Math.pow(1024, amount - 1);
1737 |       }
1738 | 
1739 |       return 0.5 * (-Math.pow(2, -10 * (amount - 1)) + 2);
1740 |     }
1741 |   },
1742 |   Circular: {
1743 |     In: function (amount) {
1744 |       return 1 - Math.sqrt(1 - amount * amount);
1745 |     },
1746 |     Out: function (amount) {
1747 |       return Math.sqrt(1 - --amount * amount);
1748 |     },
1749 |     InOut: function (amount) {
1750 |       if ((amount *= 2) < 1) {
1751 |         return -0.5 * (Math.sqrt(1 - amount * amount) - 1);
1752 |       }
1753 | 
1754 |       return 0.5 * (Math.sqrt(1 - (amount -= 2) * amount) + 1);
1755 |     }
1756 |   },
1757 |   Elastic: {
1758 |     In: function (amount) {
1759 |       if (amount === 0) {
1760 |         return 0;
1761 |       }
1762 | 
1763 |       if (amount === 1) {
1764 |         return 1;
1765 |       }
1766 | 
1767 |       return -Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
1768 |     },
1769 |     Out: function (amount) {
1770 |       if (amount === 0) {
1771 |         return 0;
1772 |       }
1773 | 
1774 |       if (amount === 1) {
1775 |         return 1;
1776 |       }
1777 | 
1778 |       return Math.pow(2, -10 * amount) * Math.sin((amount - 0.1) * 5 * Math.PI) + 1;
1779 |     },
1780 |     InOut: function (amount) {
1781 |       if (amount === 0) {
1782 |         return 0;
1783 |       }
1784 | 
1785 |       if (amount === 1) {
1786 |         return 1;
1787 |       }
1788 | 
1789 |       amount *= 2;
1790 | 
1791 |       if (amount < 1) {
1792 |         return -0.5 * Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
1793 |       }
1794 | 
1795 |       return 0.5 * Math.pow(2, -10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI) + 1;
1796 |     }
1797 |   },
1798 |   Back: {
1799 |     In: function (amount) {
1800 |       var s = 1.70158;
1801 |       return amount * amount * ((s + 1) * amount - s);
1802 |     },
1803 |     Out: function (amount) {
1804 |       var s = 1.70158;
1805 |       return --amount * amount * ((s + 1) * amount + s) + 1;
1806 |     },
1807 |     InOut: function (amount) {
1808 |       var s = 1.70158 * 1.525;
1809 | 
1810 |       if ((amount *= 2) < 1) {
1811 |         return 0.5 * (amount * amount * ((s + 1) * amount - s));
1812 |       }
1813 | 
1814 |       return 0.5 * ((amount -= 2) * amount * ((s + 1) * amount + s) + 2);
1815 |     }
1816 |   },
1817 |   Bounce: {
1818 |     In: function (amount) {
1819 |       return 1 - Easing.Bounce.Out(1 - amount);
1820 |     },
1821 |     Out: function (amount) {
1822 |       if (amount < 1 / 2.75) {
1823 |         return 7.5625 * amount * amount;
1824 |       } else if (amount < 2 / 2.75) {
1825 |         return 7.5625 * (amount -= 1.5 / 2.75) * amount + 0.75;
1826 |       } else if (amount < 2.5 / 2.75) {
1827 |         return 7.5625 * (amount -= 2.25 / 2.75) * amount + 0.9375;
1828 |       } else {
1829 |         return 7.5625 * (amount -= 2.625 / 2.75) * amount + 0.984375;
1830 |       }
1831 |     },
1832 |     InOut: function (amount) {
1833 |       if (amount < 0.5) {
1834 |         return Easing.Bounce.In(amount * 2) * 0.5;
1835 |       }
1836 | 
1837 |       return Easing.Bounce.Out(amount * 2 - 1) * 0.5 + 0.5;
1838 |     }
1839 |   }
1840 | };
1841 | exports.Easing = Easing;
1842 | var now; // Include a performance.now polyfill.
1843 | // In node.js, use process.hrtime.
1844 | // eslint-disable-next-line
1845 | // @ts-ignore
1846 | 
1847 | if (typeof self === 'undefined' && typeof process !== 'undefined' && process.hrtime) {
1848 |   now = function () {
1849 |     // eslint-disable-next-line
1850 |     // @ts-ignore
1851 |     var time = process.hrtime(); // Convert [seconds, nanoseconds] to milliseconds.
1852 | 
1853 |     return time[0] * 1000 + time[1] / 1000000;
1854 |   };
1855 | } // In a browser, use self.performance.now if it is available.
1856 | else if (typeof self !== 'undefined' && self.performance !== undefined && self.performance.now !== undefined) {
1857 |     // This must be bound, because directly assigning this function
1858 |     // leads to an invocation exception in Chrome.
1859 |     now = self.performance.now.bind(self.performance);
1860 |   } // Use Date.now if it is available.
1861 |   else if (Date.now !== undefined) {
1862 |       now = Date.now;
1863 |     } // Otherwise, use 'new Date().getTime()'.
1864 |     else {
1865 |         now = function () {
1866 |           return new Date().getTime();
1867 |         };
1868 |       }
1869 | 
1870 | var now$1 = now;
1871 | /**
1872 |  * Controlling groups of tweens
1873 |  *
1874 |  * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
1875 |  * In these cases, you may want to create your own smaller groups of tween
1876 |  */
1877 | 
1878 | exports.now = now$1;
1879 | 
1880 | var Group =
1881 | /** @class */
1882 | function () {
1883 |   function Group() {
1884 |     this._tweens = {};
1885 |     this._tweensAddedDuringUpdate = {};
1886 |   }
1887 | 
1888 |   Group.prototype.getAll = function () {
1889 |     var _this = this;
1890 | 
1891 |     return Object.keys(this._tweens).map(function (tweenId) {
1892 |       return _this._tweens[tweenId];
1893 |     });
1894 |   };
1895 | 
1896 |   Group.prototype.removeAll = function () {
1897 |     this._tweens = {};
1898 |   };
1899 | 
1900 |   Group.prototype.add = function (tween) {
1901 |     this._tweens[tween.getId()] = tween;
1902 |     this._tweensAddedDuringUpdate[tween.getId()] = tween;
1903 |   };
1904 | 
1905 |   Group.prototype.remove = function (tween) {
1906 |     delete this._tweens[tween.getId()];
1907 |     delete this._tweensAddedDuringUpdate[tween.getId()];
1908 |   };
1909 | 
1910 |   Group.prototype.update = function (time, preserve) {
1911 |     if (time === void 0) {
1912 |       time = now$1();
1913 |     }
1914 | 
1915 |     if (preserve === void 0) {
1916 |       preserve = false;
1917 |     }
1918 | 
1919 |     var tweenIds = Object.keys(this._tweens);
1920 | 
1921 |     if (tweenIds.length === 0) {
1922 |       return false;
1923 |     } // Tweens are updated in "batches". If you add a new tween during an
1924 |     // update, then the new tween will be updated in the next batch.
1925 |     // If you remove a tween during an update, it may or may not be updated.
1926 |     // However, if the removed tween was added during the current batch,
1927 |     // then it will not be updated.
1928 | 
1929 | 
1930 |     while (tweenIds.length > 0) {
1931 |       this._tweensAddedDuringUpdate = {};
1932 | 
1933 |       for (var i = 0; i < tweenIds.length; i++) {
1934 |         var tween = this._tweens[tweenIds[i]];
1935 |         var autoStart = !preserve;
1936 | 
1937 |         if (tween && tween.update(time, autoStart) === false && !preserve) {
1938 |           delete this._tweens[tweenIds[i]];
1939 |         }
1940 |       }
1941 | 
1942 |       tweenIds = Object.keys(this._tweensAddedDuringUpdate);
1943 |     }
1944 | 
1945 |     return true;
1946 |   };
1947 | 
1948 |   return Group;
1949 | }();
1950 | /**
1951 |  *
1952 |  */
1953 | 
1954 | 
1955 | exports.Group = Group;
1956 | var Interpolation = {
1957 |   Linear: function (v, k) {
1958 |     var m = v.length - 1;
1959 |     var f = m * k;
1960 |     var i = Math.floor(f);
1961 |     var fn = Interpolation.Utils.Linear;
1962 | 
1963 |     if (k < 0) {
1964 |       return fn(v[0], v[1], f);
1965 |     }
1966 | 
1967 |     if (k > 1) {
1968 |       return fn(v[m], v[m - 1], m - f);
1969 |     }
1970 | 
1971 |     return fn(v[i], v[i + 1 > m ? m : i + 1], f - i);
1972 |   },
1973 |   Bezier: function (v, k) {
1974 |     var b = 0;
1975 |     var n = v.length - 1;
1976 |     var pw = Math.pow;
1977 |     var bn = Interpolation.Utils.Bernstein;
1978 | 
1979 |     for (var i = 0; i <= n; i++) {
1980 |       b += pw(1 - k, n - i) * pw(k, i) * v[i] * bn(n, i);
1981 |     }
1982 | 
1983 |     return b;
1984 |   },
1985 |   CatmullRom: function (v, k) {
1986 |     var m = v.length - 1;
1987 |     var f = m * k;
1988 |     var i = Math.floor(f);
1989 |     var fn = Interpolation.Utils.CatmullRom;
1990 | 
1991 |     if (v[0] === v[m]) {
1992 |       if (k < 0) {
1993 |         i = Math.floor(f = m * (1 + k));
1994 |       }
1995 | 
1996 |       return fn(v[(i - 1 + m) % m], v[i], v[(i + 1) % m], v[(i + 2) % m], f - i);
1997 |     } else {
1998 |       if (k < 0) {
1999 |         return v[0] - (fn(v[0], v[0], v[1], v[1], -f) - v[0]);
2000 |       }
2001 | 
2002 |       if (k > 1) {
2003 |         return v[m] - (fn(v[m], v[m], v[m - 1], v[m - 1], f - m) - v[m]);
2004 |       }
2005 | 
2006 |       return fn(v[i ? i - 1 : 0], v[i], v[m < i + 1 ? m : i + 1], v[m < i + 2 ? m : i + 2], f - i);
2007 |     }
2008 |   },
2009 |   Utils: {
2010 |     Linear: function (p0, p1, t) {
2011 |       return (p1 - p0) * t + p0;
2012 |     },
2013 |     Bernstein: function (n, i) {
2014 |       var fc = Interpolation.Utils.Factorial;
2015 |       return fc(n) / fc(i) / fc(n - i);
2016 |     },
2017 |     Factorial: function () {
2018 |       var a = [1];
2019 |       return function (n) {
2020 |         var s = 1;
2021 | 
2022 |         if (a[n]) {
2023 |           return a[n];
2024 |         }
2025 | 
2026 |         for (var i = n; i > 1; i--) {
2027 |           s *= i;
2028 |         }
2029 | 
2030 |         a[n] = s;
2031 |         return s;
2032 |       };
2033 |     }(),
2034 |     CatmullRom: function (p0, p1, p2, p3, t) {
2035 |       var v0 = (p2 - p0) * 0.5;
2036 |       var v1 = (p3 - p1) * 0.5;
2037 |       var t2 = t * t;
2038 |       var t3 = t * t2;
2039 |       return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
2040 |     }
2041 |   }
2042 | };
2043 | /**
2044 |  * Utils
2045 |  */
2046 | 
2047 | exports.Interpolation = Interpolation;
2048 | 
2049 | var Sequence =
2050 | /** @class */
2051 | function () {
2052 |   function Sequence() {}
2053 | 
2054 |   Sequence.nextId = function () {
2055 |     return Sequence._nextId++;
2056 |   };
2057 | 
2058 |   Sequence._nextId = 0;
2059 |   return Sequence;
2060 | }();
2061 | 
2062 | exports.Sequence = Sequence;
2063 | var mainGroup = new Group();
2064 | /**
2065 |  * Tween.js - Licensed under the MIT license
2066 |  * https://github.com/tweenjs/tween.js
2067 |  * ----------------------------------------------
2068 |  *
2069 |  * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
2070 |  * Thank you all, you're awesome!
2071 |  */
2072 | 
2073 | var Tween =
2074 | /** @class */
2075 | function () {
2076 |   function Tween(_object, _group) {
2077 |     if (_group === void 0) {
2078 |       _group = mainGroup;
2079 |     }
2080 | 
2081 |     this._object = _object;
2082 |     this._group = _group;
2083 |     this._isPaused = false;
2084 |     this._pauseStart = 0;
2085 |     this._valuesStart = {};
2086 |     this._valuesEnd = {};
2087 |     this._valuesStartRepeat = {};
2088 |     this._duration = 1000;
2089 |     this._initialRepeat = 0;
2090 |     this._repeat = 0;
2091 |     this._yoyo = false;
2092 |     this._isPlaying = false;
2093 |     this._reversed = false;
2094 |     this._delayTime = 0;
2095 |     this._startTime = 0;
2096 |     this._easingFunction = Easing.Linear.None;
2097 |     this._interpolationFunction = Interpolation.Linear;
2098 |     this._chainedTweens = [];
2099 |     this._onStartCallbackFired = false;
2100 |     this._id = Sequence.nextId();
2101 |     this._isChainStopped = false;
2102 |     this._goToEnd = false;
2103 |   }
2104 | 
2105 |   Tween.prototype.getId = function () {
2106 |     return this._id;
2107 |   };
2108 | 
2109 |   Tween.prototype.isPlaying = function () {
2110 |     return this._isPlaying;
2111 |   };
2112 | 
2113 |   Tween.prototype.isPaused = function () {
2114 |     return this._isPaused;
2115 |   };
2116 | 
2117 |   Tween.prototype.to = function (properties, duration) {
2118 |     // TODO? restore this, then update the 07_dynamic_to example to set fox
2119 |     // tween's to on each update. That way the behavior is opt-in (there's
2120 |     // currently no opt-out).
2121 |     // for (const prop in properties) this._valuesEnd[prop] = properties[prop]
2122 |     this._valuesEnd = Object.create(properties);
2123 | 
2124 |     if (duration !== undefined) {
2125 |       this._duration = duration;
2126 |     }
2127 | 
2128 |     return this;
2129 |   };
2130 | 
2131 |   Tween.prototype.duration = function (d) {
2132 |     this._duration = d;
2133 |     return this;
2134 |   };
2135 | 
2136 |   Tween.prototype.start = function (time) {
2137 |     if (this._isPlaying) {
2138 |       return this;
2139 |     } // eslint-disable-next-line
2140 | 
2141 | 
2142 |     this._group && this._group.add(this);
2143 |     this._repeat = this._initialRepeat;
2144 | 
2145 |     if (this._reversed) {
2146 |       // If we were reversed (f.e. using the yoyo feature) then we need to
2147 |       // flip the tween direction back to forward.
2148 |       this._reversed = false;
2149 | 
2150 |       for (var property in this._valuesStartRepeat) {
2151 |         this._swapEndStartRepeatValues(property);
2152 | 
2153 |         this._valuesStart[property] = this._valuesStartRepeat[property];
2154 |       }
2155 |     }
2156 | 
2157 |     this._isPlaying = true;
2158 |     this._isPaused = false;
2159 |     this._onStartCallbackFired = false;
2160 |     this._isChainStopped = false;
2161 |     this._startTime = time !== undefined ? typeof time === 'string' ? now$1() + parseFloat(time) : time : now$1();
2162 |     this._startTime += this._delayTime;
2163 | 
2164 |     this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat);
2165 | 
2166 |     return this;
2167 |   };
2168 | 
2169 |   Tween.prototype._setupProperties = function (_object, _valuesStart, _valuesEnd, _valuesStartRepeat) {
2170 |     for (var property in _valuesEnd) {
2171 |       var startValue = _object[property];
2172 |       var startValueIsArray = Array.isArray(startValue);
2173 |       var propType = startValueIsArray ? 'array' : typeof startValue;
2174 |       var isInterpolationList = !startValueIsArray && Array.isArray(_valuesEnd[property]); // If `to()` specifies a property that doesn't exist in the source object,
2175 |       // we should not set that property in the object
2176 | 
2177 |       if (propType === 'undefined' || propType === 'function') {
2178 |         continue;
2179 |       } // Check if an Array was provided as property value
2180 | 
2181 | 
2182 |       if (isInterpolationList) {
2183 |         var endValues = _valuesEnd[property];
2184 | 
2185 |         if (endValues.length === 0) {
2186 |           continue;
2187 |         } // handle an array of relative values
2188 | 
2189 | 
2190 |         endValues = endValues.map(this._handleRelativeValue.bind(this, startValue)); // Create a local copy of the Array with the start value at the front
2191 | 
2192 |         _valuesEnd[property] = [startValue].concat(endValues);
2193 |       } // handle the deepness of the values
2194 | 
2195 | 
2196 |       if ((propType === 'object' || startValueIsArray) && startValue && !isInterpolationList) {
2197 |         _valuesStart[property] = startValueIsArray ? [] : {}; // eslint-disable-next-line
2198 | 
2199 |         for (var prop in startValue) {
2200 |           // eslint-disable-next-line
2201 |           // @ts-ignore FIXME?
2202 |           _valuesStart[property][prop] = startValue[prop];
2203 |         }
2204 | 
2205 |         _valuesStartRepeat[property] = startValueIsArray ? [] : {}; // TODO? repeat nested values? And yoyo? And array values?
2206 |         // eslint-disable-next-line
2207 |         // @ts-ignore FIXME?
2208 | 
2209 |         this._setupProperties(startValue, _valuesStart[property], _valuesEnd[property], _valuesStartRepeat[property]);
2210 |       } else {
2211 |         // Save the starting value, but only once.
2212 |         if (typeof _valuesStart[property] === 'undefined') {
2213 |           _valuesStart[property] = startValue;
2214 |         }
2215 | 
2216 |         if (!startValueIsArray) {
2217 |           // eslint-disable-next-line
2218 |           // @ts-ignore FIXME?
2219 |           _valuesStart[property] *= 1.0; // Ensures we're using numbers, not strings
2220 |         }
2221 | 
2222 |         if (isInterpolationList) {
2223 |           // eslint-disable-next-line
2224 |           // @ts-ignore FIXME?
2225 |           _valuesStartRepeat[property] = _valuesEnd[property].slice().reverse();
2226 |         } else {
2227 |           _valuesStartRepeat[property] = _valuesStart[property] || 0;
2228 |         }
2229 |       }
2230 |     }
2231 |   };
2232 | 
2233 |   Tween.prototype.stop = function () {
2234 |     if (!this._isChainStopped) {
2235 |       this._isChainStopped = true;
2236 |       this.stopChainedTweens();
2237 |     }
2238 | 
2239 |     if (!this._isPlaying) {
2240 |       return this;
2241 |     } // eslint-disable-next-line
2242 | 
2243 | 
2244 |     this._group && this._group.remove(this);
2245 |     this._isPlaying = false;
2246 |     this._isPaused = false;
2247 | 
2248 |     if (this._onStopCallback) {
2249 |       this._onStopCallback(this._object);
2250 |     }
2251 | 
2252 |     return this;
2253 |   };
2254 | 
2255 |   Tween.prototype.end = function () {
2256 |     this._goToEnd = true;
2257 |     this.update(Infinity);
2258 |     return this;
2259 |   };
2260 | 
2261 |   Tween.prototype.pause = function (time) {
2262 |     if (time === void 0) {
2263 |       time = now$1();
2264 |     }
2265 | 
2266 |     if (this._isPaused || !this._isPlaying) {
2267 |       return this;
2268 |     }
2269 | 
2270 |     this._isPaused = true;
2271 |     this._pauseStart = time; // eslint-disable-next-line
2272 | 
2273 |     this._group && this._group.remove(this);
2274 |     return this;
2275 |   };
2276 | 
2277 |   Tween.prototype.resume = function (time) {
2278 |     if (time === void 0) {
2279 |       time = now$1();
2280 |     }
2281 | 
2282 |     if (!this._isPaused || !this._isPlaying) {
2283 |       return this;
2284 |     }
2285 | 
2286 |     this._isPaused = false;
2287 |     this._startTime += time - this._pauseStart;
2288 |     this._pauseStart = 0; // eslint-disable-next-line
2289 | 
2290 |     this._group && this._group.add(this);
2291 |     return this;
2292 |   };
2293 | 
2294 |   Tween.prototype.stopChainedTweens = function () {
2295 |     for (var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++) {
2296 |       this._chainedTweens[i].stop();
2297 |     }
2298 | 
2299 |     return this;
2300 |   };
2301 | 
2302 |   Tween.prototype.group = function (group) {
2303 |     this._group = group;
2304 |     return this;
2305 |   };
2306 | 
2307 |   Tween.prototype.delay = function (amount) {
2308 |     this._delayTime = amount;
2309 |     return this;
2310 |   };
2311 | 
2312 |   Tween.prototype.repeat = function (times) {
2313 |     this._initialRepeat = times;
2314 |     this._repeat = times;
2315 |     return this;
2316 |   };
2317 | 
2318 |   Tween.prototype.repeatDelay = function (amount) {
2319 |     this._repeatDelayTime = amount;
2320 |     return this;
2321 |   };
2322 | 
2323 |   Tween.prototype.yoyo = function (yoyo) {
2324 |     this._yoyo = yoyo;
2325 |     return this;
2326 |   };
2327 | 
2328 |   Tween.prototype.easing = function (easingFunction) {
2329 |     this._easingFunction = easingFunction;
2330 |     return this;
2331 |   };
2332 | 
2333 |   Tween.prototype.interpolation = function (interpolationFunction) {
2334 |     this._interpolationFunction = interpolationFunction;
2335 |     return this;
2336 |   };
2337 | 
2338 |   Tween.prototype.chain = function () {
2339 |     var tweens = [];
2340 | 
2341 |     for (var _i = 0; _i < arguments.length; _i++) {
2342 |       tweens[_i] = arguments[_i];
2343 |     }
2344 | 
2345 |     this._chainedTweens = tweens;
2346 |     return this;
2347 |   };
2348 | 
2349 |   Tween.prototype.onStart = function (callback) {
2350 |     this._onStartCallback = callback;
2351 |     return this;
2352 |   };
2353 | 
2354 |   Tween.prototype.onUpdate = function (callback) {
2355 |     this._onUpdateCallback = callback;
2356 |     return this;
2357 |   };
2358 | 
2359 |   Tween.prototype.onRepeat = function (callback) {
2360 |     this._onRepeatCallback = callback;
2361 |     return this;
2362 |   };
2363 | 
2364 |   Tween.prototype.onComplete = function (callback) {
2365 |     this._onCompleteCallback = callback;
2366 |     return this;
2367 |   };
2368 | 
2369 |   Tween.prototype.onStop = function (callback) {
2370 |     this._onStopCallback = callback;
2371 |     return this;
2372 |   };
2373 |   /**
2374 |    * @returns true if the tween is still playing after the update, false
2375 |    * otherwise (calling update on a paused tween still returns true because
2376 |    * it is still playing, just paused).
2377 |    */
2378 | 
2379 | 
2380 |   Tween.prototype.update = function (time, autoStart) {
2381 |     if (time === void 0) {
2382 |       time = now$1();
2383 |     }
2384 | 
2385 |     if (autoStart === void 0) {
2386 |       autoStart = true;
2387 |     }
2388 | 
2389 |     if (this._isPaused) return true;
2390 |     var property;
2391 |     var elapsed;
2392 |     var endTime = this._startTime + this._duration;
2393 | 
2394 |     if (!this._goToEnd && !this._isPlaying) {
2395 |       if (time > endTime) return false;
2396 |       if (autoStart) this.start(time);
2397 |     }
2398 | 
2399 |     this._goToEnd = false;
2400 | 
2401 |     if (time < this._startTime) {
2402 |       return true;
2403 |     }
2404 | 
2405 |     if (this._onStartCallbackFired === false) {
2406 |       if (this._onStartCallback) {
2407 |         this._onStartCallback(this._object);
2408 |       }
2409 | 
2410 |       this._onStartCallbackFired = true;
2411 |     }
2412 | 
2413 |     elapsed = (time - this._startTime) / this._duration;
2414 |     elapsed = this._duration === 0 || elapsed > 1 ? 1 : elapsed;
2415 | 
2416 |     var value = this._easingFunction(elapsed); // properties transformations
2417 | 
2418 | 
2419 |     this._updateProperties(this._object, this._valuesStart, this._valuesEnd, value);
2420 | 
2421 |     if (this._onUpdateCallback) {
2422 |       this._onUpdateCallback(this._object, elapsed);
2423 |     }
2424 | 
2425 |     if (elapsed === 1) {
2426 |       if (this._repeat > 0) {
2427 |         if (isFinite(this._repeat)) {
2428 |           this._repeat--;
2429 |         } // Reassign starting values, restart by making startTime = now
2430 | 
2431 | 
2432 |         for (property in this._valuesStartRepeat) {
2433 |           if (!this._yoyo && typeof this._valuesEnd[property] === 'string') {
2434 |             this._valuesStartRepeat[property] = // eslint-disable-next-line
2435 |             // @ts-ignore FIXME?
2436 |             this._valuesStartRepeat[property] + parseFloat(this._valuesEnd[property]);
2437 |           }
2438 | 
2439 |           if (this._yoyo) {
2440 |             this._swapEndStartRepeatValues(property);
2441 |           }
2442 | 
2443 |           this._valuesStart[property] = this._valuesStartRepeat[property];
2444 |         }
2445 | 
2446 |         if (this._yoyo) {
2447 |           this._reversed = !this._reversed;
2448 |         }
2449 | 
2450 |         if (this._repeatDelayTime !== undefined) {
2451 |           this._startTime = time + this._repeatDelayTime;
2452 |         } else {
2453 |           this._startTime = time + this._delayTime;
2454 |         }
2455 | 
2456 |         if (this._onRepeatCallback) {
2457 |           this._onRepeatCallback(this._object);
2458 |         }
2459 | 
2460 |         return true;
2461 |       } else {
2462 |         if (this._onCompleteCallback) {
2463 |           this._onCompleteCallback(this._object);
2464 |         }
2465 | 
2466 |         for (var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++) {
2467 |           // Make the chained tweens start exactly at the time they should,
2468 |           // even if the `update()` method was called way past the duration of the tween
2469 |           this._chainedTweens[i].start(this._startTime + this._duration);
2470 |         }
2471 | 
2472 |         this._isPlaying = false;
2473 |         return false;
2474 |       }
2475 |     }
2476 | 
2477 |     return true;
2478 |   };
2479 | 
2480 |   Tween.prototype._updateProperties = function (_object, _valuesStart, _valuesEnd, value) {
2481 |     for (var property in _valuesEnd) {
2482 |       // Don't update properties that do not exist in the source object
2483 |       if (_valuesStart[property] === undefined) {
2484 |         continue;
2485 |       }
2486 | 
2487 |       var start = _valuesStart[property] || 0;
2488 |       var end = _valuesEnd[property];
2489 |       var startIsArray = Array.isArray(_object[property]);
2490 |       var endIsArray = Array.isArray(end);
2491 |       var isInterpolationList = !startIsArray && endIsArray;
2492 | 
2493 |       if (isInterpolationList) {
2494 |         _object[property] = this._interpolationFunction(end, value);
2495 |       } else if (typeof end === 'object' && end) {
2496 |         // eslint-disable-next-line
2497 |         // @ts-ignore FIXME?
2498 |         this._updateProperties(_object[property], start, end, value);
2499 |       } else {
2500 |         // Parses relative end values with start as base (e.g.: +10, -3)
2501 |         end = this._handleRelativeValue(start, end); // Protect against non numeric properties.
2502 | 
2503 |         if (typeof end === 'number') {
2504 |           // eslint-disable-next-line
2505 |           // @ts-ignore FIXME?
2506 |           _object[property] = start + (end - start) * value;
2507 |         }
2508 |       }
2509 |     }
2510 |   };
2511 | 
2512 |   Tween.prototype._handleRelativeValue = function (start, end) {
2513 |     if (typeof end !== 'string') {
2514 |       return end;
2515 |     }
2516 | 
2517 |     if (end.charAt(0) === '+' || end.charAt(0) === '-') {
2518 |       return start + parseFloat(end);
2519 |     } else {
2520 |       return parseFloat(end);
2521 |     }
2522 |   };
2523 | 
2524 |   Tween.prototype._swapEndStartRepeatValues = function (property) {
2525 |     var tmp = this._valuesStartRepeat[property];
2526 |     var endValue = this._valuesEnd[property];
2527 | 
2528 |     if (typeof endValue === 'string') {
2529 |       this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(endValue);
2530 |     } else {
2531 |       this._valuesStartRepeat[property] = this._valuesEnd[property];
2532 |     }
2533 | 
2534 |     this._valuesEnd[property] = tmp;
2535 |   };
2536 | 
2537 |   return Tween;
2538 | }();
2539 | 
2540 | exports.Tween = Tween;
2541 | var VERSION = '18.6.4';
2542 | /**
2543 |  * Tween.js - Licensed under the MIT license
2544 |  * https://github.com/tweenjs/tween.js
2545 |  * ----------------------------------------------
2546 |  *
2547 |  * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
2548 |  * Thank you all, you're awesome!
2549 |  */
2550 | 
2551 | exports.VERSION = VERSION;
2552 | var nextId = Sequence.nextId;
2553 | /**
2554 |  * Controlling groups of tweens
2555 |  *
2556 |  * Using the TWEEN singleton to manage your tweens can cause issues in large apps with many components.
2557 |  * In these cases, you may want to create your own smaller groups of tweens.
2558 |  */
2559 | 
2560 | exports.nextId = nextId;
2561 | var TWEEN = mainGroup; // This is the best way to export things in a way that's compatible with both ES
2562 | // Modules and CommonJS, without build hacks, and so as not to break the
2563 | // existing API.
2564 | // https://github.com/rollup/rollup/issues/1961#issuecomment-423037881
2565 | 
2566 | var getAll = TWEEN.getAll.bind(TWEEN);
2567 | exports.getAll = getAll;
2568 | var removeAll = TWEEN.removeAll.bind(TWEEN);
2569 | exports.removeAll = removeAll;
2570 | var add = TWEEN.add.bind(TWEEN);
2571 | exports.add = add;
2572 | var remove = TWEEN.remove.bind(TWEEN);
2573 | exports.remove = remove;
2574 | var update = TWEEN.update.bind(TWEEN);
2575 | exports.update = update;
2576 | var _exports = {
2577 |   Easing: Easing,
2578 |   Group: Group,
2579 |   Interpolation: Interpolation,
2580 |   now: now$1,
2581 |   Sequence: Sequence,
2582 |   nextId: nextId,
2583 |   Tween: Tween,
2584 |   VERSION: VERSION,
2585 |   getAll: getAll,
2586 |   removeAll: removeAll,
2587 |   add: add,
2588 |   remove: remove,
2589 |   update: update
2590 | };
2591 | var _default = _exports;
2592 | exports.default = _default;
2593 | },{"process":"pBGv"}],"QTEq":[function(require,module,exports) {
2594 | "use strict";
2595 | 
2596 | Object.defineProperty(exports, "__esModule", {
2597 |   value: true
2598 | });
2599 | exports.AnimatedValueWidget = void 0;
2600 | 
2601 | const src_1 = require("../../../src");
2602 | 
2603 | const tween_js_1 = require("@tweenjs/tween.js");
2604 | 
2605 | class AnimatedValueWidget extends src_1.Widget {
2606 |   constructor(state) {
2607 |     super();
2608 |     this.state = state;
2609 |     this.group = new tween_js_1.Group();
2610 |     this.state = state;
2611 |   }
2612 | 
2613 |   set(newState) {
2614 |     this.group.removeAll();
2615 | 
2616 |     for (let tween of this.group.getAll()) {
2617 |       tween.stop().stopChainedTweens();
2618 |     }
2619 | 
2620 |     this.state = newState;
2621 |   }
2622 | 
2623 |   update(newState, time) {
2624 |     this.group.removeAll();
2625 | 
2626 |     for (let tween of this.group.getAll()) {
2627 |       tween.stop().stopChainedTweens();
2628 |     }
2629 | 
2630 |     this.tween = new tween_js_1.Tween(this.state, this.group).easing(tween_js_1.Easing.Quadratic.Out).to(newState, time).start().onComplete(result => {
2631 |       this.state = result;
2632 |       this.tween = null;
2633 |     }).onStop(result => {
2634 |       this.state = newState;
2635 |       this.tween = null;
2636 |     });
2637 |     return this.tween;
2638 |   }
2639 | 
2640 |   willUpdate({
2641 |     tickerState
2642 |   }) {
2643 |     this.group.update(tickerState.currentTimestamp);
2644 |   }
2645 | 
2646 | }
2647 | 
2648 | exports.AnimatedValueWidget = AnimatedValueWidget;
2649 | },{"../../../src":"WdSo","@tweenjs/tween.js":"MxHY"}],"BusB":[function(require,module,exports) {
2650 | "use strict";
2651 | 
2652 | Object.defineProperty(exports, "__esModule", {
2653 |   value: true
2654 | });
2655 | exports.TrackingPathOnGridWidget = void 0;
2656 | 
2657 | const src_1 = require("../../../src");
2658 | 
2659 | class TrackingPathOnGridWidget extends src_1.Widget {
2660 |   constructor(gridSize, tileSize) {
2661 |     super();
2662 |     this.gridSize = gridSize;
2663 |     this.tileSize = tileSize;
2664 |     this.isTracking = false;
2665 |     this.startPoint = null;
2666 |     this.endPoint = null;
2667 |     this.path = [];
2668 |     this.shouldNotifyPathStart = false;
2669 |     this.shouldNotifyPathUpdated = false;
2670 |     this.shouldNotifyPathEnd = false;
2671 |   }
2672 | 
2673 |   willUpdate(context) {
2674 |     const {
2675 |       inputState
2676 |     } = context;
2677 | 
2678 |     if (this.isTracking === false && inputState.isJustPressed(src_1.Key.LMB)) {
2679 |       return this.handlePathStart(context);
2680 |     } else if (this.isTracking === true && inputState.isPressed(src_1.Key.LMB)) {
2681 |       return this.handlePath(context);
2682 |     } else if (this.isTracking === true && inputState.isJustReleased(src_1.Key.LMB)) {
2683 |       return this.handlePathEnd(context);
2684 |     }
2685 |   }
2686 | 
2687 |   whenPathStarts(callback) {
2688 |     if (this.shouldNotifyPathStart) {
2689 |       this.shouldNotifyPathStart = false;
2690 |       callback();
2691 |     }
2692 |   }
2693 | 
2694 |   whenPathEnds(callback) {
2695 |     if (this.shouldNotifyPathEnd) {
2696 |       this.shouldNotifyPathEnd = false;
2697 |       callback();
2698 |     }
2699 |   }
2700 | 
2701 |   whenPathUpdates(callback) {
2702 |     if (this.shouldNotifyPathUpdated) {
2703 |       this.shouldNotifyPathUpdated = false;
2704 |       callback();
2705 |     }
2706 |   }
2707 | 
2708 |   clear() {
2709 |     this.isTracking = false;
2710 |     this.path = [];
2711 |     this.startPoint = null;
2712 |     this.endPoint = null;
2713 |   }
2714 | 
2715 |   handlePathStart({
2716 |     inputState,
2717 |     matrix
2718 |   }) {
2719 |     const candidate = this.transformMousePosition(inputState.mouse, matrix);
2720 | 
2721 |     if (this.isPointContainedInTheGrid(candidate)) {
2722 |       this.isTracking = true;
2723 |       this.path = [candidate];
2724 |       this.startPoint = candidate;
2725 |       this.shouldNotifyPathStart = true;
2726 |     }
2727 |   }
2728 | 
2729 |   handlePath({
2730 |     inputState,
2731 |     matrix
2732 |   }) {
2733 |     const candidate = this.transformMousePosition(inputState.mouse, matrix);
2734 | 
2735 |     if (this.isPointContainedInTheGrid(candidate) && !this.lastPathPoint.equals(candidate) && this.lastPathPoint.distance(candidate) === 1) {
2736 |       const index = this.path.findIndex(candidate.equals, candidate);
2737 |       const isPenultimate = index === this.path.length - 2;
2738 | 
2739 |       if (isPenultimate && index !== -1) {
2740 |         this.path = this.path.slice(0, index);
2741 |       }
2742 | 
2743 |       if (index === -1 || isPenultimate) {
2744 |         this.endPoint = candidate;
2745 |         this.path.push(candidate);
2746 |         this.shouldNotifyPathUpdated = true;
2747 |       }
2748 |     }
2749 |   }
2750 | 
2751 |   handlePathEnd(_context) {
2752 |     this.isTracking = false;
2753 |     this.shouldNotifyPathEnd = true;
2754 |   }
2755 | 
2756 |   get lastPathPoint() {
2757 |     return this.path[this.path.length - 1];
2758 |   }
2759 | 
2760 |   isPointContainedInTheGrid(point) {
2761 |     return point.x >= 0 && point.x < this.gridSize.x && point.y >= 0 && point.y < this.gridSize.y;
2762 |   }
2763 | 
2764 |   transformMousePosition(initial, matrix) {
2765 |     return initial.transform(matrix.inverse()).snapToGrid(this.tileSize).div(this.tileSize).add(this.gridSize.div(2).floor());
2766 |   }
2767 | 
2768 | }
2769 | 
2770 | exports.TrackingPathOnGridWidget = TrackingPathOnGridWidget;
2771 | },{"../../../src":"WdSo"}],"ZPkJ":[function(require,module,exports) {
2772 | "use strict";
2773 | 
2774 | Object.defineProperty(exports, "__esModule", {
2775 |   value: true
2776 | });
2777 | exports.GridScene = exports.GridEntity = void 0;
2778 | 
2779 | const src_1 = require("../../../src");
2780 | 
2781 | const AnimationWidget_1 = require("../widgets/AnimationWidget");
2782 | 
2783 | const PathOnGridWidget_1 = require("../widgets/PathOnGridWidget");
2784 | 
2785 | class GridEntity extends src_1.Entity {
2786 |   constructor(position) {
2787 |     super();
2788 |     this.position = position;
2789 |     this.widgets = [];
2790 |   }
2791 | 
2792 |   update() {}
2793 | 
2794 |   draw({
2795 |     ctx
2796 |   }) {
2797 |     ctx.fillStyle = 'rgba(0, 0, 0, 0.1)';
2798 |     ctx.beginPath();
2799 |     ctx.arc(this.position.x, this.position.y, 5, 0, Math.PI * 2);
2800 |     ctx.closePath();
2801 |     ctx.fill();
2802 |   }
2803 | 
2804 | }
2805 | 
2806 | exports.GridEntity = GridEntity;
2807 | 
2808 | const prepare = v => v.add(-6, -4).mul(100);
2809 | 
2810 | class CreateTrackEntity extends src_1.Entity {
2811 |   constructor() {
2812 |     super(...arguments);
2813 |     this.trackWidget = new PathOnGridWidget_1.TrackingPathOnGridWidget(src_1.vec2(13, 9), src_1.vec2(100));
2814 |     this.tween = new AnimationWidget_1.AnimatedValueWidget({
2815 |       size: 0
2816 |     });
2817 |     this.lastPoint = new AnimationWidget_1.AnimatedValueWidget({
2818 |       x: 0,
2819 |       y: 0
2820 |     });
2821 |     this.widgets = [this.trackWidget, this.tween, this.lastPoint];
2822 |     this.path = [];
2823 |   }
2824 | 
2825 |   update({
2826 |     inputState,
2827 |     matrix
2828 |   }) {
2829 |     this.trackWidget.whenPathStarts(() => {
2830 |       console.log('tarl');
2831 |       this.lastPoint.set(this.trackWidget.path[0].o);
2832 |     });
2833 |     this.trackWidget.whenPathUpdates(() => {
2834 |       const oldPath = this.path;
2835 |       const newPath = this.trackWidget.path.slice(0);
2836 | 
2837 |       if (newPath.length > 1) {
2838 |         this.tween.update({
2839 |           size: 26
2840 |         }, 250);
2841 | 
2842 |         if (oldPath.length > newPath.length) {
2843 |           this.lastPoint.set(oldPath[oldPath.length - 1].o);
2844 |           this.lastPoint.update(newPath[newPath.length - 1].o, 50).onComplete(() => {
2845 |             this.path = newPath;
2846 |           }).onStop(() => {
2847 |             this.path = newPath;
2848 |           });
2849 |         } else if (oldPath.length < newPath.length) {
2850 |           this.path = newPath;
2851 |           this.lastPoint.set(newPath[newPath.length - 2].o);
2852 |           this.lastPoint.update(newPath[newPath.length - 1].o, 150);
2853 |         }
2854 |       }
2855 |     });
2856 |     this.trackWidget.whenPathEnds(() => {
2857 |       this.tween.update({
2858 |         size: 0
2859 |       }, 150).onComplete(() => {
2860 |         this.trackWidget.clear();
2861 |         this.path = [];
2862 |       });
2863 |     });
2864 |   }
2865 | 
2866 |   draw({
2867 |     ctx
2868 |   }) {
2869 |     if (this.path.length > 1) {
2870 |       const path = this.path.slice(0, this.path.length - 1);
2871 |       ctx.beginPath();
2872 |       ctx.strokeStyle = 'black';
2873 |       ctx.lineWidth = this.tween.state.size * 2;
2874 |       ctx.lineJoin = 'round';
2875 |       ctx.lineCap = 'round';
2876 |       ctx.moveTo(...path[0].pipe(prepare).e);
2877 | 
2878 |       for (let point of path.slice(1)) {
2879 |         ctx.lineTo(...point.pipe(prepare).e);
2880 |       }
2881 | 
2882 |       const lastPoint = src_1.Vector2.from(this.lastPoint.state).pipe(prepare);
2883 |       ctx.lineTo(...lastPoint.e);
2884 |       ctx.stroke();
2885 |     }
2886 |   }
2887 | 
2888 | }
2889 | 
2890 | class GridScene extends src_1.Scene {
2891 |   constructor() {
2892 |     super(...arguments);
2893 |     this.gridSize = 100;
2894 |     this.grid = [];
2895 |     this.size = src_1.vec2(13, 9);
2896 |   }
2897 | 
2898 |   willMount() {
2899 |     for (let i = 0; i < this.size.simpleProduct(); i++) {
2900 |       const position = this.size.asStride(i).pipe(prepare);
2901 |       const entity = new GridEntity(position);
2902 |       this.grid.push(entity);
2903 |     }
2904 | 
2905 |     this.addAll(this.grid);
2906 |     this.add(new CreateTrackEntity());
2907 |   }
2908 | 
2909 |   prepare(updateContext, {
2910 |     ctx,
2911 |     canvasSize
2912 |   }) {
2913 |     ctx.save();
2914 |     const half = canvasSize.div(2);
2915 |     ctx.translate(half.x, half.y);
2916 |     updateContext.matrix = ctx.getTransform();
2917 |   }
2918 | 
2919 |   cleanup(updateContext, {
2920 |     ctx
2921 |   }) {
2922 |     ctx.restore();
2923 |     updateContext.matrix = ctx.getTransform();
2924 |   }
2925 | 
2926 | }
2927 | 
2928 | exports.GridScene = GridScene;
2929 | },{"../../../src":"WdSo","../widgets/AnimationWidget":"QTEq","../widgets/PathOnGridWidget":"BusB"}],"QCba":[function(require,module,exports) {
2930 | "use strict";
2931 | 
2932 | Object.defineProperty(exports, "__esModule", {
2933 |   value: true
2934 | });
2935 | 
2936 | const src_1 = require("../../src");
2937 | 
2938 | const GridScene_1 = require("./scenes/GridScene");
2939 | 
2940 | const canvas = document.querySelector('#app');
2941 | const engine = new src_1.Engine({
2942 |   canvas: canvas,
2943 |   size: src_1.vec2(window.innerWidth, window.innerHeight),
2944 |   ticker: new src_1.AnimationFrameTicker()
2945 | });
2946 | engine.registerScene('grid', GridScene_1.GridScene);
2947 | engine.start();
2948 | engine.pushScene('grid');
2949 | },{"../../src":"WdSo","./scenes/GridScene":"ZPkJ"}]},{},["QCba"], null)
2950 | //# sourceMappingURL=/engine/example/dist/src.8e541c7a.js.map


--------------------------------------------------------------------------------