@rpgjs/client 5.0.0-alpha.20 → 5.0.0-alpha.22

package/dist/Game/Object.d.ts

@@ -0,0 +1,109 @@
+import { Hooks, RpgCommonPlayer } from '@rpgjs/common';
+import { RpgClientEngine } from '../RpgClientEngine';
+export declare abstract class RpgClientObject extends RpgCommonPlayer {
+    abstract type: string;
+    emitParticleTrigger: import('canvasengine').Trigger<any>;
+    particleName: import('canvasengine').WritableSignal<string>;
+    animationCurrentIndex: import('canvasengine').WritableSignal<number>;
+    animationIsPlaying: import('canvasengine').WritableSignal<boolean>;
+    _param: import('canvasengine').WritableObjectSignal<{}>;
+    frames: {
+        x: number;
+        y: number;
+        ts: number;
+    }[];
+    graphicsSignals: import('canvasengine').WritableArraySignal<any[]>;
+    _component: {};
+    flashTrigger: import('canvasengine').Trigger<any>;
+    constructor();
+    get hooks(): Hooks;
+    get engine(): RpgClientEngine<unknown>;
+    private animationSubscription?;
+    /**
+     * Trigger a flash animation on this sprite
+     *
+     * This method triggers a flash effect using CanvasEngine's flash directive.
+     * The flash can be configured with various options including type (alpha, tint, or both),
+     * duration, cycles, and color.
+     *
+     * ## Design
+     *
+     * The flash uses a trigger system that is connected to the flash directive in the
+     * character component. This allows for flexible configuration and can be triggered
+     * from both server events and client-side code.
+     *
+     * @param options - Flash configuration options
+     * @param options.type - Type of flash effect: 'alpha' (opacity), 'tint' (color), or 'both' (default: 'alpha')
+     * @param options.duration - Duration of the flash animation in milliseconds (default: 300)
+     * @param options.cycles - Number of flash cycles (flash on/off) (default: 1)
+     * @param options.alpha - Alpha value when flashing, from 0 to 1 (default: 0.3)
+     * @param options.tint - Tint color when flashing as hex value or color name (default: 0xffffff - white)
+     *
+     * @example
+     * ```ts
+     * // Simple flash with default settings (alpha flash)
+     * player.flash();
+     *
+     * // Flash with red tint
+     * player.flash({ type: 'tint', tint: 0xff0000 });
+     *
+     * // Flash with both alpha and tint
+     * player.flash({
+     *   type: 'both',
+     *   alpha: 0.5,
+     *   tint: 0xff0000,
+     *   duration: 200,
+     *   cycles: 2
+     * });
+     *
+     * // Quick damage flash
+     * player.flash({
+     *   type: 'tint',
+     *   tint: 0xff0000,
+     *   duration: 150,
+     *   cycles: 1
+     * });
+     * ```
+     */
+    flash(options?: {
+        type?: 'alpha' | 'tint' | 'both';
+        duration?: number;
+        cycles?: number;
+        alpha?: number;
+        tint?: number | string;
+    }): void;
+    /**
+     * Reset animation state when animation changes externally
+     *
+     * This method should be called when the animation changes due to movement
+     * or other external factors to ensure the animation system doesn't get stuck
+     *
+     * @example
+     * ```ts
+     * // Reset when player starts moving
+     * player.resetAnimationState();
+     * ```
+     */
+    resetAnimationState(): void;
+    /**
+     * Set a custom animation for a specific number of times
+     *
+     * Plays a custom animation for the specified number of repetitions.
+     * The animation system prevents overlapping animations and automatically
+     * returns to the previous animation when complete.
+     *
+     * @param animationName - Name of the animation to play
+     * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)
+     *
+     * @example
+     * ```ts
+     * // Play attack animation 3 times
+     * player.setAnimation('attack', 3);
+     *
+     * // Play continuous spell animation
+     * player.setAnimation('spell');
+     * ```
+     */
+    setAnimation(animationName: string, nbTimes?: number): void;
+    showComponentAnimation(id: string, params: any): void;
+}

package/dist/Gui/Gui.d.ts

