@rubixstudios/payload-typesense 1.0.0

package/dist/components/themes/utils.js

@@ -0,0 +1,397 @@
+import { defaultTheme, themes } from './themes.js';
+/**
+ * Get a theme by name or return the default theme
+ */ export function getTheme(themeName) {
+    return themes[themeName] || defaultTheme;
+}
+/**
+ * Merge theme configurations with custom overrides
+ */ export function mergeThemeConfig(config) {
+    const baseTheme = typeof config.theme === 'string' ? getTheme(config.theme) : config.theme;
+    return {
+        ...baseTheme,
+        animations: {
+            ...baseTheme.animations,
+            ...config.animations
+        },
+        colors: {
+            ...baseTheme.colors,
+            ...config.colors
+        },
+        shadows: {
+            ...baseTheme.shadows,
+            ...config.shadows
+        },
+        spacing: {
+            ...baseTheme.spacing,
+            ...config.spacing
+        },
+        typography: {
+            ...baseTheme.typography,
+            ...config.typography
+        }
+    };
+}
+/**
+ * Generate CSS classes from theme configuration
+ */ export function generateThemeClasses(theme, config = {}) {
+    const enableAnimations = config.enableAnimations !== false;
+    const enableShadows = config.enableShadows !== false;
+    const enableRoundedCorners = config.enableRoundedCorners !== false;
+    // Helper function to create CSS string
+    const css = (styles)=>{
+        return Object.entries(styles).map(([key, value])=>{
+            if (typeof value === 'object' && value !== null) {
+                // Handle nested objects like ':hover', '::placeholder'
+                const nested = Object.entries(value).map(([nestedKey, nestedValue])=>`${nestedKey.replace(/([A-Z])/g, '-$1').toLowerCase()}: ${nestedValue}`).join('; ');
+                return `${key.replace(/([A-Z])/g, '-$1').toLowerCase()}: { ${nested} }`;
+            }
+            return `${key.replace(/([A-Z])/g, '-$1').toLowerCase()}: ${value}`;
+        }).join('; ');
+    };
+    // Container styles
+    const containerStyles = css({
+        margin: '0 auto',
+        maxWidth: '600px',
+        position: 'relative',
+        width: '100%'
+    });
+    const inputContainerStyles = css({
+        position: 'relative',
+        width: '100%'
+    });
+    const resultsContainerStyles = css({
+        backgroundColor: theme.colors.resultsBackground,
+        border: `1px solid ${theme.colors.resultsBorder}`,
+        borderRadius: enableRoundedCorners ? theme.spacing.resultsBorderRadius : '0',
+        boxShadow: enableShadows ? theme.shadows.shadowLg : 'none',
+        left: '0',
+        marginTop: '4px',
+        maxHeight: theme.spacing.resultsMaxHeight,
+        overflowY: 'auto',
+        position: 'absolute',
+        right: '0',
+        top: '100%',
+        zIndex: '1000',
+        ...enableAnimations && {
+            animation: 'slideDown 0.2s ease-out'
+        }
+    });
+    // Input styles
+    const inputStyles = css({
+        '::placeholder': {
+            color: theme.colors.inputPlaceholder
+        },
+        ':disabled': {
+            backgroundColor: theme.colors.inputBackground,
+            cursor: 'not-allowed',
+            opacity: '0.6'
+        },
+        ':focus': {
+            borderColor: theme.colors.inputBorderFocus,
+            boxShadow: enableShadows ? `${theme.shadows.focusShadow} ${theme.shadows.focusShadowColor}` : 'none'
+        },
+        backgroundColor: theme.colors.inputBackground,
+        border: `2px solid ${theme.colors.inputBorder}`,
+        borderRadius: enableRoundedCorners ? theme.spacing.inputBorderRadius : '0',
+        boxShadow: 'none',
+        color: theme.colors.inputText,
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.spacing.inputFontSize,
+        fontWeight: theme.typography.fontWeightNormal,
+        lineHeight: theme.typography.lineHeightNormal,
+        outline: 'none',
+        padding: theme.spacing.inputPadding,
+        transition: enableAnimations ? `all ${theme.animations.transitionNormal} ${theme.animations.easeInOut}` : 'none',
+        width: '100%'
+    });
+    // Results styles
+    const resultsStyles = css({
+        backgroundColor: theme.colors.resultsBackground,
+        border: `1px solid ${theme.colors.resultsBorder}`,
+        borderRadius: enableRoundedCorners ? theme.spacing.resultsBorderRadius : '0',
+        boxShadow: enableShadows ? theme.shadows.shadowLg : 'none',
+        left: '0',
+        maxHeight: theme.spacing.resultsMaxHeight,
+        overflowY: 'auto',
+        position: 'absolute',
+        right: '0',
+        top: '100%',
+        zIndex: '1000'
+    });
+    const resultsHeaderStyles = css({
+        alignItems: 'center',
+        backgroundColor: theme.colors.headerBackground,
+        borderBottom: `1px solid ${theme.colors.headerBorder}`,
+        color: theme.colors.headerText,
+        display: 'flex',
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.spacing.headerFontSize,
+        fontWeight: theme.typography.fontWeightMedium,
+        justifyContent: 'space-between',
+        padding: theme.spacing.headerPadding
+    });
+    const resultsListStyles = css({
+        padding: '8px 0'
+    });
+    // Result item styles
+    const resultItemStyles = css({
+        ':focus': {
+            backgroundColor: theme.colors.resultBackgroundFocus,
+            boxShadow: enableShadows ? `inset 0 0 0 2px ${theme.colors.inputBorderFocus}` : 'none'
+        },
+        ':hover': {
+            backgroundColor: theme.colors.resultBackgroundHover,
+            transform: enableAnimations ? 'translateX(2px)' : 'none'
+        },
+        ':last-child': {
+            borderBottom: 'none'
+        },
+        backgroundColor: theme.colors.resultBackground,
+        borderBottom: `1px solid ${theme.colors.resultBorder}`,
+        cursor: 'pointer',
+        outline: 'none',
+        padding: theme.spacing.itemPadding,
+        transition: enableAnimations ? `all ${theme.animations.transitionFast} ${theme.animations.easeInOut}` : 'none'
+    });
+    // Content styles
+    const resultTitleStyles = css({
+        color: theme.colors.titleText,
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeLg,
+        fontWeight: theme.typography.fontWeightSemibold,
+        lineHeight: theme.typography.lineHeightTight,
+        marginBottom: '8px'
+    });
+    const resultDescriptionStyles = css({
+        color: theme.colors.descriptionText,
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeSm,
+        lineHeight: theme.typography.lineHeightNormal,
+        marginBottom: '8px'
+    });
+    const resultHighlightStyles = css({
+        backgroundColor: theme.colors.highlightBackground,
+        borderRadius: enableRoundedCorners ? '6px' : '0',
+        color: theme.colors.descriptionText,
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeSm,
+        lineHeight: theme.typography.lineHeightNormal,
+        marginBottom: '8px',
+        mark: {
+            backgroundColor: theme.colors.highlightBackground,
+            borderRadius: enableRoundedCorners ? '3px' : '0',
+            color: theme.colors.highlightText,
+            fontWeight: theme.typography.fontWeightMedium,
+            padding: '2px 4px'
+        },
+        padding: '8px 12px'
+    });
+    const resultMetaStyles = css({
+        alignItems: 'center',
+        color: theme.colors.metaText,
+        display: 'flex',
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeXs,
+        justifyContent: 'space-between',
+        marginTop: '8px'
+    });
+    // Badge styles
+    const collectionBadgeStyles = css({
+        backgroundColor: theme.colors.collectionBadge,
+        borderRadius: enableRoundedCorners ? '12px' : '0',
+        color: theme.colors.collectionBadgeText,
+        display: 'inline-block',
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeXs,
+        fontWeight: theme.typography.fontWeightSemibold,
+        letterSpacing: '0.5px',
+        padding: '4px 8px',
+        textTransform: 'uppercase'
+    });
+    const scoreBadgeStyles = css({
+        backgroundColor: theme.colors.scoreBadge,
+        borderRadius: enableRoundedCorners ? '4px' : '0',
+        color: theme.colors.scoreBadgeText,
+        display: 'inline-block',
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeXs,
+        fontWeight: theme.typography.fontWeightMedium,
+        padding: '2px 6px'
+    });
+    // State styles
+    const loadingStyles = css({
+        alignItems: 'center',
+        color: theme.colors.loadingText,
+        display: 'flex',
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeSm,
+        gap: '12px',
+        justifyContent: 'center',
+        padding: '24px'
+    });
+    const loadingSpinnerStyles = css({
+        animation: enableAnimations ? `spin 1s linear infinite` : 'none',
+        border: `2px solid ${theme.colors.inputBorder}`,
+        borderRadius: '50%',
+        borderTop: `2px solid ${theme.colors.inputBorderFocus}`,
+        height: '20px',
+        width: '20px'
+    });
+    const errorStyles = css({
+        alignItems: 'center',
+        backgroundColor: theme.colors.errorBackground,
+        borderBottom: `1px solid ${theme.colors.resultBorder}`,
+        color: theme.colors.errorText,
+        display: 'flex',
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeSm,
+        gap: '8px',
+        padding: '16px'
+    });
+    const noResultsStyles = css({
+        color: theme.colors.noResultsText,
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeSm,
+        padding: '40px 20px',
+        textAlign: 'center'
+    });
+    // Facet styles
+    const facetContainerStyles = css({
+        backgroundColor: theme.colors.headerBackground,
+        borderBottom: `1px solid ${theme.colors.headerBorder}`,
+        padding: '16px'
+    });
+    const facetItemStyles = css({
+        ':hover': {
+            backgroundColor: theme.colors.facetActiveBackground,
+            borderColor: theme.colors.facetActiveBackground,
+            color: theme.colors.facetActiveText
+        },
+        backgroundColor: theme.colors.facetBackground,
+        border: `1px solid ${theme.colors.facetBorder}`,
+        borderRadius: enableRoundedCorners ? '16px' : '0',
+        color: theme.colors.facetText,
+        cursor: 'pointer',
+        display: 'inline-block',
+        fontFamily: theme.typography.fontFamily,
+        fontSize: theme.typography.fontSizeXs,
+        fontWeight: theme.typography.fontWeightMedium,
+        margin: '4px',
+        padding: '6px 12px',
+        transition: enableAnimations ? `all ${theme.animations.transitionFast} ${theme.animations.easeInOut}` : 'none'
+    });
+    const facetItemActiveStyles = css({
+        backgroundColor: theme.colors.facetActiveBackground,
+        borderColor: theme.colors.facetActiveBackground,
+        color: theme.colors.facetActiveText
+    });
+    // Utility styles
+    const hiddenStyles = css({
+        display: 'none'
+    });
+    const visibleStyles = css({
+        display: 'block'
+    });
+    const focusableStyles = css({
+        ':focus': {
+            boxShadow: enableShadows ? `0 0 0 2px ${theme.colors.inputBorderFocus}` : 'none'
+        },
+        outline: 'none'
+    });
+    return {
+        // Container classes
+        container: containerStyles,
+        inputContainer: inputContainerStyles,
+        resultsContainer: resultsContainerStyles,
+        // Input classes
+        input: inputStyles,
+        inputDisabled: '',
+        inputFocus: '',
+        // Results classes
+        results: resultsStyles,
+        resultsHeader: resultsHeaderStyles,
+        resultsList: resultsListStyles,
+        // Item classes
+        resultItem: resultItemStyles,
+        resultItemActive: '',
+        resultItemFocus: '',
+        resultItemHover: '',
+        // Content classes
+        resultDescription: resultDescriptionStyles,
+        resultHighlight: resultHighlightStyles,
+        resultMeta: resultMetaStyles,
+        resultTitle: resultTitleStyles,
+        // Badge classes
+        collectionBadge: collectionBadgeStyles,
+        scoreBadge: scoreBadgeStyles,
+        // State classes
+        error: errorStyles,
+        loading: loadingStyles,
+        loadingSpinner: loadingSpinnerStyles,
+        noResults: noResultsStyles,
+        // Facet classes
+        facetContainer: facetContainerStyles,
+        facetItem: facetItemStyles,
+        facetItemActive: facetItemActiveStyles,
+        // Utility classes
+        focusable: focusableStyles,
+        hidden: hiddenStyles,
+        visible: visibleStyles
+    };
+}
+/**
+ * Apply theme to a CSS class with optional variant
+ */ export function applyTheme(theme, element, variant) {
+    const classes = generateThemeClasses(theme);
+    if (variant) {
+        const variantKey = `${element}${variant.charAt(0).toUpperCase() + variant.slice(1)}`;
+        return `${classes[element] || ''} ${classes[variantKey] || ''}`;
+    }
+    return classes[element] || '';
+}
+/**
+ * Check if theme is dark mode
+ */ export function isDarkTheme(theme) {
+    return theme.name === 'dark' || theme.colors.inputBackground.includes('#1f') || theme.colors.inputBackground.includes('#0f');
+}
+/**
+ * Check if theme is light mode
+ */ export function isLightTheme(theme) {
+    return !isDarkTheme(theme);
+}
+/**
+ * Get theme-specific CSS variables
+ */ export function getThemeVariables(theme) {
+    return {
+        '--search-collection-badge': theme.colors.collectionBadge,
+        '--search-collection-badge-text': theme.colors.collectionBadgeText,
+        '--search-description-text': theme.colors.descriptionText,
+        '--search-error-bg': theme.colors.errorBackground,
+        '--search-error-text': theme.colors.errorText,
+        '--search-facet-active-bg': theme.colors.facetActiveBackground,
+        '--search-facet-active-text': theme.colors.facetActiveText,
+        '--search-facet-bg': theme.colors.facetBackground,
+        '--search-facet-border': theme.colors.facetBorder,
+        '--search-facet-text': theme.colors.facetText,
+        '--search-header-bg': theme.colors.headerBackground,
+        '--search-header-text': theme.colors.headerText,
+        '--search-highlight-bg': theme.colors.highlightBackground,
+        '--search-highlight-text': theme.colors.highlightText,
+        '--search-input-bg': theme.colors.inputBackground,
+        '--search-input-border': theme.colors.inputBorder,
+        '--search-input-border-focus': theme.colors.inputBorderFocus,
+        '--search-input-placeholder': theme.colors.inputPlaceholder,
+        '--search-input-text': theme.colors.inputText,
+        '--search-loading-text': theme.colors.loadingText,
+        '--search-meta-text': theme.colors.metaText,
+        '--search-no-results-text': theme.colors.noResultsText,
+        '--search-result-bg': theme.colors.resultBackground,
+        '--search-result-bg-hover': theme.colors.resultBackgroundHover,
+        '--search-results-bg': theme.colors.resultsBackground,
+        '--search-results-border': theme.colors.resultsBorder,
+        '--search-score-badge': theme.colors.scoreBadge,
+        '--search-score-badge-text': theme.colors.scoreBadgeText,
+        '--search-title-text': theme.colors.titleText
+    };
+}

