@buley/hexgrid-3d 3.0.1 → 3.2.0

package/dist/algorithms/ParticleSystem3D.js

@@ -0,0 +1,371 @@
+/**
+ * 3D Particle System
+ *
+ * GPU-friendly particle physics for React Three Fiber InstancedMesh rendering.
+ * Supports forces, attractors, fluid coupling, and biometric visualization.
+ */
+import { Vector3 } from '../math/Vector3';
+/**
+ * 3D Particle System with GPU-friendly output
+ */
+export class ParticleSystem3D {
+    constructor(config) {
+        this.particles = new Map();
+        this.particleOrder = [];
+        this.time = 0;
+        this.idCounter = 0;
+        this.maxParticles = config.maxParticles;
+        this.gravity = config.gravity ?? new Vector3(0, 0, 0);
+        this.drag = config.drag ?? 0.99;
+        this.boundsSphereRadius = config.boundsSphereRadius ?? Infinity;
+        this.boundsCenter = config.boundsCenter ?? new Vector3(0, 0, 0);
+        this.bounceFactor = config.bounceFactor ?? 0.5;
+        // Pre-allocate buffers (unless provided via config for zero-copy)
+        if (config.sharedBuffers) {
+            this.positionBuffer = config.sharedBuffers.positions;
+            this.colorBuffer = config.sharedBuffers.colors;
+            this.scaleBuffer = config.sharedBuffers.scales;
+        }
+        else {
+            this.positionBuffer = new Float32Array(this.maxParticles * 3);
+            this.colorBuffer = new Float32Array(this.maxParticles * 3);
+            this.scaleBuffer = new Float32Array(this.maxParticles);
+        }
+    }
+    /**
+     * Zero-Copy Binding: Inject shared buffers from WASM/Dash
+     */
+    setSharedBuffers(buffers) {
+        this.positionBuffer = buffers.positions;
+        this.colorBuffer = buffers.colors;
+        this.scaleBuffer = buffers.scales;
+    }
+    /**
+     * Emit particles at a position
+     */
+    emit(position, options = {}) {
+        const count = options.count ?? 1;
+        const emittedIds = [];
+        for (let i = 0; i < count; i++) {
+            if (this.particles.size >= this.maxParticles) {
+                // Remove oldest particle
+                const oldest = this.particleOrder.shift();
+                if (oldest) {
+                    this.particles.delete(oldest);
+                }
+            }
+            const id = `p_${this.idCounter++}`;
+            const spread = options.velocitySpread ?? new Vector3(0, 0, 0);
+            const sizeSpread = options.sizeSpread ?? 0;
+            const lifeSpread = options.lifeSpread ?? 0;
+            const particle = {
+                id,
+                position: new Vector3(position.x, position.y, position.z),
+                velocity: new Vector3((options.velocity?.x ?? 0) + (Math.random() - 0.5) * 2 * spread.x, (options.velocity?.y ?? 0) + (Math.random() - 0.5) * 2 * spread.y, (options.velocity?.z ?? 0) + (Math.random() - 0.5) * 2 * spread.z),
+                acceleration: new Vector3(0, 0, 0),
+                color: options.color ?? [1, 1, 1],
+                size: (options.size ?? 1) + (Math.random() - 0.5) * 2 * sizeSpread,
+                life: (options.life ?? 5) + (Math.random() - 0.5) * 2 * lifeSpread,
+                maxLife: options.life ?? 5,
+                mass: options.mass ?? 1,
+                userData: options.userData,
+                heartRate: options.heartRate,
+                hrvValue: options.hrvValue,
+                pulseScale: 1,
+            };
+            this.particles.set(id, particle);
+            this.particleOrder.push(id);
+            emittedIds.push(id);
+        }
+        return emittedIds;
+    }
+    /**
+     * Add or update a persistent particle (for memory particles that don't expire)
+     */
+    setParticle(id, particle) {
+        const existing = this.particles.get(id);
+        if (existing) {
+            // Update existing
+            Object.assign(existing, particle);
+            existing.acceleration = new Vector3(0, 0, 0);
+        }
+        else {
+            // Add new
+            if (this.particles.size >= this.maxParticles) {
+                // Remove oldest non-persistent particle
+                for (let i = 0; i < this.particleOrder.length; i++) {
+                    const oldId = this.particleOrder[i];
+                    const oldParticle = this.particles.get(oldId);
+                    if (oldParticle && oldParticle.life !== Infinity) {
+                        this.particles.delete(oldId);
+                        this.particleOrder.splice(i, 1);
+                        break;
+                    }
+                }
+            }
+            const newParticle = {
+                ...particle,
+                acceleration: new Vector3(0, 0, 0),
+                pulseScale: 1,
+            };
+            this.particles.set(id, newParticle);
+            this.particleOrder.push(id);
+        }
+    }
+    /**
+     * Remove a particle by ID
+     */
+    removeParticle(id) {
+        this.particles.delete(id);
+        const idx = this.particleOrder.indexOf(id);
+        if (idx >= 0) {
+            this.particleOrder.splice(idx, 1);
+        }
+    }
+    /**
+     * Get a particle by ID
+     */
+    getParticle(id) {
+        return this.particles.get(id);
+    }
+    /**
+     * Apply a force field to all particles
+     */
+    applyForceField(field) {
+        Array.from(this.particles.values()).forEach((particle) => {
+            const force = field(particle.position);
+            particle.acceleration.x += force.x / particle.mass;
+            particle.acceleration.y += force.y / particle.mass;
+            particle.acceleration.z += force.z / particle.mass;
+        });
+    }
+    /**
+     * Apply an attractor force
+     */
+    applyAttractor(center, strength, falloffRadius) {
+        Array.from(this.particles.values()).forEach((particle) => {
+            const dx = center.x - particle.position.x;
+            const dy = center.y - particle.position.y;
+            const dz = center.z - particle.position.z;
+            const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            if (dist > 0.001) {
+                const falloff = Math.max(0, 1 - dist / falloffRadius);
+                const force = (strength * falloff * falloff) / (dist * dist);
+                const invDist = 1 / dist;
+                particle.acceleration.x += (dx * invDist * force) / particle.mass;
+                particle.acceleration.y += (dy * invDist * force) / particle.mass;
+                particle.acceleration.z += (dz * invDist * force) / particle.mass;
+            }
+        });
+    }
+    /**
+     * Apply velocity from a fluid simulation
+     */
+    applyFluidVelocity(fluid, strength = 1) {
+        Array.from(this.particles.values()).forEach((particle) => {
+            const fluidVel = fluid.getVelocityAt(particle.position);
+            particle.velocity.x += fluidVel.x * strength;
+            particle.velocity.y += fluidVel.y * strength;
+            particle.velocity.z += fluidVel.z * strength;
+        });
+    }
+    /**
+     * Update all particles
+     */
+    update(dt) {
+        this.time += dt;
+        const deadParticles = [];
+        Array.from(this.particles.values()).forEach((particle) => {
+            // Apply gravity
+            particle.acceleration.x += this.gravity.x;
+            particle.acceleration.y += this.gravity.y;
+            particle.acceleration.z += this.gravity.z;
+            // Integrate velocity
+            particle.velocity.x += particle.acceleration.x * dt;
+            particle.velocity.y += particle.acceleration.y * dt;
+            particle.velocity.z += particle.acceleration.z * dt;
+            // Apply drag
+            particle.velocity.x *= this.drag;
+            particle.velocity.y *= this.drag;
+            particle.velocity.z *= this.drag;
+            // Integrate position
+            particle.position.x += particle.velocity.x * dt;
+            particle.position.y += particle.velocity.y * dt;
+            particle.position.z += particle.velocity.z * dt;
+            // Reset acceleration
+            particle.acceleration.x = 0;
+            particle.acceleration.y = 0;
+            particle.acceleration.z = 0;
+            // Sphere bounds collision
+            if (this.boundsSphereRadius < Infinity) {
+                const dx = particle.position.x - this.boundsCenter.x;
+                const dy = particle.position.y - this.boundsCenter.y;
+                const dz = particle.position.z - this.boundsCenter.z;
+                const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+                if (dist > this.boundsSphereRadius) {
+                    // Push back inside
+                    const invDist = 1 / dist;
+                    const nx = dx * invDist;
+                    const ny = dy * invDist;
+                    const nz = dz * invDist;
+                    particle.position.x =
+                        this.boundsCenter.x + nx * this.boundsSphereRadius * 0.99;
+                    particle.position.y =
+                        this.boundsCenter.y + ny * this.boundsSphereRadius * 0.99;
+                    particle.position.z =
+                        this.boundsCenter.z + nz * this.boundsSphereRadius * 0.99;
+                    // Reflect velocity
+                    const dot = particle.velocity.x * nx +
+                        particle.velocity.y * ny +
+                        particle.velocity.z * nz;
+                    particle.velocity.x =
+                        (particle.velocity.x - 2 * dot * nx) * this.bounceFactor;
+                    particle.velocity.y =
+                        (particle.velocity.y - 2 * dot * ny) * this.bounceFactor;
+                    particle.velocity.z =
+                        (particle.velocity.z - 2 * dot * nz) * this.bounceFactor;
+                }
+            }
+            // Update biometric pulse
+            if (particle.heartRate) {
+                const pulseFreq = particle.heartRate / 60; // Hz
+                const pulse = Math.sin(this.time * pulseFreq * Math.PI * 2);
+                particle.pulseScale = 1 + pulse * 0.15; // 15% size variation
+            }
+            // Decrease life (skip for Infinity life)
+            if (particle.life !== Infinity) {
+                particle.life -= dt;
+                if (particle.life <= 0) {
+                    deadParticles.push(particle.id);
+                }
+            }
+        });
+        // Remove dead particles
+        deadParticles.forEach((id) => {
+            this.particles.delete(id);
+            const idx = this.particleOrder.indexOf(id);
+            if (idx >= 0) {
+                this.particleOrder.splice(idx, 1);
+            }
+        });
+    }
+    /**
+     * Get instance data for React Three Fiber InstancedMesh
+     */
+    getInstanceData() {
+        const count = this.particles.size;
+        const ids = [];
+        let i = 0;
+        const entries = Array.from(this.particles.entries());
+        for (let j = 0; j < entries.length && i < this.maxParticles; j++) {
+            const [id, particle] = entries[j];
+            // Position
+            this.positionBuffer[i * 3] = particle.position.x;
+            this.positionBuffer[i * 3 + 1] = particle.position.y;
+            this.positionBuffer[i * 3 + 2] = particle.position.z;
+            // Color with life-based alpha (encoded in color for now)
+            const lifeFactor = particle.life === Infinity
+                ? 1
+                : Math.min(1, particle.life / particle.maxLife);
+            this.colorBuffer[i * 3] = particle.color[0] * lifeFactor;
+            this.colorBuffer[i * 3 + 1] = particle.color[1] * lifeFactor;
+            this.colorBuffer[i * 3 + 2] = particle.color[2] * lifeFactor;
+            // Scale with pulse
+            this.scaleBuffer[i] = particle.size * (particle.pulseScale ?? 1);
+            ids.push(id);
+            i++;
+        }
+        return {
+            positions: this.positionBuffer.subarray(0, count * 3),
+            colors: this.colorBuffer.subarray(0, count * 3),
+            scales: this.scaleBuffer.subarray(0, count),
+            count,
+            ids,
+        };
+    }
+    /**
+     * Get all particles
+     */
+    getParticles() {
+        return Array.from(this.particles.values());
+    }
+    /**
+     * Get particle count
+     */
+    getCount() {
+        return this.particles.size;
+    }
+    /**
+     * Clear all particles
+     */
+    clear() {
+        this.particles.clear();
+        this.particleOrder = [];
+    }
+    /**
+     * Find particle nearest to a point
+     */
+    findNearest(point, maxDistance = Infinity) {
+        let nearest = null;
+        let nearestDist = maxDistance;
+        Array.from(this.particles.values()).forEach((particle) => {
+            const dist = particle.position.distanceTo(point);
+            if (dist < nearestDist) {
+                nearest = particle;
+                nearestDist = dist;
+            }
+        });
+        return nearest;
+    }
+    /**
+     * Find all particles within a radius
+     */
+    findWithinRadius(center, radius) {
+        const results = [];
+        const r2 = radius * radius;
+        Array.from(this.particles.values()).forEach((particle) => {
+            const dx = particle.position.x - center.x;
+            const dy = particle.position.y - center.y;
+            const dz = particle.position.z - center.z;
+            if (dx * dx + dy * dy + dz * dz <= r2) {
+                results.push(particle);
+            }
+        });
+        return results;
+    }
+}
+/**
+ * Pensieve-specific particle system with memory visualization presets
+ */
+export class PensieveParticleSystem extends ParticleSystem3D {
+    constructor(maxParticles = 10000) {
+        super({
+            maxParticles,
+            gravity: new Vector3(0, -0.1, 0), // Gentle downward drift
+            drag: 0.995,
+            boundsSphereRadius: 50,
+            boundsCenter: new Vector3(0, 0, 0),
+            bounceFactor: 0.3,
+        });
+    }
+    /**
+     * Add a memory particle with reflection data
+     */
+    addMemoryParticle(id, position, color, options = {}) {
+        const size = 0.5 + (options.intensity ?? 0.5) * 0.5;
+        const ageFactor = options.ageFactor ?? 1;
+        this.setParticle(id, {
+            id,
+            position,
+            velocity: new Vector3((Math.random() - 0.5) * 0.5, (Math.random() - 0.5) * 0.5, (Math.random() - 0.5) * 0.5),
+            color: [color[0] * ageFactor, color[1] * ageFactor, color[2] * ageFactor],
+            size,
+            life: Infinity, // Memory particles don't expire
+            maxLife: Infinity,
+            mass: 1,
+            heartRate: options.heartRate,
+            hrvValue: options.hrvValue,
+            userData: options.userData,
+        });
+    }
+}

