@caperjs/plugin-crunch 0.1.0

package/lib/Entity.d.ts

@@ -0,0 +1,377 @@
+import { defaultFactoryMethods, IApplication, PointLike, SignalConnection, SignalConnections } from '@caperjs/core';
+import { default as CrunchPhysicsPlugin } from './CrunchPhysicsPlugin';
+import { Group } from './Group';
+import { System } from './System';
+import { EntityData, PhysicsEntityConfig, PhysicsEntityType, PhysicsEntityView, Rectangle } from './types';
+/**
+ * Base class for all physics entities in the Crunch physics system.
+ * Provides common functionality for position, size, view management, and lifecycle.
+ *
+ * Entity is the foundation for:
+ * - Actors (dynamic objects)
+ * - Solids (static objects)
+ * - Sensors (trigger zones)
+ *
+ * It handles:
+ * - Position and size management
+ * - View (sprite) management and updates
+ * - Group membership and relative positioning
+ * - Culling and lifecycle states
+ * - Signal connections for event handling
+ *
+ * @typeParam A - Application type, defaults to base Application
+ * @typeParam D - Entity data type, defaults to base EntityData
+ *
+ * @example
+ * ```typescript
+ * // Create a custom entity
+ * class CustomEntity extends Entity {
+ *   constructor() {
+ *     super({
+ *       type: 'Custom',
+ *       position: [100, 100],
+ *       size: [32, 32],
+ *       view: sprite
+ *     });
+ *   }
+ *
+ *   // Override update for custom behavior
+ *   update(dt: number) {
+ *     super.update(dt);
+ *     // Custom update logic
+ *   }
+ * }
+ * ```
+ */
+export declare class Entity<D extends EntityData = EntityData> {
+    readonly entityType: PhysicsEntityType;
+    protected _id: string;
+    /** Unique type identifier for this entity */
+    type: string;
+    /** Color to use when rendering debug visuals */
+    debugColor: number;
+    /** Whether the entity should be removed when culled (out of bounds) */
+    shouldRemoveOnCull: boolean;
+    /** Entity width in pixels */
+    width: number;
+    /** Entity height in pixels */
+    height: number;
+    /** Visual representation (sprite/graphics) of this entity */
+    view: PhysicsEntityView;
+    /** Whether this entity is active and should be updated */
+    /** Collision layer this entity belongs to (bitwise) */
+    collisionLayer: number;
+    /** Collision mask defining which layers this entity collides with (bitwise) */
+    collisionMask: number;
+    protected _data: Partial<D>;
+    protected _group: Group | null;
+    protected _groupOffset: {
+        x: number;
+        y: number;
+    };
+    protected _isCulled: boolean;
+    protected _isDestroyed: boolean;
+    protected _isInitialized: boolean;
+    protected _xRemainder: number;
+    protected _yRemainder: number;
+    protected _x: number;
+    protected _y: number;
+    protected signalConnections: SignalConnections;
+    protected _following: Entity | null;
+    protected _followOffset: {
+        x: number;
+        y: number;
+    };
+    protected _config: PhysicsEntityConfig<D> | undefined;
+    protected _active: boolean;
+    updatedFollowPosition: boolean;
+    updatedGroupPosition: boolean;
+    set active(value: boolean);
+    get active(): boolean;
+    set id(value: string);
+    get id(): string;
+    get make(): typeof defaultFactoryMethods;
+    /**
+     * Custom data associated with this entity
+     */
+    set data(value: Partial<D>);
+    get data(): Partial<D>;
+    setFollowing(entityToFollow: Entity | null, offset?: PointLike): void;
+    get followOffset(): {
+        x: number;
+        y: number;
+    };
+    get following(): Entity | null;
+    get followers(): Entity[];
+    /**
+     * The group this entity belongs to, if any.
+     * Groups allow for collective movement and management of entities.
+     */
+    get group(): Group | null;
+    set groupOffset(value: {
+        x: number;
+        y: number;
+    });
+    get groupOffset(): {
+        x: number;
+        y: number;
+    };
+    setGroup(group: Group | null, offset?: PointLike): void;
+    set position(value: PointLike);
+    get position(): PointLike;
+    /**
+     * Entity's X position in world space.
+     * If the entity belongs to a group, returns position relative to group.
+     */
+    set x(value: number);
+    get x(): number;
+    /**
+     * Entity's Y position in world space.
+     * If the entity belongs to a group, returns position relative to group.
+     */
+    set y(value: number);
+    get y(): number;
+    /** Whether this entity is currently culled (out of bounds) */
+    get isCulled(): boolean;
+    /** Whether this entity has been destroyed */
+    get isDestroyed(): boolean;
+    /** Reference to the main application instance */
+    get app(): IApplication;
+    /** Reference to the physics plugin */
+    get physics(): CrunchPhysicsPlugin;
+    /**
+     * Creates a new Entity instance.
+     *
+     * @param config - Optional configuration for the entity
+     */
+    constructor(config?: PhysicsEntityConfig<D>);
+    /**
+     * Called after construction to perform additional initialization.
+     * Override this in subclasses to add custom initialization logic.
+     */
+    protected initialize(): void;
+    /**
+     * Called before update to prepare for the next frame.
+     * Override this in subclasses to add pre-update logic.
+     */
+    preUpdate(): void;
+    /**
+     * Called every frame to update the entity's state.
+     * Override this in subclasses to add update logic.
+     *
+     * @param dt - Delta time in seconds since last update
+     */
+    update(dt: number): void;
+    /**
+     * Called after update to finalize the frame.
+     * Override this in subclasses to add post-update logic.
+     */
+    postUpdate(): void;
+    /**
+     * Excludes collision types for this entity
+     * @deprecated Use setCollisionMask instead
+     */
+    excludeCollisionType(): void;
+    /**
+     * Includes collision types for this entity
+     * @deprecated Use setCollisionMask instead
+     */
+    includeCollisionType(): void;
+    /**
+     * Removes collision types for this entity
+     * @deprecated Use removeCollisionMask instead
+     */
+    removeCollisionType(): void;
+    /**
+     * Adds collision types for this entity
+     * @deprecated Use addCollisionMask instead
+     */
+    addCollisionType(): void;
+    /**
+     * Checks if this entity can collide with a specific type
+     */
+    canCollideWith(): boolean;
+    /**
+     * Adds the entity's view to the physics container and updates its position.
+     */
+    protected addView(): void;
+    /**
+     * Initializes or reinitializes the entity with new configuration.
+     * Used by object pools when recycling entities.
+     *
+     * @param config - New configuration to apply
+     */
+    init(config: PhysicsEntityConfig<D>): void;
+    /**
+     * Resets the entity to its initial state for reuse in object pools.
+     * Override this to handle custom reset logic.
+     */
+    reset(): void;
+    /** Reference to the physics system */
+    get system(): System;
+    /**
+     * Called when the entity is added to a group.
+     * Override this to handle custom group addition logic.
+     */
+    onAddedToGroup(): void;
+    /**
+     * Called when the entity is removed from a group.
+     * Override this to handle custom group removal logic.
+     */
+    onRemovedFromGroup(): void;
+    /**
+     * Updates the entity's position and view.
+     */
+    updatePosition(): void;
+    /**
+     * Called when the entity is culled (goes out of bounds).
+     * Override this to handle culling differently.
+     */
+    onCull(): void;
+    /**
+     * Called when the entity is brought back after being culled.
+     * Override this to handle unculling differently.
+     */
+    onUncull(): void;
+    /**
+     * Prepares the entity for removal/recycling.
+     * Override this to handle custom cleanup.
+     */
+    destroy(): void;
+    /**
+     * Called when the entity is removed from the physics system.
+     * Override this to handle custom removal logic.
+     */
+    onRemoved(): void;
+    /**
+     * Sets a new view for the entity and updates its position.
+     *
+     * @param view - The new view to use
+     */
+    setView(view: PhysicsEntityView): void;
+    /**
+     * Updates the view's position to match the entity's position.
+     */
+    updateView(): void;
+    /**
+     * Gets the entity's bounding rectangle.
+     *
+     * @returns Rectangle representing the entity's bounds
+     */
+    getBounds(): Rectangle;
+    /**
+     * Sets the entity's position, resetting any movement remainders.
+     *
+     * @param x - New X position
+     * @param y - New Y position
+     */
+    setPosition(x: number, y: number): void;
+    /**
+     * Alias for setPosition.
+     *
+     * @param x - New X position
+     * @param y - New Y position
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * Adds signal connections to the entity.
+     *
+     * @param args - Signal connections to add
+     */
+    addSignalConnection(...args: SignalConnection[]): void;
+    /**
+     * Alias for addSignalConnection.
+     *
+     * @param args - Signal connections to add
+     */
+    connectSignal(...args: SignalConnection[]): void;
+    /**
+     * Alias for addSignalConnection, specifically for action signals.
+     *
+     * @param args - Action signal connections to add
+     */
+    connectAction(...args: SignalConnection[]): void;
+    /**
+     * Checks if this entity can collide with another entity
+     */
+    canCollideWithEntity(entity: Entity): boolean;
+    /**
+     * Sets the collision layer for this entity
+     *
+     * @param layer The collision layer or layers (can be combined with bitwise OR)
+     */
+    setCollisionLayer(layer: number): void;
+    /**
+     * Adds the specified layers to this entity's collision layer
+     *
+     * @param layers The layers to add (can be combined with bitwise OR)
+     */
+    addCollisionLayer(layers: number): void;
+    /**
+     * Removes the specified layers from this entity's collision layer
+     *
+     * @param layers The layers to remove (can be combined with bitwise OR)
+     */
+    removeCollisionLayer(layers: number): void;
+    /**
+     * Sets the collision mask for this entity
+     *
+     * @param mask The collision mask (can be combined with bitwise OR)
+     */
+    setCollisionMask(...mask: number[]): void;
+    /**
+     * Adds the specified layers to this entity's collision mask
+     *
+     * @param layers The layers to add to the mask (can be combined with bitwise OR)
+     */
+    addCollisionMask(layers: number): void;
+    /**
+     * Removes the specified layers from this entity's collision mask
+     *
+     * @param layers The layers to remove from the mask (can be combined with bitwise OR)
+     */
+    removeCollisionMask(layers: number): void;
+    /**
+     * Checks if this entity belongs to a specific collision layer
+     *
+     * @param layer The layer to check
+     * @returns True if the entity belongs to the specified layer
+     *
+     * @example
+     * ```typescript
+     * // Check if entity is on the PLAYER layer
+     * if (entity.hasCollisionLayer(CollisionLayer.PLAYER)) {
+     *   console.log('Entity is a player');
+     * }
+     *
+     * // Check if entity is on a custom layer
+     * const WATER_LAYER = CollisionLayers.createLayer(0);
+     * if (entity.hasCollisionLayer(WATER_LAYER)) {
+     *   console.log('Entity is water');
+     * }
+     * ```
+     */
+    hasCollisionLayer(layer: number): boolean;
+    /**
+     * Checks if this entity can collide with a specific collision layer
+     *
+     * @param layer The layer to check
+     * @returns True if the entity can collide with the specified layer
+     *
+     * @example
+     * ```typescript
+     * // Check if entity can collide with players
+     * if (entity.canCollideWithLayer(CollisionLayer.PLAYER)) {
+     *   console.log('Entity can collide with players');
+     * }
+     *
+     * // Check if entity can collide with a custom layer
+     * const WATER_LAYER = CollisionLayers.createLayer(0);
+     * if (entity.canCollideWithLayer(WATER_LAYER)) {
+     *   console.log('Entity can collide with water');
+     * }
+     * ```
+     */
+    canCollideWithLayer(layer: number): boolean;
+}
+//# sourceMappingURL=Entity.d.ts.map

