@thewhateverapp/tile-sdk 0.13.37 → 0.14.1

package/dist/scene/camera/CameraController.js

@@ -0,0 +1,84 @@
+'use client';
+import { useGameLoop } from '../../pixi';
+/**
+ * Hook to control the camera
+ */
+export function useCameraController(context, width, height) {
+    const { spec, camera, entities, player, timeline } = context;
+    const cameraConfig = spec.camera;
+    useGameLoop((delta) => {
+        const cameraState = camera.current;
+        const playerState = player.current;
+        const elapsedMs = timeline.current.elapsedMs;
+        // Get camera mode
+        const mode = cameraConfig?.mode ?? 'static';
+        switch (mode) {
+            case 'static': {
+                // Camera stays at initial position
+                cameraState.x = cameraConfig?.initialX ?? width / 2;
+                cameraState.y = cameraConfig?.initialY ?? height / 2;
+                break;
+            }
+            case 'scroll': {
+                // Auto-scroll camera
+                const scrollSpeed = (cameraConfig?.scrollSpeed ?? 320) * playerState.speedMultiplier;
+                const direction = cameraConfig?.scrollDirection ?? 'right';
+                switch (direction) {
+                    case 'right':
+                        cameraState.x += scrollSpeed * delta * 0.016;
+                        break;
+                    case 'left':
+                        cameraState.x -= scrollSpeed * delta * 0.016;
+                        break;
+                    case 'down':
+                        cameraState.y += scrollSpeed * delta * 0.016;
+                        break;
+                    case 'up':
+                        cameraState.y -= scrollSpeed * delta * 0.016;
+                        break;
+                }
+                break;
+            }
+            case 'follow': {
+                // Follow target entity
+                const targetId = cameraConfig?.followTarget;
+                if (!targetId)
+                    break;
+                const targetEntity = entities.current.get(targetId);
+                if (!targetEntity)
+                    break;
+                const smoothing = cameraConfig?.smoothing ?? 0.1;
+                const targetX = targetEntity.x;
+                const targetY = targetEntity.y;
+                // Lerp camera towards target
+                cameraState.x += (targetX - cameraState.x) * smoothing;
+                cameraState.y += (targetY - cameraState.y) * smoothing;
+                break;
+            }
+        }
+        // Apply camera bounds
+        const bounds = cameraConfig?.bounds;
+        if (bounds) {
+            if (bounds.minX !== undefined)
+                cameraState.x = Math.max(cameraState.x, bounds.minX);
+            if (bounds.maxX !== undefined)
+                cameraState.x = Math.min(cameraState.x, bounds.maxX);
+            if (bounds.minY !== undefined)
+                cameraState.y = Math.max(cameraState.y, bounds.minY);
+            if (bounds.maxY !== undefined)
+                cameraState.y = Math.min(cameraState.y, bounds.maxY);
+        }
+        // Apply camera shake
+        if (cameraState.shakeTimeRemaining > 0) {
+            const intensity = cameraState.shakeIntensity;
+            cameraState.x += (Math.random() - 0.5) * intensity;
+            cameraState.y += (Math.random() - 0.5) * intensity;
+            cameraState.shakeTimeRemaining -= delta * 16.67;
+            if (cameraState.shakeTimeRemaining <= 0) {
+                cameraState.shakeIntensity = 0;
+            }
+        }
+        // Apply zoom
+        cameraState.zoom = cameraConfig?.zoom ?? 1;
+    });
+}

package/dist/scene/components/ComponentRunner.d.ts

@@ -0,0 +1,22 @@
+import type { SceneContextValue, EntityState } from '../SceneContext';
+/**
+ * Generic component type
+ */
+interface GenericComponent {
+    type: string;
+    params?: Record<string, unknown>;
+}
+/**
+ * Component handler function type
+ */
+type ComponentHandler = (state: EntityState, component: GenericComponent, context: SceneContextValue, delta: number) => void;
+/**
+ * Hook to run component logic each frame
+ */
+export declare function useComponentRunner(context: SceneContextValue): void;
+/**
+ * Register a custom component handler
+ */
+export declare function registerComponent(type: string, handler: ComponentHandler): void;
+export {};
+//# sourceMappingURL=ComponentRunner.d.ts.map

