melonjs 17.3.0 → 18.0.0

package/{dist/types/system/pooling.d.ts → build/system/legacy_pool.d.ts}

@@ -1,7 +1,21 @@
 export default pool;
-declare let pool: ObjectPool;
 /**
- * @classdesc
+ * a default global ObjectPool instance
+ * @namespace pool
+ * @see ObjectPool
+ * @example
+ * // register our bullet object into the object pool
+ * pool.register("bullet", BulletEntity, true);
+ * // ...
+ * // when we need to manually create a new bullet:
+ * let bullet = pool.pull("bullet", x, y, direction, velocity);
+ * // ...
+ * // when we want to destroy existing object, the remove
+ * // function will ensure the object can then be reallocated later
+ * game.world.removeChild(bullet);
+ */
+declare const pool: ObjectPool;
+/**
  * Object pooling - a technique that might speed up your game if used properly.<br>
  * If some of your classes will be instantiated and removed a lot at a time, it is a
  * good idea to add the class to this object pool. A separate pool for that class
@@ -11,7 +25,7 @@ declare let pool: ObjectPool;
  * This technique is also used by the engine to instantiate objects defined in the map,
  * which means, that on level loading the engine will try to instantiate every object
  * found in the map, based on the user defined name in each Object Properties<br>
- * <img src="images/object_properties.png"/><br>
+ * <img src="../images/object_properties.png"/><br>
  * @see {@link pool} the default global instance of ObjectPool
  */
 declare class ObjectPool {
@@ -35,7 +49,7 @@ declare class ObjectPool {
      * // add our users defined entities in the object pool and enable object recycling
      * me.pool.register("cherrysprite", Cherry, true);
      */
-    register(className: string, classObj: object, recycling?: boolean | undefined): void;
+    register(className: string, classObj: object, recycling?: boolean): void;
     /**
      * Pull a new instance of the requested object (if added into the object pool)
      * @param {string} name - as used in {@link pool.register}
@@ -57,7 +71,7 @@ declare class ObjectPool {
      * me.game.world.removeChild(enemy);
      * me.game.world.removeChild(bullet);
      */
-    pull(name: string, ...args?: any[] | undefined): object;
+    pull(name: string, ...args?: any[]): object;
     /**
      * purge the object pool from any inactive object <br>
      * Object pooling must be enabled for this function to work<br>
@@ -67,14 +81,14 @@ declare class ObjectPool {
     /**
      * Push back an object instance into the object pool <br>
      * Object pooling for the object class must be enabled,
-     * and object must have been instantiated using {@link pool#pull},
+     * and object must have been instantiated using {@link pull},
      * otherwise this function won't work
      * @throws will throw an error if the object cannot be recycled
      * @param {object} obj - instance to be recycled
      * @param {boolean} [throwOnError=true] - throw an exception if the object cannot be recycled
      * @returns {boolean} true if the object was successfully recycled in the object pool
      */
-    push(obj: object, throwOnError?: boolean | undefined): boolean;
+    push(obj: object, throwOnError?: boolean): boolean;
     /**
      * Check if an object with the provided name is registered
      * @param {string} name - of the registered object class
@@ -99,3 +113,4 @@ declare class ObjectPool {
      */
     getInstanceCount(): number;
 }
+//# sourceMappingURL=legacy_pool.d.ts.map

package/build/system/legacy_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy_pool.d.ts","sourceRoot":"","sources":["../../src/system/legacy_pool.js"],"names":[],"mappings":";AA+KA;;;;;;;;;;;;;;GAcG;AACH,+BAA8B;AA5L9B;;;;;;;;;;;;GAYG;AACH;IAEE,gBAAqB;IACrB,yBAAyB;IAG1B;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAdW,MAAM,YACN,MAAM,cACN,OAAO,QAuBjB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAnBW,MAAM,YACH,GAAC,EAAA,GACF,MAAM,CAsClB;IAED;;;;OAIG;IACH,cAOC;IAED;;;;;;;;;OASG;IACH,UAJW,MAAM,iBACN,OAAO,GACL,OAAO,CAgBnB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;OAUG;IACH,cAPW,MAAM,GACJ,OAAO,CAcnB;IAED;;;OAGG;IACH,oBAFa,MAAM,CAIlB;CACD"}

package/build/system/platform.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The device platform type
+ * @namespace platform
+ * @memberof device
+ * ua the user agent string for the current device
+ * iOS `true` if the device is an iOS platform
+ * android `true` if the device is an Android platform
+ * android2 `true` if the device is an Android 2.x platform
+ * linux `true` if the device is a Linux platform
+ * chromeOS `true` if the device is running on ChromeOS.
+ * wp `true` if the device is a Windows Phone platform
+ * BlackBerry`true` if the device is a BlackBerry platform
+ * Kindle`true` if the device is a Kindle platform
+ * ejecta `true` if running under Ejecta
+ * isWeixin `true` if running under Wechat
+ * nodeJS `true` if running under node.js
+ * isMobile `true` if a mobile device
+ * webApp `true` if running as a standalone web app
+ */
+export declare const ua: string;
+export declare const iOS: boolean;
+export declare const android: boolean;
+export declare const android2: boolean;
+export declare const linux: boolean;
+export declare const chromeOS: boolean;
+export declare const wp: boolean;
+export declare const BlackBerry: boolean;
+export declare const Kindle: boolean;
+export declare const ejecta: boolean;
+export declare const isWeixin: boolean;
+export declare const nodeJS: boolean;
+export declare const isMobile: boolean;
+export declare const webApp: boolean;
+//# sourceMappingURL=platform.d.ts.map

package/build/system/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/system/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,EAAE,QAGT,CAAC;AACP,eAAO,MAAM,GAAG,SAA+B,CAAC;AAChD,eAAO,MAAM,OAAO,SAAsB,CAAC;AAC3C,eAAO,MAAM,QAAQ,SAAwB,CAAC;AAC9C,eAAO,MAAM,KAAK,SAAoB,CAAC;AACvC,eAAO,MAAM,QAAQ,SAAkB,CAAC;AACxC,eAAO,MAAM,EAAE,SAA4B,CAAC;AAC5C,eAAO,MAAM,UAAU,SAAyB,CAAC;AACjD,eAAO,MAAM,MAAM,SAAyC,CAAC;AAC7D,eAAO,MAAM,MAAM,SAAyB,CAAC;AAC7C,eAAO,MAAM,QAAQ,SAA6B,CAAC;AACnD,eAAO,MAAM,MAAM,SAGwB,CAAC;AAC5C,eAAO,MAAM,QAAQ,SACqD,CAAC;AAC3E,eAAO,MAAM,MAAM,SAK2C,CAAC"}

package/build/system/pool.d.ts

@@ -0,0 +1,26 @@
+export interface Pool<T, A extends unknown[]> {
+    get(...args: A): T;
+    release(object: T): void;
+    purge(): void;
+    size(): number;
+    used(): number;
+}
+type Reset<A extends unknown[]> = ((...args: A) => void) | undefined;
+type Release = (() => void) | undefined;
+export interface CreatePoolOptions<T, A extends unknown[]> {
+    instance: T;
+    reset?: Reset<A>;
+    release?: Release;
+}
+/**
+ * Register a pool instance to the pool registry.
+ * @ignore
+ */
+export declare const registerPool: (key: string, pool: Pool<any, any[]>) => void;
+/**
+ * @ignore
+ */
+export declare const getRegisteredPools: () => Record<string, Pool<any, any[]>>;
+export declare const createPool: <T, A extends unknown[]>(options: (...args: A) => CreatePoolOptions<T, A>) => Pool<T, A>;
+export {};
+//# sourceMappingURL=pool.d.ts.map

package/build/system/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../src/system/pool.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE;IAC3C,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;IACnB,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,MAAM,CAAC;IACf,IAAI,IAAI,MAAM,CAAC;CACf;AAED,KAAK,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;AACrE,KAAK,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;AAExC,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE;IACxD,QAAQ,EAAE,CAAC,CAAC;IACZ,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAKD;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,EAAE,MAAM,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,SAE/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,wCAAc,CAAC;AAE9C,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE,EAChD,SAAS,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,KAC9C,IAAI,CAAC,CAAC,EAAE,CAAC,CA2DX,CAAC"}

package/build/system/save.d.ts

@@ -0,0 +1,3 @@
+declare const save: Record<string, unknown>;
+export default save;
+//# sourceMappingURL=save.d.ts.map

package/build/system/save.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../../src/system/save.ts"],"names":[],"mappings":"AAoFA,QAAA,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAgEjC,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/build/system/timer.d.ts

@@ -0,0 +1,118 @@
+/**
+ * a Timer class to manage timing related function (FPS, Game Tick, Time...)
+ * @see {@link timer} the default global timer instance
+ */
+declare class Timer {
+    tick: number;
+    fps: number;
+    maxfps: number;
+    interpolation: boolean;
+    framecount: number;
+    framedelta: number;
+    last: number;
+    now: number;
+    delta: number;
+    step: number;
+    minstep: number;
+    timers: {
+        fn: (...args: any[]) => any;
+        delay: number;
+        elapsed: number;
+        repeat: boolean;
+        timerId: number;
+        pauseable: boolean;
+        args: any[];
+    }[];
+    timerId: number;
+    constructor();
+    /**
+     * reset time (e.g. usefull in case of pause)
+     * @ignore
+     */
+    reset(): void;
+    /**
+     * Calls a function once after a specified delay. See me.timer.setInterval to repeativly call a function.
+     * @param fn - the function you want to execute after delay milliseconds.
+     * @param delay - the number of milliseconds (thousandths of a second) that the function call should be delayed by.
+     * @param [pauseable] - respects the pause state of the engine.
+     * @param args - optional parameters which are passed through to the function specified by fn once the timer expires.
+     * @returns a positive integer value which identifies the timer created by the call to setTimeout(), which can be used later with me.timer.clearTimeout().
+     * @example
+     * // set a timer to call "myFunction" after 1000ms
+     * me.timer.setTimeout(myFunction, 1000);
+     * // set a timer to call "myFunction" after 1000ms (respecting the pause state) and passing param1 and param2
+     * me.timer.setTimeout(myFunction, 1000, true, param1, param2);
+     */
+    setTimeout(fn: (...args: any[]) => any, delay: number, pauseable?: boolean, ...args: any[]): number;
+    /**
+     * Calls a function continously at the specified interval.  See setTimeout to call function a single time.
+     * @param fn - the function to execute
+     * @param delay - the number of milliseconds (thousandths of a second) on how often to execute the function
+     * @param [pauseable] - respects the pause state of the engine.
+     * @param args - optional parameters which are passed through to the function specified by fn once the timer expires.
+     * @returns a numeric, non-zero value which identifies the timer created by the call to setInterval(), which can be used later with me.timer.clearInterval().
+     * @example
+     * // set a timer to call "myFunction" every 1000ms
+     * me.timer.setInterval(myFunction, 1000);
+     * // set a timer to call "myFunction" every 1000ms (respecting the pause state) and passing param1 and param2
+     * me.timer.setInterval(myFunction, 1000, true, param1, param2);
+     */
+    setInterval(fn: (...args: any[]) => any, delay: number, pauseable?: boolean, ...args: any[]): number;
+    /**
+     * Cancels a timeout previously established by calling setTimeout().
+     * @param timeoutID - ID of the timeout to be cancelled
+     */
+    clearTimeout(timeoutID: number): void;
+    /**
+     * cancels the timed, repeating action which was previously established by a call to setInterval().
+     * @param intervalID - ID of the interval to be cleared
+     */
+    clearInterval(intervalID: number): void;
+    /**
+     * Return the current timestamp in milliseconds <br>
+     * since the game has started or since linux epoch (based on browser support for High Resolution Timer)
+     * @returns current time
+     */
+    getTime(): number;
+    /**
+     * Return elapsed time in milliseconds since the last update
+     * @returns elapsed time
+     */
+    getDelta(): number;
+    /**
+     * compute the actual frame time and fps rate
+     * @ignore
+     */
+    countFPS(): void;
+    /**
+     * update
+     * @ignore
+     */
+    update(time: number): void;
+    /**
+     * clear Timers
+     * @ignore
+     */
+    clearTimer(timerId: number): void;
+    /**
+     * update timers
+     * @ignore
+     */
+    updateTimers(): void;
+}
+declare const timer: Timer;
+/**
+ * the default global Timer instance
+ * @see Timer
+ * @example
+ * // set a timer to call "myFunction" after 1000ms
+ * timer.setTimeout(myFunction, 1000);
+ * // set a timer to call "myFunction" after 1000ms (respecting the pause state) and passing param1 and param2
+ * timer.setTimeout(myFunction, 1000, true, param1, param2);
+ * // set a timer to call "myFunction" every 1000ms
+ * timer.setInterval(myFunction, 1000);
+ * // set a timer to call "myFunction" every 1000ms (respecting the pause state) and passing param1 and param2
+ * timer.setInterval(myFunction, 1000, true, param1, param2);
+ */
+export default timer;
+//# sourceMappingURL=timer.d.ts.map

package/build/system/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/system/timer.ts"],"names":[],"mappings":"AAYA;;;GAGG;AACH,cAAM,KAAK;IACV,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE;QACP,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;QAC5B,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,IAAI,EAAE,GAAG,EAAE,CAAC;KACZ,EAAE,CAAC;IACJ,OAAO,EAAE,MAAM,CAAC;;IAsEhB;;;OAGG;IACH,KAAK;IAYL;;;;;;;;;;;;OAYG;IACH,UAAU,CACT,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC3B,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,OAAO,EACnB,GAAG,IAAI,EAAE,GAAG,EAAE;IAcf;;;;;;;;;;;;OAYG;IACH,WAAW,CACV,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC3B,KAAK,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,OAAO,EACnB,GAAG,IAAI,EAAE,GAAG,EAAE;IAcf;;;OAGG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM;IAQ9B;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM;IAQhC;;;;OAIG;IACH,OAAO;IAIP;;;OAGG;IACH,QAAQ;IAIR;;;OAGG;IACH,QAAQ;IAcR;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM;IAmBnB;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM;IAS1B;;;OAGG;IACH,YAAY;CAgBZ;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAe,KAAK,CAAC"}

package/build/tweens/easing.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Easing Function :<br>
+ * <p>
+ * Easing.Linear.None<br>
+ * Easing.Quadratic.In<br>
+ * Easing.Quadratic.Out<br>
+ * Easing.Quadratic.InOut<br>
+ * Easing.Cubic.In<br>
+ * Easing.Cubic.Out<br>
+ * Easing.Cubic.InOut<br>
+ * Easing.Quartic.In<br>
+ * Easing.Quartic.Out<br>
+ * Easing.Quartic.InOut<br>
+ * Easing.Quintic.In<br>
+ * Easing.Quintic.Out<br>
+ * Easing.Quintic.InOut<br>
+ * Easing.Sinusoidal.In<br>
+ * Easing.Sinusoidal.Out<br>
+ * Easing.Sinusoidal.InOut<br>
+ * Easing.Exponential.In<br>
+ * Easing.Exponential.Out<br>
+ * Easing.Exponential.InOut<br>
+ * Easing.Circular.In<br>
+ * Easing.Circular.Out<br>
+ * Easing.Circular.InOut<br>
+ * Easing.Elastic.In<br>
+ * Easing.Elastic.Out<br>
+ * Easing.Elastic.InOut<br>
+ * Easing.Back.In<br>
+ * Easing.Back.Out<br>
+ * Easing.Back.InOut<br>
+ * Easing.Bounce.In<br>
+ * Easing.Bounce.Out<br>
+ * Easing.Bounce.InOut
+ * </p>
+ */
+export type EasingFunction = (t: number) => number;
+export declare const Easing: {
+    Linear: {
+        None: (k: number) => number;
+    };
+    Quadratic: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Cubic: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Quartic: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Quintic: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Sinusoidal: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Exponential: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Circular: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Elastic: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Back: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+    Bounce: {
+        In: (k: number) => number;
+        Out: (k: number) => number;
+        InOut: (k: number) => number;
+    };
+};
+//# sourceMappingURL=easing.d.ts.map

package/build/tweens/easing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easing.d.ts","sourceRoot":"","sources":["../../src/tweens/easing.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAEnD,eAAO,MAAM,MAAM;;kBAEP,MAAM;;;gBAMR,MAAM;iBAGL,MAAM;mBAGJ,MAAM;;;gBAST,MAAM;iBAGL,MAAM;mBAGJ,MAAM;;;gBAST,MAAM;iBAGL,MAAM;mBAGJ,MAAM;;;gBAST,MAAM;iBAGL,MAAM;mBAGJ,MAAM;;;gBAST,MAAM;iBAGL,MAAM;mBAGJ,MAAM;;;gBAMT,MAAM;iBAGL,MAAM;mBAGJ,MAAM;;;gBAeT,MAAM;iBAGL,MAAM;mBAGJ,MAAM;;;gBAST,MAAM;iBASL,MAAM;mBASJ,MAAM;;;gBAoBT,MAAM;iBAIL,MAAM;mBAIJ,MAAM;;;gBAUT,MAAM;iBAGL,MAAM;mBAWJ,MAAM;;CAOlB,CAAC"}

package/build/tweens/interpolation.d.ts

@@ -0,0 +1,7 @@
+export type InterpolationFunction = (v: number[], k: number) => number;
+export declare const Interpolation: {
+    Linear: (v: number[], k: number) => number;
+    Bezier: (v: number[], k: number) => number;
+    CatmullRom: (v: number[], k: number) => number;
+};
+//# sourceMappingURL=interpolation.d.ts.map

package/build/tweens/interpolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolation.d.ts","sourceRoot":"","sources":["../../src/tweens/interpolation.ts"],"names":[],"mappings":"AA8CA,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAEvE,eAAO,MAAM,aAAa;gBACb,MAAM,EAAE,KAAK,MAAM;gBAcnB,MAAM,EAAE,KAAK,MAAM;oBAUf,MAAM,EAAE,KAAK,MAAM;CAoCnC,CAAC"}

package/build/tweens/tween.d.ts

@@ -0,0 +1,234 @@
+import { EasingFunction } from "./easing.js";
+import { InterpolationFunction } from "./interpolation.js";
+/** @ignore */
+type OnStartCallback<T> = (this: T) => void;
+/** @ignore */
+type OnUpdateCallback<T> = (this: T, value: number) => void;
+/** @ignore */
+type OnCompleteCallback<T> = (this: T) => void;
+/**
+ * Javascript Tweening Engine<p>
+ * Super simple, fast and easy to use tweening engine which incorporates optimised Robert Penner's equation<p>
+ * <a href="https://github.com/sole/Tween.js">https://github.com/sole/Tween.js</a><p>
+ * author sole / http://soledadpenades.com<br>
+ * author mr.doob / http://mrdoob.com<br>
+ * author Robert Eisele / http://www.xarg.org<br>
+ * author Philippe / http://philippe.elsass.me<br>
+ * author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html<br>
+ * author Paul Lewis / http://www.aerotwist.com/<br>
+ * author lechecacharro<br>
+ * author Josh Faul / http://jocafa.com/
+ */
+export default class Tween {
+    #private;
+    _object: object;
+    _valuesStart: Record<string, unknown>;
+    _valuesEnd: Record<string, unknown>;
+    _valuesStartRepeat: Record<string, unknown>;
+    _duration: number;
+    _repeat: number;
+    _yoyo: boolean;
+    _reversed: boolean;
+    _delayTime: number;
+    _startTime: number | null;
+    _easingFunction: EasingFunction;
+    _interpolationFunction: InterpolationFunction;
+    _chainedTweens: Array<Tween>;
+    _onStartCallback: OnStartCallback<object> | null;
+    _onStartCallbackFired: boolean;
+    _onUpdateCallback: OnUpdateCallback<object> | null;
+    _onCompleteCallback: OnCompleteCallback<object> | null;
+    _tweenTimeTracker: number;
+    isPersistent: boolean;
+    updateWhenPaused: boolean;
+    isRenderable: boolean;
+    /**
+     * @param object - object on which to apply the tween
+     * @example
+     * // add a tween to change the object pos.x and pos.y variable to 200 in 3 seconds
+     * tween = new me.Tween(myObject.pos).to({
+     *       x: 200,
+     *       y: 200,
+     *    }, {
+     *       duration: 3000,
+     *       easing: me.Tween.Easing.Bounce.Out,
+     *       autoStart : true
+     * }).onComplete(myFunc);
+     */
+    constructor(object: object);
+    /**
+     * @ignore
+     */
+    onResetEvent(object: object): void;
+    /**
+     * @ignore
+     */
+    setProperties(object: object): void;
+    /**
+     * @ignore
+     */
+    _resumeCallback(elapsed: number): void;
+    /**
+     * subscribe to the resume event when added
+     * @ignore
+     */
+    onActivateEvent(): void;
+    /**
+     * Unsubscribe when tween is removed
+     * @ignore
+     */
+    onDeactivateEvent(): void;
+    /**
+     * object properties to be updated and duration
+     * @param properties - hash of properties
+     * @param [options] - object of tween properties, or a duration if a numeric value is passed
+     * @param [options.duration] - tween duration
+     * @param [options.easing] - easing function
+     * @param [options.delay] - delay amount expressed in milliseconds
+     * @param [options.yoyo] - allows the tween to bounce back to their original value when finished. To be used together with repeat to create endless loops.
+     * @param [options.repeat] - amount of times the tween should be repeated
+     * @param [options.interpolation] - interpolation function
+     * @param [options.autoStart] - allow this tween to start automatically. Otherwise call me.Tween.start().
+     * @returns this instance for object chaining
+     */
+    to(properties: Record<string, unknown>, options?: {
+        duration?: number | undefined;
+        easing?: EasingFunction | undefined;
+        yoyo?: boolean | undefined;
+        repeat?: number | undefined;
+        delay?: number | undefined;
+        interpolation?: InterpolationFunction | undefined;
+        autoStart?: boolean | undefined;
+    }): this;
+    /**
+     * start the tween
+     * @param [time] - the current time when the tween was started
+     * @returns this instance for object chaining
+     */
+    start(time?: number): this;
+    /**
+     * stop the tween
+     * @returns this instance for object chaining
+     */
+    stop(): this;
+    /**
+     * delay the tween
+     * @param amount - delay amount expressed in milliseconds
+     * @returns this instance for object chaining
+     */
+    delay(amount: number): this;
+    /**
+     * Repeat the tween
+     * @param times - amount of times the tween should be repeated
+     * @returns this instance for object chaining
+     */
+    repeat(times: number): this;
+    /**
+     * Allows the tween to bounce back to their original value when finished.
+     * To be used together with repeat to create endless loops.
+     * @param yoyo flag
+     * @returns this instance for object chaining
+     */
+    yoyo(yoyo: boolean): this;
+    /**
+     * set the easing function
+     * @param easing - easing function
+     * @returns this instance for object chaining
+     */
+    easing(easing: EasingFunction): this;
+    /**
+     * set the interpolation function
+     * @param interpolation - interpolation function
+     * @returns this instance for object chaining
+     */
+    interpolation(interpolation: InterpolationFunction): this;
+    /**
+     * chain the tween
+     * @param tweens - Tween(s) to be chained
+     * @returns this instance for object chaining
+     */
+    chain(...tweens: Tween[]): this;
+    /**
+     * onStart callback
+     * @param onStartCallback - callback
+     * @returns this instance for object chaining
+     */
+    onStart(onStartCallback: OnStartCallback<object>): this;
+    /**
+     * onUpdate callback
+     * @param onUpdateCallback - callback
+     * @returns this instance for object chaining
+     */
+    onUpdate(onUpdateCallback: OnUpdateCallback<object>): this;
+    /**
+     * onComplete callback
+     * @param onCompleteCallback - callback
+     * @returns this instance for object chaining
+     */
+    onComplete(onCompleteCallback: OnCompleteCallback<object>): this;
+    /** @ignore */
+    update(dt: number): boolean;
+    static get Easing(): {
+        Linear: {
+            None: (k: number) => number;
+        };
+        Quadratic: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Cubic: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Quartic: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Quintic: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Sinusoidal: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Exponential: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Circular: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Elastic: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Back: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+        Bounce: {
+            In: (k: number) => number;
+            Out: (k: number) => number;
+            InOut: (k: number) => number;
+        };
+    };
+    static get Interpolation(): {
+        Linear: (v: number[], k: number) => number;
+        Bezier: (v: number[], k: number) => number;
+        CatmullRom: (v: number[], k: number) => number;
+    };
+}
+export declare const tweenPool: import("../system/pool.ts").Pool<Tween, [obj: object]>;
+export {};
+//# sourceMappingURL=tween.d.ts.map

package/build/tweens/tween.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tween.d.ts","sourceRoot":"","sources":["../../src/tweens/tween.ts"],"names":[],"mappings":"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"}

package/build/utils/agent.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Get a vendor-prefixed property
+ * @param name - Property name
+ * @param [obj] - Object or element reference to access
+ * @returns Value of property
+ */
+export declare function prefixed(name: string, obj?: Record<string, unknown>): unknown;
+/**
+ * Set a vendor-prefixed property
+ * @param name - Property name
+ * @param value - Property value
+ * @param [obj] - Object or element reference to access
+ * @returns true if one of the vendor-prefixed property was found
+ */
+export declare function setPrefixed(name: string, value: unknown, obj?: Record<string, unknown>): false | undefined;
+//# sourceMappingURL=agent.d.ts.map

package/build/utils/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/utils/agent.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAcnE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,qBAoB7B"}

package/build/utils/array-multimap.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A simple multimap that stores multiple values per key using arrays.
+ * @ignore
+ */
+export class ArrayMultimap {
+    _map: Map<any, any>;
+    put(key: any, value: any): void;
+    get(key: any): any;
+    has(key: any): boolean;
+    delete(key: any): void;
+    forEach(callback: any): void;
+    clear(): void;
+}
+//# sourceMappingURL=array-multimap.d.ts.map

package/build/utils/array-multimap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-multimap.d.ts","sourceRoot":"","sources":["../../src/utils/array-multimap.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IAEE,oBAAqB;IAEtB,gCAOC;IACD,mBAEC;IACD,uBAEC;IACD,uBAEC;IACD,6BAMC;IACD,cAEC;CACD"}