modern-canvas 0.1.10 → 0.2.1

package/dist/index.d.ts

@@ -1,55 +1,153 @@
-import { Visibility, Overflow, IDOCTextStyleDeclaration, IDOCTransformStyleDeclaration } from 'modern-idoc';
-import { Path2D, LineStyle, LineCap, LineJoin, BoundingBox } from 'modern-path2d';
-import { AnyColor, Colord } from 'colord';
+import { Font } from 'modern-font';
 import { AnimationItem } from 'lottie-web';
+import { AnyColor, Colord } from 'colord';
+import { IDOCTextStyleDeclaration, IDOCTransformStyleDeclaration, Visibility, Overflow } from 'modern-idoc';
+import { Path2D, LineStyle, LineCap, LineJoin } from 'modern-path2d';
 import { TextOptions, Text, MeasureResult } from 'modern-text';
-import { Font } from 'modern-font';
 
-interface CssFunctionArg {
-    unit: string | null;
-    value: string;
-    intValue: number;
-    normalizedIntValue: number;
-    normalizedDefaultIntValue: number;
+declare abstract class Loader {
+    abstract install(assets: Assets): this;
 }
-interface CssFunction {
-    name: string;
-    args: CssFunctionArg[];
+
+declare class FontLoader extends Loader {
+    load: (url: string) => Promise<Font>;
+    install(assets: Assets): this;
 }
-interface ParseArgumentContext {
-    index?: number;
-    fontSize?: number;
-    width?: number;
-    height?: number;
+
+declare const customNodes: Map<string, any>;
+declare function customNode<T = Record<string, any>>(tag: string, defaultProperties?: Partial<T>): ClassDecorator;
+
+interface PropertyDeclaration {
+    readonly default?: any;
+    readonly protected?: boolean;
+    readonly alias?: string;
 }
-declare function getDefaultCssPropertyValue<T extends CssFunctionArg | CssFunction[]>(value: T): T;
-declare function parseCssProperty(name: string, propertyValue: string, context?: ParseArgumentContext): CssFunctionArg | CssFunction[];
-declare function parseCssFunctions(propertyValue: string, context?: ParseArgumentContext): CssFunction[];
+declare function getDeclarations(constructor: any): Map<PropertyKey, PropertyDeclaration>;
+declare function defineProperty(constructor: any, name: PropertyKey, declaration?: PropertyDeclaration): void;
+declare function property(options?: PropertyDeclaration): PropertyDecorator;
 
-declare const SUPPORTS_WEBGL2: boolean;
-declare const SUPPORTS_IMAGE_BITMAP: boolean;
-declare const SUPPORTS_RESIZE_OBSERVER: boolean;
-declare const SUPPORTS_POINTER_EVENTS: boolean;
-declare const SUPPORTS_WHEEL_EVENTS: boolean;
-declare const SUPPORTS_MOUSE_EVENTS: boolean;
-declare const SUPPORTS_TOUCH_EVENTS: boolean;
-declare const SUPPORTS_CLICK_EVENTS: boolean;
-declare const SUPPORTS_CREATE_IMAGE_BITMAP: boolean;
-declare const SUPPORTS_AUDIO_CONTEXT: boolean;
-declare const SUPPORTS_WEBKIT_AUDIO_CONTEXT: boolean;
-declare const SUPPORTS_OFFLINE_AUDIO_CONTEXT: boolean;
-declare const SUPPORTS_WEBKIT_OFFLINE_AUDIO_CONTEXT: boolean;
-declare const SUPPORTS_WEB_AUDIO: boolean;
-declare const IN_BROWSER: boolean;
-declare const DEVICE_PIXEL_RATIO: number;
-declare const isElementNode: (node: unknown) => node is Element;
-declare const isVideoElement: (node: unknown) => node is HTMLVideoElement;
-declare const isImageElement: (node: unknown) => node is HTMLImageElement;
-declare function isCanvasElement(node: unknown): node is HTMLCanvasElement;
-declare function isWebgl2(gl: unknown): gl is WebGL2RenderingContext;
-declare function createHTMLCanvas(): HTMLCanvasElement | undefined;
-declare function determineCrossOrigin(url: string, loc?: Location): string;
-declare function crossOrigin(element: HTMLImageElement | HTMLVideoElement, url: string, crossorigin: boolean | string | null): void;
+declare function protectedProperty(options?: Omit<PropertyDeclaration, 'protected'>): PropertyDecorator;
+
+declare function createNode<T = any>(tag?: string, options?: Record<string, any>): T;
+
+declare function nextTick(cb?: () => void): Promise<void>;
+
+type Callback = () => void;
+interface QueueItem {
+    cb: Callback;
+    once: boolean;
+}
+interface Options {
+    sort?: number;
+    once?: boolean;
+}
+declare class Ticker {
+    protected static _queue: QueueItem[][];
+    protected static _currentTime: number;
+    protected static _elapsed: number;
+    protected static _requestId?: number;
+    static get currentTime(): number;
+    static get elapsed(): number;
+    static on(cb: Callback, options?: Options): void;
+    static off(cb: Callback, options?: Options): void;
+    static start(): void;
+    static stop(): void;
+    protected static _update(time: number): void;
+    protected static _performUpdate(): void;
+}
+
+type Cursor = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ns-resize' | 'ew-resize' | 'nesw-resize' | 'col-resize' | 'nwse-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'grab' | 'grabbing';
+
+declare class InputEvent<N extends UIEvent = UIEvent> implements UIEvent {
+    bubbles: boolean;
+    readonly cancelable = false;
+    which: number;
+    cancelBubble: boolean;
+    returnValue: boolean;
+    srcElement: EventTarget;
+    readonly composed = false;
+    currentTarget: any;
+    defaultPrevented: boolean;
+    eventPhase: number;
+    isTrusted: boolean;
+    target: any;
+    timeStamp: number;
+    type: string;
+    nativeEvent: N;
+    originalEvent: InputEvent<N> | null;
+    propagationStopped: boolean;
+    propagationImmediatelyStopped: boolean;
+    path: any[];
+    detail: number;
+    view: WindowProxy;
+    layer: {
+        x: number;
+        y: number;
+    };
+    get layerX(): number;
+    get layerY(): number;
+    page: {
+        x: number;
+        y: number;
+    };
+    get pageX(): number;
+    get pageY(): number;
+    initEvent(..._args: any[]): void;
+    initUIEvent(..._args: any[]): void;
+    composedPath(): any[];
+    preventDefault(): void;
+    stopImmediatePropagation(): void;
+    stopPropagation(): void;
+    readonly NONE = 0;
+    readonly CAPTURING_PHASE = 1;
+    readonly AT_TARGET = 2;
+    readonly BUBBLING_PHASE = 3;
+}
+
+declare class MouseInputEvent extends InputEvent implements MouseEvent {
+    altKey: boolean;
+    button: number;
+    buttons: number;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    relatedTarget: EventTarget | null;
+    shiftKey: boolean;
+    client: {
+        x: number;
+        y: number;
+    };
+    get clientX(): number;
+    get clientY(): number;
+    get x(): number;
+    get y(): number;
+    detail: number;
+    movement: {
+        x: number;
+        y: number;
+    };
+    get movementX(): number;
+    get movementY(): number;
+    offset: {
+        x: number;
+        y: number;
+    };
+    get offsetX(): number;
+    get offsetY(): number;
+    global: {
+        x: number;
+        y: number;
+    };
+    get globalX(): number;
+    get globalY(): number;
+    screen: {
+        x: number;
+        y: number;
+    };
+    get screenX(): number;
+    get screenY(): number;
+    getModifierState(key: string): boolean;
+    initMouseEvent(..._args: any[]): void;
+}
 
 type EventListenerValue = (...args: any[]) => void;
 type EventListenerOptions = boolean | AddEventListenerOptions;
@@ -67,81 +165,25 @@ declare class EventEmitter {
     emit(type: string, ...args: any[]): boolean;
 }
 
-declare class RawWeakMap<K extends WeakKey = WeakKey, V = any> {
-    protected _map: WeakMap<K, V>;
-    protected _toRaw(value: any): any;
-    /**
-     * Removes the specified element from the WeakMap.
-     * @returns true if the element was successfully removed, or false if it was not present.
-     */
-    delete(key: K): boolean;
-    /**
-     * @returns a specified element.
-     */
-    get(key: K): V | undefined;
-    /**
-     * @returns a boolean indicating whether an element with the specified key exists or not.
-     */
-    has(key: K): boolean;
-    /**
-     * Adds a new element with a specified key and value.
-     * @param key Must be an object or symbol.
-     */
-    set(key: K, value: V): this;
-}
-
-declare const PI: number;
-declare const PI_2: number;
-declare function uid(object?: Record<string, any>): number;
-declare function isPow2(v: number): boolean;
-
-interface CustomNodeOptions {
-    tag: string;
-    renderable?: boolean;
-}
-declare const customNodes: Map<string, any>;
-declare function customNode(tag: string): ClassDecorator;
-declare function customNode(options: CustomNodeOptions): ClassDecorator;
-
-interface PropertyDeclaration {
-    readonly default?: any;
-    readonly protected?: boolean;
-    readonly alias?: string;
-}
-declare function getDeclarations(constructor: any): Map<PropertyKey, PropertyDeclaration>;
-declare function defineProperty(constructor: any, name: PropertyKey, declaration?: PropertyDeclaration): void;
-declare function property(options?: PropertyDeclaration): PropertyDecorator;
-declare function protectedProperty(options?: Omit<PropertyDeclaration, 'protected'>): PropertyDecorator;
-
-interface _ObjectEventMap {
+interface CoreObjectEventMap {
     updateProperty: (key: PropertyKey, newValue: any, oldValue: any, declaration?: PropertyDeclaration) => void;
 }
-interface _Object {
-    on: (<K extends keyof _ObjectEventMap>(type: K, listener: _ObjectEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    off: (<K extends keyof _ObjectEventMap>(type: K, listener: _ObjectEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    emit: (<K extends keyof _ObjectEventMap>(type: K, ...args: Parameters<_ObjectEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+interface CoreObject {
+    on: (<K extends keyof CoreObjectEventMap>(type: K, listener: CoreObjectEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof CoreObjectEventMap>(type: K, listener: CoreObjectEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof CoreObjectEventMap>(type: K, ...args: Parameters<CoreObjectEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
 }
-/**
- * Object 是所有 Godot 类的根类。
- * 它提供了基础的功能，如内存管理、信号（signals）机制、实例化和对象生命周期等。
- *
- * 功能和用途：
- *  • 所有的类都继承自 Object，这使得 Godot 中的所有对象都能共享一些基础的功能。
- *  • 提供了内存管理功能，例如销毁对象。
- *  • 支持信号机制，允许对象间进行通信。
- *  • 支持对象的序列化和保存。
- */
-declare class _Object extends EventEmitter {
+declare class CoreObject extends EventEmitter {
     readonly instanceId: number;
     protected _defaultProperties?: Record<PropertyKey, any>;
     protected _updatedProperties: Map<PropertyKey, unknown>;
     protected _changedProperties: Set<PropertyKey>;
-    protected _updatePending: Promise<void>;
-    protected _isUpdatePending: boolean;
+    protected _updatingPromise: Promise<void>;
+    protected _updating: boolean;
     protected _enqueueUpdate(): Promise<void>;
     protected _performUpdate(): void;
     protected _onUpdate(changed: Map<PropertyKey, unknown>): void;
-    protected _onUpdateProperty(key: PropertyKey, newValue: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     isDirty(key: string): boolean;
     getPropertyDeclarations(): Map<PropertyKey, PropertyDeclaration>;
     getPropertyDeclaration(key: PropertyKey): PropertyDeclaration | undefined;
@@ -152,44 +194,516 @@ declare class _Object extends EventEmitter {
     setProperties(properties?: Record<PropertyKey, any>): this;
     requestUpdate(key?: PropertyKey, oldValue?: unknown, declaration?: PropertyDeclaration): void;
     toJSON(): Record<string, any>;
+    clone(): this;
     destroy(): void;
 }
 
-declare abstract class Renderer {
-    view?: HTMLCanvasElement;
-    pixelRatio: number;
-    readonly screen: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    readonly related: RawWeakMap<object, any>;
-    getRelated<T>(source: object, createFn?: () => T): T;
-    resize(width: number, height: number, updateStyle?: boolean): void;
+interface RefCountedEventMap extends CoreObjectEventMap {
 }
-
-type WebGLBufferTarget = 'array_buffer' | 'element_array_buffer';
-interface WebGLBufferOptions {
-    target?: WebGLBufferTarget;
-    usage?: WebGLBufferUsage;
-    data: BufferSource | number[] | null;
+interface RefCounted {
+    on: (<K extends keyof RefCountedEventMap>(type: K, listener: RefCountedEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof RefCountedEventMap>(type: K, listener: RefCountedEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof RefCountedEventMap>(type: K, ...args: Parameters<RefCountedEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
 }
-type WebGLBufferUsage = 'static_draw' | 'dynamic_draw';
-interface WebGLBufferMeta {
-    id: number;
-    target?: WebGLBufferTarget;
-    usage?: WebGLBufferUsage;
-    length: number;
-    byteLength: number;
-    bytesPerElement: number;
+declare class RefCounted extends CoreObject {
 }
-type WebGLDrawMode = 'points' | 'line_strip' | 'line_loop' | 'lines' | 'triangle_strip' | 'triangle_fan' | 'triangles';
-interface WebGLDrawOptions {
-    mode?: WebGLDrawMode;
-    count?: number;
-    first?: number;
-    bytesPerElement?: number;
+
+declare class PointerInputEvent extends MouseInputEvent implements PointerEvent {
+    altitudeAngle: number;
+    azimuthAngle: number;
+    pointerId: number;
+    width: number;
+    height: number;
+    isPrimary: boolean;
+    pointerType: string;
+    pressure: number;
+    tangentialPressure: number;
+    tiltX: number;
+    tiltY: number;
+    twist: number;
+    detail: number;
+    getCoalescedEvents(): PointerEvent[];
+    getPredictedEvents(): PointerEvent[];
+}
+
+declare class WheelInputEvent extends MouseInputEvent implements WheelEvent {
+    deltaMode: number;
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    static readonly DOM_DELTA_PIXEL = 0;
+    readonly DOM_DELTA_PIXEL = 0;
+    static readonly DOM_DELTA_LINE = 1;
+    readonly DOM_DELTA_LINE = 1;
+    static readonly DOM_DELTA_PAGE = 2;
+    readonly DOM_DELTA_PAGE = 2;
+}
+
+interface InputEventMap {
+    pointerdown: (ev: PointerInputEvent) => void;
+    pointerover: (ev: PointerInputEvent) => void;
+    pointermove: (ev: PointerInputEvent) => void;
+    pointerup: (ev: PointerInputEvent) => void;
+    wheel: (ev: WheelInputEvent) => void;
+}
+type InputEventKey = keyof InputEventMap;
+interface Input {
+    on: (<K extends keyof InputEventMap>(type: K, listener: InputEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof InputEventMap>(type: K, listener: InputEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof InputEventMap>(type: K, ...args: Parameters<InputEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class Input extends EventEmitter {
+    target?: HTMLElement;
+    cursor: Cursor | string;
+    cursorStyles: Record<string, any>;
+    setuped: boolean;
+    /**
+     * Current event
+     */
+    event?: PointerInputEvent | WheelInputEvent;
+    enableMoveEvent: boolean;
+    enableWheelEvent: boolean;
+    enableClickEvent: boolean;
+    setTarget(target: HTMLElement): void;
+    removeEventListeners(): void;
+    addEventListeners(): void;
+    protected normalize(event: WheelEvent): WheelEvent[];
+    protected normalize(event: TouchEvent | PointerEvent | MouseEvent): PointerEvent[];
+    protected cloneWheelEvent(nativeEvent: WheelEvent): WheelInputEvent;
+    protected clonePointerEvent(nativeEvent: PointerEvent): PointerInputEvent;
+    protected copyMouseEvent(event: MouseInputEvent, nativeEvent: MouseEvent): void;
+    /**
+     * Sets the current cursor mode, handling any callbacks or CSS style changes.
+     * @param mode - cursor mode, a key from the cursorStyles dictionary
+     */
+    setCursor(mode: string): void;
+    mapPositionToPoint(point: {
+        x: number;
+        y: number;
+    }, x: number, y: number): void;
+    protected onPointerDown: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
+    protected onPointerOver: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
+    protected onPointerMove: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
+    protected onPointerUp: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
+    protected onWheel: (nativeEvent: WheelEvent) => void;
+}
+
+interface ResourceEventMap extends RefCountedEventMap {
+}
+interface Resource {
+    on: (<K extends keyof ResourceEventMap>(type: K, listener: ResourceEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof ResourceEventMap>(type: K, listener: ResourceEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof ResourceEventMap>(type: K, ...args: Parameters<ResourceEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class Resource extends RefCounted {
+}
+
+type ColorValue = number | AnyColor;
+declare class Color {
+    protected _colord: Colord;
+    protected _value: ColorValue;
+    get value(): ColorValue;
+    set value(value: ColorValue | undefined);
+    get r8(): number;
+    get g8(): number;
+    get b8(): number;
+    get a8(): number;
+    get r(): number;
+    get g(): number;
+    get b(): number;
+    get a(): number;
+    get rgb(): number;
+    get bgr(): number;
+    get abgr(): number;
+    constructor(value?: ColorValue);
+    toArgb(alpha?: number, applyToRGB?: boolean): number;
+    toHex(): string;
+    toArray(): [number, number, number, number];
+}
+
+type VectorLike = number | number[] | Matrix | Vector;
+type VectorOperateOutput = number[] | Vector;
+declare abstract class Vector extends EventEmitter {
+    readonly dim: number;
+    protected _array: number[];
+    get length(): number;
+    constructor(dim: number);
+    protected _operate(operator: '+' | '-' | '*' | '/' | 'rot' | '==' | '=' | string, target: VectorLike, output?: VectorOperateOutput): any;
+    add(value: VectorLike): this;
+    add<T extends VectorOperateOutput>(value: VectorLike, output: T): T;
+    sub(value: VectorLike): this;
+    sub<T extends VectorOperateOutput>(value: VectorLike, output: T): T;
+    multiply(value: VectorLike): this;
+    multiply<T extends VectorOperateOutput>(value: VectorLike, output: T): T;
+    divide(value: VectorLike): this;
+    divide<T extends VectorOperateOutput>(value: VectorLike, output: T): T;
+    rotate(angle: number): this;
+    rotate<T extends VectorOperateOutput>(angle: number, output: T): T;
+    set(value: VectorLike, ...args: number[]): this;
+    equals(value: VectorLike): boolean;
+    clone(): this;
+    protected _emitUpdate(array: number[]): void;
+    protected _onUpdate(_array: number[]): void;
+    toArray(): number[];
+    toName(): string;
+}
+
+type MatrixLike = number | number[] | Matrix;
+type MatrixOperateOutput = number[] | Matrix | Vector;
+declare abstract class Matrix extends EventEmitter {
+    readonly rows: number;
+    readonly cols: number;
+    protected _array: number[];
+    get length(): number;
+    constructor(rows: number, cols: number, array?: number[]);
+    protected _operate(operator: string, target: MatrixLike | Vector, output?: MatrixOperateOutput): any;
+    identity(): this;
+    clone(): this;
+    set(value: MatrixLike): this;
+    multiply<T extends Vector>(value: T): T;
+    multiply(value: MatrixLike): this;
+    multiply<T extends MatrixOperateOutput>(value: MatrixLike, output: T): T;
+    onUpdate(callback: (array: number[]) => void): this;
+    offUpdate(callback: (array: number[]) => void): this;
+    protected _emitUpdate(array: number[]): void;
+    protected _onUpdate(_array: number[]): void;
+    toArray(transpose?: boolean): number[];
+    toName(): string;
+    toJSON(): number[];
+}
+
+/**
+ * Matrix4
+ *
+ * | x0 | y0 | z0 | m0 |
+ * | x1 | y1 | z1 | m1 |
+ * | x2 | y2 | z2 | m2 |
+ */
+declare class Matrix4 extends Matrix {
+    constructor(array?: number[]);
+}
+
+/**
+ * Vector4
+ */
+declare class Vector4 extends Vector {
+    constructor(x?: number, y?: number, z?: number, m?: number);
+}
+
+/**
+ * Matrix4(4x5)
+ *
+ * | r0 | g0 | b0 | a0 | tr |
+ * | r1 | g1 | b1 | a1 | tg |
+ * | r2 | g2 | b2 | a2 | tb |
+ * | r3 | g3 | b3 | a3 | ta |
+ */
+declare class ColorMatrix extends Matrix {
+    constructor(array?: number[]);
+    hueRotate(angle?: number): this;
+    saturate(amount?: number): this;
+    brightness(amount?: number): this;
+    contrast(amount?: number): this;
+    invert(amount?: number): this;
+    sepia(amount?: number): this;
+    opacity(amount?: number): this;
+    grayscale(amount?: number): this;
+    multiply(target: number[]): this;
+    toMatrix4(): Matrix4;
+    toVector4(): Vector4;
+}
+
+/**
+ * Matrix2
+ *
+ * | x0 | y0 |
+ * | x1 | y1 |
+ */
+declare class Matrix2 extends Matrix {
+    constructor(array?: number[]);
+}
+
+/**
+ * Matrix3
+ *
+ * | x0 | y0 | z0 |
+ * | x1 | y1 | z1 |
+ * | x2 | y2 | z2 |
+ */
+declare class Matrix3 extends Matrix {
+    constructor(array?: number[]);
+    invert(): this;
+}
+
+declare class Projection2D extends Matrix3 {
+    protected _x: number;
+    protected _y: number;
+    protected _width: number;
+    protected _height: number;
+    protected _flipY: boolean;
+    constructor(_x?: number, _y?: number, _width?: number, _height?: number, _flipY?: boolean);
+    flipY(flipY: boolean): this;
+    translate(x: number, y: number): this;
+    resize(width: number, height: number): this;
+    protected _performUpdateArray(): void;
+}
+
+/**
+ * Vector2
+ */
+declare class Vector2 extends Vector {
+    get x(): number;
+    set x(val: number);
+    get y(): number;
+    set y(val: number);
+    get width(): number;
+    set width(val: number);
+    get height(): number;
+    set height(val: number);
+    constructor(x?: VectorLike, y?: number);
+    update(x: number, y: number): this;
+    getLength(): number;
+    getAngle(): number;
+    distanceTo(point: Vector2): number;
+    normalize(): this;
+    static lerp(a: VectorLike, b: VectorLike, t: number): Vector2;
+}
+
+declare class Rect2 {
+    get x(): number;
+    get y(): number;
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    get width(): number;
+    get height(): number;
+    readonly end: Vector2;
+    readonly position: Vector2;
+    readonly size: Vector2;
+    constructor(from: Rect2);
+    constructor(position: Vector2, size: Vector2);
+    constructor(x: number, y: number, width: number, height: number);
+    update(): this;
+    toArray(): number[];
+}
+
+interface Transform2DObject {
+    a: number;
+    c: number;
+    tx: number;
+    b: number;
+    d: number;
+    ty: number;
+    tz: number;
+}
+/**
+ * Transform
+ *
+ * | a | c | tx|
+ * | b | d | ty|
+ * | 0 | 0 | 1 |
+ */
+declare class Transform2D extends Matrix3 {
+    autoUpdate: boolean;
+    protected _cx: number;
+    protected _sx: number;
+    protected _cy: number;
+    protected _sy: number;
+    protected _translateX: number;
+    protected _translateY: number;
+    protected _translateZ: number;
+    protected _scaleX: number;
+    protected _scaleY: number;
+    protected _skewX: number;
+    protected _skewY: number;
+    protected _rotate: number;
+    dirtyId: number;
+    protected _needsUpdateArray: boolean;
+    protected _needsUpdateFields: boolean;
+    constructor(autoUpdate?: boolean);
+    protected _onUpdate(array: number[]): void;
+    protected _updateSkew(): void;
+    protected _requestUpdateArray(): void;
+    protected _requestUpdateFields(): void;
+    protected _performUpdateArray(): void;
+    protected _performUpdateFields(): void;
+    skew(x: number, y: number): this;
+    skewX(x: number): this;
+    skewY(y: number): this;
+    translate(x: number, y: number, z?: number): this;
+    translateX(x: number): this;
+    translateY(y: number): this;
+    translateZ(z: number): this;
+    translate3d(x: number, y: number, z: number): this;
+    scale(x: number, y: number, _z?: number): this;
+    scaleX(x: number): this;
+    scaleY(y: number): this;
+    scale3d(x: number, y: number, z: number): this;
+    rotate(rad: number): this;
+    rotateX(x: number): this;
+    rotateY(y: number): this;
+    rotateZ(z: number): this;
+    rotate3d(x: number, y: number, z: number, rad: number): this;
+    protected _rotateToScale(rad: number): number;
+    protected _rotate3d(x: number, y: number, z: number, rad: number): number[];
+    applyToPoint(x: number, y: number): number[];
+    inverse(): this;
+    update(): boolean;
+    isIdentity(): boolean;
+    toObject(): Transform2DObject;
+}
+
+declare const DEG_TO_RAD: number;
+declare const RAD_TO_DEG: number;
+declare function clamp(min: number, val: number, max: number): number;
+declare function lerp(a: number, b: number, weight: number): number;
+declare const curves: {
+    adaptive: boolean;
+    maxLength: number;
+    minSegments: number;
+    maxSegments: number;
+    epsilon: number;
+    _segmentsCount(length: number, defaultSegments?: number): number;
+};
+
+/**
+ * Vector3
+ */
+declare class Vector3 extends Vector {
+    constructor();
+}
+
+interface MainLoopEventMap extends CoreObjectEventMap {
+    process: (delta: number) => void;
+}
+interface MainLoop {
+    on: (<K extends keyof MainLoopEventMap>(type: K, listener: MainLoopEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof MainLoopEventMap>(type: K, listener: MainLoopEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof EventListenerOptions>(type: K, ...args: Parameters<EventListenerOptions[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class MainLoop extends CoreObject {
+    fps: number;
+    speed: number;
+    protected _starting: boolean;
+    protected _nextDeltaTime: number;
+    get starting(): boolean;
+    get spf(): number;
+    constructor();
+    start(process: (delta: number) => void): this;
+    stop(): this;
+    protected _onNextTick(): void;
+}
+
+interface CssFunctionArg {
+    unit: string | null;
+    value: string;
+    intValue: number;
+    normalizedIntValue: number;
+    normalizedDefaultIntValue: number;
+}
+interface CssFunction {
+    name: string;
+    args: CssFunctionArg[];
+}
+interface ParseArgumentContext {
+    index?: number;
+    fontSize?: number;
+    width?: number;
+    height?: number;
+}
+declare function getDefaultCssPropertyValue<T extends CssFunctionArg | CssFunction[]>(value: T): T;
+declare function parseCssProperty(name: string, propertyValue: string, context?: ParseArgumentContext): CssFunctionArg | CssFunction[];
+declare function parseCssFunctions(propertyValue: string, context?: ParseArgumentContext): CssFunction[];
+
+declare const SUPPORTS_WEBGL2: boolean;
+declare const SUPPORTS_IMAGE_BITMAP: boolean;
+declare const SUPPORTS_RESIZE_OBSERVER: boolean;
+declare const SUPPORTS_POINTER_EVENTS: boolean;
+declare const SUPPORTS_WHEEL_EVENTS: boolean;
+declare const SUPPORTS_MOUSE_EVENTS: boolean;
+declare const SUPPORTS_TOUCH_EVENTS: boolean;
+declare const SUPPORTS_CLICK_EVENTS: boolean;
+declare const SUPPORTS_CREATE_IMAGE_BITMAP: boolean;
+declare const SUPPORTS_AUDIO_CONTEXT: boolean;
+declare const SUPPORTS_WEBKIT_AUDIO_CONTEXT: boolean;
+declare const SUPPORTS_OFFLINE_AUDIO_CONTEXT: boolean;
+declare const SUPPORTS_WEBKIT_OFFLINE_AUDIO_CONTEXT: boolean;
+declare const SUPPORTS_WEB_AUDIO: boolean;
+declare const IN_BROWSER: boolean;
+declare const DEVICE_PIXEL_RATIO: number;
+declare const isElementNode: (node: unknown) => node is Element;
+declare const isVideoElement: (node: unknown) => node is HTMLVideoElement;
+declare const isImageElement: (node: unknown) => node is HTMLImageElement;
+declare function isCanvasElement(node: unknown): node is HTMLCanvasElement;
+declare function isWebgl2(gl: unknown): gl is WebGL2RenderingContext;
+declare function createHTMLCanvas(): HTMLCanvasElement | undefined;
+declare function determineCrossOrigin(url: string, loc?: Location): string;
+declare function crossOrigin(element: HTMLImageElement | HTMLVideoElement, url: string, crossorigin: boolean | string | null): void;
+
+declare class RawWeakMap<K extends WeakKey = WeakKey, V = any> {
+    protected _map: WeakMap<K, V>;
+    protected _toRaw(value: any): any;
+    /**
+     * Removes the specified element from the WeakMap.
+     * @returns true if the element was successfully removed, or false if it was not present.
+     */
+    delete(key: K): boolean;
+    /**
+     * @returns a specified element.
+     */
+    get(key: K): V | undefined;
+    /**
+     * @returns a boolean indicating whether an element with the specified key exists or not.
+     */
+    has(key: K): boolean;
+    /**
+     * Adds a new element with a specified key and value.
+     * @param key Must be an object or symbol.
+     */
+    set(key: K, value: V): this;
+}
+
+declare const PI: number;
+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;
+    pixelRatio: number;
+    readonly screen: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    readonly related: RawWeakMap<object, any>;
+    getRelated<T>(source: object, createFn?: () => T): T;
+    resize(width: number, height: number, updateStyle?: boolean): void;
+}
+
+type WebGLBufferTarget = 'array_buffer' | 'element_array_buffer';
+interface WebGLBufferOptions {
+    target?: WebGLBufferTarget;
+    usage?: WebGLBufferUsage;
+    data: BufferSource | number[] | null;
+}
+type WebGLBufferUsage = 'static_draw' | 'dynamic_draw';
+interface WebGLBufferMeta {
+    id: number;
+    target?: WebGLBufferTarget;
+    usage?: WebGLBufferUsage;
+    length: number;
+    byteLength: number;
+    bytesPerElement: number;
+}
+type WebGLDrawMode = 'points' | 'line_strip' | 'line_loop' | 'lines' | 'triangle_strip' | 'triangle_fan' | 'triangles';
+interface WebGLDrawOptions {
+    mode?: WebGLDrawMode;
+    count?: number;
+    first?: number;
+    bytesPerElement?: number;
     instanceCount?: number;
 }
 interface WebGLExtensions {
@@ -399,14 +913,7 @@ declare class WebGLState {
     set blendMode(value: WebGLBlendMode);
     get polygonOffset(): number;
     set polygonOffset(value: number);
-    constructor(options?: {
-        blend?: boolean;
-        offsets?: boolean;
-        culling?: boolean;
-        depthTest?: boolean;
-        clockwiseFrontFace?: boolean;
-        depthMask?: boolean;
-    });
+    constructor(options?: Partial<WebGLState>);
 }
 declare class WebGLStateModule extends WebGLModule {
     install(renderer: WebGLRenderer): void;
@@ -436,7 +943,7 @@ interface Batchable2D {
     uvs?: number[];
     texture?: WebGLTexture;
     backgroundColor?: number;
-    tint?: number;
+    modulate?: number;
     colorMatrix?: ArrayLike<number>;
     colorMatrixOffset?: ArrayLike<number>;
     blendMode?: WebGLBlendMode;
@@ -451,7 +958,7 @@ declare class WebGLBatch2DModule extends WebGLModule {
     protected _batchSize: number;
     protected _vertexSize: number;
     protected _drawCallUid: number;
-    protected _defaultTint: number;
+    protected _defaultModulate: number;
     protected _defaultBackgroundColor: number;
     protected _defaultColorMatrixOffset: number[];
     protected _defaultColorMatrix: number[];
@@ -638,46 +1145,6 @@ declare class WebGLViewportModule extends WebGLModule {
     reset(): void;
 }
 
-interface ReferenceEventMap extends _ObjectEventMap {
-}
-interface Reference {
-    on: (<K extends keyof ReferenceEventMap>(type: K, listener: ReferenceEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    off: (<K extends keyof ReferenceEventMap>(type: K, listener: ReferenceEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    emit: (<K extends keyof ReferenceEventMap>(type: K, ...args: Parameters<ReferenceEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
-}
-/**
- * Reference 是 Object 的子类，提供了对对象的引用计数功能。
- * 这使得它成为 Godot 中处理资源（如纹理、音频文件）和某些类的基础。
- * 与普通对象不同，Reference 类的对象会进行引用计数，直到没有任何引用时才会被销毁。
- *
- * 功能和用途：
- *  • 提供自动内存管理，避免了内存泄漏。
- *  • 经常被用作 资源类（如 Resource 和其子类）和某些非节点类型的对象。
- */
-declare class Reference extends _Object {
-    protected _refCount: number;
-}
-
-interface ResourceEventMap extends ReferenceEventMap {
-}
-interface Resource {
-    on: (<K extends keyof ResourceEventMap>(type: K, listener: ResourceEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    off: (<K extends keyof ResourceEventMap>(type: K, listener: ResourceEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    emit: (<K extends keyof ResourceEventMap>(type: K, ...args: Parameters<ResourceEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
-}
-/**
- * Resource 是继承自 Reference 的类，是所有资源类型的基类。
- * 它用于存储各种可重用的资源，如纹理、材质、音效、脚本等。
- * Resource 类的主要功能是为资源提供序列化和管理支持，使得这些资源能够被保存、加载和共享。
- *
- * 功能和用途：
- *  • 序列化支持：Resource 支持将资源序列化为文件并保存到磁盘，通常以 .tres 或 .res 格式存储。
- *  • 资源加载和引用：可以在多个地方引用同一个资源实例，资源本身是共享的。当一个 Resource 实例被加载时，它不会创建多个副本，而是通过引用计数来管理其生命周期。
- *  • 可重用性：资源是可以在多个场景中共享的，例如一个纹理资源可以在多个 Sprite 节点中使用，而不需要重新加载。
- */
-declare class Resource extends Reference {
-}
-
 interface MaterialOptions {
     vert?: string;
     frag?: string;
@@ -707,7 +1174,7 @@ declare class IndexBuffer extends Resource {
     _glBufferOptions(): WebGLBufferOptions;
     /** @internal */
     _glBuffer(renderer: WebGLRenderer): WebGLBuffer;
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     upload(renderer: WebGLRenderer): boolean;
 }
 
@@ -724,371 +1191,117 @@ declare class VertexBuffer extends Resource {
     _glBufferOptions(): WebGLBufferOptions;
     /** @internal */
     _glBuffer(renderer: WebGLRenderer): WebGLBuffer;
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     upload(renderer: WebGLRenderer): boolean;
 }
 
-interface VertexAttributeOptions {
-    buffer?: VertexBuffer;
-    size?: number;
-    normalized?: boolean;
-    type?: 'float' | 'unsigned_byte' | 'unsigned_short';
-    stride?: number;
-    offset?: number;
-    divisor?: number;
-}
-declare class VertexAttribute extends Resource {
-    buffer: VertexBuffer;
-    size: number;
-    normalized: boolean;
-    type: 'float' | 'unsigned_byte' | 'unsigned_short';
-    stride?: number;
-    offset?: number;
-    divisor?: number;
-    needsUpload: boolean;
-    constructor(options?: VertexAttributeOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
-    upload(): boolean;
-}
-
-interface GeometryOptions {
-    vertexAttributes?: Record<string, VertexAttribute>;
-    indexBuffer?: IndexBuffer;
-    instanceCount?: number;
-    mode?: WebGLDrawMode;
-}
-declare class Geometry extends Resource {
-    vertexAttributes: Map<string, VertexAttribute>;
-    indexBuffer?: IndexBuffer;
-    instanceCount?: number;
-    mode: WebGLDrawMode;
-    protected _materialWeakMap: RawWeakMap<Material, Record<string, any>>;
-    constructor(options?: GeometryOptions);
-    /** @internal */
-    _glVertexArray(renderer: WebGLRenderer): WebGLVertexArrayObjectOptions;
-    /** @internal */
-    _glVertexArrayObject(renderer: WebGLRenderer, material: Material): WebGLVertexArrayObject | null;
-    draw(renderer: WebGLRenderer, material: Material, uniforms?: Record<string, any>): void;
-}
-
-declare class QuadGeometry extends Geometry {
-    constructor();
-}
-
-declare class UvMaterial extends Material {
-    protected static _instance: UvMaterial;
-    static get instance(): UvMaterial;
-    constructor();
-}
-
-declare class QuadUvGeometry extends Geometry {
-    protected static _instance: QuadUvGeometry;
-    static get instance(): QuadUvGeometry;
-    static draw(renderer: WebGLRenderer, material?: Material, uniforms?: Record<string, any>): void;
-    constructor();
-}
-
-declare class UvGeometry extends Geometry {
-    positionBuffer: VertexBuffer;
-    uvBuffer: VertexBuffer;
-    constructor();
-    update(vertices: Float32Array, uvs: Float32Array, indices: Uint16Array): this;
-}
-
-interface MainLoopEventMap extends _ObjectEventMap {
-    process: (delta: number) => void;
-}
-interface MainLoop {
-    on: (<K extends keyof MainLoopEventMap>(type: K, listener: MainLoopEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    off: (<K extends keyof MainLoopEventMap>(type: K, listener: MainLoopEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    emit: (<K extends keyof EventListenerOptions>(type: K, ...args: Parameters<EventListenerOptions[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
-}
-declare class MainLoop extends _Object {
-    fps: number;
-    speed: number;
-    protected _starting: boolean;
-    protected _nextDeltaTime: number;
-    get starting(): boolean;
-    get spf(): number;
-    constructor();
-    start(process: (delta: number) => void): this;
-    stop(): this;
-    protected _onNextTick(): void;
-}
-
-interface RenderCall {
-    renderable: Node;
-    fn: (renderer: WebGLRenderer, next: () => void) => void;
-    parentCall: RenderCall | undefined;
-    calls: RenderCall[];
-}
-declare class RenderStack {
-    currentCall?: RenderCall;
-    calls: RenderCall[];
-    createCall(renderable: Node): RenderCall;
-    push(renderable: Node): RenderCall;
-    render(renderer: WebGLRenderer): void;
-}
-
-interface TimerEventMap extends NodeEventMap {
-    update: (current: number, delta: number) => void;
-}
-interface TimerOptions extends NodeOptions {
-    start?: number;
-    current?: number;
-    end?: number;
-    loop?: boolean;
-}
-interface Timer {
-    on: (<K extends keyof TimerEventMap>(type: K, listener: TimerEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    off: (<K extends keyof TimerEventMap>(type: K, listener: TimerEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
-    emit: (<K extends keyof TimerEventMap>(type: K, ...args: Parameters<TimerEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
-}
-declare class Timer extends Node {
-    start: number;
-    current: number;
-    end: number;
-    loop: boolean;
-    static from(range: number | number[]): Timer;
-    constructor(options?: TimerOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
-    addTime(delta: number): this;
-    protected _process(delta: number): void;
-}
-
-type VectorLike = number | number[] | Matrix | Vector;
-type VectorOperateOutput = number[] | Vector;
-declare abstract class Vector extends EventEmitter {
-    readonly dim: number;
-    protected _array: number[];
-    get length(): number;
-    constructor(dim: number);
-    protected _operate(operator: '+' | '-' | '*' | '/' | 'rot' | '==' | '=' | string, target: VectorLike, output?: VectorOperateOutput): any;
-    add(value: VectorLike): this;
-    add<T extends VectorOperateOutput>(value: VectorLike, output: T): T;
-    sub(value: VectorLike): this;
-    sub<T extends VectorOperateOutput>(value: VectorLike, output: T): T;
-    multiply(value: VectorLike): this;
-    multiply<T extends VectorOperateOutput>(value: VectorLike, output: T): T;
-    divide(value: VectorLike): this;
-    divide<T extends VectorOperateOutput>(value: VectorLike, output: T): T;
-    rotate(angle: number): this;
-    rotate<T extends VectorOperateOutput>(angle: number, output: T): T;
-    set(value: VectorLike, ...args: number[]): this;
-    equals(value: VectorLike): boolean;
-    clone(): this;
-    onUpdate(callback: (array: number[]) => void): this;
-    offUpdate(callback: (array: number[]) => void): this;
-    protected _emitUpdate(array: number[]): void;
-    protected _onUpdate(_array: number[]): void;
-    toArray(): number[];
-    toName(): string;
-}
-
-type MatrixLike = number | number[] | Matrix;
-type MatrixOperateOutput = number[] | Matrix | Vector;
-declare abstract class Matrix extends EventEmitter {
-    readonly rows: number;
-    readonly cols: number;
-    protected _array: number[];
-    get length(): number;
-    constructor(rows: number, cols: number, array?: number[]);
-    protected _operate(operator: string, target: MatrixLike | Vector, output?: MatrixOperateOutput): any;
-    identity(): this;
-    clone(): this;
-    set(value: MatrixLike): this;
-    multiply<T extends Vector>(value: T): T;
-    multiply(value: MatrixLike): this;
-    multiply<T extends MatrixOperateOutput>(value: MatrixLike, output: T): T;
-    onUpdate(callback: (array: number[]) => void): this;
-    offUpdate(callback: (array: number[]) => void): this;
-    protected _emitUpdate(array: number[]): void;
-    protected _onUpdate(_array: number[]): void;
-    toArray(transpose?: boolean): number[];
-    toName(): string;
-    toJSON(): number[];
-}
-
-/**
- * Matrix2
- *
- * | x0 | y0 |
- * | x1 | y1 |
- */
-declare class Matrix2 extends Matrix {
-    constructor(array?: number[]);
-}
-
-/**
- * Matrix3
- *
- * | x0 | y0 | z0 |
- * | x1 | y1 | z1 |
- * | x2 | y2 | z2 |
- */
-declare class Matrix3 extends Matrix {
-    constructor(array?: number[]);
-    invert(): this;
-}
-
-/**
- * Matrix4
- *
- * | x0 | y0 | z0 | m0 |
- * | x1 | y1 | z1 | m1 |
- * | x2 | y2 | z2 | m2 |
- */
-declare class Matrix4 extends Matrix {
-    constructor(array?: number[]);
+interface VertexAttributeOptions {
+    buffer?: VertexBuffer;
+    size?: number;
+    normalized?: boolean;
+    type?: 'float' | 'unsigned_byte' | 'unsigned_short';
+    stride?: number;
+    offset?: number;
+    divisor?: number;
 }
-
-declare class Projection2D extends Matrix3 {
-    protected _x: number;
-    protected _y: number;
-    protected _width: number;
-    protected _height: number;
-    protected _flipY: boolean;
-    constructor(_x?: number, _y?: number, _width?: number, _height?: number, _flipY?: boolean);
-    flipY(flipY: boolean): this;
-    translate(x: number, y: number): this;
-    resize(width: number, height: number): this;
-    protected _performUpdateArray(): void;
+declare class VertexAttribute extends Resource {
+    buffer: VertexBuffer;
+    size: number;
+    normalized: boolean;
+    type: 'float' | 'unsigned_byte' | 'unsigned_short';
+    stride?: number;
+    offset?: number;
+    divisor?: number;
+    needsUpload: boolean;
+    constructor(options?: VertexAttributeOptions);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    upload(): boolean;
 }
 
-interface Transform2DObject {
-    a: number;
-    c: number;
-    tx: number;
-    b: number;
-    d: number;
-    ty: number;
-    tz: number;
+interface GeometryOptions {
+    vertexAttributes?: Record<string, VertexAttribute>;
+    indexBuffer?: IndexBuffer;
+    instanceCount?: number;
+    mode?: WebGLDrawMode;
 }
-/**
- * Transform
- *
- * | a | c | tx|
- * | b | d | ty|
- * | 0 | 0 | 1 |
- */
-declare class Transform2D extends Matrix3 {
-    autoUpdate: boolean;
-    protected _cx: number;
-    protected _sx: number;
-    protected _cy: number;
-    protected _sy: number;
-    protected _translateX: number;
-    protected _translateY: number;
-    protected _translateZ: number;
-    protected _scaleX: number;
-    protected _scaleY: number;
-    protected _skewX: number;
-    protected _skewY: number;
-    protected _rotate: number;
-    dirtyId: number;
-    protected _needsUpdateArray: boolean;
-    protected _needsUpdateFields: boolean;
-    constructor(autoUpdate?: boolean);
-    protected _onUpdate(array: number[]): void;
-    protected _updateSkew(): void;
-    protected _requestUpdateArray(): void;
-    protected _requestUpdateFields(): void;
-    protected _performUpdateArray(): void;
-    protected _performUpdateFields(): void;
-    skew(x: number, y: number): this;
-    skewX(x: number): this;
-    skewY(y: number): this;
-    translate(x: number, y: number, z?: number): this;
-    translateX(x: number): this;
-    translateY(y: number): this;
-    translateZ(z: number): this;
-    translate3d(x: number, y: number, z: number): this;
-    scale(x: number, y: number, _z?: number): this;
-    scaleX(x: number): this;
-    scaleY(y: number): this;
-    scale3d(x: number, y: number, z: number): this;
-    rotate(rad: number): this;
-    rotateX(x: number): this;
-    rotateY(y: number): this;
-    rotateZ(z: number): this;
-    rotate3d(x: number, y: number, z: number, rad: number): this;
-    protected _rotateToScale(rad: number): number;
-    protected _rotate3d(x: number, y: number, z: number, rad: number): number[];
-    applyToPoint(x: number, y: number): number[];
-    inverse(): this;
-    update(): boolean;
-    isIdentity(): boolean;
-    toObject(): Transform2DObject;
+declare class Geometry extends Resource {
+    vertexAttributes: Map<string, VertexAttribute>;
+    indexBuffer?: IndexBuffer;
+    instanceCount?: number;
+    mode: WebGLDrawMode;
+    protected _materialWeakMap: RawWeakMap<Material, Record<string, any>>;
+    constructor(options?: GeometryOptions);
+    /** @internal */
+    _glVertexArray(renderer: WebGLRenderer): WebGLVertexArrayObjectOptions;
+    /** @internal */
+    _glVertexArrayObject(renderer: WebGLRenderer, material: Material): WebGLVertexArrayObject | null;
+    draw(renderer: WebGLRenderer, material: Material, uniforms?: Record<string, any>): void;
 }
 
-declare const DEG_TO_RAD: number;
-declare const RAD_TO_DEG: number;
-declare function clamp(min: number, val: number, max: number): number;
-declare function lerp(a: number, b: number, weight: number): number;
-declare const curves: {
-    adaptive: boolean;
-    maxLength: number;
-    minSegments: number;
-    maxSegments: number;
-    epsilon: number;
-    _segmentsCount(length: number, defaultSegments?: number): number;
-};
+declare class QuadGeometry extends Geometry {
+    constructor();
+}
 
-/**
- * Vector2
- */
-declare class Vector2 extends Vector {
-    get x(): number;
-    set x(val: number);
-    get y(): number;
-    set y(val: number);
-    get width(): number;
-    set width(val: number);
-    get height(): number;
-    set height(val: number);
-    constructor(x?: VectorLike, y?: number);
-    update(x: number, y: number): this;
-    getLength(): number;
-    getAngle(): number;
-    distanceTo(point: Vector2): number;
-    normalize(): this;
-    static lerp(a: VectorLike, b: VectorLike, t: number): Vector2;
+declare class EffectMaterial extends Material {
+    vert: string;
+    readonly uniforms: Map<string, any>;
+    static RE: {
+        getColor: RegExp;
+        getFromColor: RegExp;
+        getToColor: RegExp;
+        transform: RegExp;
+        transition: RegExp;
+    };
+    has: {
+        getColor: boolean;
+        getFromColor: boolean;
+        getToColor: boolean;
+        transform: boolean;
+        transition: boolean;
+    };
+    constructor(glsl: string);
 }
 
-/**
- * Vector3
- */
-declare class Vector3 extends Vector {
+declare class UvMaterial extends Material {
+    protected static _instance: UvMaterial;
+    static get instance(): UvMaterial;
     constructor();
 }
 
-/**
- * Vector4
- */
-declare class Vector4 extends Vector {
-    constructor(x?: number, y?: number, z?: number, m?: number);
+declare class QuadUvGeometry extends Geometry {
+    protected static _instance: QuadUvGeometry;
+    static get instance(): QuadUvGeometry;
+    static draw(renderer: WebGLRenderer, material?: Material, uniforms?: Record<string, any>): void;
+    constructor();
+}
+
+declare class UvGeometry extends Geometry {
+    positionBuffer: VertexBuffer;
+    uvBuffer: VertexBuffer;
+    constructor();
+    update(vertices: Float32Array, uvs: Float32Array, indices: Uint16Array): this;
 }
 
-type TextureFilterMode = WebGLTextureFilterMode;
-type TextureWrapMode = WebGLTextureWrapMode;
-interface TexturePixelsSource {
+type Texture2DFilterMode = WebGLTextureFilterMode;
+type Texture2DWrapMode = WebGLTextureWrapMode;
+interface Texture2DPixelsSource {
     width: number;
     height: number;
     pixels: Uint8Array | null;
 }
-type TextureSource = TexImageSource | TexturePixelsSource;
-declare class Texture<T extends TextureSource = TextureSource> extends Resource {
-    static get EMPTY(): Texture;
-    static get WHITE(): Texture;
-    static get BLACK(): Texture;
-    static get RED(): Texture;
-    static get GREEN(): Texture;
-    static get BLUE(): Texture;
+type Texture2DSource = TexImageSource | Texture2DPixelsSource;
+declare class Texture2D<T extends Texture2DSource = Texture2DSource> extends Resource {
+    static get EMPTY(): Texture2D;
+    static get WHITE(): Texture2D;
+    static get BLACK(): Texture2D;
+    static get RED(): Texture2D;
+    static get GREEN(): Texture2D;
+    static get BLUE(): Texture2D;
     source: T;
     width: number;
     height: number;
-    filterMode: TextureFilterMode;
-    wrapMode: TextureWrapMode;
+    filterMode: Texture2DFilterMode;
+    wrapMode: Texture2DWrapMode;
     pixelRatio: number;
     protected _isPowerOfTwo: boolean;
     protected _needsUpload: boolean;
@@ -1096,26 +1309,36 @@ declare class Texture<T extends TextureSource = TextureSource> extends Resource
     get realWidth(): number;
     get realHeight(): number;
     constructor(source: T);
-    protected _refreshPOT(): void;
     /** @internal */
     _glTextureOptions(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): WebGLTextureOptions;
     /** @internal */
     _glTexture(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): WebGLTexture;
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updatePOT(): void;
     protected _updateSize(): void;
     requestUpload(): void;
     upload(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): boolean;
-    activate(renderer: WebGLRenderer, location?: number): void;
+    activate(renderer: WebGLRenderer, location?: number): boolean;
     inactivate(renderer: WebGLRenderer): void;
     destroy(): void;
 }
 
+declare class CanvasTexture extends Texture2D<HTMLCanvasElement> {
+    pixelRatio: number;
+    constructor(source?: HTMLCanvasElement);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+}
+
+declare class ColorTexture extends Texture2D {
+    constructor(value: ColorValue);
+}
+
 interface ImageTextureOptions {
     autoLoad?: boolean;
     useBitmap?: boolean;
     crossorigin?: boolean | string | null;
 }
-declare class ImageTexture extends Texture<HTMLImageElement> {
+declare class ImageTexture extends Texture2D<HTMLImageElement> {
     bitmap?: ImageBitmap;
     useBitmap: boolean;
     preserveBitmap: boolean;
@@ -1129,8 +1352,9 @@ declare class ImageTexture extends Texture<HTMLImageElement> {
     upload(renderer: WebGLRenderer): boolean;
 }
 
-declare class PixelsTexture extends Texture<TexturePixelsSource> {
-    constructor(pixels?: ArrayLike<number> | ArrayBufferLike | ArrayBufferView | null, width?: number, height?: number);
+declare class PixelsTexture extends Texture2D<Texture2DPixelsSource> {
+    constructor(pixels?: number[] | ArrayBufferLike | ArrayBufferView | null, width?: number, height?: number);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
 }
 
 interface VideoTextureOptions {
@@ -1146,7 +1370,7 @@ interface VideoTextureSource {
     src: string;
     mime: string;
 }
-declare class VideoTexture extends Texture<HTMLVideoElement> {
+declare class VideoTexture extends Texture2D<HTMLVideoElement> {
     autoUpdate: boolean;
     fps: number;
     static readonly mimeTypes: Map<string, string>;
@@ -1165,7 +1389,7 @@ declare class VideoTexture extends Texture<HTMLVideoElement> {
     protected _resolve?: (val: this) => void;
     protected _reject?: (event: ErrorEvent) => void;
     constructor(source: HTMLVideoElement | (string | VideoTextureSource)[] | string, options?: VideoTextureOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     protected _onPlayStart: () => void;
     protected _onPlayStop: () => void;
     protected _onCanPlay: () => void;
@@ -1179,19 +1403,176 @@ declare class VideoTexture extends Texture<HTMLVideoElement> {
     destroy(): void;
 }
 
-declare class ViewportTexture extends PixelsTexture {
+declare class ViewportTexture extends PixelsTexture {
+}
+
+type CanvasItemStyleFilterKey = 'hue-rotate' | 'saturate' | 'brightness' | 'contrast' | 'invert' | 'sepia' | 'opacity' | 'grayscale';
+type CanvasItemStyleFilter = Record<CanvasItemStyleFilterKey, number>;
+interface CanvasItemStyleProperties extends IDOCTextStyleDeclaration, IDOCTransformStyleDeclaration {
+    direction: 'inherit' | 'ltr' | 'rtl';
+    backgroundColor?: ColorValue;
+    backgroundImage?: string;
+    filter: string;
+    shadowColor: ColorValue;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    shadowBlur: number;
+    opacity: number;
+    borderWidth: number;
+    borderRadius: number;
+    borderColor: ColorValue;
+    borderStyle: string;
+    outlineWidth: number;
+    outlineOffset: number;
+    outlineColor: ColorValue;
+    outlineStyle: string;
+    visibility: Visibility;
+    overflow: Overflow;
+    pointerEvents: PointerEvents;
+}
+type PointerEvents = 'auto' | 'none';
+interface CanvasItemStyle extends CanvasItemStyleProperties {
+}
+declare class CanvasItemStyle extends Resource {
+    backgroundColor?: string;
+    backgroundImage?: string;
+    filter: string;
+    direction: 'inherit' | 'ltr' | 'rtl';
+    shadowColor: string;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    shadowBlur: number;
+    opacity: number;
+    borderWidth: number;
+    borderRadius: number;
+    borderColor: string;
+    borderStyle: string;
+    outlineWidth: number;
+    outlineOffset: number;
+    outlineColor: string;
+    outlineStyle: string;
+    visibility: Visibility;
+    overflow: Overflow;
+    pointerEvents: PointerEvents;
+    protected _backgroundColor: Color;
+    constructor(properties?: Partial<CanvasItemStyleProperties>);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    canPointeEvents(): boolean;
+    getComputedOpacity(): number;
+    getComputedBackgroundColor(): Color;
+    getComputedBackgroundImage(): Promise<Texture2D<ImageBitmap> | undefined>;
+    getComputedTransform(): Transform2D;
+    getComputedTransformOrigin(): number[];
+    getComputedFilter(): CanvasItemStyleFilter;
+    getComputedFilterColorMatrix(): ColorMatrix;
+}
+
+interface CanvasBatchable extends Batchable2D {
+    type: 'stroke' | 'fill';
+    texture?: Texture2D;
+}
+interface StrokedGraphics {
+    path: Path2D;
+    texture?: Texture2D;
+    textureTransform?: Transform2D;
+    style: LineStyle;
+}
+interface FilledGraphics {
+    path: Path2D;
+    texture?: Texture2D;
+    textureTransform?: Transform2D;
+}
+declare class CanvasContext extends Path2D {
+    textureTransform?: Transform2D;
+    fillStyle?: ColorValue | Texture2D;
+    strokeStyle?: ColorValue | Texture2D;
+    lineCap?: LineCap;
+    lineJoin?: LineJoin;
+    lineWidth?: number;
+    miterLimit?: number;
+    _defaultStyle: Texture2D<Texture2DSource>;
+    _stroke: StrokedGraphics[];
+    _fille: FilledGraphics[];
+    stroke(): void;
+    fillRect(x: number, y: number, width: number, height: number): void;
+    strokeRect(x: number, y: number, width: number, height: number): void;
+    fill(): void;
+    copy(source: CanvasContext): this;
+    reset(): this;
+    buildUvs(start: number, vertices: number[], uvs: number[], texture?: Texture2D, textureTransform?: Transform2D): void;
+    toBatchables(): CanvasBatchable[];
+}
+
+interface RenderCall {
+    renderable: Node;
+    fn: (renderer: WebGLRenderer, next: () => void) => void;
+    parentCall: RenderCall | undefined;
+    calls: RenderCall[];
+}
+declare class RenderStack extends Node {
+    currentCall?: RenderCall;
+    calls: RenderCall[];
+    createCall(renderable: Node): RenderCall;
+    push(renderable: Node): RenderCall;
+    render(renderer: WebGLRenderer): void;
+}
+
+interface TimelineEventMap extends NodeEventMap {
+    updateCurrentTime: (current: number, delta: number) => void;
+}
+interface TimelineProperties extends NodeProperties {
+    startTime: number;
+    currentTime: number;
+    endTime: number;
+    loop: boolean;
+}
+interface Timeline {
+    on: (<K extends keyof TimelineEventMap>(type: K, listener: TimelineEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof TimelineEventMap>(type: K, listener: TimelineEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof TimelineEventMap>(type: K, ...args: Parameters<TimelineEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class Timeline extends Node {
+    startTime: number;
+    currentTime: number;
+    endTime: number;
+    loop: boolean;
+    static from(range: number | number[], loop?: boolean): Timeline;
+    constructor(properties?: Partial<TimelineProperties>);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    addTime(delta: number): this;
+    protected _process(delta: number): void;
+}
+
+interface RectangulableEventMap {
+    updateRect: () => void;
+}
+interface Rectangulable {
+    on: (<K extends keyof RectangulableEventMap>(type: K, listener: RectangulableEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof RectangulableEventMap>(type: K, listener: RectangulableEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof RectangulableEventMap>(type: K, ...args: Parameters<RectangulableEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+interface Rectangulable {
+    getRect: () => Rect2;
 }
 
+interface ViewportEventMap extends NodeEventMap, RectangulableEventMap {
+}
 interface ViewportFramebuffer {
     texture: ViewportTexture;
     needsUpload: boolean;
 }
-declare class Viewport extends Node {
+interface Viewport {
+    on: (<K extends keyof ViewportEventMap>(type: K, listener: ViewportEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof ViewportEventMap>(type: K, listener: ViewportEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof ViewportEventMap>(type: K, ...args: Parameters<ViewportEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class Viewport extends Node implements Rectangulable {
     flipY: boolean;
     x: number;
     y: number;
     width: number;
     height: number;
+    get valid(): boolean;
     protected _projection: Projection2D;
     protected _framebufferIndex: number;
     protected _framebuffers: ViewportFramebuffer[];
@@ -1202,14 +1583,15 @@ declare class Viewport extends Node {
     _glFramebufferOptions(renderer: WebGLRenderer): WebGLFramebufferOptions;
     /** @internal */
     _glFramebuffer(renderer: WebGLRenderer): WebGLFramebuffer;
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     requestUpload(): void;
     resize(width: number, height: number): void;
     upload(renderer: WebGLRenderer): boolean;
-    activate(renderer: WebGLRenderer): void;
-    redraw(renderer: WebGLRenderer, cb: () => void): void;
+    activate(renderer: WebGLRenderer): boolean;
+    redraw(renderer: WebGLRenderer, cb: () => void): boolean;
     activateWithCopy(renderer: WebGLRenderer, target: Viewport): void;
     render(renderer: WebGLRenderer, next?: () => void): void;
+    getRect(): Rect2;
     toProjectionArray(transpose?: boolean): number[];
 }
 
@@ -1225,415 +1607,202 @@ interface SceneTree {
     emit: (<K extends keyof SceneTreeEventMap>(type: K, ...args: Parameters<SceneTreeEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
 }
 declare class SceneTree extends MainLoop {
+    paused: boolean;
+    backgroundColor?: ColorValue;
     readonly renderStack: RenderStack;
     readonly root: Viewport;
-    readonly timeline: Timer;
+    readonly timeline: Timeline;
+    protected _backgroundColor: Color;
     protected _currentViewport?: Viewport;
     getCurrentViewport(): Viewport | undefined;
     setCurrentViewport(viewport: Viewport | undefined): void;
+    constructor(timeline?: Timeline);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     protected _render(renderer: WebGLRenderer, delta?: number): this;
     protected _renderScreen(renderer: WebGLRenderer): void;
 }
 
-interface NodeEventMap extends ReferenceEventMap {
-    enterTree: () => void;
-    exitTree: () => void;
+interface NodeEventMap extends CoreObjectEventMap, InputEventMap {
+    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;
-    postEnterTree: () => void;
     ready: () => void;
-    treeEntered: () => void;
-    treeExiting: () => void;
-    treeExited: () => void;
-    parented: () => void;
-    unparented: () => void;
+    parented: (parent: Node) => void;
+    unparented: (oldParent: Node) => void;
+    processing: (delta?: number) => void;
     process: (delta?: number) => void;
+    processed: (delta?: number) => void;
     addChild: (child: Node) => void;
     removeChild: (child: Node, index: number) => void;
     moveChild: (child: Node, newIndex: number, oldIndex: number) => void;
 }
-declare enum InternalMode {
-    DEFAULT = 0,
-    FRONT = 1,
-    BACK = 2
-}
-interface NodeOptions {
-    name?: string;
-    mask?: Maskable;
-    visibility?: Visibility;
-    visibleDelay?: number;
-    visibleDuration?: number;
+type InternalMode = 'default' | 'front' | 'back';
+type ProcessMode = 'inherit' | 'pausable' | 'when_paused' | 'always' | 'disabled';
+type RenderMode = 'inherit' | 'always' | 'disabled';
+interface NodeProperties {
+    name: string;
+    processMode: ProcessMode;
+    renderMode: RenderMode;
+    internalMode: InternalMode;
+    mask: Maskable;
 }
 interface Node {
     on: (<K extends keyof NodeEventMap>(type: K, listener: NodeEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
     off: (<K extends keyof NodeEventMap>(type: K, listener: NodeEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
     emit: (<K extends keyof NodeEventMap>(type: K, ...args: Parameters<NodeEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
 }
-/**
- * Node 是所有节点的基类，提供了管理场景树的功能。
- * 在 Godot 中，节点代表了游戏中的元素或对象，所有的节点都是通过继承 Node 类来实现的。
- * Node 处理与场景树、节点的添加、删除、子父关系、以及输入事件等相关的操作。
- *
- * 功能和用途：
- *  • 管理节点在场景树中的位置和生命周期。
- *  • 节点可以有 子节点，并且可以通过 add_child() 方法将子节点添加到当前节点。
- *  • 支持 信号（signals）机制，用于事件通知。
- *  • 提供 生命周期方法，如 _ready()、_enter_tree()、_exit_tree() 等。
- *  • 支持 输入事件，通过 _input() 等方法来处理输入。
- */
-declare class Node extends Reference {
+declare class Node extends CoreObject {
     readonly tag: string;
-    renderable?: boolean;
     name: string;
     mask?: Maskable;
-    visibility: Visibility;
-    visibleDelay: number;
-    visibleDuration: number;
-    /** @internal */
-    _computedVisibleDelay: number;
-    _computedVisibleDuration: number;
-    _computedVisibility: Visibility;
-    /** @internal */
-    _internalMode: InternalMode;
+    processMode: ProcessMode;
+    renderMode: RenderMode;
+    internalMode: InternalMode;
     protected _readyed: boolean;
-    protected _tree?: SceneTree;
-    protected _parent?: Node;
-    protected _children: Node[];
-    get children(): Node[];
-    get visibleTimeline(): number[];
-    get visibleRelativeTime(): number;
-    get visibleProgress(): number;
-    get siblingIndex(): number;
-    set siblingIndex(toIndex: number);
-    get previousSibling(): Node | undefined;
-    get nextSibling(): Node | undefined;
-    get firstSibling(): Node | undefined;
-    get lastSibling(): Node | undefined;
-    constructor(options?: NodeOptions);
-    /** Meta */
-    protected _meta: Map<string, unknown>;
-    hasMeta(name: string): boolean;
-    getMeta<T = any>(name: string): T | undefined;
-    getMeta<T = any>(name: string, defaultVal: T): T;
-    setMeta(name: string, value: any): void;
-    deleteMeta(name: string): void;
-    clearMeta(): void;
+    constructor(properties?: Partial<NodeProperties>, children?: Node[]);
     /** Name */
+    getName(): string;
     setName(value: string): this;
     /** Tree */
+    protected _tree?: SceneTree;
+    get tree(): SceneTree | undefined;
+    set tree(tree: SceneTree | undefined);
     getTree(): SceneTree | undefined;
     getViewport(): Viewport | undefined;
     getWindow(): Viewport | undefined;
     isInsideTree(): boolean;
-    /** @internal */
-    _setTree(tree: SceneTree | undefined): this;
-    isRenderable(): boolean;
-    isVisible(): boolean;
-    protected _updateVisibility(): void;
-    protected _onEnterTree(): void;
-    protected _onExitTree(): void;
-    protected _onParented(): void;
-    protected _onUnparented(): void;
-    protected _onReady(): void;
-    protected _onProcess(delta?: number): void;
-    render(renderer: WebGLRenderer, next?: () => void): void;
-    input(event: UIEvent): void;
+    setTree(tree: SceneTree | undefined): this;
     /** Parent */
-    get parent(): Node | undefined;
-    hasParent(): boolean;
-    getParent(): Node | undefined;
-    /** @internal */
-    _setParent(parent: Node | undefined): this;
-    /** Children */
-    getChildren(includeInternal?: boolean | InternalMode): Node[];
-    getIndex(includeInternal?: boolean | InternalMode): number;
-    getNode<T extends Node>(path: string): T | undefined;
-    removeNode(path: string): void;
-    addSibling(sibling: Node): this;
-    addChild(child: Node, internalMode?: InternalMode): this;
-    moveChild(child: Node, toIndex: number, internalMode?: InternalMode): this;
-    removeChild(child: Node): this;
-    removeChildren(): void;
-    remove(): void;
-    forEach(fn: (child: Node) => void): this;
-    deepForEach(fn: (descendant: Node) => void): this;
-    is(target: Node | undefined | null): boolean;
-    protected _enterTree(): void;
-    protected _ready(): void;
-    protected _exitTree(): void;
-    protected _parented(): void;
-    protected _unparented(): void;
-    protected _process(_delta: number): void;
-    protected _input(_event: UIEvent): void;
-    protected _render(_renderer: WebGLRenderer): void;
-    toJSON(): Record<string, any>;
-    static parse(JSON: Record<string, any>[]): Node[];
-    static parse(JSON: Record<string, any>): Node;
-}
-
-declare function createNode<T extends Node>(tag?: string, options?: Record<string, any>): T;
-
-declare function nextTick(cb?: () => void): Promise<void>;
-
-type Callback = () => void;
-interface QueueItem {
-    cb: Callback;
-    once: boolean;
-}
-interface Options {
-    sort?: number;
-    once?: boolean;
-}
-declare class Ticker {
-    protected static _queue: QueueItem[][];
-    protected static _currentTime: number;
-    protected static _elapsed: number;
-    protected static _requestId?: number;
-    static get currentTime(): number;
-    static get elapsed(): number;
-    static on(cb: Callback, options?: Options): void;
-    static off(cb: Callback, options?: Options): void;
-    static start(): void;
-    static stop(): void;
-    protected static _update(time: number): void;
-    protected static _performUpdate(): void;
-}
-
-declare const linear: (amount: number) => number;
-declare const ease: (amount: number) => number;
-declare const easeIn: (amount: number) => number;
-declare const easeOut: (amount: number) => number;
-declare const easeInOut: (amount: number) => number;
-declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): (amount: number) => number;
-declare const timingFunctions: {
-    linear: (amount: number) => number;
-    ease: (amount: number) => number;
-    easeIn: (amount: number) => number;
-    easeOut: (amount: number) => number;
-    easeInOut: (amount: number) => number;
-};
-type TimingFunctions = typeof timingFunctions;
-type Easing = keyof TimingFunctions | `cubic-bezier(${string})`;
-interface Keyframe {
-    easing?: Easing;
-    offset?: number;
-    [property: string]: string | number | null | undefined;
-}
-interface NormalizedKeyframe {
-    easing: (amount: number) => number;
-    offset: number;
-    props: Record<string, any>;
-}
-interface AnimationOptions {
-    mode?: 'parent' | 'sibling';
-    startTime?: number;
-    duration?: number;
-    loop?: boolean;
-    keyframes?: Keyframe[];
-}
-declare class Animation2D extends Node {
-    mode: 'parent' | 'sibling';
-    loop: boolean;
-    keyframes: Keyframe[];
-    easing?: Easing;
-    delay: number;
-    duration: number;
-    protected _keyframes: NormalizedKeyframe[];
-    protected _starting: boolean;
-    protected _startProps: RawWeakMap<any, Map<string, any>>;
-    constructor(options?: AnimationOptions);
-    protected _enterTree(): void;
-    protected _exitTree(): void;
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
-    protected _getTargets(): any[];
-    protected _updateKeyframes(): void;
-    protected _onUpdateTime(): void;
-    protected _updateStartProps(): void;
-    protected _parseEasing(easing: Easing | undefined): (amount: number) => number;
-    protected _parseKeyframes(currentTime: number, startProps: Map<string, any>): [NormalizedKeyframe, NormalizedKeyframe] | null;
-    protected _commitStyle(currentTime: number, target: any, startProps: Map<string, any>, previous: NormalizedKeyframe, current: NormalizedKeyframe): void;
-    protected _getDiffValue(name: string, previous: string | undefined, current: string | undefined, weight: number, context: Record<string, any>): any;
-    cancel(): void;
-}
-
-type ColorValue = number | AnyColor;
-declare class Color {
-    protected _colord: Colord;
-    protected _value: ColorValue;
-    get value(): ColorValue;
-    set value(value: ColorValue);
-    get r8(): number;
-    get g8(): number;
-    get b8(): number;
-    get a8(): number;
-    get r(): number;
-    get g(): number;
-    get b(): number;
-    get a(): number;
-    get rgb(): number;
-    get bgr(): number;
-    get abgr(): number;
-    constructor(value?: ColorValue);
-    toArgb(alpha?: number, applyToRGB?: boolean): number;
-    toHex(): string;
-    toArray(): [number, number, number, number];
-}
-
-/**
- * Matrix4(4x5)
- *
- * | r0 | g0 | b0 | a0 | tr |
- * | r1 | g1 | b1 | a1 | tg |
- * | r2 | g2 | b2 | a2 | tb |
- * | r3 | g3 | b3 | a3 | ta |
- */
-declare class ColorMatrix extends Matrix {
-    constructor(array?: number[]);
-    hueRotate(angle?: number): this;
-    saturate(amount?: number): this;
-    brightness(amount?: number): this;
-    contrast(amount?: number): this;
-    invert(amount?: number): this;
-    sepia(amount?: number): this;
-    opacity(amount?: number): this;
-    grayscale(amount?: number): this;
-    multiply(target: number[]): this;
-    toMatrix4(): Matrix4;
-    toVector4(): Vector4;
-}
-
-declare class ColorTexture extends Texture {
-    constructor(value: ColorValue);
-}
-
-interface CanvasBatchable extends Batchable2D {
-    type: 'stroke' | 'fill';
-    texture?: Texture;
-}
-interface StrokedGraphics {
-    path: Path2D;
-    texture?: Texture;
-    textureTransform?: Transform2D;
-    style: LineStyle;
-}
-interface FilledGraphics {
-    path: Path2D;
-    texture?: Texture;
-    textureTransform?: Transform2D;
-}
-declare class CanvasContext extends Path2D {
-    textureTransform?: Transform2D;
-    fillStyle?: ColorValue | Texture;
-    strokeStyle?: ColorValue | Texture;
-    lineCap?: LineCap;
-    lineJoin?: LineJoin;
-    lineWidth?: number;
-    miterLimit?: number;
-    _defaultStyle: Texture<TextureSource>;
-    _stroke: StrokedGraphics[];
-    _fille: FilledGraphics[];
-    stroke(): void;
-    fillRect(x: number, y: number, width: number, height: number): void;
-    strokeRect(x: number, y: number, width: number, height: number): void;
-    fill(): void;
-    copy(source: CanvasContext): this;
-    reset(): this;
-    buildUvs(start: number, vertices: number[], uvs: number[], texture?: Texture, textureTransform?: Transform2D): void;
-    toBatchables(): CanvasBatchable[];
-}
-
-interface Style2DOptions extends Partial<Style2DBackgroundProperties>, Partial<Style2DFilterProperties>, Partial<Style2DTextProperties>, Partial<Style2DTransformProperties> {
-    shadowColor?: string;
-    shadowOffsetX?: number;
-    shadowOffsetY?: number;
-    shadowBlur?: number;
-    opacity?: number;
-    borderRadius?: number;
-    overflow?: Overflow;
-}
-interface Style2D extends Style2DBackgroundExtend, Style2DFilterExtend, Style2DTextExtend, Style2DTransformExtend {
-}
-declare class Style2D extends _Object {
-    shadowColor: string;
-    shadowOffsetX: number;
-    shadowOffsetY: number;
-    shadowBlur: number;
-    opacity: number;
-    borderRadius: number;
-    overflow: Overflow;
-    constructor(options?: Style2DOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
-}
-
-declare abstract class Style2DModule {
-    abstract install(Style2D: new () => Style2D): void;
-}
-
-interface Style2DBackgroundProperties {
-    backgroundColor?: string;
-    backgroundImage?: string;
-}
-interface Style2DBackgroundExtend extends Style2DBackgroundProperties {
-    getComputedBackgroundImage: typeof getComputedBackgroundImage;
-}
-declare class Style2DBackgroundModule extends Style2DModule {
-    install(Style2D: new () => Style2D): void;
+    protected _parent?: Node;
+    get parent(): Node | undefined;
+    set parent(parent: Node | undefined);
+    hasParent(): boolean;
+    getParent(): Node | undefined;
+    setParent(parent: Node | undefined): this;
+    /** Children */
+    protected _children: Node[];
+    get siblingIndex(): number;
+    set siblingIndex(toIndex: number);
+    get previousSibling(): Node | undefined;
+    get nextSibling(): Node | undefined;
+    get firstSibling(): Node | undefined;
+    get lastSibling(): Node | undefined;
+    /** Meta */
+    protected _meta: Map<string, unknown>;
+    hasMeta(name: string): boolean;
+    getMeta<T = any>(name: string): T | undefined;
+    getMeta<T = any>(name: string, defaultVal: T): T;
+    setMeta(name: string, value: any): void;
+    deleteMeta(name: string): void;
+    clearMeta(): void;
+    canProcess(): boolean;
+    canRender(): boolean;
+    protected _onTreeEnter(tree: SceneTree): void;
+    protected _onTreeExit(oldTree: SceneTree): void;
+    protected _onParented(parent: Node): void;
+    protected _onUnparented(oldParent: Node): void;
+    protected _onReady(): void;
+    protected _onProcess(delta?: number): void;
+    render(renderer: WebGLRenderer, next?: () => void): void;
+    input(event: InputEvent, key: InputEventKey): void;
+    /** Children */
+    getChildren(includeInternal?: boolean | InternalMode): Node[];
+    getIndex(includeInternal?: boolean | InternalMode): number;
+    getNode<T extends Node>(path: string): T | undefined;
+    removeNode(path: string): void;
+    addSibling(sibling: Node): this;
+    append(children: Node[]): this;
+    append(...children: Node[]): this;
+    addChild(child: Node, internalMode?: InternalMode): this;
+    moveChild(child: Node, toIndex: number, internalMode?: InternalMode): this;
+    removeChild(child: Node): this;
+    removeChildren(): void;
+    remove(): void;
+    forEach(fn: (child: Node) => void): this;
+    deepForEach(fn: (descendant: Node) => void): this;
+    is(target: Node | undefined | null): boolean;
+    /** override */
+    protected _ready(): void;
+    protected _treeEnter(tree: SceneTree): void;
+    protected _treeExit(oldTree: SceneTree): void;
+    protected _parented(parent: Node): void;
+    protected _unparented(oldParent: Node): void;
+    protected _process(delta: number): void;
+    protected _input(event: InputEvent, key: InputEventKey): void;
+    protected _render(renderer: WebGLRenderer): void;
+    toJSON(): Record<string, any>;
+    static parse(JSON: Record<string, any>[]): Node[];
+    static parse(JSON: Record<string, any>): Node;
 }
-declare function getComputedBackgroundImage(this: Style2D): Promise<Texture<ImageBitmap> | undefined>;
 
-type Style2DFilterKey = 'hue-rotate' | 'saturate' | 'brightness' | 'contrast' | 'invert' | 'sepia' | 'opacity' | 'grayscale';
-type Style2DFilter = Record<Style2DFilterKey, number>;
-interface Style2DFilterProperties {
-    filter: string;
-}
-interface Style2DFilterExtend extends Style2DFilterProperties {
-    getComputedFilter: typeof getComputedFilter;
-    getComputedFilterColorMatrix: typeof getComputedFilterColorMatrix;
-}
-declare class Style2DFilterModule extends Style2DModule {
-    install(Style2D: new () => Style2D): void;
+interface TimelineNodeProperties extends NodeProperties {
+    delay: number;
+    duration: number;
+    paused: boolean;
 }
-declare function getComputedFilter(this: Style2D): Style2DFilter;
-declare function getComputedFilterColorMatrix(this: Style2D): ColorMatrix;
-
-interface Style2DTextProperties extends IDOCTextStyleDeclaration {
-    direction: 'inherit' | 'ltr' | 'rtl';
+interface TimelineNodeEventMap extends NodeEventMap {
+    updateCurrentTime: (currentTime: number) => void;
 }
-interface Style2DTextExtend extends Style2DTextProperties {
+interface TimelineNode {
+    on: (<K extends keyof TimelineNodeEventMap>(type: K, listener: TimelineNodeEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof TimelineNodeEventMap>(type: K, listener: TimelineNodeEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof TimelineNodeEventMap>(type: K, ...args: Parameters<TimelineNodeEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
 }
-declare class Style2DTextModule extends Style2DModule {
-    install(Style2D: new () => Style2D): void;
+declare class TimelineNode extends Node {
+    delay: number;
+    duration: number;
+    paused: boolean;
+    constructor(properties?: Partial<TimelineNodeProperties>, children?: Node[]);
+    /** Timeline */
+    computedDuration: number;
+    protected _currentTime: number;
+    protected _startTime: number;
+    get timeline(): Timeline | undefined;
+    get timelineCurrentTime(): number;
+    get parentStartTime(): number;
+    get currentTime(): number;
+    get startTime(): number;
+    set startTime(val: number);
+    get endTime(): number;
+    get currentTimeProgress(): number;
+    isInsideTimeRange(): boolean;
+    protected _updateCurrentTime(force?: boolean): void;
+    protected _process(delta: number): void;
 }
 
-interface Style2DTransformProperties extends IDOCTransformStyleDeclaration {
-}
-interface Style2DTransformExtend extends Style2DTransformProperties {
-    getComputedTransform: typeof getComputedTransform;
-    getComputedTransformOrigin: typeof getComputedTransformOrigin;
+interface CanvasItemProperties extends TimelineNodeProperties {
+    visible: boolean;
+    style: Partial<CanvasItemStyleProperties>;
+    modulate: ColorValue;
+    blendMode: WebGLBlendMode;
 }
-declare class Style2DTransformModule extends Style2DModule {
-    install(Style2D: new () => Style2D): void;
+interface CanvasItemEventMap extends TimelineNodeEventMap {
+    updateStyleProperty: (key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration) => void;
+    draw: () => void;
 }
-declare function getComputedTransform(this: Style2D): Transform2D;
-declare function getComputedTransformOrigin(this: Style2D): number[];
-
-interface CanvasItemOptions extends NodeOptions {
-    style?: Style2DOptions;
-    tint?: string;
-    blendMode?: WebGLBlendMode;
+interface CanvasItem {
+    on: (<K extends keyof CanvasItemEventMap>(type: K, listener: CanvasItemEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof CanvasItemEventMap>(type: K, listener: CanvasItemEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof CanvasItemEventMap>(type: K, ...args: Parameters<CanvasItemEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
 }
-declare class CanvasItem extends Node {
-    tint?: ColorValue;
+declare class CanvasItem extends TimelineNode {
+    visible: boolean;
+    modulate?: ColorValue;
     blendMode?: WebGLBlendMode;
-    protected _style: Style2D;
-    get style(): Style2D;
-    set style(style: Style2D);
+    protected _style: CanvasItemStyle;
+    get style(): CanvasItemStyle;
+    set style(style: CanvasItemStyle);
     /** @internal */
     opacity: number;
     protected _parentOpacity?: number;
-    protected _tint: Color;
-    protected _backgroundColor: Color;
-    protected _backgroundImage?: Texture;
+    protected _modulate: Color;
+    protected _backgroundImage?: Texture2D;
+    _computedVisible: boolean;
     context: CanvasContext;
     protected _resetContext: boolean;
     protected _redrawing: boolean;
@@ -1642,14 +1811,18 @@ declare class CanvasItem extends Node {
     protected _originalBatchables: CanvasBatchable[];
     protected _layoutedBatchables: CanvasBatchable[];
     protected _batchables: CanvasBatchable[];
-    constructor(options?: CanvasItemOptions);
+    constructor(properties?: Partial<CanvasItemProperties>, children?: Node[]);
     setProperties(properties?: Record<PropertyKey, any>): this;
-    protected _onUpdateProperty(key: PropertyKey, newValue: any, oldValue: any, declaration?: PropertyDeclaration): void;
-    protected _onUpdateStyleProperty(key: PropertyKey, newValue: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     protected _updateBackgroundColor(): void;
     protected _updateBackgroundImage(): Promise<void>;
     protected _updateOpacity(): void;
-    isVisible(): boolean;
+    protected _updateVisible(): void;
+    show(): void;
+    hide(): void;
+    isVisibleInTree(): boolean;
+    canRender(): boolean;
     requestRedraw(): void;
     requestReflow(): void;
     requestRepaint(): void;
@@ -1657,7 +1830,11 @@ declare class CanvasItem extends Node {
     protected _draw(): void;
     protected _drawBackground(): void;
     protected _drawContent(): void;
+    protected _drawBorder(): void;
+    protected _drawOutline(): void;
+    protected _drawBoundingRect(): void;
     protected _fill(): void;
+    protected _stroke(): void;
     protected _relayout(batchables: CanvasBatchable[]): CanvasBatchable[];
     protected _reflow(batchables: CanvasBatchable[]): CanvasBatchable[];
     protected _repaint(batchables: CanvasBatchable[]): CanvasBatchable[];
@@ -1665,28 +1842,28 @@ declare class CanvasItem extends Node {
     toJSON(): Record<string, any>;
 }
 
-interface Node2DOptions extends CanvasItemOptions {
+interface Node2DProperties extends CanvasItemProperties {
 }
 declare class Node2D extends CanvasItem {
-    readonly _transform: Transform2D;
+    transform: Transform2D;
     protected _parentTransformDirtyId?: number;
-    constructor(options?: Node2DOptions);
-    getBoundingBox(): BoundingBox;
-    protected _onUpdateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
+    constructor(properties?: Partial<Node2DProperties>, children?: Node[]);
+    protected _updateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
     protected _updateTransform(): void;
     protected _updateOverflow(): void;
     protected _transformVertices(vertices: number[]): number[];
     protected _reflow(batchables: CanvasBatchable[]): CanvasBatchable[];
     protected _process(delta: number): void;
-    input(event: UIEvent): void;
+    protected _input(event: InputEvent, key: InputEventKey): void;
+    clone(): this;
 }
 
 declare class Graphics2D extends Node2D {
     protected _resetContext: boolean;
     lineCap?: LineCap;
     lineJoin?: LineJoin;
-    fillStyle?: ColorValue | Texture;
-    strokeStyle?: ColorValue | Texture;
+    fillStyle?: ColorValue | Texture2D;
+    strokeStyle?: ColorValue | Texture2D;
     lineWidth?: number;
     miterLimit?: number;
     rect: (x: number, y: number, width: number, height: number) => this;
@@ -1706,66 +1883,69 @@ declare class Graphics2D extends Node2D {
 }
 
 interface ImageFrame {
-    texture: Texture;
+    texture: Texture2D;
     duration: number;
 }
 declare class Image2DResource extends Resource {
     frames: ImageFrame[];
     duration: number;
-    constructor(source: Texture | ImageFrame[]);
+    constructor(source: Texture2D | ImageFrame[]);
     updateDuration(): this;
     destroy(): void;
 }
 
-interface Image2DOptions extends Node2DOptions {
-    src?: string;
-    gif?: boolean;
+interface Image2DProperties extends Node2DProperties {
+    src: string;
+    gif: boolean;
 }
 declare class Image2D extends Node2D {
     resource?: Image2DResource;
     gif: boolean;
     src: string;
-    get currentTexture(): Texture | undefined;
-    get duration(): number;
+    get currentTexture(): Texture2D | undefined;
+    get framesDuration(): number;
     get naturalWidth(): number;
     get naturalHeight(): number;
     get complete(): boolean;
     protected _frameIndex: number;
     protected _complete: boolean;
     protected _wait: Promise<void>;
-    constructor(options?: Image2DOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    constructor(properties?: Partial<Image2DProperties>, children?: Node[]);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     decode(): Promise<void>;
-    setResource(source: Texture | ImageFrame[] | Image2DResource): this;
+    setResource(source: Texture2D | ImageFrame[] | Image2DResource): this;
     protected _load(src: string): Promise<void>;
-    protected _getCurrentTime(): number;
+    protected _getFrameCurrentTime(): number;
     protected _updateFrameIndex(): this;
     protected _process(delta: number): void;
     protected _drawContent(): void;
     protected _repaint(batchables: CanvasBatchable[]): CanvasBatchable[];
 }
 
-interface LottieOptions extends Node2DOptions {
-    pixelRatio?: number;
-    src?: string;
+interface TextureRect2DProperties extends Node2DProperties {
 }
-declare class Lottie2D extends Node2D {
-    pixelRatio: number;
+declare class TextureRect2D<T extends Texture2D = Texture2D> extends Node2D implements Rectangulable {
+    texture?: T;
+    getRect(): Rect2;
+    protected _drawContent(): void;
+}
+
+interface Lottie2DProperties extends TextureRect2DProperties {
     src: string;
-    duration: number;
-    readonly texture: Texture<HTMLCanvasElement>;
+}
+declare class Lottie2D extends TextureRect2D {
+    src: string;
+    readonly texture: CanvasTexture;
     animation?: AnimationItem;
-    constructor(options?: LottieOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
-    protected _onUpdateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
+    constructor(properties?: Partial<Lottie2DProperties>, children?: Node[]);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
     protected _load(): Promise<void>;
     protected _process(delta: number): void;
-    protected _drawContent(): void;
 }
 
-interface Text2DOptions extends Node2DOptions, Omit<TextOptions, 'style'> {
-    pixelRatio?: number;
-    split?: boolean;
+interface Text2DProperties extends TextureRect2DProperties, Omit<TextOptions, 'style'> {
+    split: boolean;
 }
 /**
  * @example
@@ -1777,20 +1957,19 @@ interface Text2DOptions extends Node2DOptions, Omit<TextOptions, 'style'> {
  *   content: 'Text2D',
  * })
  */
-declare class Text2D extends Node2D {
-    pixelRatio: number;
+declare class Text2D extends TextureRect2D<CanvasTexture> {
     split: boolean;
     content: TextOptions['content'];
     effects?: TextOptions['effects'];
     measureDom?: TextOptions['measureDom'];
     fonts?: TextOptions['fonts'];
+    texture: CanvasTexture;
     text: Text;
-    readonly texture: Texture<HTMLCanvasElement>;
     protected _subTextsCount: number;
-    constructor(options?: Text2DOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    constructor(properties?: Partial<Text2DProperties>, children?: Node[]);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     protected _updateText(): void;
-    protected _onUpdateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
     protected _getSubTexts(): Text2D[];
     protected _updateSubTexts(): void;
     measure(): MeasureResult;
@@ -1798,92 +1977,81 @@ declare class Text2D extends Node2D {
     protected _drawContent(): void;
 }
 
-interface Video2DOptions extends Node2DOptions {
-    src?: string;
+interface Video2DProperties extends TextureRect2DProperties {
+    src: string;
 }
-declare class Video2D extends Node2D {
+declare class Video2D extends TextureRect2D<VideoTexture> {
     src: string;
-    texture?: VideoTexture;
-    get duration(): number;
+    get videoDuration(): number;
     protected _wait: Promise<void>;
-    constructor(options?: Video2DOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    constructor(properties?: Partial<Video2DProperties>, children?: Node[]);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     waitLoad(): Promise<void>;
     protected _load(src: string): Promise<void>;
-    protected _drawContent(): void;
     protected _updateVideoCurrentTime(): void;
     protected _process(delta: number): void;
 }
 
-declare abstract class Loader {
-    abstract install(assets: Assets): this;
-}
-
-declare class FontLoader extends Loader {
-    load: (url: string) => Promise<Font>;
-    install(assets: Assets): this;
-}
-
-declare class GifLoader extends Loader {
-    load: (url: string) => Promise<Image2DResource>;
-    install(assets: Assets): this;
-}
-
-declare class JsonLoader extends Loader {
-    load: (url: string) => Promise<Record<string, any>>;
-    install(assets: Assets): this;
-}
-
-declare class LottieLoader extends Loader {
-    load: (url: string, canvas: HTMLCanvasElement) => Promise<AnimationItem>;
-    install(assets: Assets): this;
-}
-
-declare class TextLoader extends Loader {
-    load: (url: string) => Promise<string>;
-    install(assets: Assets): this;
-}
-
-declare class TextureLoader extends Loader {
-    load: (url: string) => Promise<Texture<ImageBitmap>>;
-    install(assets: Assets): this;
+declare const linear: (amount: number) => number;
+declare const ease: (amount: number) => number;
+declare const easeIn: (amount: number) => number;
+declare const easeOut: (amount: number) => number;
+declare const easeInOut: (amount: number) => number;
+declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): (amount: number) => number;
+declare const timingFunctions: {
+    linear: (amount: number) => number;
+    ease: (amount: number) => number;
+    easeIn: (amount: number) => number;
+    easeOut: (amount: number) => number;
+    easeInOut: (amount: number) => number;
+};
+type TimingFunctions = typeof timingFunctions;
+type Easing = keyof TimingFunctions | `cubic-bezier(${string})`;
+interface Keyframe {
+    easing?: Easing;
+    offset?: number;
+    [property: string]: string | number | null | undefined;
 }
-
-declare class VideoLoader extends Loader {
-    load: (url: string) => Promise<VideoTexture>;
-    install(assets: Assets): this;
+interface NormalizedKeyframe {
+    easing: (amount: number) => number;
+    offset: number;
+    props: Record<string, any>;
 }
-
-type AssetHandler = (url: string, options?: any) => any | Promise<any>;
-interface Assets {
-    font: FontLoader;
-    gif: GifLoader;
-    json: JsonLoader;
-    lottie: LottieLoader;
-    text: TextLoader;
-    texture: TextureLoader;
-    video: VideoLoader;
+type AnimationMode = 'parent' | 'sibling';
+interface AnimationProperties extends TimelineNodeProperties {
+    animationMode: AnimationMode;
+    startTime: number;
+    duration: number;
+    loop: boolean;
+    keyframes: Keyframe[];
 }
-declare class Assets {
-    defaultHandler: AssetHandler;
-    protected _handlers: Map<string, AssetHandler>;
-    protected _handleing: Map<string, Promise<any>>;
-    protected _handled: Map<string, any>;
-    protected _gc: FinalizationRegistry<string> | undefined;
-    constructor();
-    use(loader: Loader): this;
-    register(mimeType: string, handler: AssetHandler): this;
-    fetch(url: string): Promise<Response>;
-    protected _fixSVG(dataURI: string): string;
-    fetchImageBitmap(url: string, options?: ImageBitmapOptions): Promise<ImageBitmap>;
-    get<T>(id: string): T | undefined;
-    set(id: string, value: any): void;
-    loadBy<T>(id: string, handler: () => Promise<T>): Promise<T>;
-    load<T>(url: string, options?: any): Promise<T>;
-    waitUntilLoad(): Promise<void>;
-    gc(): void;
+declare class Animation extends TimelineNode {
+    animationMode: AnimationMode;
+    loop: boolean;
+    keyframes: Keyframe[];
+    easing?: Easing;
+    protected _keyframes: NormalizedKeyframe[];
+    protected _isFirstUpdatePosition: boolean;
+    protected _cachedProps: RawWeakMap<any, Map<string, any>>;
+    protected _stoped: boolean;
+    constructor(properties?: Partial<AnimationProperties>, children?: Node[]);
+    protected _treeEnter(tree: SceneTree): void;
+    protected _treeExit(oldTree: SceneTree): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _getTargets(): any[];
+    protected _updateKeyframes(): void;
+    commitStyles(): void;
+    protected _updateCachedProps(): void;
+    protected _parseEasing(easing: Easing | undefined): (amount: number) => number;
+    protected _parseKeyframes(currentTime: number, startProps: Map<string, any>): [NormalizedKeyframe, NormalizedKeyframe] | null;
+    protected _commitStyle(currentTime: number, target: any, startProps: Map<string, any>, previous: NormalizedKeyframe, current: NormalizedKeyframe): void;
+    protected _getDiffValue(name: string, previous: string | undefined, current: string | undefined, weight: number, context: Record<string, any>): any;
+    isPlaying(): boolean;
+    play(): boolean;
+    pause(): boolean;
+    stop(): boolean;
+    cancel(): void;
 }
-declare const assets: Assets;
 
 declare abstract class AudioProcessor {
     destination: IAudioNode;
@@ -2122,7 +2290,7 @@ declare class WebAudio extends AudioPipeline {
 
 type PlatformAudio = WebAudio | HTMLAudio;
 type PlatformSound = WebSound | HTMLSound;
-declare class Audio extends Node {
+declare class Audio extends TimelineNode {
     protected static _soundPool: PlatformSound[];
     protected _sounds: PlatformSound[];
     /** PlatformAudio */
@@ -2135,7 +2303,7 @@ declare class Audio extends Node {
     isLoaded: boolean;
     get isPlayable(): boolean;
     /** Duration */
-    get duration(): number;
+    get audioDuration(): number;
     /** Volume */
     protected _volume: number;
     get volume(): number;
@@ -2155,14 +2323,11 @@ declare class Audio extends Node {
     /** IsPlaying */
     protected _isPlaying: boolean;
     get isPlaying(): boolean;
-    /** Paused */
-    protected _paused: boolean;
-    get paused(): boolean;
-    set paused(val: boolean);
     multiple: boolean;
     start: number;
     end: number;
     constructor(src?: string);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     load(): Promise<this>;
     pause(): this;
     resume(): this;
@@ -2183,20 +2348,20 @@ declare class Audio extends Node {
 declare class AudioSpectrum extends Node2D {
 }
 
-interface AudioWaveformOptions extends Node2DOptions {
-    src?: string;
-    gap?: number;
-    color?: string;
+interface AudioWaveformProperties extends Node2DProperties {
+    src: string;
+    gap: number;
+    color: string;
 }
 declare class AudioWaveform extends Node2D {
     src?: string;
     gap: number;
     color: string;
     protected _audioBuffer?: AudioBuffer;
-    protected _src: Texture<HTMLCanvasElement> | undefined;
+    protected _src: Texture2D<HTMLCanvasElement> | undefined;
     protected _needsUpdateTexture: boolean;
-    constructor(options?: AudioWaveformOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    constructor(options?: Partial<AudioWaveformProperties>);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     _loadSrc(src: string): Promise<void>;
     syncTexture(force?: boolean): void;
     protected _process(delta: number): void;
@@ -2204,9 +2369,8 @@ declare class AudioWaveform extends Node2D {
 }
 
 type EffectMode = 'before' | 'parent' | 'children' | 'transition';
-interface EffectOptions extends NodeOptions {
+interface EffectOptions extends TimelineNodeProperties {
     mode?: EffectMode;
-    duration?: number;
     glsl?: string;
     glslSrc?: string;
     material?: Material;
@@ -2220,16 +2384,14 @@ interface EffectContext {
     from?: Viewport;
     to?: Viewport;
 }
-declare class Effect extends Node {
+declare class Effect extends TimelineNode {
     material?: Material;
     mode?: EffectMode;
     glsl: string;
     glslSrc: string;
-    delay: number;
-    duration: number;
     protected get _mode(): EffectMode;
     /** Viewports */
-    readonly viewport: Viewport;
+    readonly viewport1: Viewport;
     readonly viewport2: Viewport;
     /** Render call */
     protected _renderId: number;
@@ -2238,11 +2400,11 @@ declare class Effect extends Node {
     protected _previousSibling?: Node;
     protected _nextSibling?: Node;
     constructor(options?: EffectOptions);
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
-    protected _enterTree(): void;
-    protected _exitTree(): void;
-    protected _onProcessing: () => void;
-    protected _onNodeProcessed: (node: Node) => void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _treeEnter(tree: SceneTree): void;
+    protected _treeExit(oldTree: SceneTree): void;
+    protected _onProcessing(): void;
+    protected _onNodeProcessed(node: Node): void;
     protected _processParent(): void;
     protected _processChildren(): void;
     _onProcess(delta?: number): void;
@@ -2275,13 +2437,13 @@ declare class ColorAdjustEffect extends Effect {
     apply(renderer: WebGLRenderer, source: Viewport): void;
 }
 
-interface ColorFilterEffectOptions {
+interface ColorFilterEffectProperties {
     filter?: string;
 }
 declare class ColorFilterEffect extends Effect {
     filter: string;
     protected _colorMatrix: ColorMatrix;
-    constructor(options?: ColorFilterEffectOptions);
+    constructor(properties?: Partial<ColorFilterEffectProperties>);
     apply(renderer: WebGLRenderer, source: Viewport): void;
     static material: Material;
 }
@@ -2310,26 +2472,6 @@ declare class ColorReplaceEffect extends Effect {
     apply(renderer: WebGLRenderer, source: Viewport): void;
 }
 
-declare class EffectMaterial extends Material {
-    vert: string;
-    readonly uniforms: Map<string, any>;
-    static RE: {
-        getColor: RegExp;
-        getFromColor: RegExp;
-        getToColor: RegExp;
-        transform: RegExp;
-        transition: RegExp;
-    };
-    has: {
-        getColor: boolean;
-        getFromColor: boolean;
-        getToColor: boolean;
-        transform: boolean;
-        transition: boolean;
-    };
-    constructor(glsl: string);
-}
-
 declare class EmbossEffect extends Effect {
     strength: number;
     constructor(strength?: number);
@@ -2340,7 +2482,7 @@ declare class EmbossEffect extends Effect {
 declare class GlitchEffect extends Effect {
     static material: Material;
     protected _canvas: HTMLCanvasElement;
-    protected _texture: Texture;
+    protected _texture: Texture2D;
     protected _sizes: Float32Array;
     protected _offsets: Float32Array;
     protected _redraw: boolean;
@@ -2385,11 +2527,11 @@ interface MaskEffectOptions extends EffectOptions {
     src?: string;
 }
 declare class MaskEffect extends Effect {
-    texture?: Texture<ImageBitmap>;
+    texture?: Texture2D<ImageBitmap>;
     src: string;
     constructor(options?: MaskEffectOptions);
     load(): Promise<void>;
-    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
     apply(renderer: WebGLRenderer, source: Viewport, context: EffectContext): void;
     static material: Material;
 }
@@ -2401,299 +2543,204 @@ declare class PixelateEffect extends Effect {
     apply(renderer: WebGLRenderer, source: Viewport): void;
 }
 
-declare class TiltShiftEffect extends Effect {
-    static material: Material;
-    blur: number;
-    gradientBlur: number;
-    apply(renderer: WebGLRenderer, target: Viewport): void;
+declare class ShadowEffect extends Effect {
+    static material: Material;
+    blur: BlurEffect;
+    viewport3: Viewport;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+declare class TiltShiftEffect extends Effect {
+    static material: Material;
+    blur: number;
+    gradientBlur: number;
+    apply(renderer: WebGLRenderer, target: Viewport): void;
+}
+
+declare class TwistEffect extends Effect {
+    static material: Material;
+    radius?: number;
+    angle: number;
+    padding: number;
+    offset?: number;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+declare class ZoomBlurEffect extends Effect {
+    static material: Material;
+    center?: number[];
+    innerRadius: number;
+    radius: number;
+    strength: number;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+interface ControlEventMap extends CanvasItemEventMap, RectangulableEventMap {
+}
+interface ControlProperties extends CanvasItemProperties {
+}
+interface Control {
+    on: (<K extends keyof ControlEventMap>(type: K, listener: ControlEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof ControlEventMap>(type: K, listener: ControlEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof ControlEventMap>(type: K, ...args: Parameters<ControlEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class Control extends CanvasItem implements Rectangulable {
+    constructor(properties?: Partial<ControlProperties>, children?: Node[]);
+    protected _parented(parent: any): void;
+    protected _unparented(oldParent: any): void;
+    protected _parentUpdateRect(): void;
+    protected _input(event: InputEvent, key: InputEventKey): void;
+    protected _updateStyleProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _guiInput(event: InputEvent, key: InputEventKey): void;
+    getRect(): Rect2;
+}
+
+interface RulerProperties extends ControlProperties {
+    offsetX: number;
+    offsetY: number;
+    thickness: number;
+    markHeight: number;
+    color: string;
+    markBackgroundColor: string;
+    markColor: string;
+    gap: number;
+    scale: number;
+}
+declare class Ruler extends Control {
+    offsetX: number;
+    offsetY: number;
+    thickness: number;
+    markHeight: number;
+    color: string;
+    markBackgroundColor: string;
+    markColor: string;
+    gap: number;
+    scale: number;
+    texture: CanvasTexture;
+    constructor(properties?: Partial<RulerProperties>, children?: Node[]);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateStyleProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _drawTexture(): void;
+    protected _draw(): void;
+}
+
+interface ScrollBarProperties extends ControlProperties {
+    direction: 'vertical' | 'horizontal';
+}
+declare class ScrollBar extends Control {
+    direction: 'vertical' | 'horizontal';
+    padding: number;
+    constructor(properties: Partial<ScrollBarProperties>, children?: Node[]);
+    protected _parentUpdateRect(): void;
+    protected _guiInput(event: InputEvent, key: InputEventKey): void;
+    protected _draw(): void;
+}
+
+interface ScalerEventMap extends NodeEventMap {
+    updateScale: (scale: number) => void;
+}
+interface ScalerProperties extends NodeProperties {
+}
+interface Scaler {
+    on: (<K extends keyof ScalerEventMap>(type: K, listener: ScalerEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof ScalerEventMap>(type: K, listener: ScalerEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof ScalerEventMap>(type: K, ...args: Parameters<ScalerEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class Scaler extends Node {
+    scale: number;
+    min: number;
+    max: number;
+    get target(): CanvasItem | undefined;
+    constructor(properties?: Partial<ScalerProperties>, children?: Node[]);
+    protected _updateProperty(key: PropertyKey, value: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    protected _updateScale(): void;
+    protected _onWheel(e: WheelInputEvent): void;
+    protected _input(event: InputEvent, key: InputEventKey): void;
 }
 
-declare class TwistEffect extends Effect {
-    static material: Material;
-    radius?: number;
-    angle: number;
-    padding: number;
-    offset?: number;
-    apply(renderer: WebGLRenderer, source: Viewport): void;
+declare class GifLoader extends Loader {
+    load: (url: string) => Promise<Image2DResource>;
+    install(assets: Assets): this;
 }
 
-declare class ZoomBlurEffect extends Effect {
-    static material: Material;
-    center?: number[];
-    innerRadius: number;
-    radius: number;
-    strength: number;
-    apply(renderer: WebGLRenderer, source: Viewport): void;
+declare class JsonLoader extends Loader {
+    load: (url: string) => Promise<Record<string, any>>;
+    install(assets: Assets): this;
 }
 
-type Cursor = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ns-resize' | 'ew-resize' | 'nesw-resize' | 'col-resize' | 'nwse-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'grab' | 'grabbing';
+declare class LottieLoader extends Loader {
+    load: (url: string, canvas: HTMLCanvasElement) => Promise<AnimationItem>;
+    install(assets: Assets): this;
+}
 
-declare class UIInputEvent<N extends UIEvent = UIEvent> implements UIEvent {
-    /** Flags whether this event bubbles. This will take effect only if it is set before propagation. */
-    bubbles: boolean;
-    readonly cancelable = false;
-    which: number;
-    cancelBubble: boolean;
-    returnValue: boolean;
-    srcElement: EventTarget;
-    readonly composed = false;
-    /** The listeners of the event target that are being notified. */
-    currentTarget: any;
-    /** Flags whether the default response of the user agent was prevent through this event. */
-    defaultPrevented: boolean;
-    /**
-     * The propagation phase.
-     */
-    eventPhase: number;
-    /** Flags whether this is a user-trusted event */
-    isTrusted: boolean;
-    /** The event target that this will be dispatched to. */
-    target: any;
-    /** The timestamp of when the event was created. */
-    timeStamp: number;
-    /** The type of event, e.g. {@code "mouseup"}. */
-    type: string;
-    /** The native event that caused the foremost original event. */
-    nativeEvent: N;
-    /** The original event that caused this event, if any. */
-    originalEvent: UIInputEvent<N> | null;
-    /** Flags whether propagation was stopped. */
-    propagationStopped: boolean;
-    /** Flags whether propagation was immediately stopped. */
-    propagationImmediatelyStopped: boolean;
-    /** The composed path of the event's propagation. The {@code target} is at the end. */
-    path: any[];
-    /** Event-specific detail */
-    detail: number;
-    /** The global Window object. */
-    view: WindowProxy;
-    /** The coordinates of the evnet relative to the nearest DOM layer. This is a non-standard property. */
-    layer: {
-        x: number;
-        y: number;
-    };
-    get layerX(): number;
-    get layerY(): number;
-    /** The coordinates of the event relative to the DOM document. This is a non-standard property. */
-    page: {
-        x: number;
-        y: number;
-    };
-    get pageX(): number;
-    get pageY(): number;
-    initEvent(..._args: any[]): void;
-    initUIEvent(..._args: any[]): void;
-    /** The propagation path for this event. */
-    composedPath(): any[];
-    /** Prevent default behavior of PixiJS and the user agent. */
-    preventDefault(): void;
-    stopImmediatePropagation(): void;
-    stopPropagation(): void;
-    readonly NONE = 0;
-    readonly CAPTURING_PHASE = 1;
-    readonly AT_TARGET = 2;
-    readonly BUBBLING_PHASE = 3;
+declare class TextLoader extends Loader {
+    load: (url: string) => Promise<string>;
+    install(assets: Assets): this;
 }
 
-declare class MouseInputEvent extends UIInputEvent implements MouseEvent {
-    /** Whether the "alt" key was pressed when this mouse event occurred. */
-    altKey: boolean;
-    /** The specific button that was pressed in this mouse event. */
-    button: number;
-    /** The button depressed when this event occurred. */
-    buttons: number;
-    /** Whether the "control" key was pressed when this mouse event occurred. */
-    ctrlKey: boolean;
-    /** Whether the "meta" key was pressed when this mouse event occurred. */
-    metaKey: boolean;
-    /** This is currently not implemented in the Federated Events API. */
-    relatedTarget: EventTarget | null;
-    /** Whether the "shift" key was pressed when this mouse event occurred. */
-    shiftKey: boolean;
-    /** The coordinates of the mouse event relative to the canvas. */
-    client: {
-        x: number;
-        y: number;
-    };
-    get clientX(): number;
-    get clientY(): number;
-    get x(): number;
-    get y(): number;
-    /** This is the number of clicks that occurs in 200ms/click of each other. */
-    detail: number;
-    /** The movement in this pointer relative to the last `mousemove` event. */
-    movement: {
-        x: number;
-        y: number;
-    };
-    get movementX(): number;
-    get movementY(): number;
-    /**
-     * The offset of the pointer coordinates w.r.t. target DisplayObject in world space. This is
-     * not supported at the moment.
-     */
-    offset: {
-        x: number;
-        y: number;
-    };
-    get offsetX(): number;
-    get offsetY(): number;
-    /** The pointer coordinates in world space. */
-    global: {
-        x: number;
-        y: number;
-    };
-    get globalX(): number;
-    get globalY(): number;
-    /**
-     * The pointer coordinates in the renderer's.
-     * This has slightly different semantics than native PointerEvent screenX/screenY.
-     */
-    screen: {
-        x: number;
-        y: number;
-    };
-    get screenX(): number;
-    get screenY(): number;
-    /**
-     * Whether the modifier key was pressed when this event natively occurred.
-     * @param key - The modifier key.
-     */
-    getModifierState(key: string): boolean;
-    initMouseEvent(..._args: any[]): void;
+declare class TextureLoader extends Loader {
+    load: (url: string) => Promise<Texture2D<ImageBitmap>>;
+    install(assets: Assets): this;
 }
 
-declare class PointerInputEvent extends MouseInputEvent implements PointerEvent {
-    altitudeAngle: number;
-    azimuthAngle: number;
-    /**
-     * The unique identifier of the pointer.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerId
-     */
-    pointerId: number;
-    /**
-     * The width of the pointer's contact along the x-axis, measured in CSS pixels.
-     * radiusX of TouchEvents will be represented by this value.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/width
-     */
-    width: number;
-    /**
-     * The height of the pointer's contact along the y-axis, measured in CSS pixels.
-     * radiusY of TouchEvents will be represented by this value.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/height
-     */
-    height: number;
-    /**
-     * Indicates whether or not the pointer device that created the event is the primary pointer.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/isPrimary
-     */
-    isPrimary: boolean;
-    /**
-     * The type of pointer that triggered the event.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerType
-     */
-    pointerType: string;
-    /**
-     * Pressure applied by the pointing device during the event.
-     *s
-     * A Touch's force property will be represented by this value.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pressure
-     */
-    pressure: number;
-    /**
-     * Barrel pressure on a stylus pointer.
-     * @see https://w3c.github.io/pointerevents/#pointerevent-interface
-     */
-    tangentialPressure: number;
-    /**
-     * The angle, in degrees, between the pointer device and the screen.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/tiltX
-     */
-    tiltX: number;
-    /**
-     * The angle, in degrees, between the pointer device and the screen.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/tiltY
-     */
-    tiltY: number;
-    /**
-     * Twist of a stylus pointer.
-     * @see https://w3c.github.io/pointerevents/#pointerevent-interface
-     */
-    twist: number;
-    /**
-     * This is the number of clicks that occurs in 200ms/click of each other.
-     */
-    detail: number;
-    /**
-     * Only included for completeness for now
-     */
-    getCoalescedEvents(): PointerEvent[];
-    /**
-     * Only included for completeness for now
-     */
-    getPredictedEvents(): PointerEvent[];
+declare class VideoLoader extends Loader {
+    load: (url: string) => Promise<VideoTexture>;
+    install(assets: Assets): this;
 }
 
-declare class WheelInputEvent extends MouseInputEvent implements WheelEvent {
-    /**
-     * The units of `deltaX`, `deltaY`, and `deltaZ`. This is one of `DOM_DELTA_LINE`,
-     * `DOM_DELTA_PAGE`, `DOM_DELTA_PIXEL`.
-     */
-    deltaMode: number;
-    /** Horizontal scroll amount */
-    deltaX: number;
-    /** Vertical scroll amount */
-    deltaY: number;
-    /** z-axis scroll amount. */
-    deltaZ: number;
-    /** Units specified in pixels. */
-    static readonly DOM_DELTA_PIXEL = 0;
-    /** Units specified in pixels. */
-    readonly DOM_DELTA_PIXEL = 0;
-    /** Units specified in lines. */
-    static readonly DOM_DELTA_LINE = 1;
-    /** Units specified in lines. */
-    readonly DOM_DELTA_LINE = 1;
-    /** Units specified in pages. */
-    static readonly DOM_DELTA_PAGE = 2;
-    /** Units specified in pages. */
-    readonly DOM_DELTA_PAGE = 2;
+type AssetHandler = (url: string, options?: any) => any | Promise<any>;
+interface Assets {
+    font: FontLoader;
+    gif: GifLoader;
+    json: JsonLoader;
+    lottie: LottieLoader;
+    text: TextLoader;
+    texture: TextureLoader;
+    video: VideoLoader;
+}
+declare class Assets {
+    defaultHandler: AssetHandler;
+    protected _handlers: Map<string, AssetHandler>;
+    protected _handleing: Map<string, Promise<any>>;
+    protected _handled: Map<string, any>;
+    protected _gc: FinalizationRegistry<string> | undefined;
+    constructor();
+    use(loader: Loader): this;
+    register(mimeType: string, handler: AssetHandler): this;
+    fetch(url: string): Promise<Response>;
+    protected _fixSVG(dataURI: string): string;
+    fetchImageBitmap(url: string, options?: ImageBitmapOptions): Promise<ImageBitmap>;
+    get<T>(id: string): T | undefined;
+    set(id: string, value: any): void;
+    loadBy<T>(id: string, handler: () => Promise<T>): Promise<T>;
+    load<T>(url: string, options?: any): Promise<T>;
+    waitUntilLoad(): Promise<void>;
+    gc(): void;
 }
+declare const assets: Assets;
 
-declare class Input extends EventEmitter {
-    target?: HTMLElement;
-    cursor: Cursor | string;
-    cursorStyles: Record<string, any>;
-    setuped: boolean;
-    /**
-     * Current event
-     */
-    event?: PointerInputEvent | WheelInputEvent;
-    enableMoveEvent: boolean;
-    enableWheelEvent: boolean;
-    enableClickEvent: boolean;
-    setTarget(target: HTMLElement): void;
-    removeEventListeners(): void;
-    addEventListeners(): void;
-    protected normalize(event: WheelEvent): WheelEvent[];
-    protected normalize(event: TouchEvent | PointerEvent | MouseEvent): PointerEvent[];
-    protected cloneWheelEvent(nativeEvent: WheelEvent): WheelInputEvent;
-    protected clonePointerEvent(nativeEvent: PointerEvent): PointerInputEvent;
-    protected copyMouseEvent(event: MouseInputEvent, nativeEvent: MouseEvent): void;
-    /**
-     * Sets the current cursor mode, handling any callbacks or CSS style changes.
-     * @param mode - cursor mode, a key from the cursorStyles dictionary
-     */
-    setCursor(mode: string): void;
-    mapPositionToPoint(point: {
+declare class CanvasEditor extends Control {
+    name: string;
+    hover: Node2D;
+    selectionRect: Node2D;
+    selector: Node2D;
+    scaler: Scaler;
+    xScrollBar: ScrollBar;
+    yScrollBar: ScrollBar;
+    drawboard: Node2D;
+    ruler: Ruler;
+    protected _pointerStart?: CanvasItemStyle;
+    protected _pointerOffset?: {
         x: number;
         y: number;
-    }, x: number, y: number): void;
-    protected onPointerDown: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
-    protected onPointerOver: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
-    protected onPointerMove: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
-    protected onPointerUp: (nativeEvent: PointerEvent | TouchEvent | MouseEvent) => void;
-    protected onWheel: (nativeEvent: WheelEvent) => void;
+    };
+    selected?: CanvasItem;
+    constructor();
+    protected _guiInput(event: InputEvent, key: InputEventKey): void;
+    protected _onPointerdown(e: PointerInputEvent): void;
+    protected _onPointermove(e: PointerInputEvent): void;
+    protected _onPointerup(): void;
+    protected _onHover(): void;
 }
 
 interface EngineOptions extends WebGLContextAttributes {
@@ -2701,8 +2748,10 @@ interface EngineOptions extends WebGLContextAttributes {
     width?: number;
     height?: number;
     pixelRatio?: number;
-    background?: ColorValue;
+    backgroundColor?: ColorValue;
     autoResize?: boolean;
+    autoStart?: boolean;
+    timeline?: Timeline;
 }
 interface EngineEventMap {
     pointerdown: (ev: PointerInputEvent) => void;
@@ -2739,9 +2788,6 @@ declare class Engine extends SceneTree {
     get height(): number;
     get pixelRatio(): number;
     set pixelRatio(val: number);
-    protected _background: Color;
-    get background(): ColorValue;
-    set background(val: ColorValue);
     protected _resizeObserver: ResizeObserver | undefined;
     constructor(options?: EngineOptions);
     protected _setupInput(): this;
@@ -2764,4 +2810,4 @@ interface RenderOptions {
 }
 declare function render(options: RenderOptions): Promise<HTMLCanvasElement>;
 
-export { Animation2D, type AnimationOptions, type AssetHandler, Assets, Audio, AudioPipeline, AudioProcessor, AudioSpectrum, AudioWaveform, type AudioWaveformOptions, type Batchable2D, BlurEffect, type CanvasBatchable, CanvasContext, CanvasItem, type CanvasItemOptions, Color, ColorAdjustEffect, ColorFilterEffect, type ColorFilterEffectOptions, ColorMatrix, ColorOverlayEffect, ColorRemoveEffect, ColorReplaceEffect, ColorTexture, type ColorValue, type CssFunction, type CssFunctionArg, type Cursor, type CustomNodeOptions, DEG_TO_RAD, DEVICE_PIXEL_RATIO, type Easing, Effect, type EffectContext, EffectMaterial, type EffectMode, type EffectOptions, EmbossEffect, Engine, type EngineOptions, EventEmitter, type EventListener, type EventListenerOptions, type EventListenerValue, type FilledGraphics, FontLoader, Geometry, type GeometryOptions, GifLoader, GlitchEffect, GodrayEffect, Graphics2D, HTMLAudio, HTMLAudioContext, HTMLSound, type IAudioContext, type IAudioNode, IN_BROWSER, type IPlayOptions, Image2D, type Image2DOptions, Image2DResource, type ImageFrame, ImageTexture, type ImageTextureOptions, IndexBuffer, type IndexBufferOptions, Input, InternalMode, JsonLoader, KawaseEffect, type Keyframe, LeftEraseEffect, Loader, Lottie2D, LottieLoader, type LottieOptions, MainLoop, type MainLoopEventMap, type MaskColor, type MaskData, MaskEffect, type MaskEffectOptions, type MaskObject, type MaskRect, type Maskable, Material, type MaterialOptions, Matrix, Matrix2, Matrix3, Matrix4, type MatrixLike, type MatrixOperateOutput, MouseInputEvent, Node, Node2D, type Node2DOptions, type NodeEventMap, type NodeOptions, type NormalizedKeyframe, PI, PI_2, PixelateEffect, PixelsTexture, type PlatformAudio, type PlatformSound, PointerInputEvent, Projection2D, type PropertyDeclaration, QuadGeometry, QuadUvGeometry, RAD_TO_DEG, RawWeakMap, Reference, type ReferenceEventMap, type RenderCall, type RenderOptions, RenderStack, type Renderable, Renderer, Resource, type ResourceEventMap, 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, SceneTree, type SceneTreeEventMap, type StrokedGraphics, Style2D, type Style2DBackgroundExtend, Style2DBackgroundModule, type Style2DBackgroundProperties, type Style2DFilter, type Style2DFilterExtend, type Style2DFilterKey, Style2DFilterModule, type Style2DFilterProperties, Style2DModule, type Style2DOptions, type Style2DTextExtend, Style2DTextModule, type Style2DTextProperties, type Style2DTransformExtend, Style2DTransformModule, type Style2DTransformProperties, Text2D, type Text2DOptions, TextLoader, Texture, type TextureFilterMode, TextureLoader, type TexturePixelsSource, type TextureSource, type TextureWrapMode, Ticker, TiltShiftEffect, Timer, type TimerEventMap, type TimerOptions, type TimingFunctions, Transform2D, type Transform2DObject, TwistEffect, UIInputEvent, UvGeometry, UvMaterial, Vector, Vector2, Vector3, Vector4, type VectorLike, type VectorOperateOutput, VertexAttribute, type VertexAttributeOptions, VertexBuffer, type VertexBufferOptions, Video2D, type Video2DOptions, VideoLoader, VideoTexture, type VideoTextureOptions, type VideoTextureSource, Viewport, type ViewportFramebuffer, ViewportTexture, WebAudio, WebAudioContext, WebGLBatch2DModule, WebGLBlendMode, type WebGLBufferMeta, WebGLBufferModule, type WebGLBufferOptions, type WebGLBufferTarget, type WebGLBufferUsage, type WebGLDrawMode, type WebGLDrawOptions, type WebGLExtensions, type WebGLFramebufferMeta, WebGLFramebufferModule, type WebGLFramebufferOptions, WebGLMaskModule, WebGLModule, type WebGLProgramMeta, WebGLProgramModule, type WebGLProgramOptions, WebGLRenderer, WebGLScissorModule, WebGLState, WebGLStateModule, WebGLStencilModule, type WebGLTarget, type WebGLTextureFilterMode, type WebGLTextureLocation, type WebGLTextureMeta, WebGLTextureModule, type WebGLTextureOptions, type WebGLTextureSource, type WebGLTextureTarget, type WebGLTextureWrapMode, WebGLVertexArrayModule, type WebGLVertexArrayObjectMeta, type WebGLVertexArrayObjectOptions, type WebGLVertexAttrib, type WebGLVertexAttribType, type WebGLViewport, WebGLViewportModule, WebSound, WheelInputEvent, ZoomBlurEffect, _Object, type _ObjectEventMap, assets, clamp, createHTMLCanvas, createNode, crossOrigin, cubicBezier, curves, customNode, customNodes, defaultOptions, defineProperty, determineCrossOrigin, ease, easeIn, easeInOut, easeOut, getDeclarations, getDefaultCssPropertyValue, isCanvasElement, isElementNode, isImageElement, isPow2, isVideoElement, isWebgl2, lerp, linear, log2, mapWebGLBlendModes, nextPow2, nextTick, parseCssFunctions, parseCssProperty, property, protectedProperty, render, timingFunctions, uid };
+export { Animation, type AnimationMode, type AnimationProperties, type AssetHandler, Assets, Audio, AudioPipeline, AudioProcessor, AudioSpectrum, AudioWaveform, type AudioWaveformProperties, type Batchable2D, BlurEffect, type CanvasBatchable, CanvasContext, CanvasEditor, CanvasItem, type CanvasItemEventMap, type CanvasItemProperties, CanvasItemStyle, type CanvasItemStyleFilter, type CanvasItemStyleFilterKey, type CanvasItemStyleProperties, CanvasTexture, Color, ColorAdjustEffect, ColorFilterEffect, type ColorFilterEffectProperties, ColorMatrix, ColorOverlayEffect, ColorRemoveEffect, ColorReplaceEffect, ColorTexture, type ColorValue, Control, type ControlEventMap, type ControlProperties, CoreObject, type CoreObjectEventMap, type CssFunction, type CssFunctionArg, type Cursor, DEG_TO_RAD, DEVICE_PIXEL_RATIO, type Easing, Effect, type EffectContext, EffectMaterial, type EffectMode, type EffectOptions, EmbossEffect, Engine, type EngineOptions, EventEmitter, type EventListener, type EventListenerOptions, type EventListenerValue, type FilledGraphics, FontLoader, Geometry, type GeometryOptions, GifLoader, GlitchEffect, GodrayEffect, Graphics2D, HTMLAudio, HTMLAudioContext, HTMLSound, type IAudioContext, type IAudioNode, IN_BROWSER, type IPlayOptions, Image2D, type Image2DProperties, Image2DResource, type ImageFrame, ImageTexture, type ImageTextureOptions, IndexBuffer, type IndexBufferOptions, Input, InputEvent, type InputEventKey, type InputEventMap, type InternalMode, JsonLoader, KawaseEffect, type Keyframe, LeftEraseEffect, Loader, Lottie2D, type Lottie2DProperties, LottieLoader, MainLoop, type MainLoopEventMap, type MaskColor, type MaskData, MaskEffect, type MaskEffectOptions, type MaskObject, type MaskRect, type Maskable, Material, type MaterialOptions, Matrix, Matrix2, Matrix3, Matrix4, type MatrixLike, type MatrixOperateOutput, MouseInputEvent, Node, Node2D, type Node2DProperties, type NodeEventMap, type NodeProperties, type NormalizedKeyframe, PI, PI_2, PixelateEffect, PixelsTexture, type PlatformAudio, type PlatformSound, type PointerEvents, PointerInputEvent, type ProcessMode, Projection2D, type PropertyDeclaration, QuadGeometry, QuadUvGeometry, RAD_TO_DEG, RawWeakMap, Rect2, RefCounted, type RefCountedEventMap, type RenderMode, type RenderOptions, type Renderable, Renderer, Resource, type ResourceEventMap, Ruler, type RulerProperties, 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, type ScalerEventMap, type ScalerProperties, SceneTree, type SceneTreeEventMap, ScrollBar, type ScrollBarProperties, ShadowEffect, type StrokedGraphics, Text2D, type Text2DProperties, TextLoader, Texture2D, type Texture2DFilterMode, type Texture2DPixelsSource, type Texture2DSource, type Texture2DWrapMode, TextureLoader, TextureRect2D, type TextureRect2DProperties, Ticker, TiltShiftEffect, Timeline, type TimelineEventMap, TimelineNode, type TimelineNodeEventMap, type TimelineNodeProperties, type TimelineProperties, type TimingFunctions, Transform2D, type Transform2DObject, TwistEffect, UvGeometry, UvMaterial, Vector, Vector2, Vector3, Vector4, type VectorLike, type VectorOperateOutput, VertexAttribute, type VertexAttributeOptions, VertexBuffer, type VertexBufferOptions, Video2D, type Video2DProperties, VideoLoader, VideoTexture, type VideoTextureOptions, type VideoTextureSource, Viewport, type ViewportEventMap, type ViewportFramebuffer, ViewportTexture, WebAudio, WebAudioContext, WebGLBatch2DModule, WebGLBlendMode, type WebGLBufferMeta, WebGLBufferModule, type WebGLBufferOptions, type WebGLBufferTarget, type WebGLBufferUsage, type WebGLDrawMode, type WebGLDrawOptions, type WebGLExtensions, type WebGLFramebufferMeta, WebGLFramebufferModule, type WebGLFramebufferOptions, WebGLMaskModule, WebGLModule, type WebGLProgramMeta, WebGLProgramModule, type WebGLProgramOptions, WebGLRenderer, WebGLScissorModule, WebGLState, WebGLStateModule, WebGLStencilModule, type WebGLTarget, type WebGLTextureFilterMode, type WebGLTextureLocation, type WebGLTextureMeta, WebGLTextureModule, type WebGLTextureOptions, type WebGLTextureSource, type WebGLTextureTarget, type WebGLTextureWrapMode, WebGLVertexArrayModule, type WebGLVertexArrayObjectMeta, type WebGLVertexArrayObjectOptions, type WebGLVertexAttrib, type WebGLVertexAttribType, type WebGLViewport, WebGLViewportModule, WebSound, WheelInputEvent, ZoomBlurEffect, assets, clamp, createHTMLCanvas, createNode, crossOrigin, cubicBezier, curves, customNode, customNodes, defaultOptions, defineProperty, determineCrossOrigin, ease, easeIn, easeInOut, easeOut, getDeclarations, getDefaultCssPropertyValue, isCanvasElement, isElementNode, isImageElement, isPow2, isVideoElement, isWebgl2, lerp, linear, log2, mapWebGLBlendModes, nextPow2, nextTick, parseCssFunctions, parseCssProperty, property, protectedProperty, render, timingFunctions, uid };