modern-canvas 0.9.5 → 0.10.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Font, Fonts } from 'modern-font';
-import { ObservableEvents, Observable, ReactivableEvents, Reactivable, Color as Color$1, RawWeakMap as RawWeakMap$1, LinearGradient, RadialGradient, NormalizedFill, Fill, NormalizedBackground, Background, NormalizedForeground, Foreground, NormalizedOutline, Outline, NormalizedShadow, Shadow, NormalizedShape, Shape, FullStyle, Text as Text$1, TextContent, Style, ImageFillCropRect } from 'modern-idoc';
+import { ObservableEvents, Observable, ReactivableEvents, Reactivable, Color as Color$1, RawWeakMap as RawWeakMap$1, LinearGradient, RadialGradient, Hex8Color, NormalizedFill, Fill, NormalizedBackground, Background, NormalizedForeground, Foreground, NormalizedOutline, Outline, NormalizedShadow, Shadow, NormalizedShape, Shape, FullStyle, Text as Text$1, TextContent, Style, ImageFillCropRect } from 'modern-idoc';
 export { Color as ColorValue } from 'modern-idoc';
 import { AnimationItem } from 'lottie-web';
 import { Colord, RgbaColor, HslaColor, HsvaColor } from 'colord';
@@ -191,21 +191,21 @@ declare class WheelInputEvent extends MouseInputEvent implements WheelEvent {
 }
 
 interface InputEvents extends ObservableEvents {
-    pointerdown: (ev: PointerInputEvent) => void;
-    pointerover: (ev: PointerInputEvent) => void;
-    pointermove: (ev: PointerInputEvent) => void;
-    pointerup: (ev: PointerInputEvent) => void;
-    wheel: (ev: WheelInputEvent) => void;
-    keydown: (ev: KeyboardInputEvent) => void;
-    keypress: (ev: KeyboardInputEvent) => void;
-    keyup: (ev: KeyboardInputEvent) => void;
+    pointerdown: [ev: PointerInputEvent];
+    pointerover: [ev: PointerInputEvent];
+    pointermove: [ev: PointerInputEvent];
+    pointerup: [ev: PointerInputEvent];
+    wheel: [ev: WheelInputEvent];
+    keydown: [ev: KeyboardInputEvent];
+    keypress: [ev: KeyboardInputEvent];
+    keyup: [ev: KeyboardInputEvent];
 }
 type InputEventKey = keyof InputEvents;
 interface Input {
-    on: <K extends keyof InputEvents & string>(event: K, listener: InputEvents[K]) => this;
-    once: <K extends keyof InputEvents & string>(event: K, listener: InputEvents[K]) => this;
-    off: <K extends keyof InputEvents & string>(event: K, listener: InputEvents[K]) => this;
-    emit: <K extends keyof InputEvents & string>(event: K, ...args: Parameters<InputEvents[K]>) => this;
+    on: <K extends keyof InputEvents & string>(event: K, listener: (...args: InputEvents[K]) => void) => this;
+    once: <K extends keyof InputEvents & string>(event: K, listener: (...args: InputEvents[K]) => void) => this;
+    off: <K extends keyof InputEvents & string>(event: K, listener: (...args: InputEvents[K]) => void) => this;
+    emit: <K extends keyof InputEvents & string>(event: K, ...args: InputEvents[K]) => this;
 }
 declare class Input extends Observable {
     /**
@@ -243,15 +243,16 @@ declare class Input extends Observable {
     protected _onPointerMove: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
     protected _onPointerUp: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
     protected _onWheel: (nativeEvent: WheelEvent) => void;
+    destroy(): void;
 }
 
 interface CoreObjectEvents extends ReactivableEvents {
 }
 interface CoreObject {
-    on: <K extends keyof CoreObjectEvents & string>(event: K, listener: CoreObjectEvents[K]) => this;
-    once: <K extends keyof CoreObjectEvents & string>(event: K, listener: CoreObjectEvents[K]) => this;
-    off: <K extends keyof CoreObjectEvents & string>(event: K, listener: CoreObjectEvents[K]) => this;
-    emit: <K extends keyof CoreObjectEvents & string>(event: K, ...args: Parameters<CoreObjectEvents[K]>) => this;
+    on: <K extends keyof CoreObjectEvents & string>(event: K, listener: (...args: CoreObjectEvents[K]) => void) => this;
+    once: <K extends keyof CoreObjectEvents & string>(event: K, listener: (...args: CoreObjectEvents[K]) => void) => this;
+    off: <K extends keyof CoreObjectEvents & string>(event: K, listener: (...args: CoreObjectEvents[K]) => void) => this;
+    emit: <K extends keyof CoreObjectEvents & string>(event: K, ...args: CoreObjectEvents[K]) => this;
 }
 declare class CoreObject extends Reactivable {
     readonly instanceId: number;
@@ -264,10 +265,10 @@ declare class CoreObject extends Reactivable {
 interface RefCountedEvents extends CoreObjectEvents {
 }
 interface RefCounted {
-    on: <K extends keyof RefCountedEvents & string>(event: K, listener: RefCountedEvents[K]) => this;
-    once: <K extends keyof RefCountedEvents & string>(event: K, listener: RefCountedEvents[K]) => this;
-    off: <K extends keyof RefCountedEvents & string>(event: K, listener: RefCountedEvents[K]) => this;
-    emit: <K extends keyof RefCountedEvents & string>(event: K, ...args: Parameters<RefCountedEvents[K]>) => this;
+    on: <K extends keyof RefCountedEvents & string>(event: K, listener: (...args: RefCountedEvents[K]) => void) => this;
+    once: <K extends keyof RefCountedEvents & string>(event: K, listener: (...args: RefCountedEvents[K]) => void) => this;
+    off: <K extends keyof RefCountedEvents & string>(event: K, listener: (...args: RefCountedEvents[K]) => void) => this;
+    emit: <K extends keyof RefCountedEvents & string>(event: K, ...args: RefCountedEvents[K]) => this;
 }
 declare class RefCounted extends CoreObject {
 }
@@ -275,10 +276,10 @@ declare class RefCounted extends CoreObject {
 interface ResourceEvents extends RefCountedEvents {
 }
 interface Resource {
-    on: <K extends keyof ResourceEvents & string>(event: K, listener: ResourceEvents[K]) => this;
-    once: <K extends keyof ResourceEvents & string>(event: K, listener: ResourceEvents[K]) => this;
-    off: <K extends keyof ResourceEvents & string>(event: K, listener: ResourceEvents[K]) => this;
-    emit: <K extends keyof ResourceEvents & string>(event: K, ...args: Parameters<ResourceEvents[K]>) => this;
+    on: <K extends keyof ResourceEvents & string>(event: K, listener: (...args: ResourceEvents[K]) => void) => this;
+    once: <K extends keyof ResourceEvents & string>(event: K, listener: (...args: ResourceEvents[K]) => void) => this;
+    off: <K extends keyof ResourceEvents & string>(event: K, listener: (...args: ResourceEvents[K]) => void) => this;
+    emit: <K extends keyof ResourceEvents & string>(event: K, ...args: ResourceEvents[K]) => this;
 }
 declare class Resource extends RefCounted {
 }
@@ -583,13 +584,17 @@ declare class Vector3 extends Vector {
 }
 
 interface MainLoopEvents extends CoreObjectEvents {
-    process: (delta: number) => void;
+    process: [delta: number];
+}
+interface MainLoopProperties {
+    fps: number;
+    speed: number;
 }
 interface MainLoop {
-    on: <K extends keyof MainLoopEvents & string>(event: K, listener: MainLoopEvents[K]) => this;
-    once: <K extends keyof MainLoopEvents & string>(event: K, listener: MainLoopEvents[K]) => this;
-    off: <K extends keyof MainLoopEvents & string>(event: K, listener: MainLoopEvents[K]) => this;
-    emit: <K extends keyof MainLoopEvents & string>(event: K, ...args: Parameters<MainLoopEvents[K]>) => this;
+    on: <K extends keyof MainLoopEvents & string>(event: K, listener: (...args: MainLoopEvents[K]) => void) => this;
+    once: <K extends keyof MainLoopEvents & string>(event: K, listener: (...args: MainLoopEvents[K]) => void) => this;
+    off: <K extends keyof MainLoopEvents & string>(event: K, listener: (...args: MainLoopEvents[K]) => void) => this;
+    emit: <K extends keyof MainLoopEvents & string>(event: K, ...args: MainLoopEvents[K]) => this;
 }
 declare class MainLoop extends CoreObject {
     fps: number;
@@ -599,10 +604,10 @@ declare class MainLoop extends CoreObject {
     protected _startedProcess?: (delta: number) => void;
     get starting(): boolean;
     get spf(): number;
-    constructor();
+    constructor(properties?: Partial<MainLoopProperties>);
     start(process: (delta: number) => void): void;
     stop(): void;
-    protected _onNextTick(): void;
+    protected _onTicker(): void;
     destroy(): void;
 }
 
@@ -680,9 +685,9 @@ declare const PI_2: number;
 declare function uid(object?: Record<string, any>): number;
 declare function isPow2(v: number): boolean;
 
-declare abstract class Renderer {
-    view?: HTMLCanvasElement;
+declare abstract class Renderer extends Reactivable {
     pixelRatio: number;
+    view?: HTMLCanvasElement;
     readonly screen: {
         x: number;
         y: number;
@@ -690,8 +695,10 @@ declare abstract class Renderer {
         height: number;
     };
     readonly related: RawWeakMap<object, any>;
+    protected _updateProperty(key: string, newValue: any, oldValue: any): void;
     getRelated<T>(source: object, createFn?: () => T): T;
     resize(width: number, height: number, updateStyle?: boolean): void;
+    destroy(): void;
 }
 
 type WebGLBufferTarget = 'array_buffer' | 'element_array_buffer';
@@ -742,6 +749,7 @@ interface WebGLFramebufferOptions {
     width: number;
     height: number;
     mipLevel?: number;
+    msaa?: boolean;
     stencil?: boolean;
     depth?: boolean;
     depthTexture?: WebGLTexture | null;
@@ -749,8 +757,9 @@ interface WebGLFramebufferOptions {
 }
 interface WebGLFramebufferMeta extends Required<WebGLFramebufferOptions> {
     multisample: number;
-    stencilBuffer?: WebGLBuffer | null;
-    msaaBuffer?: WebGLBuffer | null;
+    stencilBuffer: WebGLBuffer | null;
+    msaaRenderBuffers: WebGLRenderbuffer[];
+    framebuffer: WebGLFramebuffer | null;
 }
 type Pick<T> = T extends string ? T extends Uppercase<T> ? Lowercase<T> : never : never;
 type WebGLTarget = Pick<keyof WebGL2RenderingContext>;
@@ -1040,6 +1049,8 @@ declare class WebGLFramebufferModule extends WebGLModule {
         format: number;
     };
     resize(framebuffer: WebGLFramebuffer, width: number, height: number): void;
+    finishRenderPass(framebuffer: WebGLFramebuffer): void;
+    copyToTexture(framebuffer: WebGLFramebuffer, texture: WebGLTexture): void;
     bind(framebuffer: WebGLFramebuffer | null): void;
     forceStencil(): void;
     reset(): void;
@@ -1338,8 +1349,10 @@ interface ImageFrame {
     duration: number;
 }
 declare class AnimatedTexture extends Resource {
-    frames: ImageFrame[];
     duration: number;
+    frames: ImageFrame[];
+    frameIndex: number;
+    get currentFrame(): ImageFrame;
     constructor(source: Texture2D | ImageFrame[]);
     updateDuration(): this;
     destroy(): void;
@@ -1481,13 +1494,13 @@ declare class CanvasContext extends Path2D {
 }
 
 interface RectangulableEvents {
-    updateRect: () => void;
+    updateRect: [];
 }
 interface Rectangulable {
-    on: <K extends keyof RectangulableEvents & string>(event: K, listener: RectangulableEvents[K]) => this;
-    once: <K extends keyof RectangulableEvents & string>(event: K, listener: RectangulableEvents[K]) => this;
-    off: <K extends keyof RectangulableEvents & string>(event: K, listener: RectangulableEvents[K]) => this;
-    emit: <K extends keyof RectangulableEvents & string>(event: K, ...args: Parameters<RectangulableEvents[K]>) => this;
+    on: <K extends keyof RectangulableEvents & string>(event: K, listener: (...args: RectangulableEvents[K]) => void) => this;
+    once: <K extends keyof RectangulableEvents & string>(event: K, listener: (...args: RectangulableEvents[K]) => void) => this;
+    off: <K extends keyof RectangulableEvents & string>(event: K, listener: (...args: RectangulableEvents[K]) => void) => this;
+    emit: <K extends keyof RectangulableEvents & string>(event: K, ...args: RectangulableEvents[K]) => this;
 }
 interface Rectangulable {
     getRect: () => Rect2;
@@ -1500,10 +1513,10 @@ interface ViewportFramebuffer {
     needsUpload: boolean;
 }
 interface Viewport {
-    on: <K extends keyof ViewportEvents & string>(event: K, listener: ViewportEvents[K]) => this;
-    once: <K extends keyof ViewportEvents & string>(event: K, listener: ViewportEvents[K]) => this;
-    off: <K extends keyof ViewportEvents & string>(event: K, listener: ViewportEvents[K]) => this;
-    emit: <K extends keyof ViewportEvents & string>(event: K, ...args: Parameters<ViewportEvents[K]>) => this;
+    on: <K extends keyof ViewportEvents & string>(event: K, listener: (...args: ViewportEvents[K]) => void) => this;
+    once: <K extends keyof ViewportEvents & string>(event: K, listener: (...args: ViewportEvents[K]) => void) => this;
+    off: <K extends keyof ViewportEvents & string>(event: K, listener: (...args: ViewportEvents[K]) => void) => this;
+    emit: <K extends keyof ViewportEvents & string>(event: K, ...args: ViewportEvents[K]) => this;
 }
 declare class Viewport extends Node implements Rectangulable {
     flipY: boolean;
@@ -1515,6 +1528,7 @@ declare class Viewport extends Node implements Rectangulable {
     y: number;
     width: number;
     height: number;
+    msaa: boolean;
     get valid(): boolean;
     get framebuffer(): ViewportFramebuffer;
     get texture(): ViewportTexture;
@@ -1552,7 +1566,7 @@ declare class RenderStack {
 }
 
 interface TimelineEvents extends NodeEvents {
-    updateCurrentTime: (current: number, delta: number) => void;
+    updateCurrentTime: [current: number, delta: number];
 }
 interface TimelineProperties extends NodeProperties {
     startTime: number;
@@ -1561,10 +1575,10 @@ interface TimelineProperties extends NodeProperties {
     loop: boolean;
 }
 interface Timeline {
-    on: <K extends keyof TimelineEvents & string>(event: K, listener: TimelineEvents[K]) => this;
-    once: <K extends keyof TimelineEvents & string>(event: K, listener: TimelineEvents[K]) => this;
-    off: <K extends keyof TimelineEvents & string>(event: K, listener: TimelineEvents[K]) => this;
-    emit: <K extends keyof TimelineEvents & string>(event: K, ...args: Parameters<TimelineEvents[K]>) => this;
+    on: <K extends keyof TimelineEvents & string>(event: K, listener: (...args: TimelineEvents[K]) => void) => this;
+    once: <K extends keyof TimelineEvents & string>(event: K, listener: (...args: TimelineEvents[K]) => void) => this;
+    off: <K extends keyof TimelineEvents & string>(event: K, listener: (...args: TimelineEvents[K]) => void) => this;
+    emit: <K extends keyof TimelineEvents & string>(event: K, ...args: TimelineEvents[K]) => this;
 }
 declare class Timeline extends Node {
     startTime: number;
@@ -1579,36 +1593,44 @@ declare class Timeline extends Node {
 }
 
 declare class Window extends Viewport {
+    msaa: boolean;
 }
 
-interface SceneTreeEvents extends MainLoopEvents {
-    processing: () => void;
-    processed: () => void;
-    rendering: () => void;
-    rendered: () => void;
-    nodeProcessing: (node: Node) => void;
-    nodeProcessed: (node: Node) => void;
+interface SceneTreeEvents extends MainLoopEvents, InputEvents {
+    processing: [];
+    processed: [];
+    rendering: [];
+    rendered: [];
+    nodeProcessing: [node: Node];
+    nodeProcessed: [node: Node];
+}
+interface SceneTreeProperties extends MainLoopProperties {
+    backgroundColor: Hex8Color;
+    debug: boolean;
+    processPaused: boolean;
+    fonts: Fonts;
+    timeline: Timeline;
 }
 interface SceneTree {
-    on: <K extends keyof SceneTreeEvents & string>(event: K, listener: SceneTreeEvents[K]) => this;
-    once: <K extends keyof SceneTreeEvents & string>(event: K, listener: SceneTreeEvents[K]) => this;
-    off: <K extends keyof SceneTreeEvents & string>(event: K, listener: SceneTreeEvents[K]) => this;
-    emit: <K extends keyof SceneTreeEvents & string>(event: K, ...args: Parameters<SceneTreeEvents[K]>) => this;
+    on: <K extends keyof SceneTreeEvents & string>(event: K, listener: (...args: SceneTreeEvents[K]) => void) => this;
+    once: <K extends keyof SceneTreeEvents & string>(event: K, listener: (...args: SceneTreeEvents[K]) => void) => this;
+    off: <K extends keyof SceneTreeEvents & string>(event: K, listener: (...args: SceneTreeEvents[K]) => void) => this;
+    emit: <K extends keyof SceneTreeEvents & string>(event: K, ...args: SceneTreeEvents[K]) => this;
 }
 declare class SceneTree extends MainLoop {
-    processPaused: boolean;
-    backgroundColor: Color$1 | undefined;
+    backgroundColor?: Hex8Color;
     debug: boolean;
-    fonts?: Fonts;
+    processPaused: boolean;
+    fonts: Fonts | undefined;
+    timeline: Timeline;
     readonly input: Input;
     readonly renderStack: RenderStack;
     readonly root: Window;
-    readonly timeline: Timeline;
     protected _backgroundColor: Color;
     protected _currentViewport?: Viewport;
     getCurrentViewport(): Viewport | undefined;
     setCurrentViewport(viewport: Viewport | undefined): void;
-    constructor(timeline?: Timeline);
+    constructor(properties?: Partial<SceneTreeProperties>);
     protected _updateProperty(key: string, value: any, oldValue: any): void;
     log(...args: any[]): void;
     protected _process(delta?: number): void;
@@ -1629,23 +1651,23 @@ declare class Children<T extends Node = Node> {
 }
 
 interface NodeEvents extends CoreObjectEvents, InputEvents {
-    treeEnter: (tree: SceneTree) => void;
-    treeEntered: (tree: SceneTree) => void;
-    treePostEnter: (tree: SceneTree) => void;
-    treeExit: (oldTree: SceneTree) => void;
-    treeExiting: (oldTree: SceneTree) => void;
-    treeExited: (oldTree: SceneTree) => void;
-    childExitingTree: (node: Node) => void;
-    childEnteredTree: (node: Node) => void;
-    ready: () => void;
-    parented: (parent: Node) => void;
-    unparented: (oldParent: Node) => void;
-    processing: (delta?: number) => void;
-    process: (delta?: number) => void;
-    processed: (delta?: number) => void;
-    appendChild: (child: Node) => void;
-    removeChild: (child: Node, index: number) => void;
-    moveChild: (child: Node, newIndex: number, oldIndex: number) => void;
+    treeEnter: [tree: SceneTree];
+    treeEntered: [tree: SceneTree];
+    treePostEnter: [tree: SceneTree];
+    treeExit: [oldTree: SceneTree];
+    treeExiting: [oldTree: SceneTree];
+    treeExited: [oldTree: SceneTree];
+    childExitingTree: [node: Node];
+    childEnteredTree: [node: Node];
+    ready: [];
+    parented: [parent: Node];
+    unparented: [oldParent: Node];
+    processing: [delta?: number];
+    process: [delta?: number];
+    processed: [delta?: number];
+    appendChild: [child: Node];
+    removeChild: [child: Node, index: number];
+    moveChild: [child: Node, newIndex: number, oldIndex: number];
 }
 type ProcessMode = 'inherit' | 'pausable' | 'when_paused' | 'always' | 'disabled';
 type ProcessSortMode = 'default' | 'parent_before';
@@ -1663,10 +1685,10 @@ interface NodeProperties {
     meta: Record<string, any>;
 }
 interface Node {
-    on: <K extends keyof NodeEvents & string>(event: K, listener: NodeEvents[K]) => this;
-    once: <K extends keyof NodeEvents & string>(event: K, listener: NodeEvents[K]) => this;
-    off: <K extends keyof NodeEvents & string>(event: K, listener: NodeEvents[K]) => this;
-    emit: <K extends keyof NodeEvents & string>(event: K, ...args: Parameters<NodeEvents[K]>) => this;
+    on: <K extends keyof NodeEvents & string>(event: K, listener: (...args: NodeEvents[K]) => void) => this;
+    once: <K extends keyof NodeEvents & string>(event: K, listener: (...args: NodeEvents[K]) => void) => this;
+    off: <K extends keyof NodeEvents & string>(event: K, listener: (...args: NodeEvents[K]) => void) => this;
+    emit: <K extends keyof NodeEvents & string>(event: K, ...args: NodeEvents[K]) => this;
 }
 declare class Node extends CoreObject {
     readonly is: string;
@@ -1767,13 +1789,13 @@ interface TimelineNodeProperties extends NodeProperties {
     paused: boolean;
 }
 interface TimelineNodeEvents extends NodeEvents {
-    updateCurrentTime: (currentTime: number) => void;
+    updateCurrentTime: [currentTime: number];
 }
 interface TimelineNode {
-    on: <K extends keyof TimelineNodeEvents & string>(event: K, listener: TimelineNodeEvents[K]) => this;
-    once: <K extends keyof TimelineNodeEvents & string>(event: K, listener: TimelineNodeEvents[K]) => this;
-    off: <K extends keyof TimelineNodeEvents & string>(event: K, listener: TimelineNodeEvents[K]) => this;
-    emit: <K extends keyof TimelineNodeEvents & string>(event: K, ...args: Parameters<TimelineNodeEvents[K]>) => this;
+    on: <K extends keyof TimelineNodeEvents & string>(event: K, listener: (...args: TimelineNodeEvents[K]) => void) => this;
+    once: <K extends keyof TimelineNodeEvents & string>(event: K, listener: (...args: TimelineNodeEvents[K]) => void) => this;
+    off: <K extends keyof TimelineNodeEvents & string>(event: K, listener: (...args: TimelineNodeEvents[K]) => void) => this;
+    emit: <K extends keyof TimelineNodeEvents & string>(event: K, ...args: TimelineNodeEvents[K]) => this;
 }
 declare class TimelineNode extends Node {
     delay: number;
@@ -1783,8 +1805,8 @@ declare class TimelineNode extends Node {
     constructor(properties?: Partial<TimelineNodeProperties>, nodes?: Node[]);
     /** Timeline */
     computedDuration: number;
-    protected _currentTime: number;
-    protected _startTime: number;
+    _currentTime: number;
+    _startTime: number;
     get timeline(): Timeline | undefined;
     get timelineCurrentTime(): number;
     get parentStartTime(): number;
@@ -1803,13 +1825,13 @@ interface CanvasItemProperties extends TimelineNodeProperties {
     blendMode: WebGLBlendMode;
 }
 interface CanvasItemEvents extends TimelineNodeEvents {
-    draw: () => void;
+    draw: [];
 }
 interface CanvasItem {
-    on: <K extends keyof CanvasItemEvents & string>(event: K, listener: CanvasItemEvents[K]) => this;
-    once: <K extends keyof CanvasItemEvents & string>(event: K, listener: CanvasItemEvents[K]) => this;
-    off: <K extends keyof CanvasItemEvents & string>(event: K, listener: CanvasItemEvents[K]) => this;
-    emit: <K extends keyof CanvasItemEvents & string>(event: K, ...args: Parameters<CanvasItemEvents[K]>) => this;
+    on: <K extends keyof CanvasItemEvents & string>(event: K, listener: (...args: CanvasItemEvents[K]) => void) => this;
+    once: <K extends keyof CanvasItemEvents & string>(event: K, listener: (...args: CanvasItemEvents[K]) => void) => this;
+    off: <K extends keyof CanvasItemEvents & string>(event: K, listener: (...args: CanvasItemEvents[K]) => void) => this;
+    emit: <K extends keyof CanvasItemEvents & string>(event: K, ...args: CanvasItemEvents[K]) => this;
 }
 declare class CanvasItem extends TimelineNode {
     modulate: Color$1 | undefined;
@@ -1910,10 +1932,10 @@ interface Node2DProperties extends CanvasItemProperties {
 interface Node2DEvents extends CanvasItemEvents {
 }
 interface Node2D {
-    on: <K extends keyof Node2DEvents & string>(event: K, listener: Node2DEvents[K]) => this;
-    once: <K extends keyof Node2DEvents & string>(event: K, listener: Node2DEvents[K]) => this;
-    off: <K extends keyof Node2DEvents & string>(event: K, listener: Node2DEvents[K]) => this;
-    emit: <K extends keyof Node2DEvents & string>(event: K, ...args: Parameters<Node2DEvents[K]>) => this;
+    on: <K extends keyof Node2DEvents & string>(event: K, listener: (...args: Node2DEvents[K]) => void) => this;
+    once: <K extends keyof Node2DEvents & string>(event: K, listener: (...args: Node2DEvents[K]) => void) => this;
+    off: <K extends keyof Node2DEvents & string>(event: K, listener: (...args: Node2DEvents[K]) => void) => this;
+    emit: <K extends keyof Node2DEvents & string>(event: K, ...args: Node2DEvents[K]) => this;
 }
 declare class Node2D extends CanvasItem {
     rotation: number;
@@ -1942,13 +1964,13 @@ declare class Node2D extends CanvasItem {
 interface Camera2DProperties extends Node2DProperties {
 }
 interface Camera2DEvents extends Node2DEvents {
-    updateCanvasTransform: () => void;
+    updateCanvasTransform: [];
 }
 interface Camera2D {
-    on: <K extends keyof Camera2DEvents & string>(event: K, listener: Camera2DEvents[K]) => this;
-    once: <K extends keyof Camera2DEvents & string>(event: K, listener: Camera2DEvents[K]) => this;
-    off: <K extends keyof Camera2DEvents & string>(event: K, listener: Camera2DEvents[K]) => this;
-    emit: <K extends keyof Camera2DEvents & string>(event: K, ...args: Parameters<Camera2DEvents[K]>) => this;
+    on: <K extends keyof Camera2DEvents & string>(event: K, listener: (...args: Camera2DEvents[K]) => void) => this;
+    once: <K extends keyof Camera2DEvents & string>(event: K, listener: (...args: Camera2DEvents[K]) => void) => this;
+    off: <K extends keyof Camera2DEvents & string>(event: K, listener: (...args: Camera2DEvents[K]) => void) => this;
+    emit: <K extends keyof Camera2DEvents & string>(event: K, ...args: Camera2DEvents[K]) => this;
 }
 declare class Camera2D extends Node2D {
     readonly zoom: Vector2;
@@ -1987,14 +2009,17 @@ declare class BaseElement2DFill extends CoreObject {
     tile: NormalizedFill['tile'];
     opacity: NormalizedFill['opacity'];
     protected _texture?: Texture2D;
+    protected _animatedTexture?: AnimatedTexture;
     constructor(parent: BaseElement2D);
     protected _setProperties(properties?: NormalizedFill): this;
     setProperties(properties?: Fill): this;
     protected _updateProperty(key: string, value: any, oldValue: any): void;
-    loadTexture(): Promise<Texture2D | undefined>;
+    loadTexture(): Promise<void>;
     protected _updateTexture(): Promise<void>;
     canDraw(): boolean;
     draw(): void;
+    protected _getFrameCurrentTime(): number;
+    updateFrameIndex(): this;
 }
 
 declare class BaseElement2DBackground extends BaseElement2DFill {
@@ -2094,7 +2119,7 @@ declare class BaseElement2DText extends CoreObject {
 }
 
 interface BaseElement2DEvents extends Node2DEvents {
-    updateStyleProperty: (key: string, value: any, oldValue: any) => void;
+    updateStyleProperty: [key: string, value: any, oldValue: any];
 }
 interface BaseElement2DProperties extends Node2DProperties {
     modulate: Color$1;
@@ -2109,10 +2134,10 @@ interface BaseElement2DProperties extends Node2DProperties {
     shadow: Shadow;
 }
 interface BaseElement2D {
-    on: <K extends keyof BaseElement2DEvents & string>(event: K, listener: BaseElement2DEvents[K]) => this;
-    once: <K extends keyof BaseElement2DEvents & string>(event: K, listener: BaseElement2DEvents[K]) => this;
-    off: <K extends keyof BaseElement2DEvents & string>(event: K, listener: BaseElement2DEvents[K]) => this;
-    emit: <K extends keyof BaseElement2DEvents & string>(event: K, ...args: Parameters<BaseElement2DEvents[K]>) => this;
+    on: <K extends keyof BaseElement2DEvents & string>(event: K, listener: (...args: BaseElement2DEvents[K]) => void) => this;
+    once: <K extends keyof BaseElement2DEvents & string>(event: K, listener: (...args: BaseElement2DEvents[K]) => void) => this;
+    off: <K extends keyof BaseElement2DEvents & string>(event: K, listener: (...args: BaseElement2DEvents[K]) => void) => this;
+    emit: <K extends keyof BaseElement2DEvents & string>(event: K, ...args: BaseElement2DEvents[K]) => this;
 }
 declare class BaseElement2D extends Node2D implements Rectangulable {
     readonly size: Vector2;
@@ -2143,6 +2168,7 @@ declare class BaseElement2D extends Node2D implements Rectangulable {
     constructor(properties?: Partial<BaseElement2DProperties>, nodes?: Node[]);
     setProperties(properties?: Record<string, any>): this;
     protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
+    protected _process(delta: number): void;
     protected _updateMaskImage(): void;
     getTransformOrigin(): Vector2;
     updateTransform(cb?: (transform: Transform2D) => void): void;
@@ -2196,10 +2222,10 @@ interface Element2DProperties extends BaseElement2DProperties {
     style: Partial<Element2DStyleProperties>;
 }
 interface Element2D {
-    on: <K extends keyof Element2DEvents & string>(event: K, listener: Element2DEvents[K]) => this;
-    once: <K extends keyof Element2DEvents & string>(event: K, listener: Element2DEvents[K]) => this;
-    off: <K extends keyof Element2DEvents & string>(event: K, listener: Element2DEvents[K]) => this;
-    emit: <K extends keyof Element2DEvents & string>(event: K, ...args: Parameters<Element2DEvents[K]>) => this;
+    on: <K extends keyof Element2DEvents & string>(event: K, listener: (...args: Element2DEvents[K]) => void) => this;
+    once: <K extends keyof Element2DEvents & string>(event: K, listener: (...args: Element2DEvents[K]) => void) => this;
+    off: <K extends keyof Element2DEvents & string>(event: K, listener: (...args: Element2DEvents[K]) => void) => this;
+    emit: <K extends keyof Element2DEvents & string>(event: K, ...args: Element2DEvents[K]) => this;
 }
 declare class Element2D extends BaseElement2D {
     protected _style: Element2DStyle;
@@ -2304,16 +2330,16 @@ declare class FlexLayout {
 }
 
 interface FlexBaseElement2DEvents extends BaseElement2DEvents {
-    updateStyleProperty: (key: string, value: any, oldValue: any) => void;
+    updateStyleProperty: [key: string, value: any, oldValue: any];
 }
 interface FlexElement2DProperties extends BaseElement2DProperties {
     style: Partial<FlexElement2DStyleProperties>;
 }
 interface FlexElement2D {
-    on: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: FlexBaseElement2DEvents[K]) => this;
-    once: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: FlexBaseElement2DEvents[K]) => this;
-    off: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: FlexBaseElement2DEvents[K]) => this;
-    emit: <K extends keyof FlexBaseElement2DEvents & string>(event: K, ...args: Parameters<FlexBaseElement2DEvents[K]>) => this;
+    on: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: (...args: FlexBaseElement2DEvents[K]) => void) => this;
+    once: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: (...args: FlexBaseElement2DEvents[K]) => void) => this;
+    off: <K extends keyof FlexBaseElement2DEvents & string>(event: K, listener: (...args: FlexBaseElement2DEvents[K]) => void) => this;
+    emit: <K extends keyof FlexBaseElement2DEvents & string>(event: K, ...args: FlexBaseElement2DEvents[K]) => this;
 }
 declare class FlexElement2D extends BaseElement2D implements Rectangulable {
     protected _style: FlexElement2DStyle;
@@ -3045,10 +3071,10 @@ interface ControlEvents extends CanvasItemEvents, RectangulableEvents {
 interface ControlProperties extends BaseElement2DProperties {
 }
 interface Control {
-    on: <K extends keyof ControlEvents & string>(event: K, listener: ControlEvents[K]) => this;
-    once: <K extends keyof ControlEvents & string>(event: K, listener: ControlEvents[K]) => this;
-    off: <K extends keyof ControlEvents & string>(event: K, listener: ControlEvents[K]) => this;
-    emit: <K extends keyof ControlEvents & string>(event: K, ...args: Parameters<ControlEvents[K]>) => this;
+    on: <K extends keyof ControlEvents & string>(event: K, listener: (...args: ControlEvents[K]) => void) => this;
+    once: <K extends keyof ControlEvents & string>(event: K, listener: (...args: ControlEvents[K]) => void) => this;
+    off: <K extends keyof ControlEvents & string>(event: K, listener: (...args: ControlEvents[K]) => void) => this;
+    emit: <K extends keyof ControlEvents & string>(event: K, ...args: ControlEvents[K]) => this;
 }
 declare class Control extends Element2D implements Rectangulable {
     constructor(properties?: Partial<ControlProperties>, children?: Node[]);
@@ -3296,24 +3322,16 @@ declare class CanvasItemEditor extends Control {
     protected _updateScrollbars(): void;
 }
 
-interface EngineOptions extends WebGLContextAttributes {
-    debug?: boolean;
+interface EngineProperties extends WebGLContextAttributes, SceneTreeProperties {
     view?: HTMLCanvasElement | WebGLRenderingContext | WebGL2RenderingContext;
     width?: number;
     height?: number;
     pixelRatio?: number;
-    backgroundColor?: Color$1;
-    fonts?: Fonts;
-    autoResize?: boolean;
-    autoStart?: boolean;
-    timeline?: Timeline;
+    autoResize: boolean;
+    autoStart: boolean;
+    msaa: boolean;
 }
 interface EngineEvents extends SceneTreeEvents {
-    pointerdown: (ev: PointerInputEvent) => void;
-    pointerover: (ev: PointerInputEvent) => void;
-    pointermove: (ev: PointerInputEvent) => void;
-    pointerup: (ev: PointerInputEvent) => void;
-    wheel: (ev: WheelInputEvent) => void;
 }
 declare const defaultOptions: {
     readonly alpha: true;
@@ -3324,12 +3342,15 @@ declare const defaultOptions: {
     readonly powerPreference: "default";
 };
 interface Engine {
-    on: <K extends keyof EngineEvents>(event: K, listener: EngineEvents[K]) => this;
-    once: <K extends keyof EngineEvents>(event: K, listener: EngineEvents[K]) => this;
-    off: <K extends keyof EngineEvents>(event: K, listener: EngineEvents[K]) => this;
-    emit: <K extends keyof EngineEvents>(event: K, ...args: Parameters<EngineEvents[K]>) => this;
+    on: <K extends keyof EngineEvents>(event: K, listener: (...args: EngineEvents[K]) => void) => this;
+    once: <K extends keyof EngineEvents>(event: K, listener: (...args: EngineEvents[K]) => void) => this;
+    off: <K extends keyof EngineEvents>(event: K, listener: (...args: EngineEvents[K]) => void) => this;
+    emit: <K extends keyof EngineEvents>(event: K, ...args: EngineEvents[K]) => this;
 }
 declare class Engine extends SceneTree {
+    msaa: boolean;
+    autoResize: boolean;
+    autoStart: boolean;
     readonly renderer: WebGLRenderer;
     get view(): HTMLCanvasElement | undefined;
     get gl(): WebGLRenderingContext | WebGL2RenderingContext;
@@ -3344,19 +3365,19 @@ declare class Engine extends SceneTree {
     get pixelRatio(): number;
     set pixelRatio(val: number);
     protected _resizeObserver: ResizeObserver | undefined;
-    constructor(options?: EngineOptions);
+    constructor(properties?: Partial<EngineProperties>);
+    protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _setupInput(): this;
-    enableAutoResize(enable?: boolean): this;
     resize(width: number, height: number, updateCss?: boolean): this;
     nextTick(): Promise<void>;
     waitUntilLoad(): Promise<void>;
     waitAndRender(delta?: number): Promise<void>;
     render(delta?: number): void;
     start(): Promise<void>;
-    destroy(): void;
     toPixels(): Uint8ClampedArray<ArrayBuffer>;
     toImageData(): ImageData;
     toCanvas2D(): HTMLCanvasElement;
+    destroy(): void;
 }
 
 interface RenderOptions {
@@ -3371,4 +3392,4 @@ interface RenderOptions {
 declare function render(options: RenderOptions): Promise<HTMLCanvasElement>;
 
 export { AnimatedTexture, Animation, Assets, Audio, AudioPipeline, AudioProcessor, AudioSpectrum, AudioWaveform, BaseElement2D, BaseElement2DBackground, BaseElement2DFill, BaseElement2DForeground, BaseElement2DOutline, BaseElement2DShadow, BaseElement2DShape, BaseElement2DStyle, BaseElement2DText, Camera2D, CanvasContext, CanvasItem, CanvasItemEditor, CanvasTexture, Color, ColorAdjustEffect, ColorFilterEffect, ColorMatrix, ColorOverlayEffect, ColorRemoveEffect, ColorReplaceEffect, ColorTexture, Control, CoreObject, DEG_TO_RAD, DEVICE_PIXEL_RATIO, DropShadowEffect, Effect, EffectMaterial, Element2D, Element2DStyle, EmbossEffect, Engine, FlexElement2D, FlexElement2DStyle, FlexLayout, FontLoader, GaussianBlurEffect, Geometry, GifLoader, GlitchEffect, GodrayEffect, GradientTexture, HTMLAudio, HTMLAudioContext, HTMLSound, IN_BROWSER, Image2D, ImageTexture, IndexBuffer, Input, InputEvent, JsonLoader, KawaseBlurEffect, KawaseTransition, KeyboardInputEvent, LeftEraseTransition, Loader, Lottie2D, LottieLoader, MainLoop, MaskEffect, Material, Matrix, Matrix2, Matrix3, Matrix4, MouseInputEvent, Node, Node2D, OutlineEffect, PI, PI_2, PixelateEffect, PixelsTexture, PointerInputEvent, Projection2D, QuadGeometry, QuadUvGeometry, RAD_TO_DEG, Range, RawWeakMap, Rect2, RefCounted, Renderer, Resource, Ruler, SUPPORTS_AUDIO_CONTEXT, SUPPORTS_CLICK_EVENTS, SUPPORTS_CREATE_IMAGE_BITMAP, SUPPORTS_IMAGE_BITMAP, SUPPORTS_MOUSE_EVENTS, SUPPORTS_OFFLINE_AUDIO_CONTEXT, SUPPORTS_POINTER_EVENTS, SUPPORTS_RESIZE_OBSERVER, SUPPORTS_TOUCH_EVENTS, SUPPORTS_WEBGL2, SUPPORTS_WEBKIT_AUDIO_CONTEXT, SUPPORTS_WEBKIT_OFFLINE_AUDIO_CONTEXT, SUPPORTS_WEB_AUDIO, SUPPORTS_WHEEL_EVENTS, Scaler, SceneTree, ScrollBar, TextLoader, Texture2D, TextureLoader, TextureRect2D, Ticker, TiltShiftTransition, Timeline, TimelineNode, Transform2D, TransformRect2D, Transition, TwistTransition, UvGeometry, UvMaterial, Vector, Vector2, Vector3, Vector4, VertexAttribute, VertexBuffer, Video2D, VideoLoader, VideoTexture, Viewport, ViewportTexture, WebAudio, WebAudioContext, WebGLBatch2DModule, WebGLBlendMode, WebGLBufferModule, WebGLFramebufferModule, WebGLMaskModule, WebGLModule, WebGLProgramModule, WebGLRenderer, WebGLScissorModule, WebGLState, WebGLStateModule, WebGLStencilModule, WebGLTextureModule, WebGLVertexArrayModule, WebGLViewportModule, WebSound, WheelInputEvent, Window, XScrollBar, YScrollBar, ZoomBlurEffect, alignMap, assets, boxSizingMap, clamp, clampFrag, createHTMLCanvas, createNode, crossOrigin, cubicBezier, curves, customNode, customNodes, defaultOptions, determineCrossOrigin, directionMap, displayMap, ease, easeIn, easeInOut, easeOut, edgeMap, flexDirectionMap, flexWrapMap, frag, getDefaultCssPropertyValue, gutterMap, isCanvasElement, isElementNode, isImageElement, isPow2, isVideoElement, isWebgl2, justifyMap, lerp, linear, log2, mapWebGLBlendModes, nextPow2, nextTick, overflowMap, parseCSSFilter, parseCSSTransform, parseCSSTransformOrigin, parseCssFunctions, parseCssProperty, positionTypeMap, render, timingFunctions, uid };
-export type { AnimationEffectMode, AnimationProperties, AssetHandler, AudioWaveformProperties, BaseElement2DEvents, BaseElement2DProperties, BaseElement2DStyleProperties, Batchable2D, CSSFilterKey, CSSFilters, Camera2DEvents, Camera2DProperties, CanvasBatchable, CanvasItemEvents, CanvasItemProperties, ColorAdjustEffectProperties, ColorFilterEffectProperties, ColorOverlayEffectProperties, ColorRemoveEffectProperties, ColorReplaceEffectProperties, ComputedLayout, ControlEvents, ControlProperties, CoreObjectEvents, CssFunction, CssFunctionArg, Cursor, DropShadowEffectProperties, Easing, EffectContext, EffectMode, EffectProperties, Element2DEvents, Element2DProperties, Element2DStyleProperties, EmbossEffectProperties, EngineOptions, FillDraw, FlexBaseElement2DEvents, FlexElement2DProperties, FlexElement2DStyleProperties, GaussianBlurEffectProperties, GeometryOptions, GlitchEffectProperties, GodrayEffectProperties, IAudioContext, IAudioNode, IPlayOptions, Image2DProperties, ImageFrame, ImageTextureOptions, IndexBufferOptions, InputEventKey, InputEvents, InputMode, InternalMode, KawaseBlurEffectProperties, Keyframe, Lottie2DProperties, MainLoopEvents, MaskColor, MaskData, MaskEffectProperties, MaskObject, MaskRect, Maskable, MaterialOptions, MatrixLike, MatrixOperateOutput, Node2DEvents, Node2DProperties, NodeEvents, NodeProperties, NormalizedKeyframe, OutlineEffectProperties, PixelateEffectProperties, PlatformAudio, PlatformSound, ProcessMode, ProcessSortMode, RangeProperties, Rectangulable, RectangulableEvents, RefCountedEvents, RenderMode, RenderOptions, Renderable, ResourceEvents, RulerProperties, ScalerEvents, ScalerProperties, SceneTreeEvents, ScrollBarProperties, StrokeDraw, Texture2DFilterMode, Texture2DPixelsSource, Texture2DSource, Texture2DWrapMode, TextureRect2DProperties, TimelineEvents, TimelineNodeEvents, TimelineNodeProperties, TimelineProperties, TimingFunctions, TransformObject, TransformRect2DProperties, TransformableObject, TransitionProperties, UvTransform, Vector2Data, VectorLike, VectorOperateOutput, VertTransform, VertexAttributeOptions, VertexBufferOptions, Video2DProperties, VideoTextureOptions, VideoTextureSource, ViewportEvents, ViewportFramebuffer, WebGLBufferMeta, WebGLBufferOptions, WebGLBufferTarget, WebGLBufferUsage, WebGLDrawMode, WebGLDrawOptions, WebGLExtensions, WebGLFramebufferMeta, WebGLFramebufferOptions, WebGLProgramMeta, WebGLProgramOptions, WebGLTarget, WebGLTextureFilterMode, WebGLTextureLocation, WebGLTextureMeta, WebGLTextureOptions, WebGLTextureSource, WebGLTextureTarget, WebGLTextureWrapMode, WebGLVertexArrayObjectMeta, WebGLVertexArrayObjectOptions, WebGLVertexAttrib, WebGLVertexAttribType, WebGLViewport, XScrollBarProperties, YScrollBarProperties, ZoomBlurEffectProperties };
+export type { AnimationEffectMode, AnimationProperties, AssetHandler, AudioWaveformProperties, BaseElement2DEvents, BaseElement2DProperties, BaseElement2DStyleProperties, Batchable2D, CSSFilterKey, CSSFilters, Camera2DEvents, Camera2DProperties, CanvasBatchable, CanvasItemEvents, CanvasItemProperties, ColorAdjustEffectProperties, ColorFilterEffectProperties, ColorOverlayEffectProperties, ColorRemoveEffectProperties, ColorReplaceEffectProperties, ComputedLayout, ControlEvents, ControlProperties, CoreObjectEvents, CssFunction, CssFunctionArg, Cursor, DropShadowEffectProperties, Easing, EffectContext, EffectMode, EffectProperties, Element2DEvents, Element2DProperties, Element2DStyleProperties, EmbossEffectProperties, EngineProperties, FillDraw, FlexBaseElement2DEvents, FlexElement2DProperties, FlexElement2DStyleProperties, GaussianBlurEffectProperties, GeometryOptions, GlitchEffectProperties, GodrayEffectProperties, IAudioContext, IAudioNode, IPlayOptions, Image2DProperties, ImageFrame, ImageTextureOptions, IndexBufferOptions, InputEventKey, InputEvents, InputMode, InternalMode, KawaseBlurEffectProperties, Keyframe, Lottie2DProperties, MainLoopEvents, MainLoopProperties, MaskColor, MaskData, MaskEffectProperties, MaskObject, MaskRect, Maskable, MaterialOptions, MatrixLike, MatrixOperateOutput, Node2DEvents, Node2DProperties, NodeEvents, NodeProperties, NormalizedKeyframe, OutlineEffectProperties, PixelateEffectProperties, PlatformAudio, PlatformSound, ProcessMode, ProcessSortMode, RangeProperties, Rectangulable, RectangulableEvents, RefCountedEvents, RenderMode, RenderOptions, Renderable, ResourceEvents, RulerProperties, ScalerEvents, ScalerProperties, SceneTreeEvents, SceneTreeProperties, ScrollBarProperties, StrokeDraw, Texture2DFilterMode, Texture2DPixelsSource, Texture2DSource, Texture2DWrapMode, TextureRect2DProperties, TimelineEvents, TimelineNodeEvents, TimelineNodeProperties, TimelineProperties, TimingFunctions, TransformObject, TransformRect2DProperties, TransformableObject, TransitionProperties, UvTransform, Vector2Data, VectorLike, VectorOperateOutput, VertTransform, VertexAttributeOptions, VertexBufferOptions, Video2DProperties, VideoTextureOptions, VideoTextureSource, ViewportEvents, ViewportFramebuffer, WebGLBufferMeta, WebGLBufferOptions, WebGLBufferTarget, WebGLBufferUsage, WebGLDrawMode, WebGLDrawOptions, WebGLExtensions, WebGLFramebufferMeta, WebGLFramebufferOptions, WebGLProgramMeta, WebGLProgramOptions, WebGLTarget, WebGLTextureFilterMode, WebGLTextureLocation, WebGLTextureMeta, WebGLTextureOptions, WebGLTextureSource, WebGLTextureTarget, WebGLTextureWrapMode, WebGLVertexArrayObjectMeta, WebGLVertexArrayObjectOptions, WebGLVertexAttrib, WebGLVertexAttribType, WebGLViewport, XScrollBarProperties, YScrollBarProperties, ZoomBlurEffectProperties };