package/lib/Entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entity.d.ts","sourceRoot":"","sources":["../src/Entity.ts"],"names":[],"mappings":"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"}

package/lib/Group.d.ts

@@ -0,0 +1,122 @@
+import { Actor } from './Actor';
+import { Entity } from './Entity';
+import { Sensor } from './Sensor';
+import { Solid } from './Solid';
+import { EntityData, PhysicsEntityType } from './types';
+/**
+ * A container for managing collections of physics entities that move together.
+ * Groups are useful for creating compound objects, moving platforms with riders,
+ * and other scenarios where multiple entities need to move as one unit.
+ *
+ * Features:
+ * - Maintains relative positioning of child entities
+ * - Supports actors, solids, and sensors as children
+ * - Preserves world positions when adding entities
+ * - Provides type-safe access to children by entity type
+ *
+ * @typeParam T - Application type, defaults to base Application
+ *
+ * @example
+ * ```typescript
+ * // Create a moving platform with obstacles
+ * const platformGroup = physics.createGroup({
+ *   type: 'MovingPlatform',
+ *   position: [100, 300]
+ * });
+ *
+ * // Add platform and spikes
+ * const platform = physics.createSolid({
+ *   type: 'Platform',
+ *   size: [200, 32]
+ * });
+ *
+ * const spikes = physics.createSensor({
+ *   type: 'Spikes',
+ *   position: [0, -32],
+ *   size: [200, 32]
+ * });
+ *
+ * platformGroup.add(platform);
+ * platformGroup.add(spikes);
+ *
+ * // Move the entire group
+ * gsap.to(platformGroup, {
+ *   x: 500,
+ *   duration: 2,
+ *   yoyo: true,
+ *   repeat: -1
+ * });
+ * ```
+ */
+export declare class Group<D extends EntityData = EntityData> extends Entity<D> {
+    protected _visible: boolean;
+    entityType: PhysicsEntityType;
+    /** Map of child entities to their relative offsets from the group's position */
+    private childOffsets;
+    /** Whether this group's position is static (not affected by physics) */
+    isStatic: boolean;
+    /**
+     * Gets the relative offset of a child entity from the group's position.
+     * @param entity - The child entity to get the offset for
+     * @returns The relative {x, y} offset of the entity
+     */
+    getChildOffset(entity: Entity): {
+        x: number;
+        y: number;
+    };
+    set visible(value: boolean);
+    get visible(): boolean;
+    /**
+     * Sets the group's X position, affecting all child entities.
+     */
+    set x(value: number);
+    get x(): number;
+    /**
+     * Sets the group's Y position, affecting all child entities.
+     */
+    set y(value: number);
+    get y(): number;
+    /**
+     * Add an entity to this container
+     * @param entity The entity to add
+     * @param preserveWorldPosition If true, the entity's world position will be preserved
+     */
+    add(entity: Entity, offset?: {
+        x: number;
+        y: number;
+    }): Group;
+    /**
+     * Remove an entity from this container
+     */
+    remove(entity: Entity): Group;
+    /**
+     * Move the container and all its children
+     */
+    move(x: number, y: number): void;
+    /**
+     * Force move the container and all its children to an absolute position
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * Get all children of a specific type
+     */
+    getChildrenByType<E extends Entity>(type: PhysicsEntityType): E[];
+    /**
+     * Get all actors in this container
+     */
+    getActors(): Actor[];
+    /**
+     * Get all solids in this container
+     */
+    getSolids(): Solid[];
+    /**
+     * Get all sensors in this container
+     */
+    getSensors(): Sensor[];
+    /**
+     * Get all groups in this container
+     */
+    getGroups(): Group[];
+    destroy(): void;
+}
+//# sourceMappingURL=Group.d.ts.map