package/dist/algorithms/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Algorithms Module Exports
+ *
+ * @module algorithms
+ */
+export * from './GraphAlgorithms';
+export * from './FlowField';
+export * from './ParticleSystem';
+export * from './FluidSimulation';
+export * from './AdvancedStatistics';
+export * from './BayesianStatistics';
+export * from './OutlierDetection';
+export * from './FluidSimulation3D';
+export * from './ParticleSystem3D';
+export * from './FlowField3D';
+//# sourceMappingURL=index.d.ts.map

package/dist/algorithms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}

package/{src/algorithms/index.ts → dist/algorithms/index.js}

@@ -3,7 +3,6 @@
  *
  * @module algorithms
  */
-
 // 2D algorithms (existing)
 export * from './GraphAlgorithms';
 export * from './FlowField';
@@ -12,7 +11,6 @@ export * from './FluidSimulation';
 export * from './AdvancedStatistics';
 export * from './BayesianStatistics';
 export * from './OutlierDetection';
-
 // 3D algorithms (new - for Pensieve)
 export * from './FluidSimulation3D';
 export * from './ParticleSystem3D';

package/dist/compat.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Backward compatibility layer for Photo and GridItem
+ *
+ * Provides conversion utilities to ensure existing Photo-based code
+ * continues to work while new code can use GridItem.
+ */
+import type { Photo, GridItem } from './types';
+/**
+ * Convert Photo to GridItem for backward compatibility
+ */
+export declare function photoToGridItem(photo: Photo): GridItem<Photo>;
+/**
+ * Convert GridItem back to Photo if possible
+ */
+export declare function gridItemToPhoto(item: GridItem<Photo>): Photo | null;
+/**
+ * Convert an array of Photos to GridItems
+ */
+export declare function photosToGridItems(photos: Photo[]): GridItem<Photo>[];
+/**
+ * Convert an array of GridItems to Photos (filtering out non-photo items)
+ */
+export declare function gridItemsToPhotos(items: GridItem<Photo>[]): Photo[];
+//# sourceMappingURL=compat.d.ts.map