package/dist/endpoints/customEndpointHandler.d.ts

@@ -0,0 +1,3 @@
+import type { PayloadHandler } from 'payload';
+export declare const customEndpointHandler: PayloadHandler;
+//# sourceMappingURL=customEndpointHandler.d.ts.map

package/dist/endpoints/customEndpointHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customEndpointHandler.d.ts","sourceRoot":"","sources":["../../src/endpoints/customEndpointHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,eAAO,MAAM,qBAAqB,EAAE,cAEnC,CAAA"}

package/dist/endpoints/customEndpointHandler.js

@@ -0,0 +1,5 @@
+export const customEndpointHandler = ()=>{
+    return Response.json({
+        message: 'Custom endpoint response'
+    });
+};

package/dist/endpoints/health.d.ts

@@ -0,0 +1,12 @@
+import type { PayloadHandler } from 'payload';
+import type Typesense from 'typesense';
+import type { TypesenseSearchConfig } from '../index.js';
+/**
+ * Create health check handler
+ */
+export declare const createHealthCheckHandler: (typesenseClient: Typesense.Client, pluginOptions: TypesenseSearchConfig, lastSyncTime?: number) => PayloadHandler;
+/**
+ * Create detailed health check handler with more information
+ */
+export declare const createDetailedHealthCheckHandler: (typesenseClient: Typesense.Client, pluginOptions: TypesenseSearchConfig, lastSyncTime?: number) => PayloadHandler;
+//# sourceMappingURL=health.d.ts.map