package/lib/Group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Group.d.ts","sourceRoot":"","sources":["../src/Group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAAa,KAAK,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACrE,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAQ;IAE5B,UAAU,EAAE,iBAAiB,CAAW;IAC/C,gFAAgF;IAChF,OAAO,CAAC,YAAY,CAAoD;IACxE,wEAAwE;IACjE,QAAQ,EAAE,OAAO,CAAQ;IAEhC;;;;OAIG;IACI,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAI/D,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EAIzB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAElB;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAED;;OAEG;IACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAElB;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAED;;;;OAIG;IACI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAmB,GAAG,KAAK;IAKpF;;OAEG;IACI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK;IAKpC;;OAEG;IACI,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAQvC;;OAEG;IACI,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAMzC;;OAEG;IACI,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,CAAC,EAAE;IAMxE;;OAEG;IACI,SAAS,IAAI,KAAK,EAAE;IAI3B;;OAEG;IACI,SAAS,IAAI,KAAK,EAAE;IAI3B;;OAEG;IACI,UAAU,IAAI,MAAM,EAAE;IAI7B;;OAEG;IACI,SAAS,IAAI,KAAK,EAAE;IAIpB,OAAO,IAAI,IAAI;CAIvB"}

package/lib/Sensor.d.ts

@@ -0,0 +1,161 @@
+import { Actor } from './Actor';
+import { Entity } from './Entity';
+import { Solid } from './Solid';
+import { EntityData, PhysicsEntityConfig, PhysicsEntityType, SensorOverlap, Vector2 } from './types';
+/**
+ * A trigger zone that can detect overlaps with actors.
+ * Sensors are typically used for collectibles, triggers, and detection zones.
+ *
+ * Features:
+ * - Overlap detection with specific actor types
+ * - Optional gravity and movement
+ * - Can be static or dynamic
+ * - Callbacks for enter/exit events
+ *
+ * @typeParam T - Application type, defaults to base Application
+ *
+ * @example
+ * ```typescript
+ * // Create a coin pickup sensor
+ * class Coin extends Sensor {
+ *   constructor() {
+ *     super({
+ *       type: 'Coin',
+ *       position: [100, 100],
+ *       size: [32, 32],
+ *       view: coinSprite
+ *     });
+ *
+ *     // Only detect overlaps with player
+ *     this.collidableTypes = ['Player'];
+ *   }
+ *
+ *   // Called when a player enters the coin
+ *   onActorEnter(actor: Actor) {
+ *     if (actor.type === 'Player') {
+ *       increaseScore(10);
+ *       this.physics.removeSensor(this);
+ *     }
+ *   }
+ * }
+ *
+ * // Create a damage zone
+ * class Spikes extends Sensor {
+ *   constructor() {
+ *     super({
+ *       type: 'Spikes',
+ *       position: [300, 500],
+ *       size: [100, 32],
+ *       view: spikesSprite
+ *     });
+ *
+ *     this.collidableTypes = ['Player', 'Enemy'];
+ *     this.isStatic = true; // Don't move or fall
+ *   }
+ *
+ *   onActorEnter(actor: Actor) {
+ *     if (actor.type === 'Player') {
+ *       actor.damage(10);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class Sensor<D extends EntityData = EntityData> extends Entity<D> {
+    readonly entityType: PhysicsEntityType;
+    /** Whether this sensor should be removed when culled */
+    shouldRemoveOnCull: boolean;
+    /** List of actor types this sensor can detect */
+    collidableTypes: string[];
+    /** Current velocity in pixels per second */
+    velocity: Vector2;
+    /** Whether this sensor should stay in place */
+    isStatic: boolean;
+    /** Set of actors currently overlapping this sensor */
+    private overlappingActors;
+    /** Cache for isRidingSolid check */
+    private _isRidingSolidCache;
+    private _currentSensorOverlaps;
+    private _currentOverlaps;
+    setPosition(x: number, y: number): void;
+    set x(value: number);
+    get x(): number;
+    set y(value: number);
+    get y(): number;
+    /**
+     * Initializes or reinitializes the sensor with new configuration.
+     *
+     * @param config - Configuration for the sensor
+     */
+    init(config: PhysicsEntityConfig<D>): void;
+    /**
+     * Checks if this sensor is riding the given solid.
+     * Takes into account gravity direction for proper riding detection.
+     *
+     * @param solid - The solid to check against
+     * @returns True if riding the solid
+     */
+    isRiding(solid: Solid): boolean;
+    /**
+     * Checks if this sensor is riding any solid.
+     * Uses caching to optimize multiple checks per frame.
+     *
+     * @returns True if riding any solid
+     */
+    isRidingSolid(): boolean;
+    /**
+     * Force moves the sensor to a new position, ignoring static state and collisions.
+     *
+     * @param x - New X position
+     * @param y - New Y position
+     */
+    moveStatic(x: number, y: number): void;
+    /**
+     * Moves the sensor horizontally, passing through solids.
+     *
+     * @param amount - Distance to move in pixels
+     */
+    moveX(amount: number): void;
+    /**
+     * Moves the sensor vertically, colliding with solids for riding.
+     *
+     * @param amount - Distance to move in pixels
+     */
+    moveY(amount: number): void;
+    /**
+     * Updates the sensor's position and checks for overlapping actors.
+     *
+     * @param deltaTime - Delta time in seconds
+     */
+    update(deltaTime: number): void;
+    /**
+     * Checks for overlapping actors and triggers callbacks.
+     *
+     * @returns Set of current overlaps
+     */
+    checkActorOverlaps(): Set<SensorOverlap>;
+    reset(): void;
+    /**
+     * Called when an actor starts overlapping with this sensor.
+     * Override this to handle overlap start events.
+     *
+     * @param actor - The actor that entered
+     */
+    onActorEnter<A extends Actor = Actor>(actor: A): void;
+    /**
+     * Called when an actor stops overlapping with this sensor.
+     * Override this to handle overlap end events.
+     *
+     * @param actor - The actor that exited
+     */
+    onActorExit<A extends Actor = Actor>(actor: A): void;
+    /**
+     * Gets all solids at the specified position.
+     *
+     * @param x - X position to check
+     * @param y - Y position to check
+     * @returns Array of solids at the position
+     */
+    protected getSolidsAt(x: number, y: number): Solid[];
+}
+//# sourceMappingURL=Sensor.d.ts.map

