@kayelaa/canvas 0.1.1 → 0.1.2

package/dist/lea-DvxsutSf.d.cts

@@ -0,0 +1,1482 @@
+/**
+ * @fileoverview High-level 2D Canvas Engine (DOM-like, named entities/scenes)
+ */
+type Listener<T extends any[] = any[]> = (...args: T) => void;
+/**
+ * Generic event emitter with typed events and methods similar to Node.js EventEmitter.
+ *
+ * @template Events - Record mapping event names to argument tuples
+ *
+ * @example
+ * const emitter = new LeaEventEmitter<{
+ *   update: [number];
+ *   error: [Error];
+ * }>();
+ *
+ * emitter.on('update', (delta) => console.log(delta));
+ * emitter.emit('update', 0.016);
+ */
+declare class LeaEventEmitter<Events extends Record<string, any[]>> {
+    #private;
+    constructor();
+    /**
+     * Registers a listener for the specified event.
+     *
+     * @template K - Event name
+     * @param event - The name of the event
+     * @param listener - The callback to invoke when the event is emitted
+     * @returns This emitter for chaining
+     */
+    on<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    /**
+     * Registers a one-time listener for the specified event.
+     *
+     * The listener is automatically removed after the first invocation.
+     *
+     * @template K - Event name
+     * @param event - The name of the event
+     * @param listener - The callback to invoke once
+     * @returns This emitter for chaining
+     */
+    once<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    /**
+     * Removes a listener for the specified event.
+     *
+     * @template K - Event name
+     * @param event - The name of the event
+     * @param listener - The callback to remove
+     * @returns This emitter for chaining
+     */
+    off<K extends keyof Events>(event: K, listener: (...args: Events[K]) => void): this;
+    /**
+     * Emits an event, invoking all registered listeners with the provided arguments.
+     *
+     * If the event is `"error"` and no listeners are registered, the first argument (the error)
+     * will be thrown.
+     *
+     * @template K - Event name
+     * @param event - The name of the event to emit
+     * @param args - Arguments to pass to listeners
+     * @returns `true` if any listeners were invoked, `false` otherwise
+     */
+    emit<K extends keyof Events>(event: K, ...args: Events[K]): boolean;
+    /**
+     * Removes all listeners for the specified event, or all listeners if no event is provided.
+     *
+     * @template K - Event name
+     * @param event - Optional event name to clear listeners for
+     * @returns This emitter for chaining
+     */
+    removeAllListeners<K extends keyof Events>(event?: K): this;
+    /**
+     * Returns the number of listeners registered for the specified event.
+     *
+     * @template K - Event name
+     * @param event - The event to count listeners for
+     * @returns The number of registered listeners
+     */
+    listenerCount<K extends keyof Events>(event: K): number;
+}
+/**
+ * Canvas-based renderer that manages a 2D drawing context and emits a `"draw"` event each frame.
+ *
+ * Handles resolution scaling (viewport vs camera), automatic clearing, and RAF loop.
+ *
+ * @extends LeaEventEmitter<{ draw: [CanvasRenderingContext2D] }>
+ *
+ * @example
+ * const renderer = new LeaRendererII(canvas, { viewportWidth: 800, viewportHeight: 600 });
+ * renderer.on("draw", (ctx) => {
+ *   ctx.fillStyle = "black";
+ *   ctx.fillRect(0, 0, renderer.viewportWidth, renderer.viewportHeight);
+ * });
+ * renderer.start();
+ */
+declare class LeaRendererII extends LeaEventEmitter<{
+    draw: [CanvasRenderingContext2D];
+}> {
+    #private;
+    /**
+     * The target canvas element.
+     */
+    canvas: HTMLCanvasElement;
+    /**
+     * The 2D rendering context.
+     */
+    ctx: CanvasRenderingContext2D;
+    /**
+     * Whether the renderer is currently running (RAF loop active).
+     */
+    running: boolean;
+    private _rafId;
+    private _fps;
+    private _frameCount;
+    private _fpsTimer;
+    private _lastFrameTime;
+    constructor(canvas: HTMLCanvasElement, { viewportWidth, viewportHeight, cameraWidth, cameraHeight, }?: {
+        viewportWidth?: number;
+        viewportHeight?: number;
+        cameraWidth?: number;
+        cameraHeight?: number;
+    });
+    automatic: boolean;
+    retransform(): void;
+    /**
+     * The logical viewport width (game coordinate space).
+     */
+    get viewportWidth(): number;
+    set viewportWidth(v: number);
+    get width(): number;
+    get height(): number;
+    /**
+     * Center X of the viewport (viewportWidth / 2).
+     */
+    get centerX(): number;
+    /**
+     * Center Y of the viewport (viewportHeight / 2).
+     */
+    get centerY(): number;
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    /**
+     * The logical viewport height (game coordinate space).
+     */
+    get viewportHeight(): number;
+    set viewportHeight(v: number);
+    /**
+     * The camera/pixel resolution width (canvas backing resolution).
+     */
+    get cameraWidth(): number;
+    set cameraWidth(v: number);
+    /**
+     * The camera/pixel resolution height (canvas backing resolution).
+     */
+    get cameraHeight(): number;
+    set cameraHeight(v: number);
+    /**
+     * Update canvas resolution to match camera
+     * Units remain the same
+     */
+    updateCanvasResolution(): void;
+    /**
+     * Apply viewport → canvas transform
+     * Scale computed dynamically each frame
+     */
+    applyTransform(): void;
+    /**
+     * Current measured FPS (updated every second).
+     */
+    get FPS(): number;
+    private _loop;
+    update(): void;
+    /**
+     * Starts the RAF loop and begins emitting `"draw"` events.
+     *
+     * @throws If called in a non-browser environment or RAF is unavailable
+     */
+    start(): void;
+    /**
+     * Stops the RAF loop and halts drawing.
+     *
+     * @throws If called in a non-browser environment or RAF is unavailable
+     */
+    stop(): void;
+}
+/**
+ * Fixed or variable timestep ticker that emits a `"tick"` event with delta time (seconds).
+ *
+ * Supports RAF mode (`tickInterval = Infinity`) or fixed interval.
+ *
+ * @extends LeaEventEmitter<{ tick: [number]; error: [unknown] }>
+ *
+ * @example
+ * const ticker = new LeaTickerII(1000 / 60); // 60 Hz
+ * ticker.on("tick", (delta) => {
+ *   // update game state
+ * });
+ * ticker.start();
+ */
+declare class LeaTickerII extends LeaEventEmitter<{
+    tick: [number];
+    error: [unknown];
+}> {
+    #private;
+    setNow(now: number): void;
+    /**
+     * @type {NodeJS.Timeout}
+     */
+    private __intervalId;
+    private __lastTime;
+    /**
+     * @param tickInterval Interval in ms
+     */
+    constructor(tickInterval?: number);
+    /**
+     * Speed multiplier for delta time (for slow-motion / fast-forward).
+     */
+    speedHackDT: number;
+    /**
+     * Whether the ticker is using requestAnimationFrame (RAF) mode.
+     */
+    get isRaf(): boolean;
+    /**
+     * Tick interval in milliseconds.
+     * - Finite number = fixed timestep
+     * - `Infinity` = RAF / variable timestep
+     */
+    get tickInterval(): number;
+    set tickInterval(s: number);
+    /**
+     * Current time in milliseconds (monotonic).
+     */
+    now(): number;
+    private __tick;
+    /**
+     *
+     * @param {number} ms
+     * @returns
+     */
+    createTimeout(ms: number): LeaTimeout;
+    createTween(config: ConstructorParameters<typeof DeltaTweenII>[0], callback?: (change: number) => void): DeltaTweenII;
+    /**
+     * Starts the ticker loop.
+     */
+    start(): void;
+    /**
+     * Stops the ticker loop.
+     */
+    stop(): void;
+    /**
+     *
+     * @param {number} ms
+     * @param {number} offset
+     * @returns {number}
+     */
+    getSineMod(ms: number, offset?: number): number;
+}
+type LeaEntitySerializerEach<T extends Record<string, any>, K extends keyof T = keyof T> = [
+    K,
+    {
+        mapExport?: (value: T[K]) => any;
+        mapImport?: (value: any) => T[K];
+    }
+];
+type LeaEntitySerializer<T extends Record<string, any>> = {
+    [K in keyof T]: LeaEntitySerializerEach<T, K>;
+}[keyof T][];
+type LeaEntitySerializerArray<T extends Record<string, any>> = {
+    [K in keyof T]: LeaEntitySerializerEach<T, K>;
+}[keyof T][];
+type OrderedLeaEntitySerializer<T extends Record<string, any>, FirstKeys extends (keyof T)[]> = [
+    ...{
+        [I in keyof FirstKeys]: LeaEntitySerializerEach<T, FirstKeys[I]>;
+    },
+    ...LeaEntitySerializerArray<T>
+];
+declare namespace LeaSerializers {
+    function booleanExport(a: boolean): 0 | 1;
+    function booleanImport(a: 0 | 1): boolean;
+    function vec2Export(vec: Vector2): string;
+    function vec2Import(str: string): Vector2;
+    const booleanMap: {
+        mapExport: typeof booleanExport;
+        mapImport: typeof booleanImport;
+    };
+    function createRounder(maxDecimals: number): (num: number) => number;
+    function createLowPrecision(base?: number): {
+        mapExport(num: number): number;
+        mapImport(num: number): number;
+    };
+    function lightWeightRounder(n: number): number;
+    function createPercent(exportedMax?: number): {
+        mapExport(n: number): number;
+        mapImport(n: number): number;
+    };
+    function createLookup<T extends Record<string, any>>(record: T): {
+        mapExport: (key: string) => any;
+        mapImport: (value: any) => any;
+    };
+    function radToDeg(rad: number): number;
+    function degToRad(deg: number): number;
+    const angleRadToDeg: {
+        mapExport: typeof radToDeg;
+        mapImport: typeof degToRad;
+    };
+    function createLowPrecisionRadToDeg(base?: number): {
+        mapExport(n: number): number;
+        mapImport(n: number): number;
+    };
+}
+/**
+ * Abstract base class for all entities in a LEA scene.
+ *
+ * Provides event emission (`update`, `draw`, `error`), position, name, and z-order.
+ *
+ * @extends LeaEventEmitter<{ update: [number]; draw: [CanvasRenderingContext2D]; error: [unknown] }>
+ */
+declare abstract class LeaEntityII extends LeaEventEmitter<{
+    update: [number];
+    error: [unknown];
+    draw: [CanvasRenderingContext2D];
+}> {
+    /**
+     * Unique name of the entity (used for lookup and serialization).
+     */
+    name: string;
+    /**
+     * @type {number}
+     */
+    scaleRotate: number;
+    /**
+     * @type {number}
+     */
+    scale: number;
+    /**
+     *  @param {string} name
+     *  @param {number} [x]
+     *  @param {number} [y]
+     */
+    constructor(name: string, x?: number, y?: number);
+    arraySerializeMap?: LeaEntitySerializer<any>;
+    autoTranslate: boolean;
+    /**
+     * Z-order for draw sorting (higher = drawn later / on top).
+     */
+    z: number;
+    private ___pos;
+    /**
+     * @type {(keyof this)[]}
+     */
+    nonSerializableProperties: (keyof this)[];
+    /**
+     * @type {(keyof this)[]}
+     */
+    forceSerializableProperties: (keyof this)[];
+    /**
+     * Current position (center point).
+     */
+    get pos(): Vector2;
+    /**
+     * X coordinate (center).
+     */
+    get x(): number;
+    /**
+     * Y coordinate (center).
+     */
+    get y(): number;
+    set x(s: number);
+    set y(s: number);
+    /**
+     * Update entity.
+     */
+    handleUpdate(delta: number): void;
+    /**
+     * Called once per tick with delta time (seconds).
+     *
+     * @param delta - Time since last tick in seconds
+     */
+    abstract update(_delta: number): void;
+    /**
+     * Draw entity.
+     */
+    handleDraw(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Called once per frame to draw the entity.
+     *
+     * The context is already translated to the entity's position if `autoTranslate` is true.
+     *
+     * @param ctx - The 2D rendering context
+     */
+    abstract draw?(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Serializes the entity to a plain object (for save/load).
+     *
+     * Excludes internal properties and respects `nonSerializableProperties`.
+     *
+     * @returns Serializable data
+     */
+    serialize(): any;
+    /**
+     * Converts a world position to local space relative to this entity.
+     *
+     * @param worldVec - World position
+     * @returns Local position
+     */
+    toLocal(worldVec: Vector2): Vector2;
+    /**
+     * Converts a local position to world space.
+     *
+     * @param localVec - Local position
+     * @returns World position
+     */
+    toWorld(localVec: Vector2): Vector2;
+    deserializeArray(snapshot: any[]): any;
+    static deserializeArray(map: LeaEntityII["arraySerializeMap"], snapshot: any[]): any;
+}
+/**
+ * Container for a collection of entities, handling update/draw loops and z-order sorting.
+ *
+ * @extends LeaEventEmitter<{ update: [number]; draw: [CanvasRenderingContext2D] }>
+ */
+declare class LeaSceneII extends LeaEventEmitter<{
+    update: [number];
+    draw: [CanvasRenderingContext2D];
+}> {
+    /**
+     * Unique name of the scene.
+     */
+    name: string;
+    /**
+     * Map of entities by name.
+     */
+    entities: Map<string, LeaEntityII>;
+    /**
+     * Whether updates and drawing are paused.
+     */
+    paused: boolean;
+    constructor(name: string);
+    /**
+     * Updates all non-paused entities in the scene.
+     *
+     * @param delta - Time since last update in seconds
+     */
+    handleUpdate(delta: number): void;
+    /**
+     * Draws all entities in z-order (higher z = drawn later).
+     *
+     * @param ctx - The 2D rendering context
+     */
+    handleDraw(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Adds an entity to the scene.
+     *
+     * @param entity - The entity to add
+     * @throws If the entity has no name
+     */
+    addEntity(entity: any): void;
+    /**
+     * Removes an entity from the scene by name.
+     *
+     * @param entity - The entity to remove
+     */
+    removeEntity(entity: any): void;
+    /**
+     * Retrieves an entity by name.
+     *
+     * @param name - The name of the entity
+     * @returns The entity, or undefined if not found
+     */
+    getEntity(name: string): LeaEntityII;
+}
+/**
+ * Top-level game manager that owns scenes and a shared ticker.
+ *
+ * Coordinates updates across all scenes and provides viewport utilities.
+ */
+declare class LeaGameII {
+    /**
+     * Map of scenes by name.
+     */
+    scenes: Map<string, LeaSceneII>;
+    /**
+     * The shared ticker driving updates.
+     */
+    ticker: LeaTickerII;
+    /**
+     * Center X of the viewport (width / 2).
+     */
+    get centerX(): number;
+    /**
+     * Center Y of the viewport (height / 2).
+     */
+    get centerY(): number;
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    /**
+     * Logical viewport width.
+     */
+    width: number;
+    /**
+     * Logical viewport height.
+     */
+    height: number;
+    /**
+     * @param {number} width
+     * @param {number} height
+     * @param {number} tickInterval
+     */
+    constructor(width: number, height: number, tickInterval?: number);
+    /**
+     * Adds a scene to the game.
+     *
+     * @param scene - The scene to add
+     * @throws If the scene has no name
+     */
+    addScene(scene: LeaSceneII): void;
+    /**
+     * Removes a scene from the game.
+     *
+     * @param scene - The scene to remove
+     */
+    removeScene(scene: LeaSceneII): void;
+    /**
+     * Current time in milliseconds (from ticker).
+     */
+    now(): number;
+    /**
+     * Starts the ticker loop (begins emitting "tick" events).
+     */
+    start(): void;
+    /**
+     * Stops the ticker loop.
+     */
+    stop(): void;
+}
+/**
+ * @fileoverview Basic math & easing utilities
+ */
+declare const LeaUtilsII: {
+    /**
+     * Linear interpolation
+     *
+     * @param {number} a Start value
+     * @param {number} b End value
+     * @param {number} t Progress (0–1)
+     * @returns {number}
+     */
+    lerp(a: number, b: number, t: number): number;
+    /**
+     * Clamp a value between min and max
+     *
+     * @param {number} v
+     * @param {number} min
+     * @param {number} max
+     * @returns {number}
+     */
+    clamp(v: number, min: number, max: number): number;
+    /**
+     * Clamp a value between 0 and 1
+     *
+     * @param {number} v
+     * @returns {number}
+     */
+    clamp01(v: number): number;
+    /**
+     * Linear easing
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeLinear(t: number): number;
+    /**
+     * Quadratic ease-in
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInQuad(t: number): number;
+    /**
+     * Quadratic ease-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeOutQuad(t: number): number;
+    /**
+     * Quadratic ease-in-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInOutQuad(t: number): number;
+    /**
+     * Sine ease-in
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInSine(t: number): number;
+    /**
+     * Sine ease-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeOutSine(t: number): number;
+    /**
+     * Sine ease-in-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInOutSine(t: number): number;
+    /**
+     * Expo ease-in
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInExpo(t: number): number;
+    /**
+     * Expo ease-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeOutExpo(t: number): number;
+    /**
+     * Expo ease-in-out
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    easeInOutExpo(t: number): number;
+    /**
+     * Smoothstep easing
+     *
+     * @param {number} t
+     * @returns {number}
+     */
+    smoothstep(t: number): number;
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     */
+    randomLerp(a: number, b: number): number;
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     * @returns
+     */
+    randomInt(a: number, b: number): number;
+    /**
+     * @template T
+     * @param {T[]} arr
+     * @returns {T}
+     */
+    randomArrayValue<T>(arr: T[]): T;
+    /**
+     * Create a real cubic-bezier easing function
+     * (same behavior as CSS cubic-bezier)
+     *
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @returns {(t:number)=>number}
+     */
+    createBezier(x1: number, y1: number, x2: number, y2: number): (t: number) => number;
+    /**
+     *
+     * @param  {...number} values
+     * @returns
+     */
+    lengthSquared(...values: number[]): number;
+    /**
+     * Normalize an angle in radians to [0, 2π)
+     * @param {number} rad
+     * @returns {number}
+     */
+    normalizeRad(rad: number): number;
+    /**
+     * Convert a Y-down canvas angle to standard mathematical radian coordinates (Y-up)
+     * @param {number} rad
+     * @returns {number}
+     */
+    angleInvertY(rad: number): number;
+    /**
+     * Convert degrees to radians, flipping Y-axis for canvas (top-left origin)
+     * @param {number} deg
+     * @returns {number}
+     */
+    degToRadFlipY(deg: number): number;
+    /**
+     * Determines the **minimal angular rotation direction** along a unit circle
+     * Returns 1 if clockwise is the shorter path, -1 if counter-clockwise is shorter
+     * @param {number} fromRad - starting angle in radians
+     * @param {number} toRad - target angle in radians
+     * @returns {1 | -1}
+     */
+    minimalAngularDirection(fromRad: number, toRad: number): 1 | -1;
+};
+/**
+ * @fileoverview Delta-based tween for a single numeric change
+ */
+declare class DeltaTweenII extends LeaEventEmitter<{
+    delta: number[];
+    finish: void[];
+}> {
+    constructor({ delta, ms, easing, }: {
+        delta: number;
+        ms: number;
+        easing?: (t: number) => number;
+    });
+    delta: number;
+    duration: number;
+    elapsed: number;
+    lastValue: number;
+    finished: boolean;
+    easing: (t: number) => number;
+    /**
+     * Advance tween by delta time
+     */
+    update(delta: number): void;
+}
+/**
+ * Rectangular entity with centered position, width, height, and basic AABB collision.
+ *
+ * Automatically handles translation and rotation for drawing if needed.
+ *
+ * @extends LeaEntityII
+ */
+declare abstract class RectLeaEntity extends LeaEntityII {
+    /**
+     * @param {string} name
+     * @param {number} x Center X
+     * @param {number} y Center Y
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(name: string, x?: number, y?: number, width?: number, height?: number);
+    /**
+     * Width of the rectangle (centered on x).
+     */
+    width: number;
+    /**
+     * Height of the rectangle (centered on y).
+     */
+    height: number;
+    /**
+     * Left edge of the bounding box.
+     */
+    get left(): number;
+    set left(val: number);
+    /**
+     * Right edge of the bounding box.
+     */
+    get right(): number;
+    set right(val: number);
+    /**
+     * Top edge of the bounding box.
+     */
+    get top(): number;
+    set top(val: number);
+    /**
+     * Bottom edge of the bounding box.
+     */
+    get bottom(): number;
+    set bottom(val: number);
+    get lx(): number;
+    get ly(): number;
+    get lleft(): number;
+    get lright(): number;
+    get ltop(): number;
+    get lbottom(): number;
+    /**
+     * Checks for axis-aligned bounding box collision with another rectangular entity.
+     *
+     * @param other - The other entity to check against
+     * @returns `true` if the bounding boxes overlap
+     */
+    isCollidingWith(other: RectLeaEntity): boolean;
+    /**
+     * Default fill color for the rectangle (used in base draw implementation).
+     */
+    color: string;
+    abstract update(_delta: number): void;
+    /**
+     * Draws a filled rectangle centered on the entity's position.
+     *
+     * Subclasses should override or call `super.draw(ctx)` if extending.
+     *
+     * @param ctx - The 2D rendering context
+     */
+    draw(ctx: CanvasRenderingContext2D): void;
+}
+declare class LeaTimeout extends LeaEventEmitter<{
+    finish: [void];
+}> {
+    duration: number;
+    ticker: LeaTickerII;
+    elapsed: number;
+    finished: boolean;
+    _resolve: (value?: unknown) => void;
+    promise: Promise<unknown>;
+    _timeoutId: NodeJS.Timeout;
+    /**
+     * @param {number} duration Duration in milliseconds
+     * @param {LeaTickerII} ticker Optional ticker to drive the timeout
+     */
+    constructor(duration: number, ticker?: LeaTickerII);
+    update(delta?: number): void;
+    finish(): void;
+    /**
+     * Start the timeout manually if no ticker is provided
+     */
+    start(): this;
+    /**
+     * Cancel the timeout
+     */
+    cancel(): void;
+    then<TResult1 = unknown, TResult2 = never>(onfulfilled?: ((value: unknown) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    /**
+     * @type {Promise<void>['then']}
+     */
+    after<TResult1 = unknown, TResult2 = never>(onfulfilled?: ((value: unknown) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+}
+/**
+ * 2D Vector class similar to Godot's Vector2
+ */
+declare class Vector2 {
+    /**
+     * Creates a new Vector2
+     * @param {number} x
+     * @param {number} y
+     */
+    constructor(x?: number, y?: number);
+    x: number;
+    y: number;
+    toJSON(): {
+        x: number;
+        y: number;
+        vec2: boolean;
+    };
+    /**
+     *
+     * @param {any} data
+     */
+    static isVec2(data: any): boolean;
+    /**
+     *
+     * @param {any} data
+     */
+    static fromSerialized(data: any): Vector2;
+    /**
+     * Rotate vector by angle (radians) around origin
+     * @param {number} angle
+     */
+    rotate(angle: number): Vector2;
+    /**
+     * Returns a new Vector2 representing a unit vector pointing in the given angle (radians)
+     * @param {number} rad
+     * @returns {Vector2}
+     */
+    static from(rad: number): Vector2;
+    /**
+     * Returns the angle of the vector relative to the positive X-axis in radians
+     * @returns {number}
+     */
+    get angle(): number;
+    /**
+     * Returns the length (magnitude) of the vector
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * Returns the squared length (more efficient)
+     * @returns {number}
+     */
+    get lengthSquared(): number;
+    /**
+     * Returns a normalized vector (length = 1)
+     * @returns {Vector2}
+     */
+    normalized(): Vector2;
+    project(other: Vector2): Vector2;
+    /**
+     * Reflects a normalized vector (length = 1)
+     * @returns {Vector2}
+     */
+    reflect(normal: Vector2): Vector2;
+    /**
+     * Alignment
+     * Dot product with another vector (normalized)
+     * @param {Vector2} other
+     * @returns {number} -1 .. 1 if vectors are normalized
+     */
+    dotNormalized(other: Vector2): number;
+    /**
+     *
+     * @param {Vector2} other
+     * @returns
+     */
+    lengthSquaredTo(other: Vector2): number;
+    /**
+     * Projection
+     * True dot product including magnitude
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    dot(other: Vector2): number;
+    /**
+     * Distance to another vector
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    distanceTo(other: Vector2): number;
+    /**
+     * Distance to another vector
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    distanceToCheap(other: Vector2): number;
+    /**
+     * Returns a vector pointing from this vector to another
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    directionTo(other: Vector2): Vector2;
+    /**
+     * Adds another vector
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    add(other: Vector2): Vector2;
+    /**
+     * Adds another vector
+     * @param {number} raw
+     * @returns {Vector2}
+     */
+    addRaw(raw: number): Vector2;
+    /**
+     * Overwrite instance
+     * @param {Vector2} newVec
+     */
+    overwite(newVec: Vector2): void;
+    /**
+     * Subtracts another vector
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    subtract(other: Vector2): Vector2;
+    /**
+     * Scales the vector by a scalar
+     * @param {number} scalar
+     * @returns {Vector2}
+     */
+    scale(scalar: number): Vector2;
+    /**
+     * Returns a string representation
+     * @returns {string}
+     */
+    toString(): string;
+    /**
+     * Clones a vector.
+     * @returns {Vector2}
+     */
+    clone(): Vector2;
+}
+/**
+ *
+ * @param {string} col
+ */
+declare function getNormalizedColor(col: string): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ *
+ * @param {{ r: number; g: number; b: number; a:number }} col
+ */
+declare function colToRGBA(col: {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}): string;
+/**
+ * Extract numeric RGBA from ctx.fillStyle
+ * Supports hex (#rgb, #rrggbb) and rgb(a)
+ * @param {string} fillStyle
+ * @returns {{r:number, g:number, b:number, a:number}}
+ */
+declare function parseFillStyle(fillStyle: string): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ *
+ * @param {string} str
+ * @param {{ r?: number; g?: number; b?: number; a?: number }} param1
+ * @returns {string}
+ */
+declare function editRGBA(str: string, { r, g, b, a }?: {
+    r?: number;
+    g?: number;
+    b?: number;
+    a?: number;
+}): string;
+/**
+ * Scales a 2D coordinate relative to an origin.
+ *
+ * @param {number} absoluteCoord - The original coordinate.
+ * @param {number} scale - The scale factor.
+ * @param {number} origin - The origin point for scaling.
+ * @returns {number} - The new scaled coordinate.
+ */
+declare function scaleCoord(absoluteCoord: number, scale: number, origin: number): number;
+declare function getEnvironment(): "web" | "node" | "unknown";
+declare const ENVIRONMENT: "web" | "node" | "unknown";
+declare const isNode: boolean;
+declare const isWeb: boolean;
+declare class LiaAudio {
+    static unlock(): void;
+    /**
+     * @type {AudioContext}
+     */
+    static audioCtx: AudioContext;
+    static masterGain: GainNode;
+    static musicGain: GainNode;
+    static sfxGain: GainNode;
+    static get SFX_VOLUME(): number;
+    static get MUSIC_VOLUME(): number;
+    static get VOLUME(): number;
+    static set SFX_VOLUME(n: number);
+    static set MUSIC_VOLUME(n: number);
+    static set VOLUME(n: number);
+    /**
+     *
+     * @param {number} note
+     * @returns
+     */
+    static noteToHz(note: number): number;
+    static tuningFreq: number;
+    /**
+     * @type {Map<string, AudioBuffer>}
+     */
+    static audioBufferCache: Map<string, AudioBuffer>;
+    /**
+     * @type {Map<number, { source: LiaAudioSrc, gain: GainNode }>}
+     */
+    static loops: Map<number, {
+        source: LiaAudioSrc;
+        gain: GainNode;
+    }>;
+    /**
+     * @type {Map<string, { source: LiaAudioSrc, gain: GainNode }>}
+     */
+    static sfsx: Map<string, {
+        source: LiaAudioSrc;
+        gain: GainNode;
+    }>;
+    static loopIdCounter: number;
+    static CACHE_NAME: string;
+    /**
+     * Preload and decode audio buffer
+     * @param {string} path
+     * @returns {Promise<AudioBuffer>}
+     */
+    static preLoad(path: string): Promise<AudioBuffer>;
+    /**
+     * @param {string} path
+     * @returns {Promise<Response>}
+     */
+    static getOnlyDownloadedCache(path: string): Promise<Response>;
+    /**
+     * Get AudioBuffer (returns null if not yet loaded)
+     * @param {string} path
+     * @returns {AudioBuffer|null}
+     */
+    static getCached(path: string): AudioBuffer | null;
+    /**
+     * Play SFX once with optional volume
+     * @param {string} path
+     * @param {number} volume
+     * @param {number | null} speed default to random
+     */
+    static playSound(path: string, volume?: number, speed?: number | null, override?: boolean): Promise<void>;
+    /**
+     * Play looping SFX and return loop id
+     * @param {string} path
+     * @param {number} volume
+     * @param {Object} [param2={}]
+     * @param {number} [param2.loopStart=0]
+     * @param {null | number} [param2.loopEnd=null]
+     * @param {boolean} [param2.exclusive=true]
+     * @param {number} [param2.skipMS=0]
+     * @returns {Promise<number | undefined>}
+     */
+    static playLoop(path: string, volume?: number, { loopStart, loopEnd, exclusive, skipMS, }?: {
+        loopStart?: number;
+        loopEnd?: null | number;
+        exclusive?: boolean;
+        skipMS?: number;
+    }): Promise<number | undefined>;
+    /**
+     * Stop a loop by id
+     * @param {number} id
+     */
+    static stopLoop(id: number): void;
+    /**
+     * Create a LiaAudioSrc from a file path without playing it.
+     * @param {string} path - audio file path
+     * @param {Object} [options={}]
+     * @param {number} [options.volume=1]
+     * @param {number} [options.speed=1]
+     * @param {boolean} [options.loop=false]
+     * @param {number} [options.loopStart=0]
+     * @param {number|null} [options.loopEnd=null]
+     * @param {boolean} [options.isMusic]
+     * @returns {Promise<LiaAudioSrc|null>}
+     */
+    static createLiaSource(path: string, { volume, speed, loop, loopStart, loopEnd, isMusic, gain: parentGain, }?: {
+        volume?: number;
+        speed?: number;
+        loop?: boolean;
+        loopStart?: number;
+        loopEnd?: number | null;
+        isMusic?: boolean;
+        gain?: GainNode;
+    }): Promise<LiaAudioSrc | null>;
+}
+declare const NOTE_NAMES: readonly ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+type NOTE_NAME = (typeof NOTE_NAMES)[number];
+declare function isNote(note: string): note is NOTE_NAME;
+/**
+ * High-level AudioBufferSourceNode replacement with play/pause, fades, speed, and strict AudioNode interface.
+ * @implements {AudioNode}
+ */
+declare class LiaAudioSrc {
+    numberOfInputs: number;
+    numberOfOutputs: number;
+    /**
+     * @param {AudioBuffer} buffer
+     * @param {AudioContext} [context=LiaSfx.audioCtx]
+     */
+    constructor(buffer: AudioBuffer, context?: AudioContext);
+    channelCount: number;
+    channelCountMode: string;
+    channelInterpretation: string;
+    onended: () => any;
+    /**
+     * @type {AudioBufferSourceNode|null}
+     */
+    source: AudioBufferSourceNode | null;
+    /**
+     * @type {AudioBuffer}
+     */
+    buffer: AudioBuffer;
+    /**
+     * @type {AudioContext}
+     */
+    context: AudioContext;
+    _createSource(): AudioBufferSourceNode;
+    /**
+     * Start playback
+     * @param {Object} [options]
+     * @param {number} [options.fadeIn=0] - seconds to fade in
+     * @param {number} [options.offset=null] - start offset in seconds
+     */
+    play({ fadeIn, offset, }?: {
+        fadeIn?: number;
+        offset?: number;
+    }): void;
+    /**
+     * Start playback identical to AudioBufferSourceNode.start()
+     * @param {number} [when=0] - seconds from context.currentTime to start
+     * @param {number} [offset=0] - offset in seconds into the buffer
+     * @param {number} [duration] - how long to play in seconds
+     */
+    start(when: number, offset: number, duration: number): void;
+    /**
+     * Pause playback
+     * @param {Object} [options]
+     * @param {number} [options.fadeOut=0] - seconds to fade out
+     */
+    pause({ fadeOut }?: {
+        fadeOut?: number;
+    }): void;
+    /**
+     * Get playback elapsed time in milliseconds
+     * @returns {number}
+     */
+    getElapsed(): number;
+    /**
+     * Set playback speed
+     * @param {number} rate
+     */
+    setSpeed(rate: number): void;
+    /**
+     * Set loop mode
+     * @param {boolean} loop
+     */
+    setLoop(loop?: boolean): void;
+    loop: boolean;
+    playbackRate: number;
+    startTime: number;
+    /**
+     * @type {GainNode}
+     */
+    tempGain: GainNode;
+    /**
+     * Connect node to AudioNode or AudioParam
+     * @param {AudioNode|AudioParam} destination
+     * @param {number} [output=0]
+     * @param {number} [input=0]
+     * @returns {AudioNode|undefined}
+     */
+    connect(destination: AudioNode | AudioParam, output?: number, input?: number): AudioNode | undefined;
+    /**
+     * Disconnect node from AudioNode or AudioParam
+     * @param {AudioNode} [destinationOrOutput]
+     * @param {number} [output]
+     * @param {number} [input]
+     */
+    disconnect(destinationOrOutput: AudioNode, output: number, input: number): void;
+    output: GainNode;
+    /**
+     * Stop playback immediately or at optional future time
+     * @param {number} [when=0] - seconds from now to stop
+     */
+    stop(when?: number): void;
+    pauseTime: number;
+    isPlaying: boolean;
+    notIndependent: boolean;
+    /** @type {number} */
+    loopStart: number;
+    /** @type {number} */
+    loopEnd: number;
+}
+interface SFXConfig {
+    osc: {
+        enabled: boolean;
+        type: "sine" | "square" | "sawtooth" | "triangle";
+        freq: number;
+        detune: number;
+    };
+    noise: {
+        enabled: boolean;
+        level: number;
+    };
+    ampEnv: {
+        attack: number;
+        decay: number;
+        sustain: number;
+        release: number;
+        volume: number;
+    };
+    pitchEnv: {
+        amount: number;
+        decay: number;
+    };
+    filter: {
+        enabled: boolean;
+        type: "lowpass" | "highpass" | "bandpass" | "notch";
+        freq: number;
+        Q: number;
+        envAmount: number;
+        decay: number;
+    };
+    lfo: {
+        enabled: boolean;
+        target: "freq" | "gain" | "filter";
+        rate: number;
+        depth: number;
+    };
+    duration: number;
+}
+/**
+ * @type {SFXConfig}
+ */
+declare const defaultSFXConfig: SFXConfig;
+declare class LiaOscSFX {
+    /**
+     *
+     * @param {Partial<SFXConfig>} config
+     */
+    constructor(config?: Partial<SFXConfig>);
+    ctx: typeof LiaAudio.audioCtx;
+    /**
+     * @type {SFXConfig}
+     */
+    cfg: SFXConfig;
+    play(outputGain?: GainNode): void;
+    /** @returns {SFXConfig} */
+    getConfig(): SFXConfig;
+    /** @param {Partial<SFXConfig>} patch */
+    setConfig(patch: Partial<SFXConfig>): this;
+    getKey<K extends keyof SFXConfig>(key: K): SFXConfig[K];
+    setKey<K extends keyof SFXConfig>(key: K, value: Partial<SFXConfig[K]>): this;
+    /** @param {SFXConfig['osc']['freq']} freq */
+    setFreq(freq: SFXConfig["osc"]["freq"]): this;
+    /** @param {SFXConfig['osc']['type']} type */
+    setWave(type: SFXConfig["osc"]["type"]): this;
+    /** @param {SFXConfig['ampEnv']['volume']} volume */
+    setVolume(volume: SFXConfig["ampEnv"]["volume"]): this;
+    /** @param {SFXConfig['ampEnv']['attack']} attack @param {SFXConfig['ampEnv']['decay']} decay @param {SFXConfig['ampEnv']['sustain']} sustain @param {SFXConfig['ampEnv']['release']} release */
+    setAmpEnv(attack: SFXConfig["ampEnv"]["attack"], decay: SFXConfig["ampEnv"]["decay"], sustain: SFXConfig["ampEnv"]["sustain"], release: SFXConfig["ampEnv"]["release"]): this;
+    /** @param {SFXConfig['pitchEnv']['amount']} amount @param {SFXConfig['pitchEnv']['decay']} decay */
+    setPitchEnv(amount: SFXConfig["pitchEnv"]["amount"], decay: SFXConfig["pitchEnv"]["decay"]): this;
+    /** @param {SFXConfig['noise']['enabled']} enabled */
+    setNoiseEnabled(enabled: SFXConfig["noise"]["enabled"]): this;
+    /** @param {SFXConfig['noise']['level']} level */
+    setNoiseLevel(level: SFXConfig["noise"]["level"]): this;
+    /** @param {SFXConfig['filter']['enabled']} enabled */
+    setFilterEnabled(enabled: SFXConfig["filter"]["enabled"]): this;
+    setFilter(type: SFXConfig["filter"]["type"], freq: SFXConfig["filter"]["freq"], Q: SFXConfig["filter"]["Q"]): this;
+    setLFOEnabled(enabled: SFXConfig["lfo"]["enabled"]): this;
+    /** @param {SFXConfig['lfo']['target']} target @param {SFXConfig['lfo']['rate']} rate @param {SFXConfig['lfo']['depth']} depth */
+    setLFO(target: SFXConfig["lfo"]["target"], rate: SFXConfig["lfo"]["rate"], depth: SFXConfig["lfo"]["depth"]): this;
+    /** @param {SFXConfig['duration']} duration */
+    setDuration(duration: SFXConfig["duration"]): this;
+    clone(): LiaOscSFX;
+}
+declare const sfxUIClick: LiaOscSFX;
+declare const sfxUIHover: LiaOscSFX;
+declare const sfxJump: LiaOscSFX;
+declare const sfxLaser: LiaOscSFX;
+declare const sfxHit: LiaOscSFX;
+declare const LiaSFXMap: Map<string, LiaOscSFX>;
+declare function shortUID(length?: number): string;
+declare function tinyUID(length?: number): string;
+/**
+ * @template EventMap
+ * Default event structure
+ */
+type DefaultWSE<EventMap> = {
+    open: void;
+    close: void;
+    error: Error;
+    message: EventMap[keyof EventMap];
+    key: {
+        key: string;
+        mode: 1 | 2;
+    };
+};
+/**
+ * Memory-based client for in-process IPC
+ */
+declare class GEmitterMemory<Events extends DefaultWSE<Events>> {
+    private peer;
+    private key;
+    private events;
+    mbAcc: number;
+    private connected;
+    constructor();
+    /** Connect to a peer client */
+    connect(peer?: GEmitterMemory<Events>): void;
+    /** Is connected */
+    isConnected(): boolean;
+    /** Add event listener */
+    on<K extends keyof Events>(event: K, listener: (payload: Events[K]) => void): void;
+    /** Remove event listener */
+    off<K extends keyof Events>(event: K, listener: (payload: Events[K]) => void): void;
+    /** Emit event internally */
+    private _emit;
+    /** Send message to peer */
+    send<K extends keyof Events>(event: K, payload: Events[K]): void;
+    /** Receive message from peer */
+    private _receive;
+    /** Disconnect */
+    close(): void;
+    /** Get the client's key */
+    getKey(): string;
+}
+/** Cross-browser UUIDv4 generator */
+declare function generateUUID(): string;
+declare function setAnimInterval(callback: () => void): {
+    clear: () => boolean;
+};
+type Side = "left" | "right" | "top" | "bottom";
+interface RayHit {
+    side: Side;
+    t: number;
+}
+interface RaycastResult extends RayHit {
+    avoidAngle: number;
+}
+/**
+ * Core: Raycast to single rectangle
+ */
+declare function getRayHit(x0: number, y0: number, w: number, h: number, angle: number): RayHit | null;
+declare function getAvoidAngle(angle: number, side: Side): number;
+/**
+ Full reusable raycast with avoidance
+*/
+declare function raycastAvoid(x0: number, y0: number, w: number, h: number, angle: number): RaycastResult | null;
+declare function isMobile(): boolean;
+declare const isInitiallyMobile: boolean;
+
+type LEA_DefaultWSE<EventMap> = DefaultWSE<EventMap>;
+type LEA_DeltaTweenII = DeltaTweenII;
+declare const LEA_DeltaTweenII: typeof DeltaTweenII;
+declare const LEA_ENVIRONMENT: typeof ENVIRONMENT;
+type LEA_GEmitterMemory<Events extends DefaultWSE<Events>> = GEmitterMemory<Events>;
+declare const LEA_GEmitterMemory: typeof GEmitterMemory;
+type LEA_LeaEntityII = LeaEntityII;
+declare const LEA_LeaEntityII: typeof LeaEntityII;
+type LEA_LeaEntitySerializer<T extends Record<string, any>> = LeaEntitySerializer<T>;
+type LEA_LeaEntitySerializerArray<T extends Record<string, any>> = LeaEntitySerializerArray<T>;
+type LEA_LeaEntitySerializerEach<T extends Record<string, any>, K extends keyof T = keyof T> = LeaEntitySerializerEach<T, K>;
+type LEA_LeaEventEmitter<Events extends Record<string, any[]>> = LeaEventEmitter<Events>;
+declare const LEA_LeaEventEmitter: typeof LeaEventEmitter;
+type LEA_LeaGameII = LeaGameII;
+declare const LEA_LeaGameII: typeof LeaGameII;
+type LEA_LeaRendererII = LeaRendererII;
+declare const LEA_LeaRendererII: typeof LeaRendererII;
+type LEA_LeaSceneII = LeaSceneII;
+declare const LEA_LeaSceneII: typeof LeaSceneII;
+declare const LEA_LeaSerializers: typeof LeaSerializers;
+type LEA_LeaTickerII = LeaTickerII;
+declare const LEA_LeaTickerII: typeof LeaTickerII;
+type LEA_LeaTimeout = LeaTimeout;
+declare const LEA_LeaTimeout: typeof LeaTimeout;
+declare const LEA_LeaUtilsII: typeof LeaUtilsII;
+type LEA_LiaAudio = LiaAudio;
+declare const LEA_LiaAudio: typeof LiaAudio;
+type LEA_LiaAudioSrc = LiaAudioSrc;
+declare const LEA_LiaAudioSrc: typeof LiaAudioSrc;
+type LEA_LiaOscSFX = LiaOscSFX;
+declare const LEA_LiaOscSFX: typeof LiaOscSFX;
+declare const LEA_LiaSFXMap: typeof LiaSFXMap;
+type LEA_Listener<T extends any[] = any[]> = Listener<T>;
+type LEA_NOTE_NAME = NOTE_NAME;
+declare const LEA_NOTE_NAMES: typeof NOTE_NAMES;
+type LEA_OrderedLeaEntitySerializer<T extends Record<string, any>, FirstKeys extends (keyof T)[]> = OrderedLeaEntitySerializer<T, FirstKeys>;
+type LEA_RayHit = RayHit;
+type LEA_RaycastResult = RaycastResult;
+type LEA_RectLeaEntity = RectLeaEntity;
+declare const LEA_RectLeaEntity: typeof RectLeaEntity;
+type LEA_SFXConfig = SFXConfig;
+type LEA_Side = Side;
+type LEA_Vector2 = Vector2;
+declare const LEA_Vector2: typeof Vector2;
+declare const LEA_colToRGBA: typeof colToRGBA;
+declare const LEA_defaultSFXConfig: typeof defaultSFXConfig;
+declare const LEA_editRGBA: typeof editRGBA;
+declare const LEA_generateUUID: typeof generateUUID;
+declare const LEA_getAvoidAngle: typeof getAvoidAngle;
+declare const LEA_getEnvironment: typeof getEnvironment;
+declare const LEA_getNormalizedColor: typeof getNormalizedColor;
+declare const LEA_getRayHit: typeof getRayHit;
+declare const LEA_isInitiallyMobile: typeof isInitiallyMobile;
+declare const LEA_isMobile: typeof isMobile;
+declare const LEA_isNode: typeof isNode;
+declare const LEA_isNote: typeof isNote;
+declare const LEA_isWeb: typeof isWeb;
+declare const LEA_parseFillStyle: typeof parseFillStyle;
+declare const LEA_raycastAvoid: typeof raycastAvoid;
+declare const LEA_scaleCoord: typeof scaleCoord;
+declare const LEA_setAnimInterval: typeof setAnimInterval;
+declare const LEA_sfxHit: typeof sfxHit;
+declare const LEA_sfxJump: typeof sfxJump;
+declare const LEA_sfxLaser: typeof sfxLaser;
+declare const LEA_sfxUIClick: typeof sfxUIClick;
+declare const LEA_sfxUIHover: typeof sfxUIHover;
+declare const LEA_shortUID: typeof shortUID;
+declare const LEA_tinyUID: typeof tinyUID;
+declare namespace LEA {
+  export { type LEA_DefaultWSE as DefaultWSE, LEA_DeltaTweenII as DeltaTweenII, LEA_ENVIRONMENT as ENVIRONMENT, LEA_GEmitterMemory as GEmitterMemory, LEA_LeaEntityII as LeaEntityII, type LEA_LeaEntitySerializer as LeaEntitySerializer, type LEA_LeaEntitySerializerArray as LeaEntitySerializerArray, type LEA_LeaEntitySerializerEach as LeaEntitySerializerEach, LEA_LeaEventEmitter as LeaEventEmitter, LEA_LeaGameII as LeaGameII, LEA_LeaRendererII as LeaRendererII, LEA_LeaSceneII as LeaSceneII, LEA_LeaSerializers as LeaSerializers, LEA_LeaTickerII as LeaTickerII, LEA_LeaTimeout as LeaTimeout, LEA_LeaUtilsII as LeaUtilsII, LEA_LiaAudio as LiaAudio, LEA_LiaAudioSrc as LiaAudioSrc, LEA_LiaOscSFX as LiaOscSFX, LEA_LiaSFXMap as LiaSFXMap, type LEA_Listener as Listener, type LEA_NOTE_NAME as NOTE_NAME, LEA_NOTE_NAMES as NOTE_NAMES, type LEA_OrderedLeaEntitySerializer as OrderedLeaEntitySerializer, type LEA_RayHit as RayHit, type LEA_RaycastResult as RaycastResult, LEA_RectLeaEntity as RectLeaEntity, type LEA_SFXConfig as SFXConfig, type LEA_Side as Side, LEA_Vector2 as Vector2, LEA_colToRGBA as colToRGBA, LEA_defaultSFXConfig as defaultSFXConfig, LEA_editRGBA as editRGBA, LEA_generateUUID as generateUUID, LEA_getAvoidAngle as getAvoidAngle, LEA_getEnvironment as getEnvironment, LEA_getNormalizedColor as getNormalizedColor, LEA_getRayHit as getRayHit, LEA_isInitiallyMobile as isInitiallyMobile, LEA_isMobile as isMobile, LEA_isNode as isNode, LEA_isNote as isNote, LEA_isWeb as isWeb, LEA_parseFillStyle as parseFillStyle, LEA_raycastAvoid as raycastAvoid, LEA_scaleCoord as scaleCoord, LEA_setAnimInterval as setAnimInterval, LEA_sfxHit as sfxHit, LEA_sfxJump as sfxJump, LEA_sfxLaser as sfxLaser, LEA_sfxUIClick as sfxUIClick, LEA_sfxUIHover as sfxUIHover, LEA_shortUID as shortUID, LEA_tinyUID as tinyUID };
+}
+
+export { shortUID as $, getAvoidAngle as A, getEnvironment as B, getNormalizedColor as C, type DefaultWSE as D, ENVIRONMENT as E, getRayHit as F, GEmitterMemory as G, isInitiallyMobile as H, isMobile as I, isNode as J, isNote as K, LEA as L, isWeb as M, type NOTE_NAME as N, type OrderedLeaEntitySerializer as O, parseFillStyle as P, raycastAvoid as Q, RectLeaEntity as R, type SFXConfig as S, scaleCoord as T, setAnimInterval as U, Vector2 as V, sfxHit as W, sfxJump as X, sfxLaser as Y, sfxUIClick as Z, sfxUIHover as _, LeaGameII as a, tinyUID as a0, LeaRendererII as b, LeaSceneII as c, DeltaTweenII as d, LeaEntityII as e, type LeaEntitySerializer as f, type LeaEntitySerializerArray as g, type LeaEntitySerializerEach as h, LeaEventEmitter as i, LeaSerializers as j, LeaTickerII as k, LeaTimeout as l, LeaUtilsII as m, LiaAudio as n, LiaAudioSrc as o, LiaOscSFX as p, LiaSFXMap as q, type Listener as r, NOTE_NAMES as s, type RayHit as t, type RaycastResult as u, type Side as v, colToRGBA as w, defaultSFXConfig as x, editRGBA as y, generateUUID as z };