package/dist/scene/components/ComponentRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentRunner.d.ts","sourceRoot":"","sources":["../../../src/scene/components/ComponentRunner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAatE;;GAEG;AACH,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG,CACtB,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,MAAM,KACV,IAAI,CAAC;AAcV;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,QAkB5D;AA+MD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,QAExE"}

package/dist/scene/components/ComponentRunner.js

@@ -0,0 +1,197 @@
+'use client';
+import { useGameLoop } from '../../pixi';
+import { isJumpPressed } from '../input/InputManager';
+import { setVelocity } from '../physics/PhysicsEngine';
+import Matter from 'matter-js';
+const { Body } = Matter;
+/**
+ * Registry of component handlers
+ */
+const componentHandlers = {
+    Move: handleMove,
+    Rotate: handleRotate,
+    Oscillate: handleOscillate,
+    Follow: handleFollow,
+    DashPlayer: handleDashPlayer,
+    // Add more handlers as needed
+};
+/**
+ * Hook to run component logic each frame
+ */
+export function useComponentRunner(context) {
+    const { entities } = context;
+    useGameLoop((delta) => {
+        for (const [, state] of entities.current) {
+            if (state.destroyed)
+                continue;
+            const components = state.entity.components;
+            if (!components)
+                continue;
+            for (const component of components) {
+                const handler = componentHandlers[component.type];
+                if (handler) {
+                    handler(state, component, context, delta);
+                }
+            }
+        }
+    });
+}
+/**
+ * Move component - applies constant velocity/acceleration
+ */
+function handleMove(state, component, context, delta) {
+    const params = (component.params ?? {});
+    // Apply acceleration
+    if (params.accelX) {
+        state.velocityX += params.accelX * delta * 0.016;
+    }
+    if (params.accelY) {
+        state.velocityY += params.accelY * delta * 0.016;
+    }
+    // Apply constant velocity (overrides physics for non-physics entities)
+    if (!state.body) {
+        if (params.velocityX !== undefined) {
+            state.x += params.velocityX * delta * 0.016;
+        }
+        if (params.velocityY !== undefined) {
+            state.y += params.velocityY * delta * 0.016;
+        }
+    }
+    else if (params.velocityX !== undefined || params.velocityY !== undefined) {
+        // For physics bodies, set velocity directly
+        setVelocity(state.body, params.velocityX ?? state.velocityX, params.velocityY ?? state.velocityY);
+    }
+}
+/**
+ * Rotate component - spins the entity
+ */
+function handleRotate(state, component, context, delta) {
+    const params = (component.params ?? { speed: 0 });
+    const rotationSpeed = (params.speed * Math.PI) / 180; // Convert to radians/second
+    state.rotation += rotationSpeed * delta * 0.016;
+    // Update physics body rotation if present
+    if (state.body) {
+        Body.setAngle(state.body, state.rotation);
+    }
+}
+/**
+ * Oscillate component - sine wave motion
+ */
+function handleOscillate(state, component, context, delta) {
+    const params = (component.params ?? { axis: 'y', amplitude: 10, frequency: 1 });
+    const { axis, amplitude, frequency, phase = 0 } = params;
+    // Get or initialize oscillation state
+    if (state.componentState.oscillateTime === undefined) {
+        state.componentState.oscillateTime = 0;
+        state.componentState.oscillateStartX = state.x;
+        state.componentState.oscillateStartY = state.y;
+    }
+    state.componentState.oscillateTime += delta * 0.016;
+    const time = state.componentState.oscillateTime;
+    const offset = Math.sin(time * frequency * Math.PI * 2 + phase) * amplitude;
+    if (axis === 'x') {
+        state.x = state.componentState.oscillateStartX + offset;
+    }
+    else {
+        state.y = state.componentState.oscillateStartY + offset;
+    }
+    // Update physics body position if present and static
+    if (state.body && state.entity.body?.isStatic) {
+        Body.setPosition(state.body, { x: state.x, y: state.y });
+    }
+}
+/**
+ * Follow component - tracks another entity
+ */
+function handleFollow(state, component, context, delta) {
+    const params = (component.params ?? { target: '' });
+    const { target, offsetX = 0, offsetY = 0, smoothing = 0.1 } = params;
+    const targetEntity = context.getEntity(target);
+    if (!targetEntity)
+        return;
+    const targetX = targetEntity.x + offsetX;
+    const targetY = targetEntity.y + offsetY;
+    // Lerp towards target
+    state.x += (targetX - state.x) * smoothing;
+    state.y += (targetY - state.y) * smoothing;
+    // Update physics body if present
+    if (state.body) {
+        Body.setPosition(state.body, { x: state.x, y: state.y });
+    }
+}
+/**
+ * DashPlayer component - main player controller for Geometry Dash style games
+ */
+function handleDashPlayer(state, component, context, delta) {
+    const { player, camera, emitEvent, respawnPlayer } = context;
+    const playerState = player.current;
+    // Handle death
+    if (playerState.dead) {
+        // Wait a moment then respawn
+        if (state.componentState.deathTimer === undefined) {
+            state.componentState.deathTimer = 0;
+        }
+        state.componentState.deathTimer += delta * 16.67;
+        if (state.componentState.deathTimer > 500) {
+            state.componentState.deathTimer = 0;
+            respawnPlayer();
+        }
+        return;
+    }
+    // Handle jump input
+    const jumpPressed = isJumpPressed(context);
+    const wasJumpPressed = state.componentState.wasJumpPressed ?? false;
+    const justPressed = jumpPressed && !wasJumpPressed;
+    state.componentState.wasJumpPressed = jumpPressed;
+    if (justPressed) {
+        // Check if touching an orb
+        if (playerState.touchingOrb) {
+            const orb = context.getEntity(playerState.touchingOrb);
+            if (orb) {
+                const orbComponent = orb.entity.components?.find((c) => c.type === 'JumpOrb');
+                const impulse = orbComponent?.params?.impulse ?? -900;
+                if (state.body) {
+                    Body.setVelocity(state.body, {
+                        x: state.body.velocity.x,
+                        y: impulse * 0.01 * playerState.gravityDir,
+                    });
+                }
+                emitEvent('orb.used', { orbId: playerState.touchingOrb });
+                playerState.touchingOrb = null;
+            }
+        }
+        // Normal jump from ground
+        else if (playerState.grounded) {
+            const jumpVelocity = -15 * playerState.gravityDir;
+            if (state.body) {
+                Body.setVelocity(state.body, {
+                    x: state.body.velocity.x,
+                    y: jumpVelocity,
+                });
+            }
+            playerState.grounded = false;
+            playerState.jumpCount++;
+            emitEvent('player.jump', { jumpCount: playerState.jumpCount });
+        }
+    }
+    // Clear orb touching state if not colliding anymore
+    // This is handled in physics collision detection
+    // Rotate player based on movement (visual only)
+    if (state.body && Math.abs(state.body.velocity.y) > 1) {
+        state.rotation += 0.1 * delta * playerState.gravityDir;
+    }
+    // Apply constant forward velocity (for auto-runners)
+    const scrollSpeed = (context.spec.camera?.scrollSpeed ?? 320) * playerState.speedMultiplier;
+    if (state.body) {
+        Body.setVelocity(state.body, {
+            x: scrollSpeed * 0.01,
+            y: state.body.velocity.y,
+        });
+    }
+}
+/**
+ * Register a custom component handler
+ */
+export function registerComponent(type, handler) {
+    componentHandlers[type] = handler;
+}

