@grainql/analytics-web 1.7.4 → 2.1.0

package/dist/react/react/hooks/useConfig.mjs

@@ -0,0 +1,79 @@
+/**
+ * useConfig - Cache-first config access with automatic background refresh
+ *
+ * Returns cached/default value immediately, fetches fresh data in background,
+ * and automatically updates when configuration changes.
+ */
+import * as React from 'react';
+import { useGrainAnalytics } from './useGrainAnalytics';
+export function useConfig(key, options = {}) {
+    const client = useGrainAnalytics();
+    // Get initial value from cache/defaults (synchronous, instant)
+    const [value, setValue] = React.useState(() => client.getConfig(key));
+    const [isRefreshing, setIsRefreshing] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const isMountedRef = React.useRef(true);
+    // Fetch fresh config from API
+    const fetchConfig = React.useCallback(async () => {
+        if (!isMountedRef.current)
+            return;
+        setIsRefreshing(true);
+        setError(null);
+        try {
+            const response = await client.fetchConfig({
+                immediateKeys: options.immediateKeys || [key],
+                properties: options.properties,
+                forceRefresh: options.forceRefresh,
+            });
+            if (isMountedRef.current && response) {
+                const newValue = response.configurations[key];
+                if (newValue !== undefined) {
+                    setValue(newValue);
+                }
+            }
+        }
+        catch (err) {
+            if (isMountedRef.current) {
+                setError(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+        finally {
+            if (isMountedRef.current) {
+                setIsRefreshing(false);
+            }
+        }
+    }, [client, key, options.immediateKeys, options.properties, options.forceRefresh]);
+    // Manual refresh function
+    const refresh = React.useCallback(async () => {
+        await fetchConfig();
+    }, [fetchConfig]);
+    // Background fetch on mount and when key/options change
+    React.useEffect(() => {
+        fetchConfig();
+    }, [fetchConfig]);
+    // Subscribe to config changes
+    React.useEffect(() => {
+        const listener = (configurations) => {
+            if (isMountedRef.current && configurations[key] !== undefined) {
+                setValue(configurations[key]);
+            }
+        };
+        client.addConfigChangeListener(listener);
+        return () => {
+            client.removeConfigChangeListener(listener);
+        };
+    }, [client, key]);
+    // Track mount state
+    React.useEffect(() => {
+        isMountedRef.current = true;
+        return () => {
+            isMountedRef.current = false;
+        };
+    }, []);
+    return {
+        value,
+        isRefreshing,
+        error,
+        refresh,
+    };
+}

package/dist/react/react/hooks/useConsent.d.ts

@@ -0,0 +1,13 @@
+/**
+ * useConsent - Hook for managing user consent
+ */
+import type { ConsentState } from '../../consent';
+export declare function useConsent(): {
+    consentState: ConsentState;
+    grantConsent: (categories?: string[]) => void;
+    revokeConsent: (categories?: string[]) => void;
+    hasConsent: (category?: string) => boolean;
+    isGranted: boolean;
+    categories: string[];
+};
+//# sourceMappingURL=useConsent.d.ts.map

package/dist/react/react/hooks/useConsent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConsent.d.ts","sourceRoot":"","sources":["../../../../src/react/hooks/useConsent.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,wBAAgB,UAAU;;gCAwBR,MAAM,EAAE;iCASR,MAAM,EAAE;4BASV,MAAM;;;EAerB"}

package/dist/react/react/hooks/useConsent.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * useConsent - Hook for managing user consent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConsent = useConsent;
+const React = require("react");
+const useGrainAnalytics_1 = require("./useGrainAnalytics");
+function useConsent() {
+    const client = (0, useGrainAnalytics_1.useGrainAnalytics)();
+    const [consentState, setConsentState] = React.useState(null);
+    React.useEffect(() => {
+        if (!client)
+            return;
+        // Get initial consent state
+        const initialState = client.getConsentState();
+        setConsentState(initialState);
+        // Listen for consent changes
+        const listener = (state) => {
+            setConsentState(state);
+        };
+        client.onConsentChange(listener);
+        return () => {
+            client.offConsentChange(listener);
+        };
+    }, [client]);
+    const grantConsent = React.useCallback((categories) => {
+        if (client) {
+            client.grantConsent(categories);
+        }
+    }, [client]);
+    const revokeConsent = React.useCallback((categories) => {
+        if (client) {
+            client.revokeConsent(categories);
+        }
+    }, [client]);
+    const hasConsent = React.useCallback((category) => {
+        if (!client)
+            return false;
+        return client.hasConsent(category);
+    }, [client]);
+    return {
+        consentState,
+        grantConsent,
+        revokeConsent,
+        hasConsent,
+        isGranted: consentState?.granted ?? false,
+        categories: consentState?.categories ?? [],
+    };
+}

package/dist/react/react/hooks/useConsent.mjs

@@ -0,0 +1,47 @@
+/**
+ * useConsent - Hook for managing user consent
+ */
+import * as React from 'react';
+import { useGrainAnalytics } from './useGrainAnalytics';
+export function useConsent() {
+    const client = useGrainAnalytics();
+    const [consentState, setConsentState] = React.useState(null);
+    React.useEffect(() => {
+        if (!client)
+            return;
+        // Get initial consent state
+        const initialState = client.getConsentState();
+        setConsentState(initialState);
+        // Listen for consent changes
+        const listener = (state) => {
+            setConsentState(state);
+        };
+        client.onConsentChange(listener);
+        return () => {
+            client.offConsentChange(listener);
+        };
+    }, [client]);
+    const grantConsent = React.useCallback((categories) => {
+        if (client) {
+            client.grantConsent(categories);
+        }
+    }, [client]);
+    const revokeConsent = React.useCallback((categories) => {
+        if (client) {
+            client.revokeConsent(categories);
+        }
+    }, [client]);
+    const hasConsent = React.useCallback((category) => {
+        if (!client)
+            return false;
+        return client.hasConsent(category);
+    }, [client]);
+    return {
+        consentState,
+        grantConsent,
+        revokeConsent,
+        hasConsent,
+        isGranted: consentState?.granted ?? false,
+        categories: consentState?.categories ?? [],
+    };
+}

package/dist/react/react/hooks/useDataDeletion.d.ts

@@ -0,0 +1,17 @@
+/**
+ * useDataDeletion - Hook for triggering data deletion requests
+ * This is a client-side utility - actual deletion happens on the server
+ */
+export interface DataDeletionOptions {
+    apiUrl: string;
+    tenantId: string;
+    onSuccess?: (message: string) => void;
+    onError?: (error: string) => void;
+}
+export declare function useDataDeletion(options: DataDeletionOptions): {
+    requestDeletion: (userId: string) => Promise<any>;
+    requestAnonymization: (userId: string) => Promise<any>;
+    loading: boolean;
+    error: string;
+};
+//# sourceMappingURL=useDataDeletion.d.ts.map

package/dist/react/react/hooks/useDataDeletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataDeletion.d.ts","sourceRoot":"","sources":["../../../../src/react/hooks/useDataDeletion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB;8BAKzC,MAAM;mCAyCN,MAAM;;;EA6CxB"}

package/dist/react/react/hooks/useDataDeletion.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * useDataDeletion - Hook for triggering data deletion requests
+ * This is a client-side utility - actual deletion happens on the server
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataDeletion = useDataDeletion;
+const React = require("react");
+function useDataDeletion(options) {
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const requestDeletion = React.useCallback(async (userId) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await fetch(`${options.apiUrl}/v1/privacy/${options.tenantId}/data-deletion`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    userId,
+                    deleteEvents: true,
+                    deleteProperties: true,
+                    deleteConsentAudit: false,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const result = await response.json();
+            options.onSuccess?.(result.message);
+            return result;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+            setError(errorMessage);
+            options.onError?.(errorMessage);
+            throw err;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [options]);
+    const requestAnonymization = React.useCallback(async (userId) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await fetch(`${options.apiUrl}/v1/privacy/${options.tenantId}/anonymize-user`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    userId,
+                    anonymizeEvents: true,
+                    anonymizeProperties: true,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const result = await response.json();
+            options.onSuccess?.(result.message);
+            return result;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+            setError(errorMessage);
+            options.onError?.(errorMessage);
+            throw err;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [options]);
+    return {
+        requestDeletion,
+        requestAnonymization,
+        loading,
+        error,
+    };
+}

package/dist/react/react/hooks/useDataDeletion.mjs

@@ -0,0 +1,80 @@
+/**
+ * useDataDeletion - Hook for triggering data deletion requests
+ * This is a client-side utility - actual deletion happens on the server
+ */
+import * as React from 'react';
+export function useDataDeletion(options) {
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const requestDeletion = React.useCallback(async (userId) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await fetch(`${options.apiUrl}/v1/privacy/${options.tenantId}/data-deletion`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    userId,
+                    deleteEvents: true,
+                    deleteProperties: true,
+                    deleteConsentAudit: false,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const result = await response.json();
+            options.onSuccess?.(result.message);
+            return result;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+            setError(errorMessage);
+            options.onError?.(errorMessage);
+            throw err;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [options]);
+    const requestAnonymization = React.useCallback(async (userId) => {
+        setLoading(true);
+        setError(null);
+        try {
+            const response = await fetch(`${options.apiUrl}/v1/privacy/${options.tenantId}/anonymize-user`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    userId,
+                    anonymizeEvents: true,
+                    anonymizeProperties: true,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const result = await response.json();
+            options.onSuccess?.(result.message);
+            return result;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+            setError(errorMessage);
+            options.onError?.(errorMessage);
+            throw err;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [options]);
+    return {
+        requestDeletion,
+        requestAnonymization,
+        loading,
+        error,
+    };
+}

package/dist/react/react/hooks/useGrainAnalytics.d.ts

@@ -0,0 +1,6 @@
+/**
+ * useGrainAnalytics - Access the GrainAnalytics client from context
+ */
+import type { GrainAnalytics } from '../../index';
+export declare function useGrainAnalytics(): GrainAnalytics;
+//# sourceMappingURL=useGrainAnalytics.d.ts.map

package/dist/react/react/hooks/useGrainAnalytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGrainAnalytics.d.ts","sourceRoot":"","sources":["../../../../src/react/hooks/useGrainAnalytics.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,wBAAgB,iBAAiB,IAAI,cAAc,CAWlD"}

package/dist/react/react/hooks/useGrainAnalytics.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * useGrainAnalytics - Access the GrainAnalytics client from context
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGrainAnalytics = useGrainAnalytics;
+const React = require("react");
+const context_1 = require("../context");
+function useGrainAnalytics() {
+    const context = React.useContext(context_1.GrainContext);
+    if (!context) {
+        throw new Error('useGrainAnalytics must be used within a GrainProvider. ' +
+            'Wrap your component tree with <GrainProvider client={client}> or <GrainProvider config={{...}}>');
+    }
+    return context.client;
+}

package/dist/react/react/hooks/useGrainAnalytics.mjs

@@ -0,0 +1,13 @@
+/**
+ * useGrainAnalytics - Access the GrainAnalytics client from context
+ */
+import * as React from 'react';
+import { GrainContext } from '../context';
+export function useGrainAnalytics() {
+    const context = React.useContext(GrainContext);
+    if (!context) {
+        throw new Error('useGrainAnalytics must be used within a GrainProvider. ' +
+            'Wrap your component tree with <GrainProvider client={client}> or <GrainProvider config={{...}}>');
+    }
+    return context.client;
+}

package/dist/react/react/hooks/usePrivacyPreferences.d.ts

@@ -0,0 +1,15 @@
+/**
+ * usePrivacyPreferences - Hook for managing privacy preferences
+ */
+export interface PrivacyPreferences {
+    necessary: boolean;
+    analytics: boolean;
+    functional: boolean;
+}
+export declare function usePrivacyPreferences(): {
+    preferences: PrivacyPreferences;
+    updatePreferences: (newPreferences: Partial<PrivacyPreferences>) => void;
+    acceptAll: () => void;
+    rejectAll: () => void;
+};
+//# sourceMappingURL=usePrivacyPreferences.d.ts.map

package/dist/react/react/hooks/usePrivacyPreferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrivacyPreferences.d.ts","sourceRoot":"","sources":["../../../../src/react/hooks/usePrivacyPreferences.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,wBAAgB,qBAAqB;;wCAahB,OAAO,CAAC,kBAAkB,CAAC;;;EAqC/C"}

package/dist/react/react/hooks/usePrivacyPreferences.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * usePrivacyPreferences - Hook for managing privacy preferences
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePrivacyPreferences = usePrivacyPreferences;
+const React = require("react");
+const useConsent_1 = require("./useConsent");
+function usePrivacyPreferences() {
+    const { consentState, grantConsent, revokeConsent } = (0, useConsent_1.useConsent)();
+    const preferences = React.useMemo(() => {
+        const categories = consentState?.categories ?? [];
+        return {
+            necessary: categories.includes('necessary'),
+            analytics: categories.includes('analytics'),
+            functional: categories.includes('functional'),
+        };
+    }, [consentState]);
+    const updatePreferences = React.useCallback((newPreferences) => {
+        const categories = [];
+        // Necessary is always enabled
+        categories.push('necessary');
+        if (newPreferences.analytics ?? preferences.analytics) {
+            categories.push('analytics');
+        }
+        if (newPreferences.functional ?? preferences.functional) {
+            categories.push('functional');
+        }
+        if (categories.length > 0) {
+            grantConsent(categories);
+        }
+        else {
+            revokeConsent();
+        }
+    }, [preferences, grantConsent, revokeConsent]);
+    const acceptAll = React.useCallback(() => {
+        grantConsent(['necessary', 'analytics', 'functional']);
+    }, [grantConsent]);
+    const rejectAll = React.useCallback(() => {
+        grantConsent(['necessary']); // Keep only necessary
+    }, [grantConsent]);
+    return {
+        preferences,
+        updatePreferences,
+        acceptAll,
+        rejectAll,
+    };
+}

package/dist/react/react/hooks/usePrivacyPreferences.mjs

@@ -0,0 +1,45 @@
+/**
+ * usePrivacyPreferences - Hook for managing privacy preferences
+ */
+import * as React from 'react';
+import { useConsent } from './useConsent';
+export function usePrivacyPreferences() {
+    const { consentState, grantConsent, revokeConsent } = useConsent();
+    const preferences = React.useMemo(() => {
+        const categories = consentState?.categories ?? [];
+        return {
+            necessary: categories.includes('necessary'),
+            analytics: categories.includes('analytics'),
+            functional: categories.includes('functional'),
+        };
+    }, [consentState]);
+    const updatePreferences = React.useCallback((newPreferences) => {
+        const categories = [];
+        // Necessary is always enabled
+        categories.push('necessary');
+        if (newPreferences.analytics ?? preferences.analytics) {
+            categories.push('analytics');
+        }
+        if (newPreferences.functional ?? preferences.functional) {
+            categories.push('functional');
+        }
+        if (categories.length > 0) {
+            grantConsent(categories);
+        }
+        else {
+            revokeConsent();
+        }
+    }, [preferences, grantConsent, revokeConsent]);
+    const acceptAll = React.useCallback(() => {
+        grantConsent(['necessary', 'analytics', 'functional']);
+    }, [grantConsent]);
+    const rejectAll = React.useCallback(() => {
+        grantConsent(['necessary']); // Keep only necessary
+    }, [grantConsent]);
+    return {
+        preferences,
+        updatePreferences,
+        acceptAll,
+        rejectAll,
+    };
+}

package/dist/react/react/hooks/useTrack.d.ts

@@ -0,0 +1,9 @@
+/**
+ * useTrack - Get a stable, memoized track function
+ *
+ * Returns a track function that doesn't cause re-renders when passed to child components.
+ * Prevents unnecessary re-renders compared to using useCallback.
+ */
+import type { TrackFunction } from '../types';
+export declare function useTrack(): TrackFunction;
+//# sourceMappingURL=useTrack.d.ts.map

package/dist/react/react/hooks/useTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTrack.d.ts","sourceRoot":"","sources":["../../../../src/react/hooks/useTrack.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,wBAAgB,QAAQ,IAAI,aAAa,CAYxC"}

package/dist/react/react/hooks/useTrack.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * useTrack - Get a stable, memoized track function
+ *
+ * Returns a track function that doesn't cause re-renders when passed to child components.
+ * Prevents unnecessary re-renders compared to using useCallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTrack = useTrack;
+const React = require("react");
+const useGrainAnalytics_1 = require("./useGrainAnalytics");
+function useTrack() {
+    const client = (0, useGrainAnalytics_1.useGrainAnalytics)();
+    // Create stable track function that won't change across renders
+    const track = React.useCallback(async (eventName, properties, options) => {
+        await client.track(eventName, properties, options);
+    }, [client]);
+    return track;
+}

package/dist/react/react/hooks/useTrack.mjs

@@ -0,0 +1,16 @@
+/**
+ * useTrack - Get a stable, memoized track function
+ *
+ * Returns a track function that doesn't cause re-renders when passed to child components.
+ * Prevents unnecessary re-renders compared to using useCallback.
+ */
+import * as React from 'react';
+import { useGrainAnalytics } from './useGrainAnalytics';
+export function useTrack() {
+    const client = useGrainAnalytics();
+    // Create stable track function that won't change across renders
+    const track = React.useCallback(async (eventName, properties, options) => {
+        await client.track(eventName, properties, options);
+    }, [client]);
+    return track;
+}

package/dist/react/react/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Grain Analytics React Hooks
+ *
+ * React integration for @grainql/analytics-web
+ *
+ * @example
+ * ```tsx
+ * import { GrainProvider, useConfig, useTrack } from '@grainql/analytics-web/react';
+ *
+ * // Pattern 1: Provider-managed client
+ * <GrainProvider config={{ tenantId: 'xxx' }}>
+ *   <App />
+ * </GrainProvider>
+ *
+ * // Pattern 2: External client
+ * const grain = new GrainAnalytics({ tenantId: 'xxx' });
+ * <GrainProvider client={grain}>
+ *   <App />
+ * </GrainProvider>
+ *
+ * // Use hooks in components
+ * function MyComponent() {
+ *   const { value } = useConfig('hero_variant');
+ *   const track = useTrack();
+ *
+ *   return <button onClick={() => track('clicked')}>Click</button>;
+ * }
+ * ```
+ */
+export { GrainProvider } from './GrainProvider';
+export { useGrainAnalytics } from './hooks/useGrainAnalytics';
+export { useConfig } from './hooks/useConfig';
+export { useAllConfigs } from './hooks/useAllConfigs';
+export { useTrack } from './hooks/useTrack';
+export { useConsent } from './hooks/useConsent';
+export { usePrivacyPreferences } from './hooks/usePrivacyPreferences';
+export { useDataDeletion } from './hooks/useDataDeletion';
+export { ConsentBanner } from './components/ConsentBanner';
+export { PrivacyPreferenceCenter } from './components/PrivacyPreferenceCenter';
+export { CookieNotice } from './components/CookieNotice';
+export type { GrainProviderProps, UseConfigOptions, UseConfigResult, UseAllConfigsOptions, UseAllConfigsResult, TrackFunction, } from './types';
+export type { ConsentBannerProps } from './components/ConsentBanner';
+export type { PrivacyPreferenceCenterProps } from './components/PrivacyPreferenceCenter';
+export type { CookieNoticeProps } from './components/CookieNotice';
+export type { PrivacyPreferences } from './hooks/usePrivacyPreferences';
+export type { DataDeletionOptions } from './hooks/useDataDeletion';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/react/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,aAAa,GACd,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,YAAY,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AACzF,YAAY,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,YAAY,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}