@@ -18,6 +18,12 @@ interface GuiOptions {
      * @returns Array of Signal dependencies
      */
     dependencies?: () => Signal[];
+    /**
+     * Attach the GUI to sprites instead of displaying globally
+     * When true, the GUI will be rendered in character.ce for each sprite
+     * @default false
+     */
+    attachToSprite?: boolean;
 }
 interface GuiInstance {
     name: string;
@@ -27,6 +33,7 @@ interface GuiInstance {
     autoDisplay: boolean;
     dependencies?: () => Signal[];
     subscription?: Subscription;
+    attachToSprite?: boolean;
 }
 export declare class RpgGui {
     private context;
@@ -34,6 +41,11 @@ export declare class RpgGui {
     gui: import('canvasengine').WritableObjectSignal<Record<string, GuiInstance>>;
     extraGuis: GuiInstance[];
     private vueGuiInstance;
+    /**
+     * Signal tracking which player IDs should display attached GUIs
+     * Key: player ID, Value: boolean (true = show, false = hide)
+     */
+    attachedGuiDisplayState: import('canvasengine').WritableObjectSignal<Record<string, boolean>>;
     constructor(context: Context);
     _initialize(): Promise<void>;
     /**
@@ -73,6 +85,7 @@ export declare class RpgGui {
      * @param gui.data - Initial data for the component
      * @param gui.autoDisplay - Auto display when added (default: false)
      * @param gui.dependencies - Function returning Signal dependencies
+     * @param gui.attachToSprite - Attach GUI to sprites instead of global display (default: false)
      *
      * @example
      * ```ts
@@ -82,9 +95,38 @@ export declare class RpgGui {
      *   autoDisplay: true,
      *   dependencies: () => [playerSignal, inventorySignal]
      * });
+     *
+     * // Attach to sprites
+     * gui.add({
+     *   name: 'tooltip',
+     *   component: TooltipComponent,
+     *   attachToSprite: true
+     * });
      * ```
      */
     add(gui: GuiOptions): void;
+    /**
+     * Get all attached GUI components (attachToSprite: true)
+     *
+     * Returns all GUI instances that are configured to be attached to sprites.
+     * These GUIs should be rendered in character.ce instead of canvas.ce.
+     *
+     * @returns Array of GUI instances with attachToSprite: true
+     *
+     * @example
+     * ```ts
+     * const attachedGuis = gui.getAttachedGuis();
+     * // Use in character.ce to render tooltips
+     * ```
+     */
+    getAttachedGuis(): GuiInstance[];
+    /**
+     * Check if a player should display attached GUIs
+     *
+     * @param playerId - The player ID to check
+     * @returns true if attached GUIs should be displayed for this player
+     */
+    shouldDisplayAttachedGui(playerId: string): boolean;
     get(id: string): GuiInstance | undefined;
     exists(id: string): boolean;
     getAll(): Record<string, GuiInstance>;

package/dist/Resource.d.ts

@@ -0,0 +1,97 @@
+import { RpgClientEngine } from './RpgClientEngine';
+/**
+ * RpgResource class
+ *
+ * Provides a unified API to access resource file links (images and sounds) in the game.
+ * Resources are stored as Maps of resource IDs to file paths/URLs.
+ *
+ * ## Design
+ *
+ * RpgResource acts as a facade over the engine's resource storage, providing
+ * easy access to resource file links. It maintains Maps that are synchronized
+ * with the engine's internal storage, but only stores the file paths/URLs,
+ * not the full resource objects.
+ *
+ * @example
+ * ```ts
+ * import { RpgResource } from '@rpgjs/client'
+ *
+ * // Get spritesheet image link
+ * const imageLink = RpgResource.spritesheets.get('hero')
+ *
+ * // Get sound file link
+ * const soundLink = RpgResource.sounds.get('town-music')
+ *
+ * // Set a new resource link
+ * RpgResource.spritesheets.set('new-sprite', './assets/new-sprite.png')
+ * ```
+ */
+export declare class RpgResource {
+    private static engine;
+    private static _spritesheets;
+    private static _sounds;
+    /**
+     * Initialize RpgResource with the engine instance
+     *
+     * This is called automatically by the engine during initialization.
+     * It synchronizes the resource Maps with the engine's internal storage.
+     *
+     * @param engine - The RpgClientEngine instance
+     */
+    static init(engine: RpgClientEngine): void;
+    /**
+     * Synchronize resource Maps with the engine's internal storage
+     *
+     * Extracts file links from spritesheets and sounds stored in the engine
+     * and updates the Maps accordingly.
+     *
+     * @private
+     */
+    private static syncResources;
+    /**
+     * Get/Set image links for spritesheets
+     *
+     * Map of spritesheet IDs to their image file paths/URLs.
+     * This Map is synchronized with the engine's spritesheet storage.
+     *
+     * @type {Map<string, string>}
+     *
+     * @example
+     * ```ts
+     * // Get an image link
+     * const imageLink = RpgResource.spritesheets.get('hero')
+     *
+     * // Set a new image link
+     * RpgResource.spritesheets.set('new-sprite', './assets/new-sprite.png')
+     *
+     * // Check if a spritesheet exists
+     * if (RpgResource.spritesheets.has('monster')) {
+     *   const link = RpgResource.spritesheets.get('monster')
+     * }
+     * ```
+     */
+    static get spritesheets(): Map<string, string>;
+    /**
+     * Get/Set sound file links
+     *
+     * Map of sound IDs to their audio file paths/URLs.
+     * This Map is synchronized with the engine's sound storage.
+     *
+     * @type {Map<string, string>}
+     *
+     * @example
+     * ```ts
+     * // Get a sound link
+     * const soundLink = RpgResource.sounds.get('town-music')
+     *
+     * // Set a new sound link
+     * RpgResource.sounds.set('new-sound', './assets/new-sound.ogg')
+     *
+     * // Iterate over all sounds
+     * RpgResource.sounds.forEach((link, id) => {
+     *   console.log(`Sound ${id}: ${link}`)
+     * })
+     * ```
+     */
+    static get sounds(): Map<string, string>;
+}

package/dist/RpgClient.d.ts

@@ -383,6 +383,48 @@ export interface RpgClient {
          * The GUI will only display when all dependencies are resolved (!= undefined)
          */
         dependencies?: () => Signal[];
+        /**
+         * Attach the GUI to sprites instead of displaying globally
+         *
+         * When set to `true`, the GUI component will be rendered directly on each sprite
+         * in the game world, rather than being displayed as a fixed overlay on the screen.
+         * This is useful for tooltips, health bars, name tags, or any UI element that
+         * should follow a specific sprite.
+         *
+         * The GUI will be rendered in the `character.ce` component for each sprite.
+         * You can control the display state of attached GUIs from the server side using
+         * `player.showAttachedGui()` and `player.hideAttachedGui()` methods.
+         *
+         * @default false
+         * @example
+         * ```ts
+         * import { defineModule, RpgClient } from '@rpgjs/client'
+         * import TooltipComponent from './tooltip.ce'
+         *
+         * defineModule<RpgClient>({
+         *     gui: [
+         *         {
+         *             id: "my-tooltip",
+         *             component: TooltipComponent,
+         *             attachToSprite: true
+         *         }
+         *     ]
+         * })
+         * ```
+         *
+         * On the server side, control the display:
+         * ```ts
+         * // Show the tooltip for this player
+         * player.showAttachedGui()
+         *
+         * // Hide the tooltip for this player
+         * player.hideAttachedGui()
+         *
+         * // Show tooltip for other players
+         * player.showAttachedGui([otherPlayer1, otherPlayer2])
+         * ```
+         */
+        attachToSprite?: boolean;
     } | any)[];
     /**
      * Array containing the list of sounds

package/dist/RpgClientEngine.d.ts

@@ -31,6 +31,10 @@ export declare class RpgClientEngine<T = any> {
     playerIdSignal: import('canvasengine').WritableSignal<string | null>;
     spriteComponentsBehind: import('canvasengine').WritableArraySignal<any[]>;
     spriteComponentsInFront: import('canvasengine').WritableArraySignal<any[]>;
+    /** ID of the sprite that the camera should follow. null means follow the current player */
+    cameraFollowTargetId: import('canvasengine').WritableSignal<string | null>;
+    /** Trigger for map shake animation */
+    mapShakeTrigger: import('canvasengine').Trigger<any>;
     private predictionEnabled;
     private prediction?;
     private readonly SERVER_CORRECTION_THRESHOLD;
@@ -41,6 +45,40 @@ export declare class RpgClientEngine<T = any> {
     private readonly PING_INTERVAL_MS;
     private lastInputTime;
     constructor(context: Context);
+    /**
+     * Assigns a CanvasEngine KeyboardControls instance to the dependency injection context
+     *
+     * This method registers a KeyboardControls instance from CanvasEngine into the DI container,
+     * making it available for injection throughout the application. The particularity is that
+     * this method is automatically called when a sprite is displayed on the map, allowing the
+     * controls to be automatically associated with the active sprite.
+     *
+     * ## Design
+     *
+     * - The instance is stored in the DI context under the `KeyboardControls` token
+     * - It's automatically assigned when a sprite component mounts (in `character.ce`)
+     * - The controls instance comes from the CanvasEngine component's directives
+     * - Once registered, it can be retrieved using `inject(KeyboardControls)` from anywhere
+     *
+     * @param controlInstance - The CanvasEngine KeyboardControls instance to register
+     *
+     * @example
+     * ```ts
+     * // The method is automatically called when a sprite is displayed:
+     * // client.setKeyboardControls(element.directives.controls)
+     *
+     * // Later, retrieve and use the controls instance:
+     * import { Input, inject, KeyboardControls } from '@rpgjs/client'
+     *
+     * const controls = inject(KeyboardControls)
+     * const control = controls.getControl(Input.Enter)
+     *
+     * if (control) {
+     *   console.log(control.actionName) // 'action'
+     * }
+     * ```
+     */
+    setKeyboardControls(controlInstance: any): void;
     start(): Promise<void>;
     private initListeners;
     /**
@@ -257,6 +295,59 @@ export declare class RpgClientEngine<T = any> {
      * ```
      */
     stopSound(soundId: string): void;
+    /**
+     * Stop all currently playing sounds
+     *
+     * This method stops all sounds that are currently playing.
+     * Useful when changing maps to prevent sound overlap.
+     *
+     * @example
+     * ```ts
+     * // Stop all sounds
+     * engine.stopAllSounds();
+     * ```
+     */
+    stopAllSounds(): void;
+    /**
+     * Set the camera to follow a specific sprite
+     *
+     * This method changes which sprite the camera viewport should follow.
+     * The camera will smoothly animate to the target sprite if smoothMove options are provided.
+     *
+     * ## Design
+     *
+     * The camera follow target is stored in a signal that is read by sprite components.
+     * Each sprite checks if it should be followed by comparing its ID with the target ID.
+     * When smoothMove options are provided, the viewport animation is handled by CanvasEngine's
+     * viewport system.
+     *
+     * @param targetId - The ID of the sprite to follow. Set to null to follow the current player
+     * @param smoothMove - Animation options. Can be a boolean (default: true) or an object with time and ease
+     * @param smoothMove.time - Duration of the animation in milliseconds (optional)
+     * @param smoothMove.ease - Easing function name from https://easings.net (optional)
+     *
+     * @example
+     * ```ts
+     * // Follow another player with default smooth animation
+     * engine.setCameraFollow(otherPlayerId, true);
+     *
+     * // Follow an event with custom smooth animation
+     * engine.setCameraFollow(eventId, {
+     *   time: 1000,
+     *   ease: "easeInOutQuad"
+     * });
+     *
+     * // Follow without animation (instant)
+     * engine.setCameraFollow(targetId, false);
+     *
+     * // Return to following current player
+     * engine.setCameraFollow(null);
+     * ```
+     */
+    setCameraFollow(targetId: string | null, smoothMove?: boolean | {
+        time?: number;
+        ease?: string;
+    }): void;
     addParticle(particle: any): any;
     /**
      * Add a component to render behind sprites
@@ -365,6 +456,60 @@ export declare class RpgClientEngine<T = any> {
      * ```
      */
     clearClientPredictionStates(): void;
+    /**
+     * Trigger a flash animation on a sprite
+     *
+     * This method allows you to trigger a flash effect on any sprite from client-side code.
+     * The flash can be configured with various options including type (alpha, tint, or both),
+     * duration, cycles, and color.
+     *
+     * ## Design
+     *
+     * The flash is applied directly to the sprite object using its flash trigger.
+     * This is useful for client-side visual feedback, UI interactions, or local effects
+     * that don't need to be synchronized with the server.
+     *
+     * @param spriteId - The ID of the sprite to flash. If not provided, flashes the current player
+     * @param options - Flash configuration options
+     * @param options.type - Type of flash effect: 'alpha' (opacity), 'tint' (color), or 'both' (default: 'alpha')
+     * @param options.duration - Duration of the flash animation in milliseconds (default: 300)
+     * @param options.cycles - Number of flash cycles (flash on/off) (default: 1)
+     * @param options.alpha - Alpha value when flashing, from 0 to 1 (default: 0.3)
+     * @param options.tint - Tint color when flashing as hex value or color name (default: 0xffffff - white)
+     *
+     * @example
+     * ```ts
+     * // Flash the current player with default settings
+     * engine.flash();
+     *
+     * // Flash a specific sprite with red tint
+     * engine.flash('sprite-id', { type: 'tint', tint: 0xff0000 });
+     *
+     * // Flash with both alpha and tint for dramatic effect
+     * engine.flash(undefined, {
+     *   type: 'both',
+     *   alpha: 0.5,
+     *   tint: 0xff0000,
+     *   duration: 200,
+     *   cycles: 2
+     * });
+     *
+     * // Quick damage flash on current player
+     * engine.flash(undefined, {
+     *   type: 'tint',
+     *   tint: 'red',
+     *   duration: 150,
+     *   cycles: 1
+     * });
+     * ```
+     */
+    flash(spriteId?: string, options?: {
+        type?: 'alpha' | 'tint' | 'both';
+        duration?: number;
+        cycles?: number;
+        alpha?: number;
+        tint?: number | string;
+    }): void;
     private applyServerAck;
     /**
      * Replay unacknowledged inputs from a given frame to resimulate client prediction

package/dist/index.d.ts

@@ -13,4 +13,7 @@ export * from './presets';
 export * from './components';
 export * from './components/gui';
 export * from './Sound';
+export * from './Resource';
 export { Context } from '@signe/di';
+export { KeyboardControls, Input } from 'canvasengine';
+export { Control } from './services/keyboardControls';

package/dist/index.js

@@ -14,5 +14,8 @@ export { default as EventLayerComponent } from './index14.js';
 export { default as CharacterComponent } from './index15.js';
 export { default as HpBar } from './index16.js';
 export { RpgSound, Sound, getSoundMetadata } from './index17.js';
-export { Context } from './index18.js';
+export { RpgResource } from './index18.js';
+export { Context } from './index19.js';
+export { Input, KeyboardControls } from 'canvasengine';
+export { Control } from './index20.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

package/dist/index10.js

@@ -1,5 +1,5 @@
 import { useProps, useDefineProps, signal, animatedSignal, computed, trigger, mount, effect, h, Container, Rect, cond, Text, Sprite } from 'canvasengine';
-import component$1 from './index42.js';
+import component$1 from './index43.js';
 import { inject } from './index6.js';
 import { RpgClientEngine } from './index2.js';
 

package/dist/index11.js

@@ -1,13 +1,14 @@
 import { useProps, useDefineProps, computed, h, Container, Rect } from 'canvasengine';
 import { RpgClientEngine } from './index2.js';
-import './index24.js';
+import './index26.js';
 import '@rpgjs/common';
-import './index18.js';
+import './index19.js';
 import { inject } from './index6.js';
 import 'rxjs';
-import './index25.js';
+import './index27.js';
 import './index17.js';
 import '@canvasengine/presets';
+import './index18.js';
 
 function component($$props) {
         useProps($$props);

package/dist/index11.js.map

@@ -1 +1 @@
-{"version":3,"file":"index11.js","sources":["../src/components/gui/box.ce"],"sourcesContent":["<Container positionType=\"absolute\" top={top} left={left}>\n    <Container\n      anchor={[0.5, 0.5]}\n    >\n    <Rect width height color={_color} />\n    <Container attach={child}></Container>\n  </Container>  \n</Container>\n\n<script>\n  import { RpgClientEngine, inject } from \"../../index\";\n\n  const { width, height, children, color, top, left } = defineProps();\n  const engine = inject(RpgClientEngine)\n  const child = children[0]\n  const _color = computed(() => engine.globalConfig.gui?.windowColor || color?.() || \"#1a1a2e\")\n</script>"],"names":[],"mappings":";;;;;;;;;;;AAOqB,SAAS,SAAS,CAAC,OAAO,EAAE;AACjD,QAAuB,QAAQ,CAAC,OAAO;AACvC,QAAQ,MAAM,WAAW,GAAG,cAAc,CAAC,OAAO;AAClD,QAAQ,IAAI,EAAE,GAAG,WAAW,EAAE,EAAE,KAAK,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC,MAAM,EAAE,QAAQ,GAAG,EAAE,CAAC,QAAQ,EAAE,KAAK,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC,IAAI;AAC5I,IAAI,MAAM,GAAG,MAAM,CAAC,eAAe,CAAC;AACpC,IAAI,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC;AACvB,IAAI,MAAM,GAAG,QAAQ,CAAC,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,MAAM,IAAI,IAAI,EAAE,KAAK,MAAM,GAAG,MAAM,GAAG,EAAE,CAAC,WAAW,MAAM,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,GAAG,MAAM,GAAG,KAAK,EAAE,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC;AAClN,QAAQ,IAAI,KAAK,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AACvM,QAAQ,OAAO;AACf,MAAM;;;;"}
+{"version":3,"file":"index11.js","sources":["../src/components/gui/box.ce"],"sourcesContent":["<Container positionType=\"absolute\" top={top} left={left}>\n    <Container\n      anchor={[0.5, 0.5]}\n    >\n    <Rect width height color={_color} />\n    <Container attach={child}></Container>\n  </Container>  \n</Container>\n\n<script>\n  import { RpgClientEngine, inject } from \"../../index\";\n\n  const { width, height, children, color, top, left } = defineProps();\n  const engine = inject(RpgClientEngine)\n  const child = children[0]\n  const _color = computed(() => engine.globalConfig.gui?.windowColor || color?.() || \"#1a1a2e\")\n</script>"],"names":[],"mappings":";;;;;;;;;;;;AAOqB,SAAS,SAAS,CAAC,OAAO,EAAE;AACjD,QAAuB,QAAQ,CAAC,OAAO;AACvC,QAAQ,MAAM,WAAW,GAAG,cAAc,CAAC,OAAO;AAClD,QAAQ,IAAI,EAAE,GAAG,WAAW,EAAE,EAAE,KAAK,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,EAAE,CAAC,MAAM,EAAE,QAAQ,GAAG,EAAE,CAAC,QAAQ,EAAE,KAAK,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC,IAAI;AAC5I,IAAI,MAAM,GAAG,MAAM,CAAC,eAAe,CAAC;AACpC,IAAI,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC;AACvB,IAAI,MAAM,GAAG,QAAQ,CAAC,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,MAAM,IAAI,IAAI,EAAE,KAAK,MAAM,GAAG,MAAM,GAAG,EAAE,CAAC,WAAW,MAAM,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,GAAG,MAAM,GAAG,KAAK,EAAE,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC;AAClN,QAAQ,IAAI,KAAK,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AACvM,QAAQ,OAAO;AACf,MAAM;;;;"}

package/dist/index12.js

@@ -1,5 +1,5 @@
-import component$1 from './index26.js';
-import component from './index27.js';
+import component$1 from './index28.js';
+import component from './index29.js';
 
 const PrebuiltComponentAnimations = {
   Hit: component$1,

package/dist/index13.js

@@ -1,7 +1,7 @@
-import { AnimationSpritesheetPreset } from './index28.js';
-import { LPCSpritesheetPreset } from './index29.js';
-import { RMSpritesheet } from './index30.js';
-import { FacesetPreset } from './index31.js';
+import { AnimationSpritesheetPreset } from './index30.js';
+import { LPCSpritesheetPreset } from './index31.js';
+import { RMSpritesheet } from './index32.js';
+import { FacesetPreset } from './index33.js';
 
 const Presets = {
   RMSpritesheet,