modern-canvas 0.0.3 → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,3115 @@
+import { Visibility, Overflow, FontWeight, FontStyle, FontKerning, TextWrap, TextAlign, VerticalAlign, TextTransform, TextDecoration, WritingMode, IDOCTextContent, IDOCStyleDeclaration } from 'modern-idoc';
+import { AnyColor, Colord } from 'colord';
+import { AnimationItem } from 'lottie-web';
+import { MeasureResult } from 'modern-text';
+import { Font } from 'modern-font';
+
+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;
+
+type EventListenerValue = (...args: any[]) => void;
+type EventListenerOptions = boolean | AddEventListenerOptions;
+interface EventListener {
+    value: EventListenerValue;
+    options?: EventListenerOptions;
+}
+declare class EventEmitter {
+    eventListeners: Map<string, EventListener | EventListener[]>;
+    removeAllListeners(): this;
+    hasEventListener(event: string): boolean;
+    on(type: string, listener: EventListenerValue, options?: EventListenerOptions): any;
+    once(type: string, listener: EventListenerValue): this;
+    off(type: string, listener: EventListenerValue, options?: EventListenerOptions): this;
+    emit(type: string, ...args: any[]): boolean;
+}
+
+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 {
+    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);
+}
+/**
+ * Object 是所有 Godot 类的根类。
+ * 它提供了基础的功能，如内存管理、信号（signals）机制、实例化和对象生命周期等。
+ *
+ * 功能和用途：
+ *  • 所有的类都继承自 Object，这使得 Godot 中的所有对象都能共享一些基础的功能。
+ *  • 提供了内存管理功能，例如销毁对象。
+ *  • 支持信号机制，允许对象间进行通信。
+ *  • 支持对象的序列化和保存。
+ */
+declare class _Object 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 _enqueueUpdate(): Promise<void>;
+    protected _performUpdate(): void;
+    protected _onUpdate(changed: Map<PropertyKey, unknown>): void;
+    protected _onUpdateProperty(key: PropertyKey, newValue: any, oldValue: any, declaration?: PropertyDeclaration): void;
+    isDirty(key: string): boolean;
+    getPropertyDeclarations(): Map<PropertyKey, PropertyDeclaration>;
+    getPropertyDeclaration(key: PropertyKey): PropertyDeclaration | undefined;
+    getDefaultProperties(): Record<PropertyKey, any>;
+    getProperty(key: PropertyKey): any | undefined;
+    setProperty(key: PropertyKey, value: any): this;
+    getProperties(keys?: PropertyKey[]): Record<PropertyKey, any>;
+    setProperties(properties?: Record<PropertyKey, any>): this;
+    requestUpdate(key?: PropertyKey, oldValue?: unknown, declaration?: PropertyDeclaration): void;
+    toJSON(): Record<string, any>;
+    destroy(): void;
+}
+
+declare abstract class Renderer {
+    view?: HTMLCanvasElement;
+    pixelRatio: number;
+    readonly screen: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    readonly related: WeakMap<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 {
+    loseContext?: WEBGL_lose_context | null;
+    anisotropicFiltering?: EXT_texture_filter_anisotropic | null;
+    floatTextureLinear?: OES_texture_float_linear | null;
+    s3tc?: WEBGL_compressed_texture_s3tc | null;
+    s3tcSRGB?: WEBGL_compressed_texture_s3tc_srgb | null;
+    etc?: WEBGL_compressed_texture_etc | null;
+    etc1?: WEBGL_compressed_texture_etc1 | null;
+    pvrtc?: any | null;
+    atc?: any | null;
+    astc?: WEBGL_compressed_texture_astc | null;
+    instancedArrays?: ANGLE_instanced_arrays | null;
+    drawBuffers?: WEBGL_draw_buffers | null;
+    depthTexture?: WEBGL_depth_texture | null;
+    vertexArrayObject?: OES_vertex_array_object | null;
+    uint32ElementIndex?: OES_element_index_uint | null;
+    floatTexture?: OES_texture_float | null;
+    textureHalfFloat?: OES_texture_half_float | null;
+    textureHalfFloatLinear?: OES_texture_half_float_linear | null;
+    colorBufferFloat?: EXT_color_buffer_float | null;
+}
+interface WebGLFramebufferOptions {
+    width: number;
+    height: number;
+    mipLevel?: number;
+    stencil?: boolean;
+    depth?: boolean;
+    depthTexture?: WebGLTexture | null;
+    colorTextures?: WebGLTexture[];
+}
+interface WebGLFramebufferMeta extends Required<WebGLFramebufferOptions> {
+    multisample: number;
+    stencilBuffer?: WebGLBuffer | null;
+    msaaBuffer?: WebGLBuffer | null;
+}
+type Pick<T> = T extends string ? T extends Uppercase<T> ? Lowercase<T> : never : never;
+type WebGLTarget = Pick<keyof WebGL2RenderingContext>;
+interface WebGLProgramMeta {
+    attributes: Map<string, {
+        type: WebGLTarget;
+        size: number;
+        name: string;
+        location: number;
+    }>;
+    uniforms: Map<string, {
+        index: number;
+        type: WebGLTarget;
+        size: number;
+        isArray: boolean;
+        name: string;
+        location: WebGLUniformLocation | null;
+    }>;
+    boundUniforms: WeakMap<object, any>;
+}
+interface WebGLProgramOptions {
+    vert: string;
+    frag: string;
+}
+type WebGLTextureFilterMode = 'linear' | 'nearest' | 'nearest_mipmap_nearest' | 'linear_mipmap_nearest' | 'nearest_mipmap_linear' | 'linear_mipmap_linear';
+type WebGLTextureLocation = number;
+interface WebGLTextureMeta extends Omit<WebGLTextureOptions, 'value'> {
+}
+interface WebGLTextureOptions {
+    value: WebGLTextureSource;
+    target?: WebGLTextureTarget;
+    location?: WebGLTextureLocation;
+    filterMode?: WebGLTextureFilterMode;
+    wrapMode?: WebGLTextureWrapMode;
+    anisoLevel?: number;
+}
+type WebGLTextureSource = TexImageSource | null | {
+    width: number;
+    height: number;
+    pixels: ArrayBufferView | null;
+};
+type WebGLTextureTarget = 'texture_2d' | 'texture_cube_map';
+type WebGLTextureWrapMode = 'repeat' | 'clamp_to_edge' | 'mirrored_repeat';
+interface WebGLVertexArrayObjectMeta {
+    attributes: Record<string, WebGLVertexAttrib>;
+    elementArrayBuffer: WebGLBuffer | null;
+}
+interface WebGLVertexArrayObjectOptions {
+    attributes?: Record<string, WebGLBuffer | WebGLVertexAttrib>;
+    elementArrayBuffer?: WebGLBuffer | null;
+}
+type WebGLVertexAttribType = 'float' | 'unsigned_byte' | 'unsigned_short';
+interface WebGLVertexAttrib {
+    buffer: WebGLBuffer;
+    enable?: boolean;
+    size?: number;
+    type?: WebGLVertexAttribType;
+    normalized?: boolean;
+    stride?: number;
+    offset?: number;
+    divisor?: number;
+}
+interface WebGLViewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+interface WebGLRenderer {
+    texture: WebGLTextureModule;
+    buffer: WebGLBufferModule;
+    framebuffer: WebGLFramebufferModule;
+    program: WebGLProgramModule;
+    vertexArray: WebGLVertexArrayModule;
+    viewport: WebGLViewportModule;
+    state: WebGLStateModule;
+    mask: WebGLMaskModule;
+    scissor: WebGLScissorModule;
+    stencil: WebGLStencilModule;
+    batch2D: WebGLBatch2DModule;
+}
+declare class WebGLRenderer extends Renderer {
+    gl: WebGLRenderingContext | WebGL2RenderingContext;
+    version: 1 | 2;
+    extensions: WebGLExtensions;
+    protected _modules: (WebGLTextureModule | WebGLBufferModule | WebGLFramebufferModule | WebGLProgramModule | WebGLVertexArrayModule | WebGLViewportModule | WebGLStateModule | WebGLMaskModule | WebGLScissorModule | WebGLStencilModule | WebGLBatch2DModule)[];
+    readonly bindPoints: Map<number, WebGLTarget>;
+    constructor(view?: HTMLCanvasElement | WebGLRenderingContext | WebGL2RenderingContext, options?: WebGLContextAttributes);
+    protected _setupContext(view: HTMLCanvasElement, options?: WebGLContextAttributes): this;
+    /**
+     * Setup extensions
+     *
+     * @protected
+     */
+    protected _setupExtensions(): this;
+    /**
+     * Setup bind points
+     *
+     * @protected
+     */
+    protected _setupBindPoints(): this;
+    /**
+     * Setup polyfill
+     *
+     * @protected
+     */
+    protected _setupPolyfill(): this;
+    protected _onContextLost(event: WebGLContextEvent): void;
+    protected _onContextRestored(): void;
+    getBindPoint(target: WebGLTarget): number;
+    clear(mask?: number): void;
+    draw(options?: WebGLDrawOptions): void;
+    reset(): void;
+    flush(): void;
+    destroy(): void;
+    toPixels(): Uint8ClampedArray;
+}
+
+interface Renderable {
+    render: (renderer: WebGLRenderer) => void;
+}
+
+declare enum WebGLBlendMode {
+    NORMAL = "normal",
+    ADD = "add",
+    MULTIPLY = "multiply",
+    SCREEN = "screen",
+    NONE = "none",
+    NORMAL_NPM = "normal_npm",
+    ADD_NPM = "add_npm",
+    SCREEN_NPM = "screen_npm",
+    SRC_IN = "src_in",
+    SRC_OUT = "src_out",
+    SRC_ATOP = "src_atop",
+    DST_OVER = "dst_over",
+    DST_IN = "dst_in",
+    DST_OUT = "dst_out",
+    DST_ATOP = "dst_atop",
+    XOR = "xor",
+    SUBTRACT = "subtract"
+}
+declare function mapWebGLBlendModes(gl: WebGLRenderingContext): Record<WebGLBlendMode, any>;
+
+declare abstract class WebGLModule {
+    protected _renderer: WebGLRenderer;
+    get gl(): WebGLRenderingContext | WebGL2RenderingContext;
+    install(renderer: WebGLRenderer): void;
+    onUpdateContext(): void;
+    flush(): void;
+    reset(): void;
+    destroy(): void;
+}
+
+interface WebGLState {
+    blend: boolean;
+    offsets: boolean;
+    culling: boolean;
+    depthTest: boolean;
+    clockwiseFrontFace: boolean;
+    depthMask: boolean;
+}
+declare class WebGLState {
+    static readonly _properties: string[];
+    static _init(): void;
+    static for2D(): WebGLState;
+    protected _blendMode: WebGLBlendMode;
+    protected _polygonOffset: number;
+    bitmap: number;
+    get blendMode(): WebGLBlendMode;
+    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;
+    });
+}
+declare class WebGLStateModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    protected _blendEq: boolean;
+    protected _setters: any[];
+    boundStateBitmap: number;
+    boundBlendMode?: string;
+    blendModes: Record<WebGLBlendMode, any>;
+    defaultState: WebGLState;
+    onUpdateContext(): void;
+    toggle(boundPoint: number, enable: boolean): void;
+    setBlend(value: boolean): void;
+    setOffsets(value: boolean): void;
+    setCulling(value: boolean): void;
+    setDepthTest(value: boolean): void;
+    setDepthMask(value: boolean): void;
+    setClockwiseFrontFace(value: boolean): void;
+    setBlendMode(value: WebGLBlendMode): void;
+    setPolygonOffset(value: number, scale: number): void;
+    bind(state: WebGLState): void;
+    reset(): void;
+}
+
+interface Batchable2D {
+    vertices: number[];
+    indices: number[];
+    uvs?: number[];
+    texture?: WebGLTexture;
+    backgroundColor?: number;
+    tint?: number;
+    colorMatrix?: ArrayLike<number>;
+    colorMatrixOffset?: ArrayLike<number>;
+    blendMode?: WebGLBlendMode;
+}
+interface Shader {
+    update: (attributeBuffer: ArrayBuffer, indexBuffer: Uint16Array) => void;
+    draw: (options?: WebGLDrawOptions) => void;
+}
+declare class WebGLBatch2DModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    protected _state: WebGLState;
+    protected _batchSize: number;
+    protected _vertexSize: number;
+    protected _drawCallUid: number;
+    protected _defaultTint: number;
+    protected _defaultBackgroundColor: number;
+    protected _defaultColorMatrixOffset: number[];
+    protected _defaultColorMatrix: number[];
+    protected _batchables: Batchable2D[];
+    protected _vertexCount: number;
+    protected _indexCount: number;
+    protected _attributeBuffer: ArrayBuffer[];
+    protected _indexBuffers: Uint16Array[];
+    protected _shaders: Map<number, Shader>;
+    protected _attributes: Record<string, Partial<WebGLVertexAttrib>>;
+    protected _getShader(maxTextureUnits: number): Shader;
+    protected _createShader(maxTextureUnits: number): Shader;
+    render(batchable: Batchable2D): void;
+    flush(): void;
+    /**
+     * Fetches an attribute buffer from `this._attributeBuffer` that can hold atleast `size` floats.
+     * @param size - minimum capacity required
+     * @returns - buffer than can hold atleast `size` floats
+     */
+    protected _getAttributeBuffer(size: number): ArrayBuffer;
+    /**
+     * Fetches an index buffer from `this._indexBuffers` that can
+     * have at least `size` capacity.
+     * @param size - minimum required capacity
+     * @returns - buffer that can fit `size` indices.
+     */
+    protected _getIndexBuffer(size: number): Uint16Array;
+}
+/**
+ * Rounds to next power of two.
+ * @param {number} v - input value
+ * @returns {number} - next rounded power of two
+ */
+declare function nextPow2(v: number): number;
+/**
+ * Computes ceil of log base 2
+ * @param {number} v - input value
+ * @returns {number} logarithm base 2
+ */
+declare function log2(v: number): number;
+
+declare class WebGLBufferModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    boundArrayBuffer: WebGLBuffer | null;
+    boundTarget: WebGLBufferTarget;
+    create(options?: WebGLBufferOptions): WebGLBuffer;
+    getMeta(buffer: WebGLBuffer): WebGLBufferMeta;
+    update(options: WebGLBufferOptions): void;
+    update(buffer: WebGLBuffer, options: WebGLBufferOptions): void;
+    bind(options: {
+        target?: WebGLBufferTarget;
+        value: WebGLBuffer | null;
+    }): void;
+    unbind(target: WebGLBufferTarget): void;
+    reset(): void;
+}
+
+declare class WebGLFramebufferModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    boundFramebuffer: WebGLFramebuffer | null;
+    protected _msaaSamples: number[];
+    protected _hasMRT: boolean;
+    protected _writeDepthTexture: boolean;
+    onUpdateContext(): void;
+    create(options?: WebGLFramebufferOptions): WebGLFramebuffer;
+    getMeta(framebuffer: WebGLFramebuffer): WebGLFramebufferMeta;
+    update(options: WebGLFramebufferOptions): void;
+    update(framebuffer: WebGLFramebuffer, options: WebGLFramebufferOptions): void;
+    protected _getAttachmentAndFormat(meta: WebGLFramebufferMeta): {
+        attachment: number;
+        format: number;
+    };
+    resize(framebuffer: WebGLFramebuffer, width: number, height: number): void;
+    bind(framebuffer: WebGLFramebuffer | null): void;
+    forceStencil(): void;
+    reset(): void;
+}
+
+type MaskColor = number;
+interface MaskRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+type MaskObject = Renderable;
+type Maskable = MaskColor | MaskRect | MaskObject;
+interface MaskData {
+    source: Renderable;
+    mask: Maskable;
+    color?: number;
+    preComputedColor?: number;
+    scissorCounter?: number;
+    stencilCounter?: number;
+}
+declare class WebGLMaskModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    stack: MaskData[];
+    get length(): number;
+    get last(): MaskData;
+    push(source: Renderable, mask: Maskable): void;
+    pop(source: Renderable): void;
+    pushColorMask(data: MaskData): void;
+    popColorMask(data: MaskData): void;
+    useColorMask(value: number): void;
+}
+
+declare class WebGLProgramModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    boundProgram: WebGLProgram | null;
+    uniforms: Record<string, any>;
+    create(options?: WebGLProgramOptions): WebGLProgram;
+    getMeta(program: WebGLProgram): WebGLProgramMeta;
+    update(options: WebGLProgramOptions): void;
+    update(program: WebGLProgram, options: WebGLProgramOptions): void;
+    bind(program: WebGLProgram | null): void;
+    createShader(source: string, type: 'vertex_shader' | 'fragment_shader'): WebGLShader;
+    updateUniforms(program: WebGLProgram, uniforms: Record<string, any>): void;
+    updateUniforms(uniforms: Record<string, any>): void;
+    reset(): void;
+    destroy(): void;
+}
+
+declare class WebGLScissorModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    get length(): number;
+    push(data: MaskData): void;
+    pop(_data: MaskData): void;
+    use(): void;
+}
+
+declare class WebGLStencilModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    get length(): number;
+    push(data: MaskData): void;
+    pop(data: MaskData): void;
+    use(): void;
+}
+
+declare class WebGLTextureModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    maxUnits: number;
+    boundLocation: WebGLTextureLocation;
+    boundTarget: WebGLTextureTarget;
+    boundTextures: Record<WebGLTextureTarget, WebGLTexture | null>[];
+    emptyTextures: Record<WebGLTextureTarget, WebGLTexture | null>;
+    onUpdateContext(): void;
+    create(options?: WebGLTextureOptions): WebGLTexture;
+    getMeta(texture: WebGLTexture): WebGLTextureMeta;
+    update(options: WebGLTextureOptions): void;
+    update(texture: WebGLTexture, options: WebGLTextureOptions): void;
+    bind(texture: {
+        location?: WebGLTextureLocation;
+        forceUpdateLocation?: boolean;
+        target?: WebGLTextureTarget;
+        value: WebGLTexture | null;
+    } | null): void;
+    unbind(location: number, target?: WebGLTextureTarget): void;
+    unbind(texture: WebGLTexture): void;
+    reset(): void;
+}
+
+declare class WebGLVertexArrayModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    boundVertexArrayNull: WebGLVertexArrayObjectMeta;
+    boundVertexArrayObject: WebGLVertexArrayObject | null;
+    boundVertexArray: WebGLVertexArrayObjectMeta;
+    enableVertexAttrib(key: string, location: number, attrib: WebGLVertexAttrib, dimension?: number): void;
+    create(options?: WebGLVertexArrayObjectOptions): WebGLVertexArrayObject | null;
+    create(program?: WebGLProgram, options?: WebGLVertexArrayObjectOptions): WebGLVertexArrayObject | null;
+    getVertexArrayMeta(vertexArray: WebGLVertexArrayObject): WebGLVertexArrayObjectMeta;
+    update(options: WebGLVertexArrayObjectOptions): void;
+    update(vertexArray: WebGLVertexArrayObject, options: WebGLVertexArrayObjectOptions): void;
+    update(program: WebGLProgram, vertexArray: WebGLVertexArrayObject, options: WebGLVertexArrayObjectOptions): void;
+    bind(vertexArrayObject: WebGLVertexArrayObject | null | WebGLVertexArrayObjectOptions): void;
+    unbind(): void;
+    reset(): void;
+}
+
+declare class WebGLViewportModule extends WebGLModule {
+    install(renderer: WebGLRenderer): void;
+    boundViewport: WebGLViewport;
+    bind(viewport: WebGLViewport): void;
+    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;
+    uniforms?: Record<string, any>;
+}
+declare class Material extends Resource {
+    static instance: Material;
+    vert: string;
+    frag: string;
+    readonly uniforms: Map<string, any>;
+    constructor(options?: MaterialOptions);
+    /** @internal */
+    _glProgram(renderer: WebGLRenderer): WebGLProgram;
+    activate(renderer: WebGLRenderer, uniforms?: Record<string, any>): void;
+}
+
+interface IndexBufferOptions {
+    data?: Uint16Array | null;
+    dynamic?: boolean;
+}
+declare class IndexBuffer extends Resource {
+    data: Uint16Array | null;
+    dynamic: boolean;
+    needsUpload: boolean;
+    constructor(options?: IndexBufferOptions);
+    /** @internal */
+    _glBufferOptions(): WebGLBufferOptions;
+    /** @internal */
+    _glBuffer(renderer: WebGLRenderer): WebGLBuffer;
+    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    upload(renderer: WebGLRenderer): boolean;
+}
+
+interface VertexBufferOptions {
+    data?: BufferSource | null;
+    dynamic?: boolean;
+}
+declare class VertexBuffer extends Resource {
+    data: BufferSource | null;
+    dynamic: boolean;
+    needsUpload: boolean;
+    constructor(options?: VertexBufferOptions);
+    /** @internal */
+    _glBufferOptions(): WebGLBufferOptions;
+    /** @internal */
+    _glBuffer(renderer: WebGLRenderer): WebGLBuffer;
+    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): 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: WeakMap<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[];
+}
+
+/**
+ * Matrix3
+ *
+ * | x0 | y0 | z0 |
+ * | x1 | y1 | z1 |
+ * | x2 | y2 | z2 |
+ */
+declare class Matrix3 extends Matrix {
+    constructor(array?: number[]);
+    invert(): this;
+}
+
+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;
+}
+
+interface Shape {
+    x: number;
+    y: number;
+    contains: (x: number, y: number) => boolean;
+    strokeContains: (x: number, y: number, strokeWidth: number) => boolean;
+    getBounds: (out?: Rectangle) => Rectangle;
+    buildOutline: (points: number[]) => void;
+    buildGeometry: (vertices: number[], indices: number[]) => void;
+}
+
+declare class Rectangle implements Shape {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    get left(): number;
+    get right(): number;
+    get top(): number;
+    get bottom(): number;
+    isEmpty(): boolean;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    copyFromBounds(bounds: Bounds): this;
+    contains(x: number, y: number): boolean;
+    strokeContains(x: number, y: number, strokeWidth: number): boolean;
+    clone(): Rectangle;
+    copyFrom(rectangle: Rectangle): void;
+    copyTo(rectangle: Rectangle): void;
+    intersects(other: Rectangle, transform?: Transform2D): boolean;
+    pad(paddingX?: number, paddingY?: number): this;
+    fit(rectangle: Rectangle): this;
+    ceil(resolution?: number, eps?: number): this;
+    enlarge(rectangle: Rectangle): this;
+    getBounds(out?: Rectangle): Rectangle;
+    buildOutline(points: number[]): void;
+    buildGeometry(vertices: number[], indices: number[]): void;
+}
+
+interface BoundsData {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+declare class Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    matrix: Transform2D;
+    protected _rectangle?: Rectangle;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get left(): number;
+    get right(): number;
+    get top(): number;
+    get bottom(): number;
+    get isPositive(): boolean;
+    get isValid(): boolean;
+    constructor(minX?: number, minY?: number, maxX?: number, maxY?: number);
+    isEmpty(): boolean;
+    get rectangle(): Rectangle;
+    clear(): this;
+    set(x0: number, y0: number, x1: number, y1: number): this;
+    addFrame(x0: number, y0: number, x1: number, y1: number, matrix?: Transform2D): void;
+    addRect(rect: Rectangle, matrix?: Transform2D): this;
+    addBounds(bounds: BoundsData, matrix?: Transform2D): this;
+    addBoundsMask(mask: Bounds): void;
+    applyMatrix(matrix: Transform2D): void;
+    fit(rect: Rectangle): this;
+    fitBounds(left: number, right: number, top: number, bottom: number): this;
+    pad(paddingX: number, paddingY?: number): this;
+    ceil(): this;
+    clone(): Bounds;
+    scale(x: number, y?: number): this;
+    addVertexData(vertexData: Float32Array, beginOffset: number, endOffset: number, matrix?: Transform2D): void;
+    containsPoint(x: number, y: number): boolean;
+}
+
+declare function buildAdaptiveBezier(points: number[], sX: number, sY: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, eX: number, eY: number, smoothness?: number): number[];
+
+declare function buildAdaptiveQuadratic(points: number[], sX: number, sY: number, cp1x: number, cp1y: number, eX: number, eY: number, smoothness?: number): number[];
+
+declare function buildArc(points: number[], x: number, y: number, radius: number, start: number, end: number, clockwise: boolean, steps?: number): void;
+
+/**
+ * The arcTo() method creates an arc/curve between two tangents on the canvas.
+ * "borrowed" from https://code.google.com/p/fxcanvas/ - thanks google!
+ * @param points
+ * @param x1
+ * @param y1
+ * @param x2
+ * @param y2
+ * @param radius
+ */
+declare function buildArcTo(points: number[], x1: number, y1: number, x2: number, y2: number, radius: number): void;
+
+declare function buildArcToSvg(points: number[], px: number, py: number, cx: number, cy: number, rx: number, ry: number, xAxisRotation?: number, largeArcFlag?: number, sweepFlag?: number): void;
+
+declare class Circle implements Shape {
+    x: number;
+    y: number;
+    radius: number;
+    constructor(x?: number, y?: number, radius?: number);
+    contains(x: number, y: number): boolean;
+    strokeContains(x: number, y: number, width: number): boolean;
+    clone(): Circle;
+    copyFrom(circle: Circle): this;
+    copyTo(circle: Circle): Circle;
+    getBounds(out?: Rectangle): Rectangle;
+    buildOutline(points: number[]): void;
+    buildGeometry(vertices: number[], indices: number[]): void;
+}
+
+declare class Ellipse implements Shape {
+    x: number;
+    y: number;
+    halfWidth: number;
+    halfHeight: number;
+    constructor(x?: number, y?: number, halfWidth?: number, halfHeight?: number);
+    contains(x: number, y: number): boolean;
+    strokeContains(x: number, y: number, width: number): boolean;
+    clone(): Ellipse;
+    copyFrom(ellipse: Ellipse): this;
+    copyTo(ellipse: Ellipse): Ellipse;
+    getBounds(): Rectangle;
+    buildOutline(points: number[]): void;
+    buildGeometry(vertices: number[], indices: number[]): void;
+}
+
+interface PointData {
+    x: number;
+    y: number;
+}
+interface PointLike extends PointData {
+    copyFrom: (p: PointData) => this;
+    copyTo: <T extends PointLike>(p: T) => T;
+    equals: (p: PointData) => boolean;
+    set: (x?: number, y?: number) => void;
+}
+declare class Point {
+    x: number;
+    y: number;
+    protected static _shared?: Point;
+    static get shared(): Point;
+    constructor(x?: number, y?: number);
+    copyFrom(p: PointData): this;
+    copyTo<T extends PointLike>(p: T): T;
+    equals(p: PointData): boolean;
+    set(x?: number, y?: number): this;
+}
+
+declare class Polygon implements Shape {
+    points: number[];
+    closed: boolean;
+    get lastX(): number;
+    get lastY(): number;
+    get x(): number;
+    get y(): number;
+    constructor(points: PointData[] | number[]);
+    constructor(...points: PointData[] | number[]);
+    reset(): this;
+    contains(x: number, y: number): boolean;
+    strokeContains(x: number, y: number, strokeWidth: number): boolean;
+    clone(): Polygon;
+    copyFrom(polygon: Polygon): this;
+    copyTo(polygon: Polygon): Polygon;
+    getBounds(out?: Rectangle): Rectangle;
+    buildOutline(points: number[]): void;
+    buildGeometry(vertices: number[], indices: number[]): void;
+}
+
+declare class RoundedRectangle implements Shape {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius: number;
+    constructor(x?: number, y?: number, width?: number, height?: number, radius?: number);
+    getBounds(out?: Rectangle): Rectangle;
+    clone(): RoundedRectangle;
+    copyFrom(rectangle: RoundedRectangle): this;
+    copyTo(rectangle: RoundedRectangle): RoundedRectangle;
+    contains(x: number, y: number): boolean;
+    strokeContains(pX: number, pY: number, strokeWidth: number): boolean;
+    buildOutline(points: number[]): void;
+    buildGeometry(vertices: number[], indices: number[]): void;
+}
+
+declare class Star extends Polygon {
+    constructor(x?: number, y?: number, points?: number, radius?: number, innerRadius?: number, rotation?: number);
+}
+
+declare function squaredDistanceToLineSegment(x: number, y: number, x1: number, y1: number, x2: number, y2: number): number;
+declare class Triangle implements Shape {
+    x: number;
+    y: number;
+    x2: number;
+    y2: number;
+    x3: number;
+    y3: number;
+    constructor(x?: number, y?: number, x2?: number, y2?: number, x3?: number, y3?: number);
+    contains(x: number, y: number): boolean;
+    strokeContains(pointX: number, pointY: number, strokeWidth: number): boolean;
+    clone(): Triangle;
+    copyFrom(triangle: Triangle): this;
+    copyTo(triangle: Triangle): Triangle;
+    getBounds(out?: Rectangle): Rectangle;
+    buildOutline(points: number[]): void;
+    buildGeometry(vertices: number[], indices: number[]): void;
+}
+
+interface ShapeBuildCommand<T extends Shape = Shape> {
+    build: (shape: T, points: number[]) => void;
+    triangulate: (points: number[], vertices: number[], verticesStride: number, verticesOffset: number, indices: number[], indicesOffset: number) => void;
+}
+
+type RoundedShape = Circle | Ellipse | RoundedRectangle;
+declare const buildCircle: ShapeBuildCommand<RoundedShape>;
+
+type LineCap = 'butt' | 'round' | 'square';
+type LineJoin = 'round' | 'bevel' | 'miter';
+declare const closePointEps = 0.0001;
+declare const curveEps = 0.0001;
+interface LineStyle {
+    width: number;
+    alignment: number;
+    join: LineJoin;
+    cap: LineCap;
+    miterLimit: number;
+}
+/**
+ * Builds a line to draw using the polygon method.
+ * @param points
+ * @param lineStyle
+ * @param flipAlignment
+ * @param closed
+ * @param vertices
+ * @param _verticesStride
+ * @param _verticesOffset
+ * @param indices
+ * @param _indicesOffset
+ */
+declare function buildLine(points: number[], lineStyle: LineStyle, flipAlignment: boolean, closed: boolean, vertices: number[], _verticesStride: number, _verticesOffset: number, indices: number[], _indicesOffset: number): void;
+
+declare const buildPolygon: ShapeBuildCommand<Polygon>;
+
+declare const buildRectangle: ShapeBuildCommand<Rectangle>;
+
+declare const buildTriangle: ShapeBuildCommand<Triangle>;
+
+interface Path2DShape {
+    shape: Shape;
+    transform?: Transform2D;
+}
+declare class Path2D {
+    protected _polygon?: Polygon;
+    protected _bounds: Bounds;
+    shapes: Path2DShape[];
+    get bounds(): Bounds;
+    startPolygon(x: number, y: number): this;
+    endPolygon(closePath?: boolean): this;
+    ensurePolygon(start?: boolean): void;
+    beginPath(): this;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): this;
+    quadraticCurveTo(cp1x: number, cp1y: number, x: number, y: number, smoothing?: number): this;
+    rect(x: number, y: number, width: number, height: number, transform?: Transform2D): void;
+    roundRect(x: number, y: number, width: number, height: number, radii: number, transform?: Transform2D): void;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, transform?: Transform2D): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise: boolean): this;
+    ellipticalArc(rx: number, ry: number, xAxisRotation: number, largeArcFlag: number, sweepFlag: number, x: number, y: number): this;
+    poly(points: number[] | PointData[], close?: boolean, transform?: Transform2D): this;
+    addShape(shape: Shape, transform?: Transform2D): this;
+    addPath(path2D: Path2D): this;
+    addSVGPath(d: string): this;
+    closePath(): this;
+    buildOutline(points?: number[]): number[];
+    buildGeometry(vertices?: number[], indices?: number[]): {
+        vertices: number[];
+        indices: number[];
+    };
+}
+
+type SVGPathDefineCommand = 'a' | 's' | 't' | 'v' | 'z' | 'q' | 'g' | 'm' | 'h' | 'l' | 'c' | 'A' | 'S' | 'T' | 'V' | 'Z' | 'Q' | 'G' | 'M' | 'H' | 'L' | 'C';
+interface SVGPathDefine {
+    command: SVGPathDefineCommand;
+    args: number[];
+}
+type Path2DCallMethod = 'moveTo' | 'lineTo' | 'bezierCurveTo' | 'quadraticCurveTo' | 'ellipticalArc' | 'closePath' | 'rect' | 'roundRect' | 'circle' | 'ellipse' | 'arc' | 'poly' | 'addPath' | 'arcTo' | 'regularPoly' | 'roundPoly' | 'roundShape' | 'filletRect' | 'chamferRect';
+interface Path2DCall {
+    method: Path2DCallMethod;
+    args: any[];
+}
+declare class SVGPath {
+    defines: SVGPathDefine[];
+    protected _calls: Path2DCall[];
+    protected _dirty: boolean;
+    get path2D(): Path2D;
+    constructor(d: string | SVGPath);
+    protected _addCall(method: Path2DCallMethod, args?: any[], dirty?: boolean): this;
+    protected _parseDefines(d: string): SVGPathDefine[];
+    update(): void;
+    protected _getLastPoint(out: Point): Point;
+    protected _smoothBezierCurveTo(cp2x: number, cp2y: number, x: number, y: number, smoothness?: number): this;
+    protected _smoothQuadraticCurveTo(x: number, y: number, smoothness?: number): this;
+}
+
+/**
+ * Matrix2
+ *
+ * | x0 | y0 |
+ * | x1 | y1 |
+ */
+declare class Matrix2 extends Matrix {
+    constructor(array?: number[]);
+}
+
+/**
+ * Matrix4
+ *
+ * | x0 | y0 | z0 | m0 |
+ * | x1 | y1 | z1 | m1 |
+ * | x2 | y2 | z2 | m2 |
+ */
+declare class Matrix4 extends Matrix {
+    constructor(array?: 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 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;
+};
+
+/**
+ * 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;
+}
+
+/**
+ * Vector3
+ */
+declare class Vector3 extends Vector {
+    constructor();
+}
+
+/**
+ * Vector4
+ */
+declare class Vector4 extends Vector {
+    constructor(x?: number, y?: number, z?: number, m?: number);
+}
+
+type TextureFilterMode = WebGLTextureFilterMode;
+type TextureWrapMode = WebGLTextureWrapMode;
+interface TexturePixelsSource {
+    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;
+    source: T;
+    width: number;
+    height: number;
+    filterMode: TextureFilterMode;
+    wrapMode: TextureWrapMode;
+    pixelRatio: number;
+    protected _isPowerOfTwo: boolean;
+    protected _needsUpload: boolean;
+    get valid(): boolean;
+    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 _updateSize(): void;
+    requestUpload(): void;
+    upload(renderer: WebGLRenderer, options?: Partial<WebGLTextureOptions>): boolean;
+    activate(renderer: WebGLRenderer, location?: number): void;
+    inactivate(renderer: WebGLRenderer): void;
+    destroy(): void;
+}
+
+interface ImageTextureOptions {
+    autoLoad?: boolean;
+    useBitmap?: boolean;
+    crossorigin?: boolean | string | null;
+}
+declare class ImageTexture extends Texture<HTMLImageElement> {
+    bitmap?: ImageBitmap;
+    useBitmap: boolean;
+    preserveBitmap: boolean;
+    protected _loadSource?: Promise<this>;
+    protected _loadBitmap?: Promise<this>;
+    constructor(source: HTMLImageElement, options?: ImageTextureOptions);
+    load(): Promise<this>;
+    genBitmap(): Promise<this>;
+    /** @internal */
+    _glTextureOptions(renderer: WebGLRenderer): WebGLTextureOptions;
+    upload(renderer: WebGLRenderer): boolean;
+}
+
+declare class PixelsTexture extends Texture<TexturePixelsSource> {
+    constructor(pixels?: ArrayLike<number> | ArrayBufferLike | ArrayBufferView | null, width?: number, height?: number);
+}
+
+interface VideoTextureOptions {
+    autoLoad?: boolean;
+    autoPlay?: boolean;
+    fps?: number;
+    crossorigin?: boolean | string | null;
+    loop?: boolean;
+    muted?: boolean;
+    playsinline?: boolean;
+}
+interface VideoTextureSource {
+    src: string;
+    mime: string;
+}
+declare class VideoTexture extends Texture<HTMLVideoElement> {
+    autoUpdate: boolean;
+    fps: number;
+    static readonly mimeTypes: Map<string, string>;
+    get isReady(): boolean;
+    get isPlaying(): boolean;
+    get duration(): number;
+    get seeking(): boolean;
+    get currentTime(): number;
+    set currentTime(val: number);
+    protected _spf: number;
+    protected _autoPlay: boolean;
+    protected _sourceLoad?: Promise<this>;
+    protected _nextTime: number;
+    protected _connected: boolean;
+    protected _requestId?: number;
+    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 _onPlayStart: () => void;
+    protected _onPlayStop: () => void;
+    protected _onCanPlay: () => void;
+    protected _onError: (event: ErrorEvent) => void;
+    /** Fired when the video is completed seeking to the current playback position. */
+    protected _onSeeked: () => void;
+    protected _setupAutoUpdate(): void;
+    protected _videoFrameRequestCallback: () => void;
+    requestUpload: () => void;
+    load(): Promise<this>;
+    destroy(): void;
+}
+
+declare class ViewportTexture extends PixelsTexture {
+}
+
+interface ViewportFramebuffer {
+    texture: ViewportTexture;
+    needsUpload: boolean;
+}
+declare class Viewport extends Node {
+    flipY: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protected _projection: Projection2D;
+    protected _framebufferIndex: number;
+    protected _framebuffers: ViewportFramebuffer[];
+    get framebuffer(): ViewportFramebuffer;
+    get texture(): ViewportTexture;
+    constructor(flipY?: boolean);
+    /** @internal */
+    _glFramebufferOptions(renderer: WebGLRenderer): WebGLFramebufferOptions;
+    /** @internal */
+    _glFramebuffer(renderer: WebGLRenderer): WebGLFramebuffer;
+    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    requestUpload(): void;
+    resize(width: number, height: number): void;
+    upload(renderer: WebGLRenderer): boolean;
+    activate(renderer: WebGLRenderer): void;
+    redraw(renderer: WebGLRenderer, cb: () => void): void;
+    activateWithCopy(renderer: WebGLRenderer, target: Viewport): void;
+    render(renderer: WebGLRenderer, next?: () => void): void;
+    toProjectionArray(transpose?: boolean): number[];
+}
+
+interface SceneTreeEventMap extends MainLoopEventMap {
+    processing: () => void;
+    processed: () => void;
+    nodeProcessing: (node: Node) => void;
+    nodeProcessed: (node: Node) => void;
+}
+interface SceneTree {
+    on: (<K extends keyof SceneTreeEventMap>(type: K, listener: SceneTreeEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof SceneTreeEventMap>(type: K, listener: SceneTreeEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof SceneTreeEventMap>(type: K, ...args: Parameters<SceneTreeEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class SceneTree extends MainLoop {
+    readonly renderStack: RenderStack;
+    readonly root: Viewport;
+    readonly timeline: Timer;
+    protected _currentViewport?: Viewport;
+    getCurrentViewport(): Viewport | undefined;
+    setCurrentViewport(viewport: Viewport | undefined): void;
+    protected _render(renderer: WebGLRenderer, delta?: number): this;
+    protected _renderScreen(renderer: WebGLRenderer): void;
+}
+
+interface NodeEventMap extends ReferenceEventMap {
+    enterTree: () => void;
+    exitTree: () => void;
+    childExitingTree: (node: Node) => void;
+    childEnteredTree: (node: Node) => void;
+    postEnterTree: () => void;
+    ready: () => void;
+    treeEntered: () => void;
+    treeExiting: () => void;
+    treeExited: () => void;
+    parented: () => void;
+    unparented: () => void;
+    process: (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;
+}
+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 {
+    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;
+    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;
+    /** Name */
+    setName(value: string): this;
+    /** Tree */
+    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;
+    /** 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: WeakMap<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 {
+    shapes: Path2DShape[];
+    texture?: Texture;
+    textureTransform?: Transform2D;
+    style: LineStyle;
+}
+interface FilledGraphics {
+    shapes: Path2DShape[];
+    texture?: Texture;
+    textureTransform?: Transform2D;
+}
+declare class CanvasContext {
+    moveTo: (x: number, y: number) => this;
+    lineTo: (x: number, y: number) => this;
+    bezierCurveTo: (cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, smoothness?: number) => this;
+    quadraticCurveTo: (cp1x: number, cp1y: number, x: number, y: number, smoothing?: number) => this;
+    ellipticalArc: (rx: number, ry: number, xAxisRotation: number, largeArcFlag: number, sweepFlag: number, x: number, y: number) => this;
+    rect: (x: number, y: number, width: number, height: number, transform?: Transform2D) => this;
+    roundRect: (x: number, y: number, width: number, height: number, radii: number, transform?: Transform2D) => this;
+    ellipse: (x: number, y: number, radiusX: number, radiusY: number, transform?: Transform2D) => this;
+    arc: (x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise: boolean) => this;
+    poly: (points: number[] | PointData[], close?: boolean, transform?: Transform2D) => this;
+    addShape: (shape: Shape, transform?: Transform2D) => this;
+    addPath: (path2D: Path2D) => this;
+    addSvgPath: (d: string) => this;
+    closePath: () => this;
+    textureTransform?: Transform2D;
+    fillStyle?: ColorValue | Texture;
+    strokeStyle?: ColorValue | Texture;
+    lineCap?: LineCap;
+    lineJoin?: LineJoin;
+    lineWidth?: number;
+    miterLimit?: number;
+    protected _path2D: Path2D;
+    protected _defaultStyle: Texture<TextureSource>;
+    protected _stroked: StrokedGraphics[];
+    protected _filled: 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;
+    reset(): void;
+    buildUvs(start: number, vertices: number[], uvs: number[], texture?: Texture, textureTransform?: Transform2D): void;
+    toBatchables(): CanvasBatchable[];
+}
+
+interface Style2DOptions extends Partial<Style2DBackgroundProperties>, Partial<Style2DFilterProperties>, Partial<Style2DOffsetProperties>, Partial<Style2DTextProperties>, Partial<Style2DTransformProperties> {
+    shadowColor?: string;
+    shadowOffsetX?: number;
+    shadowOffsetY?: number;
+    shadowBlur?: number;
+    opacity?: number;
+    borderRadius?: number;
+    overflow?: Overflow;
+}
+interface Style2D extends Style2DBackgroundExtend, Style2DFilterExtend, Style2DOffsetExtend, 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 {
+    getComputedBackground: typeof getComputedBackground;
+}
+declare class Style2DBackgroundModule extends Style2DModule {
+    install(Style2D: new () => Style2D): void;
+}
+declare function getComputedBackground(this: Style2D): Promise<ColorTexture | 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;
+}
+declare function getComputedFilter(this: Style2D): Style2DFilter;
+declare function getComputedFilterColorMatrix(this: Style2D): ColorMatrix;
+
+interface Style2DOffsetProperties {
+    offsetPath?: string;
+    offsetAnchor?: string | number;
+    offsetDistance?: string | number;
+    offsetPosition?: string | number;
+}
+interface Style2DOffsetExtend extends Style2DOffsetProperties {
+    getComputedOffset: typeof getComputedOffset;
+}
+declare module '../Style2D' {
+    interface Style2DOptions extends Partial<Style2DOffsetProperties> {
+    }
+    interface Style2D extends Style2DOffsetProperties {
+        getComputedOffset: typeof getComputedOffset;
+    }
+}
+declare class Style2DOffsetModule extends Style2DModule {
+    install(Style2D: new () => Style2D): void;
+}
+declare function getComputedOffset(this: Style2D): void;
+
+interface Style2DTextProperties {
+    color: string;
+    fontSize: number;
+    fontWeight: FontWeight;
+    fontFamily: string;
+    fontStyle: FontStyle;
+    fontKerning: FontKerning;
+    textWrap: TextWrap;
+    textAlign: TextAlign;
+    verticalAlign: VerticalAlign;
+    textTransform: TextTransform;
+    textDecoration: TextDecoration | null;
+    textStrokeWidth: number;
+    textStrokeColor: string;
+    direction: 'inherit' | 'ltr' | 'rtl';
+    lineHeight: number;
+    letterSpacing: number;
+    writingMode: WritingMode;
+}
+interface Style2DTextExtend extends Style2DTextProperties {
+}
+declare class Style2DTextModule extends Style2DModule {
+    install(Style2D: new () => Style2D): void;
+}
+
+interface Style2DTransformProperties {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    rotate: number;
+    scaleX: number;
+    scaleY: number;
+    transform?: string;
+    transformOrigin: string;
+}
+interface Style2DTransformExtend extends Style2DTransformProperties {
+    getComputedTransform: typeof getComputedTransform;
+    getComputedTransformOrigin: typeof getComputedTransformOrigin;
+}
+declare class Style2DTransformModule extends Style2DModule {
+    install(Style2D: new () => Style2D): void;
+}
+declare function getComputedTransform(this: Style2D): Transform2D;
+declare function getComputedTransformOrigin(this: Style2D): number[];
+
+interface CanvasItemOptions extends NodeOptions {
+    style?: Style2DOptions;
+    tint?: string;
+    blendMode?: WebGLBlendMode;
+}
+declare class CanvasItem extends Node {
+    tint?: ColorValue;
+    blendMode?: WebGLBlendMode;
+    protected _style: Style2D;
+    get style(): Style2D;
+    set style(style: Style2D);
+    /** @internal */
+    opacity: number;
+    protected _parentOpacity?: number;
+    protected _tint: Color;
+    protected _backgroundColor: Color;
+    context: CanvasContext;
+    protected _resetContext: boolean;
+    protected _waitingRedraw: boolean;
+    protected _waitingReflow: boolean;
+    protected _waitingRepaint: boolean;
+    protected _originalBatchables: CanvasBatchable[];
+    protected _layoutedBatchables: CanvasBatchable[];
+    protected _batchables: CanvasBatchable[];
+    constructor(options?: CanvasItemOptions);
+    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 _updateOpacity(): void;
+    isVisible(): boolean;
+    requestRedraw(): void;
+    requestReflow(): void;
+    requestRepaint(): void;
+    protected _process(delta: number): void;
+    protected _draw(): void;
+    protected _relayout(batchables: CanvasBatchable[]): CanvasBatchable[];
+    protected _reflow(batchables: CanvasBatchable[]): CanvasBatchable[];
+    protected _repaint(batchables: CanvasBatchable[]): CanvasBatchable[];
+    protected _render(renderer: WebGLRenderer): void;
+    toJSON(): Record<string, any>;
+}
+
+interface Node2DOptions extends CanvasItemOptions {
+}
+declare class Node2D extends CanvasItem {
+    readonly _transform: Transform2D;
+    protected _parentTransformDirtyId?: number;
+    constructor(options?: Node2DOptions);
+    getBoundingBox(): Rectangle;
+    protected _onUpdateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateTransform(): void;
+    protected _transformVertices(vertices: number[]): number[];
+    protected _reflow(batchables: CanvasBatchable[]): CanvasBatchable[];
+    protected _process(delta: number): void;
+    input(event: UIEvent): void;
+}
+
+interface Element2DOptions extends Node2DOptions {
+    draggable?: boolean;
+}
+declare class Element2D extends Node2D {
+    draggable?: boolean;
+    protected _background?: Texture;
+    constructor(options?: Element2DOptions);
+    protected _onUpdateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _updateBackground(): Promise<void>;
+    protected _updateTransform(): void;
+    protected _updateOverflow(): void;
+    protected _draw(): void;
+    protected _drawBackground(): void;
+    protected _drawContent(): void;
+    protected _drawRect(): void;
+}
+
+declare class Graphics2D extends Node2D {
+    protected _resetContext: boolean;
+    lineCap?: LineCap;
+    lineJoin?: LineJoin;
+    fillStyle?: ColorValue | Texture;
+    strokeStyle?: ColorValue | Texture;
+    lineWidth?: number;
+    miterLimit?: number;
+    rect: (x: number, y: number, width: number, height: number) => this;
+    fillRect: (x: number, y: number, width: number, height: number) => this;
+    strokeRect: (x: number, y: number, width: number, height: number) => this;
+    roundRect: (x: number, y: number, width: number, height: number, radii: number) => this;
+    ellipse: (x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean) => this;
+    arc: (x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean) => this;
+    beginPath: () => this;
+    moveTo: (x: number, y: number) => this;
+    lineTo: (x: number, y: number) => this;
+    closePath: () => this;
+    fill: () => this;
+    stroke: () => this;
+    drawCircle(x: number, y: number, radius: number): this;
+    drawEllipse(x: number, y: number, width: number, height: number): this;
+}
+
+interface ImageFrame {
+    texture: Texture;
+    duration: number;
+}
+declare class Image2DResource extends Resource {
+    frames: ImageFrame[];
+    duration: number;
+    constructor(source: Texture | ImageFrame[]);
+    updateDuration(): this;
+    destroy(): void;
+}
+
+interface Image2DOptions extends Element2DOptions {
+    src?: string;
+    gif?: boolean;
+}
+declare class Image2D extends Element2D {
+    resource?: Image2DResource;
+    gif: boolean;
+    src: string;
+    get currentTexture(): Texture | undefined;
+    get duration(): 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;
+    decode(): Promise<void>;
+    setResource(source: Texture | ImageFrame[] | Image2DResource): this;
+    protected _load(src: string): Promise<void>;
+    protected _getCurrentTime(): number;
+    protected _updateFrameIndex(): this;
+    protected _process(delta: number): void;
+    protected _drawContent(): void;
+    protected _repaint(batchables: CanvasBatchable[]): CanvasBatchable[];
+}
+
+interface LottieOptions extends Element2DOptions {
+    pixelRatio?: number;
+    src?: string;
+}
+declare class Lottie2D extends Element2D {
+    pixelRatio: number;
+    src: string;
+    duration: number;
+    readonly texture: Texture<HTMLCanvasElement>;
+    animation?: AnimationItem;
+    constructor(options?: LottieOptions);
+    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _onUpdateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _load(): Promise<void>;
+    protected _process(delta: number): void;
+    protected _drawContent(): void;
+}
+
+interface Text2DOptions extends Element2DOptions {
+    pixelRatio?: number;
+    split?: boolean;
+    content?: IDOCTextContent;
+    effects?: Partial<IDOCStyleDeclaration>[];
+}
+declare class Text2D extends Element2D {
+    pixelRatio: number;
+    split: boolean;
+    content: IDOCTextContent;
+    effects?: Partial<IDOCStyleDeclaration>[];
+    readonly texture: Texture<HTMLCanvasElement>;
+    protected _subTextsCount: number;
+    constructor(options?: Text2DOptions);
+    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _onUpdateStyleProperty(key: PropertyKey, value: any, oldValue: any): void;
+    protected _getSubTexts(): Text2D[];
+    protected _updateSubTexts(): void;
+    measure(): MeasureResult;
+    protected _updateSplit(): void;
+    protected _drawContent(): void;
+}
+
+interface Video2DOptions extends Element2DOptions {
+    src?: string;
+}
+declare class Video2D extends Element2D {
+    src: string;
+    texture?: VideoTexture;
+    get duration(): number;
+    protected _wait: Promise<void>;
+    constructor(options?: Video2DOptions);
+    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): 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 class VideoLoader extends Loader {
+    load: (url: string) => Promise<VideoTexture>;
+    install(assets: Assets): this;
+}
+
+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 abstract class AudioProcessor {
+    destination: IAudioNode;
+    source: IAudioNode | null;
+    constructor(destination: IAudioNode, source?: IAudioNode | null);
+    connect(destination: IAudioNode): void;
+    disconnect(): void;
+}
+
+declare class AudioPipeline extends EventEmitter {
+    protected _input: IAudioNode;
+    protected _output: IAudioNode;
+    protected _processers: AudioProcessor[];
+    constructor(_input: IAudioNode, _output: IAudioNode);
+    get processors(): AudioProcessor[];
+    set processors(val: AudioProcessor[]);
+    get destination(): IAudioNode;
+}
+
+interface IAudioContext {
+    muted: boolean;
+    volume: number;
+    playbackRate: number;
+    paused: boolean;
+    processors: AudioProcessor[];
+    toggleMute: () => boolean;
+    togglePause: () => boolean;
+    refreshPaused: () => void;
+    refresh: () => void;
+    audioContext: AudioContext;
+}
+
+type IAudioNode = AudioNode;
+
+interface IPlayOptions {
+    start?: number;
+    end?: number;
+    playbackRate?: number;
+    loop?: boolean;
+    volume?: number;
+    muted?: boolean;
+    processors?: AudioProcessor[];
+    complete?: () => void;
+    multiple?: boolean;
+}
+
+declare class HTMLAudioContext extends EventEmitter implements IAudioContext {
+    protected static _instance?: HTMLAudioContext;
+    static get instance(): HTMLAudioContext;
+    playbackRate: number;
+    muted: boolean;
+    volume: number;
+    paused: boolean;
+    refresh(): void;
+    refreshPaused(): void;
+    get processors(): AudioProcessor[];
+    set processors(_processors: AudioProcessor[]);
+    get audioContext(): AudioContext;
+    toggleMute(): boolean;
+    togglePause(): boolean;
+    destroy(): void;
+}
+
+declare class HTMLSound extends EventEmitter {
+    static readonly PADDING = 0.1;
+    protected _source: HTMLAudioElement | null;
+    protected _audio: HTMLAudio | null;
+    protected _end: number;
+    protected _pausedReal: boolean;
+    protected _duration: number;
+    protected _start: number;
+    protected _playing: boolean;
+    get progress(): number;
+    /** Paused */
+    protected _paused: boolean;
+    get paused(): boolean;
+    set paused(val: boolean);
+    /** PlaybackRate */
+    protected _playbackRate: number;
+    get playbackRate(): number;
+    set playbackRate(val: number);
+    /** Volume */
+    protected _volume: number;
+    get volume(): number;
+    set volume(val: number);
+    /** Loop */
+    protected _loop: boolean;
+    get loop(): boolean;
+    set loop(val: boolean);
+    /** Muted */
+    protected _muted: boolean;
+    get muted(): boolean;
+    set muted(val: boolean);
+    set(name: 'playbackRate' | 'volume' | 'muted' | 'loop' | 'paused', value: number | boolean): this;
+    protected _onPlay(): void;
+    protected _onPause(): void;
+    init(audio: HTMLAudio): this;
+    protected _stop(): void;
+    stop(): void;
+    get processors(): AudioProcessor[];
+    set processors(_val: AudioProcessor[]);
+    refresh(): void;
+    refreshPaused(): void;
+    play(options?: IPlayOptions): void;
+    protected _onUpdate: () => void;
+    protected _onComplete(): void;
+    destroy(): void;
+}
+
+declare class HTMLAudio {
+    parent: Audio;
+    source: HTMLAudioElement;
+    protected _src: string;
+    get src(): string;
+    set src(val: string);
+    get duration(): number;
+    get isPlayable(): boolean;
+    get context(): HTMLAudioContext;
+    constructor(parent: Audio);
+    load(): Promise<this>;
+    createSound(): HTMLSound;
+}
+
+declare class WebAudioContext extends AudioPipeline implements IAudioContext {
+    /** Singleton */
+    protected static _instance?: WebAudioContext;
+    static get instance(): WebAudioContext;
+    static get audioContext(): AudioContext;
+    static get offlineContext(): OfflineAudioContext;
+    static setParamValue(param: AudioParam, value: number): void;
+    static decode(buffer: ArrayBuffer): Promise<AudioBuffer>;
+    /** Context */
+    protected _context: AudioContext;
+    protected _offlineContext: OfflineAudioContext;
+    get audioContext(): AudioContext;
+    get offlineContext(): OfflineAudioContext;
+    protected _locked: boolean;
+    muted: boolean;
+    volume: number;
+    playbackRate: number;
+    /** Paused */
+    autoPause: boolean;
+    protected _paused: boolean;
+    protected _pausedOnBlur: boolean;
+    get paused(): boolean;
+    set paused(val: boolean);
+    /** Nodes */
+    protected _compressor: DynamicsCompressorNode;
+    protected _analyser: AnalyserNode;
+    constructor();
+    protected _onFocus(): void;
+    protected _onBlur(): void;
+    protected _unlock: () => void;
+    playEmptySound(): void;
+    refresh(): void;
+    refreshPaused(): void;
+    toggleMute(): boolean;
+    togglePause(): boolean;
+    decode(buffer: ArrayBuffer): Promise<AudioBuffer>;
+    setParamValue(param: AudioParam, value: number): void;
+}
+
+declare class WebSound extends EventEmitter {
+    protected _audio: WebAudio | null;
+    protected _sourceNode: AudioBufferSourceNode | null;
+    protected _gain: GainNode | null;
+    /** Progress */
+    protected _progress: number;
+    get progress(): number;
+    /** Paused */
+    protected _pausedReal: boolean;
+    protected _paused: boolean;
+    get paused(): boolean;
+    set paused(val: boolean);
+    /** Volume */
+    protected _volume: number;
+    get volume(): number;
+    set volume(val: number);
+    /** PlaybackRate */
+    protected _playbackRate: number;
+    get playbackRate(): number;
+    set playbackRate(val: number);
+    /** Loop */
+    protected _loop: boolean;
+    get loop(): boolean;
+    set loop(val: boolean);
+    /** Muted */
+    protected _muted: boolean;
+    get muted(): boolean;
+    set muted(val: boolean);
+    protected _duration: number;
+    protected _end: number;
+    protected _elapsed: number;
+    protected _lastUpdate: number;
+    /** Processors */
+    protected _processors: AudioProcessor[];
+    init(audio: WebAudio): this;
+    protected _now(): number;
+    play(options?: IPlayOptions): void;
+    protected _stop(): void;
+    stop(): void;
+    protected _update(force?: boolean): void;
+    refresh(): void;
+    applyProcessors(): void;
+    refreshPaused(): void;
+    protected _onComplete: () => void;
+    protected _updateListener: () => void;
+    protected _enableTicker(enabled: boolean): void;
+    destroy(): void;
+}
+
+declare class WebAudio extends AudioPipeline {
+    parent: Audio;
+    /** Source */
+    protected _sourceBuffer?: AudioBuffer;
+    protected _sourceNode: AudioBufferSourceNode;
+    protected _sourceLoad?: Promise<this>;
+    /** Nodes */
+    gain: GainNode;
+    analyser: AnalyserNode;
+    get context(): WebAudioContext;
+    get isPlayable(): boolean;
+    get duration(): number;
+    get buffer(): AudioBuffer | null;
+    set buffer(val: AudioBuffer | null);
+    constructor(parent: Audio);
+    load(): Promise<this>;
+    protected _loadUrl(url: string): Promise<this>;
+    protected _decode(buffer: ArrayBuffer | AudioBuffer): Promise<AudioBuffer>;
+    cloneSource(): {
+        source: AudioBufferSourceNode;
+        gain: GainNode;
+    };
+    createSound(): WebSound;
+}
+
+type PlatformAudio = WebAudio | HTMLAudio;
+type PlatformSound = WebSound | HTMLSound;
+declare class Audio extends Node {
+    protected static _soundPool: PlatformSound[];
+    protected _sounds: PlatformSound[];
+    /** PlatformAudio */
+    protected _platformAudio: HTMLAudio | WebAudio;
+    get platformAudio(): PlatformAudio;
+    /** Src */
+    protected _src: string;
+    get src(): string;
+    set src(val: string);
+    isLoaded: boolean;
+    get isPlayable(): boolean;
+    /** Duration */
+    get duration(): number;
+    /** Volume */
+    protected _volume: number;
+    get volume(): number;
+    set volume(val: number);
+    /** Muted */
+    protected _muted: boolean;
+    get muted(): boolean;
+    set muted(val: boolean);
+    /** Loop */
+    protected _loop: boolean;
+    get loop(): boolean;
+    set loop(val: boolean);
+    /** PlaybackRate */
+    protected _playbackRate: number;
+    get playbackRate(): number;
+    set playbackRate(val: number);
+    /** 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);
+    load(): Promise<this>;
+    pause(): this;
+    resume(): this;
+    stop(): this;
+    play(options?: IPlayOptions): PlatformSound | undefined;
+    protected _removeSounds(): void;
+    protected _createSound(): PlatformSound;
+    refresh(): void;
+    refreshPaused(): void;
+    protected _onComplete: (sound: PlatformSound) => void;
+    protected _recycleSound(sound: PlatformSound): void;
+    protected _prevTime: number;
+    protected _timer: number;
+    protected _process(delta: number): void;
+    protected _setTimeStop(): void;
+}
+
+declare class AudioSpectrum extends Element2D {
+}
+
+interface AudioWaveformOptions extends Element2DOptions {
+    src?: string;
+    gap?: number;
+    color?: string;
+}
+declare class AudioWaveform extends Element2D {
+    src?: string;
+    gap: number;
+    color: string;
+    protected _audioBuffer?: AudioBuffer;
+    protected _src: Texture<HTMLCanvasElement> | undefined;
+    protected _needsUpdateTexture: boolean;
+    constructor(options?: AudioWaveformOptions);
+    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    _loadSrc(src: string): Promise<void>;
+    syncTexture(force?: boolean): void;
+    protected _process(delta: number): void;
+    protected _drawSrc(): void;
+}
+
+type EffectMode = 'before' | 'parent' | 'children' | 'transition';
+interface EffectOptions extends NodeOptions {
+    mode?: EffectMode;
+    duration?: number;
+    glsl?: string;
+    glslSrc?: string;
+    material?: Material;
+}
+interface EffectContext {
+    redraw?: boolean;
+    /** parent redraw */
+    target?: Node;
+    targetArea?: [number, number, number, number];
+    /** transition */
+    from?: Viewport;
+    to?: Viewport;
+}
+declare class Effect extends Node {
+    material?: Material;
+    mode?: EffectMode;
+    glsl: string;
+    glslSrc: string;
+    delay: number;
+    duration: number;
+    protected get _mode(): EffectMode;
+    /** Viewports */
+    readonly viewport: Viewport;
+    readonly viewport2: Viewport;
+    /** Render call */
+    protected _renderId: number;
+    protected _renderViewport?: Viewport;
+    /** Temporary nodes for transition */
+    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 _processParent(): void;
+    protected _processChildren(): void;
+    _onProcess(delta?: number): void;
+    protected _renderBefore(renderer: WebGLRenderer): void;
+    protected _renderTransition(renderer: WebGLRenderer): void;
+    protected _renderParentOrChildren(renderer: WebGLRenderer): void;
+    protected _parseTargetArea(): number[] | undefined;
+    protected _render(renderer: WebGLRenderer): void;
+    apply(renderer: WebGLRenderer, viewport: Viewport, context?: EffectContext): void;
+}
+
+declare class BlurEffect extends Effect {
+    static materialX: Material;
+    static materialY: Material;
+    strength: number;
+    quality: number;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+declare class ColorAdjustEffect extends Effect {
+    static material: Material;
+    saturation: number;
+    contrast: number;
+    brightness: number;
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+    gamma: number;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+interface ColorFilterEffectOptions {
+    filter?: string;
+}
+declare class ColorFilterEffect extends Effect {
+    filter: string;
+    protected _colorMatrix: ColorMatrix;
+    constructor(options?: ColorFilterEffectOptions);
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+    static material: Material;
+}
+
+declare class ColorOverlayEffect extends Effect {
+    static material: Material;
+    colors: ColorValue[];
+    alpha: number;
+    protected _color: Color;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+declare class ColorRemoveEffect extends Effect {
+    static material: Material;
+    colors: ColorValue[];
+    epsilon: number;
+    protected _color: Color;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+declare class ColorReplaceEffect extends Effect {
+    static material: Material;
+    colors: ColorValue[][];
+    epsilon: number;
+    protected _color: Color;
+    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);
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+    static material: Material;
+}
+
+declare class GlitchEffect extends Effect {
+    static material: Material;
+    protected _canvas: HTMLCanvasElement;
+    protected _texture: Texture;
+    protected _sizes: Float32Array;
+    protected _offsets: Float32Array;
+    protected _redraw: boolean;
+    slices: number;
+    sampleSize: number;
+    offset: number;
+    direction: number;
+    fillMode: number;
+    seed: number;
+    red: number[];
+    green: number[];
+    blue: number[];
+    constructor();
+    redraw(): void;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+declare class GodrayEffect extends Effect {
+    static material: Material;
+    angle: number;
+    gain: number;
+    lacunarity: number;
+    parallel: boolean;
+    center: number[];
+    alpha: number;
+    apply(renderer: WebGLRenderer, source: Viewport): void;
+}
+
+declare class KawaseEffect extends Effect {
+    static material: Material;
+    blur: number;
+    quality: number;
+    apply(renderer: WebGLRenderer, target: Viewport): void;
+}
+
+declare class LeftEraseEffect extends Effect {
+    static material: Material;
+    apply(renderer: WebGLRenderer): void;
+}
+
+interface MaskEffectOptions extends EffectOptions {
+    src?: string;
+}
+declare class MaskEffect extends Effect {
+    texture?: Texture<ImageBitmap>;
+    src: string;
+    constructor(options?: MaskEffectOptions);
+    load(): Promise<void>;
+    protected _onUpdateProperty(key: PropertyKey, value: any, oldValue: any): void;
+    apply(renderer: WebGLRenderer, source: Viewport, context: EffectContext): void;
+    static material: Material;
+}
+
+declare class PixelateEffect extends Effect {
+    static material: Material;
+    size: number;
+    constructor(size?: number);
+    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;
+}
+
+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 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 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 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 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;
+}
+
+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 EngineOptions extends WebGLContextAttributes {
+    view?: HTMLCanvasElement | WebGLRenderingContext | WebGL2RenderingContext;
+    width?: number;
+    height?: number;
+    pixelRatio?: number;
+    background?: ColorValue;
+    autoResize?: boolean;
+}
+interface EngineEventMap {
+    pointerdown: (ev: PointerInputEvent) => void;
+    pointerover: (ev: PointerInputEvent) => void;
+    pointermove: (ev: PointerInputEvent) => void;
+    pointerup: (ev: PointerInputEvent) => void;
+    wheel: (ev: WheelInputEvent) => void;
+}
+declare const defaultOptions: {
+    readonly alpha: true;
+    readonly stencil: true;
+    readonly antialias: false;
+    readonly premultipliedAlpha: true;
+    readonly preserveDrawingBuffer: false;
+    readonly powerPreference: "default";
+};
+interface Engine {
+    on: (<K extends keyof EngineEventMap>(type: K, listener: EngineEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    off: (<K extends keyof EngineEventMap>(type: K, listener: EngineEventMap[K], options?: EventListenerOptions) => this) & ((type: string, listener: EventListenerValue, options?: EventListenerOptions) => this);
+    emit: (<K extends keyof EngineEventMap>(type: K, ...args: Parameters<EngineEventMap[K]>) => boolean) & ((type: string, ...args: any[]) => boolean);
+}
+declare class Engine extends SceneTree {
+    readonly input: Input;
+    readonly renderer: WebGLRenderer;
+    get view(): HTMLCanvasElement | undefined;
+    get gl(): WebGLRenderingContext | WebGL2RenderingContext;
+    get screen(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    get width(): number;
+    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;
+    enableAutoResize(enable?: boolean): this;
+    resize(width: number, height: number, updateCss?: boolean): this;
+    nextTick(): Promise<void>;
+    waitUntilLoad(): Promise<void>;
+    render(delta?: number): this;
+    start(): this;
+    destroy(): void;
+    toPixels(): Uint8ClampedArray;
+    toImageData(): ImageData;
+    toCanvas2D(): HTMLCanvasElement;
+}
+
+interface RenderOptions {
+    data: Record<string, any> | Node | (Node | Record<string, any>)[];
+    width: number;
+    height: number;
+}
+declare function render(options: RenderOptions): Promise<HTMLCanvasElement>;
+
+export { Animation2D, type AnimationOptions, type AssetHandler, Assets, Audio, AudioPipeline, AudioProcessor, AudioSpectrum, AudioWaveform, type AudioWaveformOptions, type Batchable2D, BlurEffect, Bounds, type BoundsData, type CanvasBatchable, CanvasContext, CanvasItem, type CanvasItemOptions, Circle, 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, Element2D, type Element2DOptions, Ellipse, 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, type LineCap, type LineJoin, type LineStyle, 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, Path2D, type Path2DCall, type Path2DCallMethod, type Path2DShape, PixelateEffect, PixelsTexture, type PlatformAudio, type PlatformSound, Point, type PointData, type PointLike, PointerInputEvent, Polygon, Projection2D, type PropertyDeclaration, QuadGeometry, QuadUvGeometry, RAD_TO_DEG, Rectangle, Reference, type ReferenceEventMap, type RenderCall, type RenderOptions, RenderStack, type Renderable, Renderer, Resource, type ResourceEventMap, RoundedRectangle, 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, SVGPath, type SVGPathDefine, type SVGPathDefineCommand, SceneTree, type SceneTreeEventMap, type Shape, type ShapeBuildCommand, Star, type StrokedGraphics, Style2D, type Style2DBackgroundExtend, Style2DBackgroundModule, type Style2DBackgroundProperties, type Style2DFilter, type Style2DFilterExtend, type Style2DFilterKey, Style2DFilterModule, type Style2DFilterProperties, Style2DModule, type Style2DOffsetExtend, Style2DOffsetModule, type Style2DOffsetProperties, 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, Triangle, 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, buildAdaptiveBezier, buildAdaptiveQuadratic, buildArc, buildArcTo, buildArcToSvg, buildCircle, buildLine, buildPolygon, buildRectangle, buildTriangle, clamp, closePointEps, createHTMLCanvas, createNode, crossOrigin, cubicBezier, curveEps, 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, squaredDistanceToLineSegment, timingFunctions, uid };