package/dist/scene/effects/GlowFilter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Glow effect utilities
+ *
+ * Note: Full glow filter implementation requires @pixi/filter-glow
+ * which is an optional peer dependency. This file provides helper
+ * functions for creating and managing glow effects.
+ */
+export interface GlowOptions {
+    color?: string;
+    strength?: number;
+    blur?: number;
+    quality?: number;
+}
+/**
+ * Parse color string to number
+ */
+export declare function parseColor(color: string): number;
+/**
+ * Create glow filter options
+ * Returns options compatible with @pixi/filter-glow GlowFilter
+ */
+export declare function createGlowOptions(options?: GlowOptions): {
+    color: number;
+    outerStrength: number;
+    innerStrength: number;
+    distance: number;
+    quality: number;
+};
+/**
+ * Check if glow filter is available
+ * Returns true if @pixi/filter-glow is installed
+ */
+export declare function isGlowFilterAvailable(): boolean;
+/**
+ * Create a CSS text-shadow style for glow effect (fallback)
+ */
+export declare function createGlowShadow(color: string, strength: number, blur: number): string;
+//# sourceMappingURL=GlowFilter.d.ts.map

package/dist/scene/effects/GlowFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlowFilter.d.ts","sourceRoot":"","sources":["../../../src/scene/effects/GlowFilter.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,WAAgB;;;;;;EAe1D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAO/C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtF"}