package/lib/Sensor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sensor.d.ts","sourceRoot":"","sources":["../src/Sensor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,qBAAa,MAAM,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACtE,SAAgB,UAAU,EAAE,iBAAiB,CAAY;IACzD,wDAAwD;IACjD,kBAAkB,UAAS;IAElC,iDAAiD;IAC1C,eAAe,EAAE,MAAM,EAAE,CAAM;IAEtC,4CAA4C;IACrC,QAAQ,EAAE,OAAO,CAAkB;IAE1C,+CAA+C;IACxC,QAAQ,EAAE,OAAO,CAAS;IAEjC,sDAAsD;IACtD,OAAO,CAAC,iBAAiB,CAAyB;IAElD,oCAAoC;IACpC,OAAO,CAAC,mBAAmB,CAAwB;IAEnD,OAAO,CAAC,sBAAsB,CAA4B;IAC1D,OAAO,CAAC,gBAAgB,CAAoB;IAErC,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAa9C,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAOlB;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAED,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAOlB;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAED;;;;OAIG;IACI,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI;IAajD;;;;;;OAMG;IACI,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAiBtC;;;;;OAKG;IACI,aAAa,IAAI,OAAO;IAY/B;;;;;OAKG;IACI,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAS7C;;;;OAIG;IACI,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAuClC;;;;OAIG;IACI,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IA2ClC;;;;OAIG;IACI,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAsBtC;;;;OAIG;IACI,kBAAkB,IAAI,GAAG,CAAC,aAAa,CAAC;IA4DxC,KAAK,IAAI,IAAI;IASpB;;;;;OAKG;IACI,YAAY,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAK5D;;;;;OAKG;IACI,WAAW,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAK3D;;;;;;OAMG;IACH,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,EAAE;CAGrD"}