package/dist/compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.d.ts","sourceRoot":"","sources":["../src/compat.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/C;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,CA4B7D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,IAAI,CAkCnE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,EAAE,CAEpE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,EAAE,CAInE"}

package/dist/compat.js

@@ -0,0 +1,88 @@
+/**
+ * Backward compatibility layer for Photo and GridItem
+ *
+ * Provides conversion utilities to ensure existing Photo-based code
+ * continues to work while new code can use GridItem.
+ */
+/**
+ * Convert Photo to GridItem for backward compatibility
+ */
+export function photoToGridItem(photo) {
+    return {
+        id: photo.id,
+        type: 'photo',
+        imageUrl: photo.imageUrl,
+        thumbnailUrl: photo.thumbnailUrl,
+        title: photo.title,
+        alt: photo.alt,
+        description: photo.description,
+        category: photo.category,
+        data: photo,
+        // Map all Photo fields
+        url: photo.imageUrl,
+        userId: photo.userId,
+        username: photo.username,
+        videoUrl: photo.videoUrl,
+        platform: photo.platform,
+        author: photo.author,
+        authorUrl: photo.authorUrl,
+        likes: photo.likes,
+        views: photo.views,
+        comments: photo.comments,
+        dominantColor: photo.dominantColor,
+        source: photo.source,
+        sourceUrl: photo.sourceUrl,
+        createdAt: photo.createdAt,
+        velocity: photo.velocity,
+    };
+}
+/**
+ * Convert GridItem back to Photo if possible
+ */
+export function gridItemToPhoto(item) {
+    // If item contains original Photo data, return it
+    if (item.type === 'photo' && item.data) {
+        return item.data;
+    }
+    // Fallback: construct Photo from GridItem fields
+    if (item.imageUrl || item.url) {
+        return {
+            id: item.id,
+            title: item.title ?? '',
+            alt: item.alt ?? item.title ?? '',
+            imageUrl: item.imageUrl || item.url || '',
+            category: item.category ?? 'uncategorized',
+            description: item.description,
+            source: item.source || 'unknown',
+            sourceUrl: item.sourceUrl,
+            createdAt: item.createdAt,
+            thumbnailUrl: item.thumbnailUrl,
+            userId: item.userId,
+            username: item.username,
+            videoUrl: item.videoUrl,
+            platform: item.platform,
+            author: item.author,
+            authorUrl: item.authorUrl,
+            likes: item.likes,
+            views: item.views,
+            comments: item.comments,
+            dominantColor: item.dominantColor,
+            velocity: item.velocity,
+        };
+    }
+    return null;
+}
+/**
+ * Convert an array of Photos to GridItems
+ */
+export function photosToGridItems(photos) {
+    return photos.map(photoToGridItem);
+}
+/**
+ * Convert an array of GridItems to Photos (filtering out non-photo items)
+ */
+export function gridItemsToPhotos(items) {
+    return items
+        .map(gridItemToPhoto)
+        .filter((photo) => photo !== null);
+}