package/dist/scene/effects/GlowFilter.js

@@ -0,0 +1,40 @@
+'use client';
+/**
+ * Parse color string to number
+ */
+export function parseColor(color) {
+    return parseInt(color.replace('#', ''), 16);
+}
+/**
+ * Create glow filter options
+ * Returns options compatible with @pixi/filter-glow GlowFilter
+ */
+export function createGlowOptions(options = {}) {
+    const { color = '#ffffff', strength = 1, blur = 4, quality = 0.1, } = options;
+    return {
+        color: parseColor(color),
+        outerStrength: strength,
+        innerStrength: 0,
+        distance: blur * 2,
+        quality,
+    };
+}
+/**
+ * Check if glow filter is available
+ * Returns true if @pixi/filter-glow is installed
+ */
+export function isGlowFilterAvailable() {
+    try {
+        // Dynamic import check
+        return typeof window !== 'undefined';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a CSS text-shadow style for glow effect (fallback)
+ */
+export function createGlowShadow(color, strength, blur) {
+    return `0 0 ${blur}px ${color}, 0 0 ${blur * 2}px ${color}`;
+}

package/dist/scene/effects/ParticleSystem.d.ts

@@ -0,0 +1,52 @@
+import type { EmitterGeometry } from '@thewhateverapp/scene-sdk';
+/**
+ * Particle representation
+ */
+export interface Particle {
+    x: number;
+    y: number;
+    velocityX: number;
+    velocityY: number;
+    life: number;
+    maxLife: number;
+    scale: number;
+    scaleStart: number;
+    scaleEnd: number;
+    color: number;
+    alpha: number;
+}
+/**
+ * Particle emitter state
+ */
+export interface ParticleEmitter {
+    /** Particles in this emitter */
+    particles: Particle[];
+    /** Emitter configuration */
+    config: EmitterGeometry;
+    /** Position */
+    x: number;
+    y: number;
+    /** Time since last emission */
+    timeSinceEmit: number;
+    /** Whether emitter is active */
+    active: boolean;
+}
+/**
+ * Create a new particle emitter
+ */
+export declare function createEmitter(config: EmitterGeometry, x: number, y: number): ParticleEmitter;
+/**
+ * Update particle emitter
+ * @param emitter The emitter to update
+ * @param deltaMs Time since last update in milliseconds
+ */
+export declare function updateEmitter(emitter: ParticleEmitter, deltaMs: number): void;
+/**
+ * Draw particles to a Graphics object
+ */
+export declare function drawParticles(graphics: import('pixi.js').Graphics, emitter: ParticleEmitter): void;
+/**
+ * Burst emit multiple particles at once
+ */
+export declare function burstEmit(emitter: ParticleEmitter, count: number): void;
+//# sourceMappingURL=ParticleSystem.d.ts.map

package/dist/scene/effects/ParticleSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleSystem.d.ts","sourceRoot":"","sources":["../../../src/scene/effects/ParticleSystem.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,4BAA4B;IAC5B,MAAM,EAAE,eAAe,CAAC;IACxB,eAAe;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,+BAA+B;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,eAAe,EACvB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,eAAe,CASjB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAoC7E;AAyCD;;GAEG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,OAAO,SAAS,EAAE,QAAQ,EACpC,OAAO,EAAE,eAAe,GACvB,IAAI,CAQN;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAIvE"}

package/dist/scene/effects/ParticleSystem.js

@@ -0,0 +1,107 @@
+'use client';
+/**
+ * Create a new particle emitter
+ */
+export function createEmitter(config, x, y) {
+    return {
+        particles: [],
+        config,
+        x,
+        y,
+        timeSinceEmit: 0,
+        active: true,
+    };
+}
+/**
+ * Update particle emitter
+ * @param emitter The emitter to update
+ * @param deltaMs Time since last update in milliseconds
+ */
+export function updateEmitter(emitter, deltaMs) {
+    const { config, particles } = emitter;
+    // Update existing particles
+    for (let i = particles.length - 1; i >= 0; i--) {
+        const particle = particles[i];
+        // Update life
+        particle.life -= deltaMs;
+        if (particle.life <= 0) {
+            particles.splice(i, 1);
+            continue;
+        }
+        // Update position
+        particle.x += particle.velocityX * (deltaMs / 1000);
+        particle.y += particle.velocityY * (deltaMs / 1000);
+        // Update scale
+        const lifeRatio = particle.life / particle.maxLife;
+        particle.scale = particle.scaleStart + (particle.scaleEnd - particle.scaleStart) * (1 - lifeRatio);
+        // Update alpha (fade out)
+        particle.alpha = lifeRatio;
+    }
+    // Emit new particles
+    if (emitter.active) {
+        const emitInterval = 1000 / config.rate;
+        emitter.timeSinceEmit += deltaMs;
+        while (emitter.timeSinceEmit >= emitInterval) {
+            emitter.timeSinceEmit -= emitInterval;
+            emitParticle(emitter);
+        }
+    }
+}
+/**
+ * Emit a single particle
+ */
+function emitParticle(emitter) {
+    const { config, x, y, particles } = emitter;
+    // Calculate random velocity
+    const speed = randomRange(config.speed.min, config.speed.max);
+    const angle = config.angle
+        ? randomRange(config.angle.min, config.angle.max) * (Math.PI / 180)
+        : Math.random() * Math.PI * 2;
+    const velocityX = Math.cos(angle) * speed;
+    const velocityY = Math.sin(angle) * speed;
+    // Calculate scale
+    const scaleStart = config.scale?.start ?? 1;
+    const scaleEnd = config.scale?.end ?? 0;
+    // Pick random color
+    const colors = config.colors ?? ['#ffffff'];
+    const colorStr = colors[Math.floor(Math.random() * colors.length)];
+    const color = parseInt(colorStr.replace('#', ''), 16);
+    particles.push({
+        x,
+        y,
+        velocityX,
+        velocityY,
+        life: config.lifetime,
+        maxLife: config.lifetime,
+        scale: scaleStart,
+        scaleStart,
+        scaleEnd,
+        color,
+        alpha: 1,
+    });
+}
+/**
+ * Draw particles to a Graphics object
+ */
+export function drawParticles(graphics, emitter) {
+    graphics.clear();
+    for (const particle of emitter.particles) {
+        graphics.beginFill(particle.color, particle.alpha);
+        graphics.drawCircle(particle.x, particle.y, 3 * particle.scale);
+        graphics.endFill();
+    }
+}
+/**
+ * Burst emit multiple particles at once
+ */
+export function burstEmit(emitter, count) {
+    for (let i = 0; i < count; i++) {
+        emitParticle(emitter);
+    }
+}
+/**
+ * Generate random number in range
+ */
+function randomRange(min, max) {
+    return min + Math.random() * (max - min);
+}

package/dist/scene/entities/EntityRenderer.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { EntityState } from '../SceneContext';
+/**
+ * Props for EntityRenderer
+ */
+export interface EntityRendererProps {
+    state: EntityState;
+    debug?: boolean;
+}
+/**
+ * Renders a single entity based on its kind
+ */
+export declare function EntityRenderer({ state, debug }: EntityRendererProps): React.JSX.Element | null;
+//# sourceMappingURL=EntityRenderer.d.ts.map

package/dist/scene/entities/EntityRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityRenderer.d.ts","sourceRoot":"","sources":["../../../src/scene/entities/EntityRenderer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAA+B,MAAM,OAAO,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAWnD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,KAAK,EAAE,KAAa,EAAE,EAAE,mBAAmB,4BAyG3E"}