package/dist/endpoints/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/endpoints/health.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,KAAK,SAAS,MAAM,WAAW,CAAA;AAEtC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA2CxD;;GAEG;AACH,eAAO,MAAM,wBAAwB,GACnC,iBAAiB,SAAS,CAAC,MAAM,EACjC,eAAe,qBAAqB,EACpC,eAAe,MAAM,KACpB,cA4DF,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,gCAAgC,GAC3C,iBAAiB,SAAS,CAAC,MAAM,EACjC,eAAe,qBAAqB,EACpC,eAAe,MAAM,KACpB,cAuFF,CAAA"}

package/dist/endpoints/health.js

@@ -0,0 +1,174 @@
+import { searchCache } from '../lib/cache.js';
+/**
+ * Test Typesense connection
+ */ const testTypesenseConnection = async (typesenseClient)=>{
+    try {
+        const health = await typesenseClient.health.retrieve();
+        return health.ok === true;
+    } catch (_error) {
+        // Handle health check error
+        return false;
+    }
+};
+/**
+ * Get collection information
+ */ const getCollectionInfo = async (typesenseClient)=>{
+    try {
+        const collections = await typesenseClient.collections().retrieve();
+        return collections.map((col)=>col.name);
+    } catch (_error) {
+        // Handle collections retrieval error
+        return [];
+    }
+};
+/**
+ * Get cache statistics
+ */ const getCacheStats = ()=>{
+    const stats = searchCache.getStats();
+    return {
+        hitRate: stats.hitRate || 0,
+        maxSize: stats.maxSize,
+        size: stats.size
+    };
+};
+/**
+ * Create health check handler
+ */ export const createHealthCheckHandler = (typesenseClient, pluginOptions, lastSyncTime)=>{
+    return async ()=>{
+        try {
+            const startTime = Date.now();
+            // Test Typesense connection
+            const isTypesenseHealthy = await testTypesenseConnection(typesenseClient);
+            const typesenseInfo = isTypesenseHealthy ? {
+                ok: true,
+                version: 'unknown'
+            } // Typesense doesn't expose version in health check
+             : {
+                ok: false
+            };
+            // Get collection information
+            const collections = isTypesenseHealthy ? await getCollectionInfo(typesenseClient) : [];
+            // Get cache statistics
+            const cacheStats = getCacheStats();
+            // Determine overall health status
+            const isHealthy = isTypesenseHealthy && collections.length > 0;
+            const response = {
+                cache: cacheStats,
+                collections,
+                ...lastSyncTime !== undefined && {
+                    lastSync: lastSyncTime
+                },
+                status: isHealthy ? 'healthy' : 'unhealthy',
+                typesense: typesenseInfo
+            };
+            // Add error details if unhealthy
+            if (!isHealthy) {
+                const errors = [];
+                if (!isTypesenseHealthy) {
+                    errors.push('Typesense connection failed');
+                }
+                if (collections.length === 0) {
+                    errors.push('No collections available');
+                }
+                response.error = errors.join(', ');
+            }
+            const responseTime = Date.now() - startTime;
+            return Response.json({
+                ...response,
+                responseTime,
+                timestamp: new Date().toISOString(),
+                version: '1.0.11'
+            });
+        } catch (_error) {
+            // Handle health check error
+            const errorResponse = {
+                cache: getCacheStats(),
+                error: _error instanceof Error ? _error.message : 'Unknown error',
+                status: 'unhealthy'
+            };
+            return Response.json(errorResponse, {
+                status: 500
+            });
+        }
+    };
+};
+/**
+ * Create detailed health check handler with more information
+ */ export const createDetailedHealthCheckHandler = (typesenseClient, pluginOptions, lastSyncTime)=>{
+    return async ()=>{
+        try {
+            const startTime = Date.now();
+            // Test Typesense connection
+            const isTypesenseHealthy = await testTypesenseConnection(typesenseClient);
+            // Get detailed collection information
+            let collections = [];
+            if (isTypesenseHealthy) {
+                try {
+                    const collectionsData = await typesenseClient.collections().retrieve();
+                    collections = collectionsData.map((col)=>({
+                            name: col.name,
+                            createdAt: col.created_at,
+                            fields: col.fields?.length || 0,
+                            numDocuments: col.num_documents
+                        }));
+                } catch (_error) {
+                // Handle detailed collection info error
+                }
+            }
+            // Get cache statistics
+            const cacheStats = getCacheStats();
+            // Get plugin configuration info
+            const configInfo = {
+                enabledCollections: Object.entries(pluginOptions.collections || {}).filter(([_, config])=>config?.enabled).map(([name, config])=>({
+                        name,
+                        displayName: config?.displayName,
+                        facetFields: config?.facetFields || [],
+                        searchFields: config?.searchFields || []
+                    })),
+                settings: pluginOptions.settings,
+                totalCollections: Object.keys(pluginOptions.collections || {}).length
+            };
+            // Determine overall health status
+            const isHealthy = isTypesenseHealthy && collections.length > 0;
+            const response = {
+                cache: cacheStats,
+                collectionDetails: collections,
+                collections: collections.map((col)=>col.name),
+                config: configInfo,
+                lastSync: lastSyncTime,
+                responseTime: Date.now() - startTime,
+                status: isHealthy ? 'healthy' : 'unhealthy',
+                timestamp: new Date().toISOString(),
+                typesense: {
+                    ok: isTypesenseHealthy,
+                    version: 'unknown'
+                },
+                version: '1.0.11'
+            };
+            // Add error details if unhealthy
+            if (!isHealthy) {
+                const errors = [];
+                if (!isTypesenseHealthy) {
+                    errors.push('Typesense connection failed');
+                }
+                if (collections.length === 0) {
+                    errors.push('No collections available');
+                }
+                response.error = errors.join(', ');
+            }
+            return Response.json(response);
+        } catch (_error) {
+            // Handle detailed health check error
+            const errorResponse = {
+                cache: getCacheStats(),
+                error: _error instanceof Error ? _error.message : 'Unknown error',
+                status: 'unhealthy',
+                timestamp: new Date().toISOString(),
+                version: '1.0.11'
+            };
+            return Response.json(errorResponse, {
+                status: 500
+            });
+        }
+    };
+};

package/dist/endpoints/search.d.ts

@@ -0,0 +1,13 @@
+import type { PayloadHandler } from 'payload';
+import type Typesense from 'typesense';
+import type { TypesenseSearchConfig } from '../index.js';
+export declare const createSearchEndpoints: (typesenseClient: Typesense.Client, pluginOptions: TypesenseSearchConfig, lastSyncTime?: number) => ({
+    handler: PayloadHandler;
+    method: "get";
+    path: string;
+} | {
+    handler: PayloadHandler;
+    method: "post";
+    path: string;
+})[];
+//# sourceMappingURL=search.d.ts.map

package/dist/endpoints/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/endpoints/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,KAAK,SAAS,MAAM,WAAW,CAAA;AAEtC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA4HxD,eAAO,MAAM,qBAAqB,GAChC,iBAAiB,SAAS,CAAC,MAAM,EACjC,eAAe,qBAAqB,EACpC,eAAe,MAAM;;;;;;;;IAuCtB,CAAA"}