package/dist/components/HexGrid.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { HexGridProps } from '../types';
+export declare function HexGrid(props: HexGridProps): React.JSX.Element;
+export default HexGrid;
+//# sourceMappingURL=HexGrid.d.ts.map

package/dist/components/HexGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HexGrid.d.ts","sourceRoot":"","sources":["../../src/components/HexGrid.tsx"],"names":[],"mappings":"AACA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAE3D,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAqD9D;AAED,eAAe,OAAO,CAAC"}

package/dist/components/HexGrid.js

@@ -0,0 +1,39 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { FluidEngineFactory } from '../algorithms/FluidEngineFactory';
+export function HexGrid(props) {
+    const canvasRef = useRef(null);
+    const [engine, setEngine] = useState(null);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        // Initialize Fluid Engine
+        const initEngine = async () => {
+            try {
+                const fluidEngine = await FluidEngineFactory.create({
+                    width: 64,
+                    height: 64,
+                    depth: 64,
+                    viscosity: 0.0001,
+                    diffusion: 0.00001
+                });
+                setEngine(fluidEngine);
+            }
+            catch (err) {
+                console.error("Failed to init fluid engine", err);
+                setError(err instanceof Error ? err.message : String(err));
+            }
+        };
+        initEngine();
+        return () => {
+            // Cleanup if engine has cleanup method
+            if (engine && 'clear' in engine) {
+                engine.clear();
+            }
+        };
+    }, []);
+    if (error) {
+        return _jsxs("div", { className: "text-red-500", children: ["Error initializing simulation: ", error] });
+    }
+    return (_jsxs("div", { className: "hexgrid-container", style: { width: '100%', height: '100%', position: 'relative' }, children: [_jsx("canvas", { ref: canvasRef, width: 800, height: 600, style: { width: '100%', height: '100%' } }), _jsxs("div", { style: { position: 'absolute', top: 10, left: 10, background: 'rgba(0,0,0,0.5)', color: 'white', padding: '5px', pointerEvents: 'none' }, children: ["Engine: ", engine ? engine.constructor.name : 'Initializing...'] })] }));
+}
+export default HexGrid;

package/dist/components/NarrationOverlay.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Narration Overlay Component
+ *
+ * Displays play-by-play narration messages with sparklines in a NOC dashboard style.
+ */
+import React from 'react';
+import { NarrationMessage } from '@/lib/narration';
+import { StatsTracker } from '@/lib/stats-tracker';
+export interface NarrationOverlayProps {
+    messages: NarrationMessage[];
+    statsTracker: StatsTracker | null;
+    isVisible: boolean;
+    onClose: () => void;
+}
+export declare const NarrationOverlay: React.FC<NarrationOverlayProps>;
+//# sourceMappingURL=NarrationOverlay.d.ts.map

package/dist/components/NarrationOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NarrationOverlay.d.ts","sourceRoot":"","sources":["../../src/components/NarrationOverlay.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAA4B,MAAM,OAAO,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CAkS5D,CAAC"}