react-achievements 3.6.5 → 3.8.0

package/dist/index.js

@@ -1,2747 +0,0 @@
-import React, { useState, useEffect, createContext, useRef, useContext } from 'react';
-import Modal from 'react-modal';
-import Confetti from 'react-confetti';
-
-const isDate = (value) => {
-    return value instanceof Date;
-};
-// Type guard to detect async storage
-function isAsyncStorage(storage) {
-    // Check if methods return Promises
-    const testResult = storage.getMetrics();
-    return testResult && typeof testResult.then === 'function';
-}
-var StorageType;
-(function (StorageType) {
-    StorageType["Local"] = "local";
-    StorageType["Memory"] = "memory";
-    StorageType["IndexedDB"] = "indexeddb";
-    StorageType["RestAPI"] = "restapi"; // Asynchronous REST API storage
-})(StorageType || (StorageType = {}));
-
-/**
- * Base error class for all achievement-related errors
- */
-class AchievementError extends Error {
-    constructor(message, code, recoverable, remedy) {
-        super(message);
-        this.code = code;
-        this.recoverable = recoverable;
-        this.remedy = remedy;
-        this.name = 'AchievementError';
-        // Maintains proper stack trace for where our error was thrown (only available on V8)
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, AchievementError);
-        }
-    }
-}
-/**
- * Error thrown when browser storage quota is exceeded
- */
-class StorageQuotaError extends AchievementError {
-    constructor(bytesNeeded) {
-        super('Browser storage quota exceeded. Achievement data could not be saved.', 'STORAGE_QUOTA_EXCEEDED', true, 'Clear browser storage, reduce the number of achievements, or use an external database backend. You can export your current data using exportData() before clearing storage.');
-        this.bytesNeeded = bytesNeeded;
-        this.name = 'StorageQuotaError';
-    }
-}
-/**
- * Error thrown when imported data fails validation
- */
-class ImportValidationError extends AchievementError {
-    constructor(validationErrors) {
-        super(`Imported data failed validation: ${validationErrors.join(', ')}`, 'IMPORT_VALIDATION_ERROR', true, 'Check that the imported data was exported from a compatible version and matches your current achievement configuration.');
-        this.validationErrors = validationErrors;
-        this.name = 'ImportValidationError';
-    }
-}
-/**
- * Error thrown when storage operations fail
- */
-class StorageError extends AchievementError {
-    constructor(message, originalError) {
-        super(message, 'STORAGE_ERROR', true, 'Check browser storage permissions and available space. If using custom storage, verify the implementation is correct.');
-        this.originalError = originalError;
-        this.name = 'StorageError';
-    }
-}
-/**
- * Error thrown when configuration is invalid
- */
-class ConfigurationError extends AchievementError {
-    constructor(message) {
-        super(message, 'CONFIGURATION_ERROR', false, 'Review your achievement configuration and ensure it follows the correct format.');
-        this.name = 'ConfigurationError';
-    }
-}
-/**
- * Error thrown when network sync operations fail
- */
-class SyncError extends AchievementError {
-    constructor(message, details) {
-        super(message, 'SYNC_ERROR', true, // recoverable (can retry)
-        'Check your network connection and try again. If the problem persists, achievements will sync when connection is restored.');
-        this.name = 'SyncError';
-        this.statusCode = details === null || details === void 0 ? void 0 : details.statusCode;
-        this.timeout = details === null || details === void 0 ? void 0 : details.timeout;
-    }
-}
-/**
- * Type guard to check if an error is an AchievementError
- */
-function isAchievementError(error) {
-    return error instanceof AchievementError;
-}
-/**
- * Type guard to check if an error is recoverable
- */
-function isRecoverableError(error) {
-    return isAchievementError(error) && error.recoverable;
-}
-
-class LocalStorage {
-    constructor(storageKey) {
-        this.storageKey = storageKey;
-    }
-    serializeValue(value) {
-        if (isDate(value)) {
-            return { __type: 'Date', value: value.toISOString() };
-        }
-        return value;
-    }
-    deserializeValue(value) {
-        if (value && typeof value === 'object' && value.__type === 'Date') {
-            return new Date(value.value);
-        }
-        return value;
-    }
-    serializeMetrics(metrics) {
-        const serialized = {};
-        for (const [key, values] of Object.entries(metrics)) {
-            serialized[key] = values.map(this.serializeValue);
-        }
-        return serialized;
-    }
-    deserializeMetrics(metrics) {
-        if (!metrics)
-            return {};
-        const deserialized = {};
-        for (const [key, values] of Object.entries(metrics)) {
-            deserialized[key] = values.map(this.deserializeValue);
-        }
-        return deserialized;
-    }
-    getStorageData() {
-        const data = localStorage.getItem(this.storageKey);
-        if (!data)
-            return { metrics: {}, unlockedAchievements: [] };
-        try {
-            const parsed = JSON.parse(data);
-            return {
-                metrics: this.deserializeMetrics(parsed.metrics || {}),
-                unlockedAchievements: parsed.unlockedAchievements || []
-            };
-        }
-        catch (_a) {
-            return { metrics: {}, unlockedAchievements: [] };
-        }
-    }
-    setStorageData(data) {
-        try {
-            const serialized = {
-                metrics: this.serializeMetrics(data.metrics),
-                unlockedAchievements: data.unlockedAchievements
-            };
-            const jsonString = JSON.stringify(serialized);
-            localStorage.setItem(this.storageKey, jsonString);
-        }
-        catch (error) {
-            // Throw proper error instead of silently failing
-            if (error instanceof DOMException &&
-                (error.name === 'QuotaExceededError' ||
-                    error.name === 'NS_ERROR_DOM_QUOTA_REACHED')) {
-                const serialized = {
-                    metrics: this.serializeMetrics(data.metrics),
-                    unlockedAchievements: data.unlockedAchievements
-                };
-                const bytesNeeded = JSON.stringify(serialized).length;
-                throw new StorageQuotaError(bytesNeeded);
-            }
-            if (error instanceof Error) {
-                if (error.message && error.message.includes('QuotaExceeded')) {
-                    const serialized = {
-                        metrics: this.serializeMetrics(data.metrics),
-                        unlockedAchievements: data.unlockedAchievements
-                    };
-                    const bytesNeeded = JSON.stringify(serialized).length;
-                    throw new StorageQuotaError(bytesNeeded);
-                }
-                throw new StorageError(`Failed to save achievement data: ${error.message}`, error);
-            }
-            throw new StorageError('Failed to save achievement data');
-        }
-    }
-    getMetrics() {
-        return this.getStorageData().metrics;
-    }
-    setMetrics(metrics) {
-        const data = this.getStorageData();
-        this.setStorageData(Object.assign(Object.assign({}, data), { metrics }));
-    }
-    getUnlockedAchievements() {
-        return this.getStorageData().unlockedAchievements;
-    }
-    setUnlockedAchievements(achievements) {
-        const data = this.getStorageData();
-        this.setStorageData(Object.assign(Object.assign({}, data), { unlockedAchievements: achievements }));
-    }
-    clear() {
-        localStorage.removeItem(this.storageKey);
-    }
-}
-
-class MemoryStorage {
-    constructor() {
-        this.metrics = {};
-        this.unlockedAchievements = [];
-    }
-    getMetrics() {
-        return this.metrics;
-    }
-    setMetrics(metrics) {
-        this.metrics = metrics;
-    }
-    getUnlockedAchievements() {
-        return this.unlockedAchievements;
-    }
-    setUnlockedAchievements(achievements) {
-        this.unlockedAchievements = achievements;
-    }
-    clear() {
-        this.metrics = {};
-        this.unlockedAchievements = [];
-    }
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-class AsyncStorageAdapter {
-    constructor(asyncStorage, options) {
-        this.pendingWrites = [];
-        this.asyncStorage = asyncStorage;
-        this.onError = options === null || options === void 0 ? void 0 : options.onError;
-        this.cache = {
-            metrics: {},
-            unlocked: [],
-            loaded: false
-        };
-        // Eagerly load data from async storage (non-blocking)
-        this.initializeCache();
-    }
-    /**
-     * Initialize cache by loading from async storage
-     * This happens in the background during construction
-     */
-    initializeCache() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const [metrics, unlocked] = yield Promise.all([
-                    this.asyncStorage.getMetrics(),
-                    this.asyncStorage.getUnlockedAchievements()
-                ]);
-                this.cache.metrics = metrics;
-                this.cache.unlocked = unlocked;
-                this.cache.loaded = true;
-            }
-            catch (error) {
-                // Handle initialization errors
-                console.error('Failed to initialize async storage:', error);
-                if (this.onError) {
-                    const storageError = error instanceof AchievementError
-                        ? error
-                        : new StorageError('Failed to initialize storage', error);
-                    this.onError(storageError);
-                }
-                // Set to empty state on error
-                this.cache.loaded = true; // Mark as loaded even on error to prevent blocking
-            }
-        });
-    }
-    /**
-     * Wait for cache to be loaded (used internally)
-     * Returns immediately if already loaded, otherwise waits
-     */
-    ensureCacheLoaded() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (!this.cache.loaded) {
-                yield new Promise(resolve => setTimeout(resolve, 10));
-            }
-        });
-    }
-    /**
-     * SYNC READ: Returns cached metrics immediately
-     * Cache is loaded eagerly during construction
-     */
-    getMetrics() {
-        return this.cache.metrics;
-    }
-    /**
-     * SYNC WRITE: Updates cache immediately, writes to storage in background
-     * Uses optimistic updates - assumes write will succeed
-     */
-    setMetrics(metrics) {
-        // Update cache immediately (optimistic update)
-        this.cache.metrics = metrics;
-        // Write to async storage in background
-        const writePromise = this.asyncStorage.setMetrics(metrics).catch(error => {
-            console.error('Failed to write metrics to async storage:', error);
-            if (this.onError) {
-                const storageError = error instanceof AchievementError
-                    ? error
-                    : new StorageError('Failed to write metrics', error);
-                this.onError(storageError);
-            }
-        });
-        // Track pending write for cleanup/testing
-        this.pendingWrites.push(writePromise);
-    }
-    /**
-     * SYNC READ: Returns cached unlocked achievements immediately
-     */
-    getUnlockedAchievements() {
-        return this.cache.unlocked;
-    }
-    /**
-     * SYNC WRITE: Updates cache immediately, writes to storage in background
-     */
-    setUnlockedAchievements(achievements) {
-        // Update cache immediately (optimistic update)
-        this.cache.unlocked = achievements;
-        // Write to async storage in background
-        const writePromise = this.asyncStorage.setUnlockedAchievements(achievements).catch(error => {
-            console.error('Failed to write unlocked achievements to async storage:', error);
-            if (this.onError) {
-                const storageError = error instanceof AchievementError
-                    ? error
-                    : new StorageError('Failed to write achievements', error);
-                this.onError(storageError);
-            }
-        });
-        // Track pending write
-        this.pendingWrites.push(writePromise);
-    }
-    /**
-     * SYNC CLEAR: Clears cache immediately, clears storage in background
-     */
-    clear() {
-        // Clear cache immediately
-        this.cache.metrics = {};
-        this.cache.unlocked = [];
-        // Clear async storage in background
-        const clearPromise = this.asyncStorage.clear().catch(error => {
-            console.error('Failed to clear async storage:', error);
-            if (this.onError) {
-                const storageError = error instanceof AchievementError
-                    ? error
-                    : new StorageError('Failed to clear storage', error);
-                this.onError(storageError);
-            }
-        });
-        // Track pending write
-        this.pendingWrites.push(clearPromise);
-    }
-    /**
-     * Wait for all pending writes to complete (useful for testing/cleanup)
-     * NOT part of AchievementStorage interface - utility method
-     */
-    flush() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(this.pendingWrites);
-            this.pendingWrites = [];
-        });
-    }
-}
-
-class IndexedDBStorage {
-    constructor(dbName = 'react-achievements') {
-        this.storeName = 'achievements';
-        this.db = null;
-        this.dbName = dbName;
-        this.initPromise = this.initDB();
-    }
-    /**
-     * Initialize IndexedDB database and object store
-     */
-    initDB() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const request = indexedDB.open(this.dbName, 1);
-                request.onerror = () => {
-                    reject(new StorageError('Failed to open IndexedDB'));
-                };
-                request.onsuccess = () => {
-                    this.db = request.result;
-                    resolve();
-                };
-                request.onupgradeneeded = (event) => {
-                    const db = event.target.result;
-                    // Create object store if it doesn't exist
-                    if (!db.objectStoreNames.contains(this.storeName)) {
-                        db.createObjectStore(this.storeName);
-                    }
-                };
-            });
-        });
-    }
-    /**
-     * Generic get operation from IndexedDB
-     */
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initPromise;
-            if (!this.db)
-                throw new StorageError('Database not initialized');
-            return new Promise((resolve, reject) => {
-                const transaction = this.db.transaction([this.storeName], 'readonly');
-                const store = transaction.objectStore(this.storeName);
-                const request = store.get(key);
-                request.onsuccess = () => {
-                    resolve(request.result || null);
-                };
-                request.onerror = () => {
-                    reject(new StorageError(`Failed to read from IndexedDB: ${key}`));
-                };
-            });
-        });
-    }
-    /**
-     * Generic set operation to IndexedDB
-     */
-    set(key, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initPromise;
-            if (!this.db)
-                throw new StorageError('Database not initialized');
-            return new Promise((resolve, reject) => {
-                const transaction = this.db.transaction([this.storeName], 'readwrite');
-                const store = transaction.objectStore(this.storeName);
-                const request = store.put(value, key);
-                request.onsuccess = () => {
-                    resolve();
-                };
-                request.onerror = () => {
-                    reject(new StorageError(`Failed to write to IndexedDB: ${key}`));
-                };
-            });
-        });
-    }
-    /**
-     * Delete operation from IndexedDB
-     */
-    delete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initPromise;
-            if (!this.db)
-                throw new StorageError('Database not initialized');
-            return new Promise((resolve, reject) => {
-                const transaction = this.db.transaction([this.storeName], 'readwrite');
-                const store = transaction.objectStore(this.storeName);
-                const request = store.delete(key);
-                request.onsuccess = () => {
-                    resolve();
-                };
-                request.onerror = () => {
-                    reject(new StorageError(`Failed to delete from IndexedDB: ${key}`));
-                };
-            });
-        });
-    }
-    getMetrics() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const metrics = yield this.get('metrics');
-            return metrics || {};
-        });
-    }
-    setMetrics(metrics) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.set('metrics', metrics);
-        });
-    }
-    getUnlockedAchievements() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const unlocked = yield this.get('unlocked');
-            return unlocked || [];
-        });
-    }
-    setUnlockedAchievements(achievements) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.set('unlocked', achievements);
-        });
-    }
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all([
-                this.delete('metrics'),
-                this.delete('unlocked')
-            ]);
-        });
-    }
-}
-
-class RestApiStorage {
-    constructor(config) {
-        this.config = Object.assign({ timeout: 10000, headers: {} }, config);
-    }
-    /**
-     * Generic fetch wrapper with timeout and error handling
-     */
-    fetchWithTimeout(url, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-            try {
-                const response = yield fetch(url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({ 'Content-Type': 'application/json' }, this.config.headers), options.headers), signal: controller.signal }));
-                clearTimeout(timeoutId);
-                if (!response.ok) {
-                    throw new SyncError(`HTTP ${response.status}: ${response.statusText}`, { statusCode: response.status });
-                }
-                return response;
-            }
-            catch (error) {
-                clearTimeout(timeoutId);
-                if (error instanceof Error && error.name === 'AbortError') {
-                    throw new SyncError('Request timeout', { timeout: this.config.timeout });
-                }
-                throw error;
-            }
-        });
-    }
-    getMetrics() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements/metrics`;
-                const response = yield this.fetchWithTimeout(url, { method: 'GET' });
-                const data = yield response.json();
-                return data.metrics || {};
-            }
-            catch (error) {
-                // Re-throw SyncError and other AchievementErrors (but not StorageError)
-                // Multiple checks for Jest compatibility
-                const err = error;
-                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError') {
-                    throw error;
-                }
-                // Also check instanceof for normal cases
-                if (error instanceof AchievementError && !(error instanceof StorageError)) {
-                    throw error;
-                }
-                throw new StorageError('Failed to fetch metrics from API', error);
-            }
-        });
-    }
-    setMetrics(metrics) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements/metrics`;
-                yield this.fetchWithTimeout(url, {
-                    method: 'PUT',
-                    body: JSON.stringify({ metrics })
-                });
-            }
-            catch (error) {
-                const err = error;
-                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError')
-                    throw error;
-                if (error instanceof AchievementError && !(error instanceof StorageError))
-                    throw error;
-                throw new StorageError('Failed to save metrics to API', error);
-            }
-        });
-    }
-    getUnlockedAchievements() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements/unlocked`;
-                const response = yield this.fetchWithTimeout(url, { method: 'GET' });
-                const data = yield response.json();
-                return data.unlocked || [];
-            }
-            catch (error) {
-                const err = error;
-                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError')
-                    throw error;
-                if (error instanceof AchievementError && !(error instanceof StorageError))
-                    throw error;
-                throw new StorageError('Failed to fetch unlocked achievements from API', error);
-            }
-        });
-    }
-    setUnlockedAchievements(achievements) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements/unlocked`;
-                yield this.fetchWithTimeout(url, {
-                    method: 'PUT',
-                    body: JSON.stringify({ unlocked: achievements })
-                });
-            }
-            catch (error) {
-                const err = error;
-                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError')
-                    throw error;
-                if (error instanceof AchievementError && !(error instanceof StorageError))
-                    throw error;
-                throw new StorageError('Failed to save unlocked achievements to API', error);
-            }
-        });
-    }
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                const url = `${this.config.baseUrl}/users/${this.config.userId}/achievements`;
-                yield this.fetchWithTimeout(url, { method: 'DELETE' });
-            }
-            catch (error) {
-                const err = error;
-                if (((_a = err === null || err === void 0 ? void 0 : err.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'SyncError' || (err === null || err === void 0 ? void 0 : err.name) === 'SyncError')
-                    throw error;
-                if (error instanceof AchievementError && !(error instanceof StorageError))
-                    throw error;
-                throw new StorageError('Failed to clear achievements via API', error);
-            }
-        });
-    }
-}
-
-class OfflineQueueStorage {
-    constructor(innerStorage) {
-        this.queue = [];
-        this.isOnline = typeof navigator !== 'undefined' ? navigator.onLine : true;
-        this.isSyncing = false;
-        this.queueStorageKey = 'achievements_offline_queue';
-        this.handleOnline = () => {
-            this.isOnline = true;
-            console.log('[OfflineQueue] Back online, processing queue...');
-            this.processQueue();
-        };
-        this.handleOffline = () => {
-            this.isOnline = false;
-            console.log('[OfflineQueue] Offline mode activated');
-        };
-        this.innerStorage = innerStorage;
-        // Load queued operations from localStorage
-        this.loadQueue();
-        // Listen for online/offline events (only in browser environment)
-        if (typeof window !== 'undefined') {
-            window.addEventListener('online', this.handleOnline);
-            window.addEventListener('offline', this.handleOffline);
-        }
-        // Process queue if already online
-        if (this.isOnline) {
-            this.processQueue();
-        }
-    }
-    loadQueue() {
-        try {
-            if (typeof localStorage !== 'undefined') {
-                const queueData = localStorage.getItem(this.queueStorageKey);
-                if (queueData) {
-                    this.queue = JSON.parse(queueData);
-                }
-            }
-        }
-        catch (error) {
-            console.error('Failed to load offline queue:', error);
-            this.queue = [];
-        }
-    }
-    saveQueue() {
-        try {
-            if (typeof localStorage !== 'undefined') {
-                localStorage.setItem(this.queueStorageKey, JSON.stringify(this.queue));
-            }
-        }
-        catch (error) {
-            console.error('Failed to save offline queue:', error);
-        }
-    }
-    processQueue() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isSyncing || this.queue.length === 0 || !this.isOnline) {
-                return;
-            }
-            this.isSyncing = true;
-            try {
-                // Process operations in order
-                while (this.queue.length > 0 && this.isOnline) {
-                    const operation = this.queue[0];
-                    try {
-                        switch (operation.type) {
-                            case 'setMetrics':
-                                yield this.innerStorage.setMetrics(operation.data);
-                                break;
-                            case 'setUnlockedAchievements':
-                                yield this.innerStorage.setUnlockedAchievements(operation.data);
-                                break;
-                            case 'clear':
-                                yield this.innerStorage.clear();
-                                break;
-                        }
-                        // Operation succeeded, remove from queue
-                        this.queue.shift();
-                        this.saveQueue();
-                    }
-                    catch (error) {
-                        console.error('Failed to sync queued operation:', error);
-                        // Stop processing on error, will retry later
-                        break;
-                    }
-                }
-            }
-            finally {
-                this.isSyncing = false;
-            }
-        });
-    }
-    queueOperation(type, data) {
-        const operation = {
-            id: `${Date.now()}_${Math.random()}`,
-            type,
-            data,
-            timestamp: Date.now()
-        };
-        this.queue.push(operation);
-        this.saveQueue();
-        // Try to process queue if online
-        if (this.isOnline) {
-            this.processQueue();
-        }
-    }
-    getMetrics() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Reads always try to hit the server first
-            try {
-                return yield this.innerStorage.getMetrics();
-            }
-            catch (error) {
-                if (!this.isOnline) {
-                    throw new StorageError('Cannot read metrics while offline');
-                }
-                throw error;
-            }
-        });
-    }
-    setMetrics(metrics) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isOnline) {
-                try {
-                    yield this.innerStorage.setMetrics(metrics);
-                    return;
-                }
-                catch (error) {
-                    // Failed while online, queue it
-                    console.warn('Failed to set metrics, queuing for later:', error);
-                }
-            }
-            // Queue operation if offline or if online operation failed
-            this.queueOperation('setMetrics', metrics);
-        });
-    }
-    getUnlockedAchievements() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Reads always try to hit the server first
-            try {
-                return yield this.innerStorage.getUnlockedAchievements();
-            }
-            catch (error) {
-                if (!this.isOnline) {
-                    throw new StorageError('Cannot read achievements while offline');
-                }
-                throw error;
-            }
-        });
-    }
-    setUnlockedAchievements(achievements) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isOnline) {
-                try {
-                    yield this.innerStorage.setUnlockedAchievements(achievements);
-                    return;
-                }
-                catch (error) {
-                    // Failed while online, queue it
-                    console.warn('Failed to set unlocked achievements, queuing for later:', error);
-                }
-            }
-            // Queue operation if offline or if online operation failed
-            this.queueOperation('setUnlockedAchievements', achievements);
-        });
-    }
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isOnline) {
-                try {
-                    yield this.innerStorage.clear();
-                    // Also clear the queue
-                    this.queue = [];
-                    this.saveQueue();
-                    return;
-                }
-                catch (error) {
-                    console.warn('Failed to clear, queuing for later:', error);
-                }
-            }
-            // Queue operation if offline or if online operation failed
-            this.queueOperation('clear');
-        });
-    }
-    /**
-     * Manually trigger queue processing (useful for testing)
-     */
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.processQueue();
-        });
-    }
-    /**
-     * Get current queue status (useful for debugging)
-     */
-    getQueueStatus() {
-        return {
-            pending: this.queue.length,
-            operations: [...this.queue]
-        };
-    }
-    /**
-     * Cleanup listeners (call on unmount)
-     */
-    destroy() {
-        if (typeof window !== 'undefined') {
-            window.removeEventListener('online', this.handleOnline);
-            window.removeEventListener('offline', this.handleOffline);
-        }
-    }
-}
-
-/**
- * Built-in theme presets
- */
-const builtInThemes = {
-    /**
-     * Modern theme - Dark gradients with vibrant accents
-     * Inspired by contemporary achievement systems (Discord, Steam, Xbox)
-     */
-    modern: {
-        name: 'modern',
-        notification: {
-            background: 'linear-gradient(135deg, rgba(30, 30, 50, 0.98) 0%, rgba(50, 50, 70, 0.98) 100%)',
-            textColor: '#ffffff',
-            accentColor: '#4CAF50',
-            borderRadius: '12px',
-            boxShadow: '0 8px 32px rgba(0, 0, 0, 0.4)',
-            fontSize: {
-                header: '12px',
-                title: '18px',
-                description: '14px',
-            },
-        },
-        modal: {
-            overlayColor: 'rgba(0, 0, 0, 0.85)',
-            background: 'linear-gradient(135deg, #1e1e32 0%, #323246 100%)',
-            textColor: '#ffffff',
-            accentColor: '#4CAF50',
-            borderRadius: '16px',
-            headerFontSize: '28px',
-        },
-        confetti: {
-            colors: ['#FFD700', '#4CAF50', '#2196F3', '#FF6B6B'],
-            particleCount: 50,
-            shapes: ['circle', 'square'],
-        },
-    },
-    /**
-     * Minimal theme - Clean, light design with subtle accents
-     * Perfect for professional or minimalist applications
-     */
-    minimal: {
-        name: 'minimal',
-        notification: {
-            background: 'rgba(255, 255, 255, 0.98)',
-            textColor: '#333333',
-            accentColor: '#4CAF50',
-            borderRadius: '8px',
-            boxShadow: '0 4px 12px rgba(0, 0, 0, 0.15)',
-            fontSize: {
-                header: '11px',
-                title: '16px',
-                description: '13px',
-            },
-        },
-        modal: {
-            overlayColor: 'rgba(0, 0, 0, 0.5)',
-            background: '#ffffff',
-            textColor: '#333333',
-            accentColor: '#4CAF50',
-            borderRadius: '12px',
-            headerFontSize: '24px',
-        },
-        confetti: {
-            colors: ['#4CAF50', '#2196F3'],
-            particleCount: 30,
-            shapes: ['circle'],
-        },
-    },
-    /**
-     * Gamified theme - Modern gaming aesthetic with sci-fi colors
-     * Dark navy backgrounds with cyan and orange accents (2024 gaming trend)
-     * Features square/badge-shaped achievement cards
-     */
-    gamified: {
-        name: 'gamified',
-        notification: {
-            background: 'linear-gradient(135deg, rgba(5, 8, 22, 0.98) 0%, rgba(15, 23, 42, 0.98) 100%)',
-            textColor: '#22d3ee', // Bright cyan
-            accentColor: '#f97316', // Bright orange
-            borderRadius: '6px',
-            boxShadow: '0 8px 32px rgba(34, 211, 238, 0.4), 0 0 20px rgba(249, 115, 22, 0.3)',
-            fontSize: {
-                header: '13px',
-                title: '20px',
-                description: '15px',
-            },
-        },
-        modal: {
-            overlayColor: 'rgba(5, 8, 22, 0.85)',
-            background: 'linear-gradient(135deg, #0f172a 0%, #050816 100%)',
-            textColor: '#22d3ee', // Bright cyan
-            accentColor: '#f97316', // Bright orange
-            borderRadius: '8px',
-            headerFontSize: '32px',
-            achievementCardBorderRadius: '8px', // Square badge-like cards
-            achievementLayout: 'badge', // Use badge/grid layout instead of horizontal list
-        },
-        confetti: {
-            colors: ['#22d3ee', '#f97316', '#a855f7', '#eab308'], // Cyan, orange, purple, yellow
-            particleCount: 100,
-            shapes: ['circle', 'square'],
-        },
-    },
-};
-/**
- * Retrieve a theme by name (internal use only)
- * Only checks built-in themes
- *
- * @param name - Theme name (built-in only)
- * @returns Theme configuration or undefined if not found
- * @internal
- */
-function getTheme(name) {
-    return builtInThemes[name];
-}
-
-const getPositionStyles = (position) => {
-    const base = {
-        position: 'fixed',
-        margin: '20px',
-        zIndex: 1000,
-    };
-    switch (position) {
-        case 'top-left':
-            return Object.assign(Object.assign({}, base), { top: 0, left: 0 });
-        case 'top-right':
-            return Object.assign(Object.assign({}, base), { top: 0, right: 0 });
-        case 'bottom-left':
-            return Object.assign(Object.assign({}, base), { bottom: 0, left: 0 });
-        case 'bottom-right':
-            return Object.assign(Object.assign({}, base), { bottom: 0, right: 0 });
-    }
-};
-const BadgesButton = ({ onClick, position = 'bottom-right', placement = 'fixed', styles = {}, unlockedAchievements, theme = 'modern', }) => {
-    // Get theme configuration for consistent styling
-    const themeConfig = getTheme(theme) || builtInThemes.modern;
-    const accentColor = themeConfig.notification.accentColor;
-    // Different styling for fixed vs inline placement
-    const baseStyles = placement === 'inline'
-        ? Object.assign({ 
-            // Inline mode: looks like a navigation item
-            backgroundColor: 'transparent', color: themeConfig.notification.textColor, padding: '12px 16px', border: 'none', borderRadius: '6px', cursor: 'pointer', display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: '8px', fontSize: '15px', width: '100%', textAlign: 'left', transition: 'background-color 0.2s ease-in-out' }, styles) : Object.assign(Object.assign({ 
-        // Fixed mode: floating button
-        backgroundColor: accentColor, color: 'white', padding: '10px 20px', border: 'none', borderRadius: '20px', cursor: 'pointer', display: 'flex', alignItems: 'center', gap: '8px', fontSize: '16px', boxShadow: '0 2px 5px rgba(0,0,0,0.2)', transition: 'transform 0.2s ease-in-out' }, getPositionStyles(position)), styles);
-    return (React.createElement("button", { onClick: onClick, style: baseStyles, onMouseEnter: (e) => {
-            if (placement === 'inline') {
-                // Inline mode: subtle background color change
-                e.target.style.backgroundColor = 'rgba(255, 255, 255, 0.1)';
-            }
-            else {
-                // Fixed mode: scale transformation
-                e.target.style.transform = 'scale(1.05)';
-            }
-        }, onMouseLeave: (e) => {
-            if (placement === 'inline') {
-                e.target.style.backgroundColor = 'transparent';
-            }
-            else {
-                e.target.style.transform = 'scale(1)';
-            }
-        }, "data-placement": placement, "data-testid": "badges-button" },
-        "\uD83C\uDFC6 Achievements (",
-        unlockedAchievements.length,
-        ")"));
-};
-
-const defaultAchievementIcons = {
-    // Essential fallback icons for system use
-    default: '⭐', // Fallback when no icon is provided
-    loading: '⏳', // For loading states
-    error: '⚠️', // For error states
-    success: '✅', // For success states
-    // A few common icons for backward compatibility
-    trophy: '🏆',
-    star: '⭐',
-};
-
-const defaultStyles = {
-    badgesButton: {
-        backgroundColor: '#4CAF50',
-        color: 'white',
-        padding: '10px 20px',
-        border: 'none',
-        borderRadius: '20px',
-        cursor: 'pointer',
-        display: 'flex',
-        alignItems: 'center',
-        gap: '8px',
-        fontSize: '16px',
-        boxShadow: '0 2px 5px rgba(0,0,0,0.2)',
-        transition: 'transform 0.2s ease-in-out',
-    },
-    badgesModal: {
-        overlay: {
-            backgroundColor: 'rgba(0, 0, 0, 0.75)',
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            zIndex: 1000,
-        },
-        content: {
-            position: 'relative',
-            background: '#fff',
-            borderRadius: '8px',
-            padding: '20px',
-            maxWidth: '500px',
-            width: '90%',
-            maxHeight: '80vh',
-            overflow: 'auto',
-        },
-        header: {
-            display: 'flex',
-            justifyContent: 'space-between',
-            alignItems: 'center',
-            marginBottom: '20px',
-        },
-        closeButton: {
-            background: 'none',
-            border: 'none',
-            fontSize: '24px',
-            cursor: 'pointer',
-            padding: '0',
-        },
-        achievementList: {
-            display: 'flex',
-            flexDirection: 'column',
-            gap: '16px',
-        },
-        achievementItem: {
-            display: 'flex',
-            gap: '16px',
-            padding: '16px',
-            borderRadius: '8px',
-            backgroundColor: '#f5f5f5',
-            alignItems: 'center',
-        },
-        achievementTitle: {
-            margin: '0',
-            fontSize: '18px',
-            fontWeight: 'bold',
-        },
-        achievementDescription: {
-            margin: '4px 0 0 0',
-            color: '#666',
-        },
-        achievementIcon: {
-            fontSize: '32px',
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-        },
-        lockIcon: {
-            fontSize: '24px',
-            position: 'absolute',
-            top: '50%',
-            right: '16px',
-            transform: 'translateY(-50%)',
-        },
-        lockedAchievementItem: {
-            display: 'flex',
-            gap: '16px',
-            padding: '16px',
-            borderRadius: '8px',
-            backgroundColor: '#e0e0e0',
-            alignItems: 'center',
-            opacity: 0.5,
-        },
-    },
-};
-
-const BadgesModal = ({ isOpen, onClose, achievements, styles = {}, icons = {}, showAllAchievements = false, showUnlockConditions = false, allAchievements, }) => {
-    // Merge custom icons with default icons, with custom icons taking precedence
-    const mergedIcons = Object.assign(Object.assign({}, defaultAchievementIcons), icons);
-    return (React.createElement(Modal, { isOpen: isOpen, onRequestClose: onClose, style: {
-            overlay: Object.assign(Object.assign({}, defaultStyles.badgesModal.overlay), styles === null || styles === void 0 ? void 0 : styles.overlay),
-            content: Object.assign(Object.assign({}, defaultStyles.badgesModal.content), styles === null || styles === void 0 ? void 0 : styles.content)
-        }, contentLabel: "Achievements" },
-        React.createElement("div", { style: Object.assign(Object.assign({}, defaultStyles.badgesModal.header), styles === null || styles === void 0 ? void 0 : styles.header) },
-            React.createElement("h2", { style: { margin: 0 } }, "\uD83C\uDFC6 Achievements"),
-            React.createElement("button", { onClick: onClose, style: Object.assign(Object.assign({}, defaultStyles.badgesModal.closeButton), styles === null || styles === void 0 ? void 0 : styles.closeButton), "aria-label": "Close" }, "\u00D7")),
-        React.createElement("div", { style: Object.assign(Object.assign({}, defaultStyles.badgesModal.achievementList), styles === null || styles === void 0 ? void 0 : styles.achievementList) }, (() => {
-            // Determine which achievements to display
-            const achievementsToDisplay = showAllAchievements && allAchievements
-                ? allAchievements
-                : achievements.map(a => (Object.assign(Object.assign({}, a), { isUnlocked: true })));
-            return (React.createElement(React.Fragment, null,
-                achievementsToDisplay.map((achievement) => {
-                    const isLocked = !achievement.isUnlocked;
-                    return (React.createElement("div", { key: achievement.achievementId, style: Object.assign(Object.assign(Object.assign({}, (isLocked
-                            ? Object.assign(Object.assign({}, defaultStyles.badgesModal.lockedAchievementItem), styles === null || styles === void 0 ? void 0 : styles.lockedAchievementItem) : defaultStyles.badgesModal.achievementItem)), styles === null || styles === void 0 ? void 0 : styles.achievementItem), { position: 'relative' }) },
-                        achievement.achievementIconKey && (React.createElement("div", { style: Object.assign(Object.assign(Object.assign({}, defaultStyles.badgesModal.achievementIcon), styles === null || styles === void 0 ? void 0 : styles.achievementIcon), { opacity: isLocked ? 0.4 : 1 }) }, achievement.achievementIconKey in mergedIcons
-                            ? mergedIcons[achievement.achievementIconKey]
-                            : mergedIcons.default || '⭐')),
-                        React.createElement("div", { style: { flex: 1 } },
-                            React.createElement("h3", { style: Object.assign(Object.assign(Object.assign({}, defaultStyles.badgesModal.achievementTitle), styles === null || styles === void 0 ? void 0 : styles.achievementTitle), { color: isLocked ? '#999' : undefined }) }, achievement.achievementTitle),
-                            React.createElement("p", { style: Object.assign(Object.assign(Object.assign({}, defaultStyles.badgesModal.achievementDescription), styles === null || styles === void 0 ? void 0 : styles.achievementDescription), { color: isLocked ? '#aaa' : '#666' }) },
-                                achievement.achievementDescription,
-                                showUnlockConditions && isLocked && achievement.achievementDescription && (React.createElement("span", { style: {
-                                        display: 'block',
-                                        fontSize: '12px',
-                                        marginTop: '4px',
-                                        fontStyle: 'italic',
-                                        color: '#888'
-                                    } },
-                                    "\uD83D\uDD13 ",
-                                    achievement.achievementDescription)))),
-                        isLocked && (React.createElement("div", { style: Object.assign(Object.assign({}, defaultStyles.badgesModal.lockIcon), styles === null || styles === void 0 ? void 0 : styles.lockIcon) }, "\uD83D\uDD12"))));
-                }),
-                achievementsToDisplay.length === 0 && (React.createElement("p", { style: { textAlign: 'center', color: '#666' } }, "No achievements configured."))));
-        })())));
-};
-
-/**
- * Hook to track window dimensions
- * Replacement for react-use's useWindowSize
- *
- * @returns Object with width and height properties
- *
- * @example
- * ```tsx
- * const { width, height } = useWindowSize();
- * console.log(`Window size: ${width}x${height}`);
- * ```
- */
-function useWindowSize() {
-    const [size, setSize] = useState({
-        width: typeof window !== 'undefined' ? window.innerWidth : 0,
-        height: typeof window !== 'undefined' ? window.innerHeight : 0,
-    });
-    useEffect(() => {
-        // Handle SSR - window may not be defined
-        if (typeof window === 'undefined') {
-            return;
-        }
-        const handleResize = () => {
-            setSize({
-                width: window.innerWidth,
-                height: window.innerHeight,
-            });
-        };
-        // Set initial size
-        handleResize();
-        // Add event listener
-        window.addEventListener('resize', handleResize);
-        // Cleanup
-        return () => {
-            window.removeEventListener('resize', handleResize);
-        };
-    }, []);
-    return size;
-}
-
-const ConfettiWrapper = ({ show }) => {
-    const { width, height } = useWindowSize();
-    if (!show)
-        return null;
-    return (React.createElement(Confetti, { width: width, height: height, numberOfPieces: 200, recycle: false, style: {
-            position: 'fixed',
-            top: 0,
-            left: 0,
-            zIndex: 1001,
-            pointerEvents: 'none',
-        } }));
-};
-
-// Type guard to check if config is simple format
-function isSimpleConfig(config) {
-    if (!config || typeof config !== 'object')
-        return false;
-    const firstKey = Object.keys(config)[0];
-    if (!firstKey)
-        return true; // Empty config is considered simple
-    const firstValue = config[firstKey];
-    // Check if it's the current complex format (array of AchievementCondition)
-    if (Array.isArray(firstValue))
-        return false;
-    // Check if it's the simple format (object with string keys)
-    return typeof firstValue === 'object' && !Array.isArray(firstValue);
-}
-// Generate a unique ID for achievements
-function generateId() {
-    return Math.random().toString(36).substr(2, 9);
-}
-// Check if achievement details has a custom condition
-function hasCustomCondition(details) {
-    return 'condition' in details && typeof details.condition === 'function';
-}
-// Convert simple config to complex config format
-function normalizeAchievements(config) {
-    if (!isSimpleConfig(config)) {
-        // Already in complex format, return as-is
-        return config;
-    }
-    const normalized = {};
-    Object.entries(config).forEach(([metric, achievements]) => {
-        normalized[metric] = Object.entries(achievements).map(([key, achievement]) => {
-            if (hasCustomCondition(achievement)) {
-                // Custom condition function
-                return {
-                    isConditionMet: (_value, _state) => {
-                        // Convert internal metrics format (arrays) to simple format for custom conditions
-                        const simpleMetrics = {};
-                        Object.entries(_state.metrics).forEach(([key, val]) => {
-                            simpleMetrics[key] = Array.isArray(val) ? val[0] : val;
-                        });
-                        return achievement.condition(simpleMetrics);
-                    },
-                    achievementDetails: {
-                        achievementId: `${metric}_custom_${generateId()}`,
-                        achievementTitle: achievement.title,
-                        achievementDescription: achievement.description || '',
-                        achievementIconKey: achievement.icon || 'default'
-                    }
-                };
-            }
-            else {
-                // Threshold-based achievement
-                const threshold = parseFloat(key);
-                const isValidThreshold = !isNaN(threshold);
-                let conditionMet;
-                if (isValidThreshold) {
-                    // Numeric threshold
-                    conditionMet = (value) => {
-                        const numValue = Array.isArray(value) ? value[0] : value;
-                        return typeof numValue === 'number' && numValue >= threshold;
-                    };
-                }
-                else {
-                    // String or boolean threshold
-                    conditionMet = (value) => {
-                        const actualValue = Array.isArray(value) ? value[0] : value;
-                        // Handle boolean thresholds
-                        if (key === 'true')
-                            return actualValue === true;
-                        if (key === 'false')
-                            return actualValue === false;
-                        // Handle string thresholds
-                        return actualValue === key;
-                    };
-                }
-                return {
-                    isConditionMet: conditionMet,
-                    achievementDetails: {
-                        achievementId: `${metric}_${key}`,
-                        achievementTitle: achievement.title,
-                        achievementDescription: achievement.description || (isValidThreshold ? `Reach ${threshold} ${metric}` : `Achieve ${key} for ${metric}`),
-                        achievementIconKey: achievement.icon || 'default'
-                    }
-                };
-            }
-        });
-    });
-    return normalized;
-}
-
-/**
- * Exports achievement data to a JSON string
- *
- * @param metrics - Current achievement metrics
- * @param unlocked - Array of unlocked achievement IDs
- * @param configHash - Optional hash of achievement configuration for validation
- * @returns JSON string containing all achievement data
- *
- * @example
- * ```typescript
- * const json = exportAchievementData(_metrics, ['score_100', 'level_5']);
- * // Save json to file or send to server
- * ```
- */
-function exportAchievementData(metrics, unlocked, configHash) {
-    const data = Object.assign({ version: '3.3.0', timestamp: Date.now(), metrics, unlockedAchievements: unlocked }, (configHash && { configHash }));
-    return JSON.stringify(data, null, 2);
-}
-/**
- * Creates a simple hash of the achievement configuration
- * Used to validate that imported data matches the current configuration
- *
- * @param config - Achievement configuration object
- * @returns Simple hash string
- */
-function createConfigHash(config) {
-    // Simple hash based on stringified config
-    // In production, you might want to use a more robust hashing algorithm
-    const str = JSON.stringify(config);
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    return hash.toString(36);
-}
-
-/**
- * Imports achievement data from a JSON string
- *
- * @param jsonString - JSON string containing exported achievement data
- * @param currentMetrics - Current metrics state
- * @param currentUnlocked - Current unlocked achievements
- * @param options - Import options
- * @returns Import result with success status and any errors
- *
- * @example
- * ```typescript
- * const result = importAchievementData(
- *   jsonString,
- *   currentMetrics,
- *   currentUnlocked,
- *   { mergeStrategy: 'merge', validate: true }
- * );
- *
- * if (result.success) {
- *   console.log(`Imported ${result.imported.achievements} achievements`);
- * } else {
- *   console.error('Import failed:', result.errors);
- * }
- * ```
- */
-function importAchievementData(jsonString, currentMetrics, currentUnlocked, options = {}) {
-    const { mergeStrategy = 'replace', validate = true, expectedConfigHash } = options;
-    const warnings = [];
-    // Parse JSON
-    let data;
-    try {
-        data = JSON.parse(jsonString);
-    }
-    catch (_a) {
-        return {
-            success: false,
-            imported: { metrics: 0, achievements: 0 },
-            errors: ['Invalid JSON format']
-        };
-    }
-    // Validate structure
-    if (validate) {
-        const validationErrors = validateExportedData(data, expectedConfigHash);
-        if (validationErrors.length > 0) {
-            return {
-                success: false,
-                imported: { metrics: 0, achievements: 0 },
-                errors: validationErrors
-            };
-        }
-    }
-    // Version compatibility check
-    if (data.version && data.version !== '3.3.0') {
-        warnings.push(`Data exported from version ${data.version}, current version is 3.3.0`);
-    }
-    // Merge metrics based on strategy
-    let mergedMetrics;
-    let mergedUnlocked;
-    switch (mergeStrategy) {
-        case 'replace':
-            // Replace all existing data
-            mergedMetrics = data.metrics;
-            mergedUnlocked = data.unlockedAchievements;
-            break;
-        case 'merge':
-            // Union of both datasets, keeping higher metric values
-            mergedMetrics = mergeMetrics(currentMetrics, data.metrics);
-            mergedUnlocked = Array.from(new Set([...currentUnlocked, ...data.unlockedAchievements]));
-            break;
-        case 'preserve':
-            // Keep existing values, only add new ones
-            mergedMetrics = preserveMetrics(currentMetrics, data.metrics);
-            mergedUnlocked = Array.from(new Set([...currentUnlocked, ...data.unlockedAchievements]));
-            break;
-        default:
-            return {
-                success: false,
-                imported: { metrics: 0, achievements: 0 },
-                errors: [`Invalid merge strategy: ${mergeStrategy}`]
-            };
-    }
-    return Object.assign(Object.assign({ success: true, imported: {
-            metrics: Object.keys(mergedMetrics).length,
-            achievements: mergedUnlocked.length
-        } }, (warnings.length > 0 && { warnings })), { mergedMetrics,
-        mergedUnlocked });
-}
-/**
- * Validates the structure and content of exported data
- */
-function validateExportedData(data, expectedConfigHash) {
-    const errors = [];
-    // Check required fields
-    if (!data.version) {
-        errors.push('Missing version field');
-    }
-    if (!data.timestamp) {
-        errors.push('Missing timestamp field');
-    }
-    if (!data.metrics || typeof data.metrics !== 'object') {
-        errors.push('Missing or invalid metrics field');
-    }
-    if (!Array.isArray(data.unlockedAchievements)) {
-        errors.push('Missing or invalid unlockedAchievements field');
-    }
-    // Validate config hash if provided
-    if (expectedConfigHash && data.configHash && data.configHash !== expectedConfigHash) {
-        errors.push('Configuration mismatch: imported data may not be compatible with current achievement configuration');
-    }
-    // Validate metrics structure
-    if (data.metrics && typeof data.metrics === 'object') {
-        for (const [key, value] of Object.entries(data.metrics)) {
-            if (!Array.isArray(value)) {
-                errors.push(`Invalid metric format for "${key}": expected array, got ${typeof value}`);
-            }
-        }
-    }
-    // Validate achievement IDs are strings
-    if (Array.isArray(data.unlockedAchievements)) {
-        const invalidIds = data.unlockedAchievements.filter((id) => typeof id !== 'string');
-        if (invalidIds.length > 0) {
-            errors.push('All achievement IDs must be strings');
-        }
-    }
-    return errors;
-}
-/**
- * Merges two metrics objects, keeping higher values for overlapping keys
- */
-function mergeMetrics(current, imported) {
-    const merged = Object.assign({}, current);
-    for (const [key, importedValues] of Object.entries(imported)) {
-        if (!merged[key]) {
-            // New metric, add it
-            merged[key] = importedValues;
-        }
-        else {
-            // Existing metric, merge values
-            merged[key] = mergeMetricValues(merged[key], importedValues);
-        }
-    }
-    return merged;
-}
-/**
- * Merges two metric value arrays, keeping higher numeric values
- */
-function mergeMetricValues(current, imported) {
-    // For simplicity, we'll use the imported values if they're "higher"
-    // This works for numeric values; for other types, we prefer imported
-    const currentValue = current[0];
-    const importedValue = imported[0];
-    // If both are numbers, keep the higher one
-    if (typeof currentValue === 'number' && typeof importedValue === 'number') {
-        return currentValue >= importedValue ? current : imported;
-    }
-    // For non-numeric values, prefer imported (assume it's newer)
-    return imported;
-}
-/**
- * Preserves existing metrics, only adding new ones from imported data
- */
-function preserveMetrics(current, imported) {
-    const preserved = Object.assign({}, current);
-    for (const [key, value] of Object.entries(imported)) {
-        if (!preserved[key]) {
-            // Only add if it doesn't exist
-            preserved[key] = value;
-        }
-        // If it exists, keep current value (preserve strategy)
-    }
-    return preserved;
-}
-
-/**
- * Built-in notification component
- * Modern, theme-aware achievement notification with smooth animations
- */
-const BuiltInNotification = ({ achievement, onClose, duration = 5000, position = 'top-center', theme = 'modern', }) => {
-    var _a, _b, _c;
-    const [isVisible, setIsVisible] = useState(false);
-    const [isExiting, setIsExiting] = useState(false);
-    //  Get theme configuration
-    const themeConfig = getTheme(theme) || builtInThemes.modern;
-    const { notification: themeStyles } = themeConfig;
-    useEffect(() => {
-        // Slide in animation
-        const showTimer = setTimeout(() => setIsVisible(true), 10);
-        // Auto-dismiss
-        const dismissTimer = setTimeout(() => {
-            setIsExiting(true);
-            setTimeout(() => onClose === null || onClose === void 0 ? void 0 : onClose(), 300);
-        }, duration);
-        return () => {
-            clearTimeout(showTimer);
-            clearTimeout(dismissTimer);
-        };
-    }, [duration, onClose]);
-    const getPositionStyles = () => {
-        const base = {
-            position: 'fixed',
-            zIndex: 9999,
-        };
-        switch (position) {
-            case 'top-center':
-                return Object.assign(Object.assign({}, base), { top: 20, left: '50%', transform: 'translateX(-50%)' });
-            case 'top-left':
-                return Object.assign(Object.assign({}, base), { top: 20, left: 20 });
-            case 'top-right':
-                return Object.assign(Object.assign({}, base), { top: 20, right: 20 });
-            case 'bottom-center':
-                return Object.assign(Object.assign({}, base), { bottom: 20, left: '50%', transform: 'translateX(-50%)' });
-            case 'bottom-left':
-                return Object.assign(Object.assign({}, base), { bottom: 20, left: 20 });
-            case 'bottom-right':
-                return Object.assign(Object.assign({}, base), { bottom: 20, right: 20 });
-            default:
-                return Object.assign(Object.assign({}, base), { top: 20, left: '50%', transform: 'translateX(-50%)' });
-        }
-    };
-    const containerStyles = Object.assign(Object.assign({}, getPositionStyles()), { background: themeStyles.background, borderRadius: themeStyles.borderRadius, boxShadow: themeStyles.boxShadow, padding: '16px 24px', minWidth: '320px', maxWidth: '500px', display: 'flex', alignItems: 'center', gap: '16px', opacity: isVisible && !isExiting ? 1 : 0, transform: position.startsWith('top')
-            ? `translateY(${isVisible && !isExiting ? '0' : '-20px'}) ${position.includes('center') ? 'translateX(-50%)' : ''}`
-            : `translateY(${isVisible && !isExiting ? '0' : '20px'}) ${position.includes('center') ? 'translateX(-50%)' : ''}`, transition: 'all 0.3s cubic-bezier(0.4, 0, 0.2, 1)', pointerEvents: isVisible ? 'auto' : 'none' });
-    const iconStyles = {
-        fontSize: '48px',
-        lineHeight: 1,
-        flexShrink: 0,
-    };
-    const contentStyles = {
-        flex: 1,
-        color: themeStyles.textColor,
-        minWidth: 0,
-    };
-    const headerStyles = {
-        fontSize: ((_a = themeStyles.fontSize) === null || _a === void 0 ? void 0 : _a.header) || '12px',
-        textTransform: 'uppercase',
-        letterSpacing: '1px',
-        opacity: 0.8,
-        marginBottom: '4px',
-        color: themeStyles.accentColor,
-        fontWeight: 600,
-    };
-    const titleStyles = {
-        fontSize: ((_b = themeStyles.fontSize) === null || _b === void 0 ? void 0 : _b.title) || '18px',
-        fontWeight: 'bold',
-        marginBottom: '4px',
-        overflow: 'hidden',
-        textOverflow: 'ellipsis',
-        whiteSpace: 'nowrap',
-    };
-    const descriptionStyles = {
-        fontSize: ((_c = themeStyles.fontSize) === null || _c === void 0 ? void 0 : _c.description) || '14px',
-        opacity: 0.9,
-        overflow: 'hidden',
-        textOverflow: 'ellipsis',
-        display: '-webkit-box',
-        WebkitLineClamp: 2,
-        WebkitBoxOrient: 'vertical',
-    };
-    const closeButtonStyles = {
-        background: 'none',
-        border: 'none',
-        color: themeStyles.textColor,
-        fontSize: '24px',
-        cursor: 'pointer',
-        opacity: 0.6,
-        transition: 'opacity 0.2s',
-        padding: '4px',
-        flexShrink: 0,
-        lineHeight: 1,
-    };
-    return (React.createElement("div", { style: containerStyles, "data-testid": "built-in-notification" },
-        React.createElement("div", { style: iconStyles }, achievement.icon),
-        React.createElement("div", { style: contentStyles },
-            React.createElement("div", { style: headerStyles }, "Achievement Unlocked!"),
-            React.createElement("div", { style: titleStyles }, achievement.title),
-            achievement.description && (React.createElement("div", { style: descriptionStyles }, achievement.description))),
-        React.createElement("button", { onClick: () => {
-                setIsExiting(true);
-                setTimeout(() => onClose === null || onClose === void 0 ? void 0 : onClose(), 300);
-            }, style: closeButtonStyles, onMouseEnter: (e) => (e.currentTarget.style.opacity = '1'), onMouseLeave: (e) => (e.currentTarget.style.opacity = '0.6'), "aria-label": "Close notification" }, "\u00D7")));
-};
-
-/**
- * Built-in confetti component
- * Lightweight CSS-based confetti animation
- */
-const BuiltInConfetti = ({ show, duration = 5000, particleCount = 50, colors = ['#FFD700', '#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7'], }) => {
-    const [isVisible, setIsVisible] = useState(false);
-    const { width, height } = useWindowSize();
-    useEffect(() => {
-        if (show) {
-            setIsVisible(true);
-            const timer = setTimeout(() => setIsVisible(false), duration);
-            return () => clearTimeout(timer);
-        }
-        else {
-            setIsVisible(false);
-        }
-    }, [show, duration]);
-    if (!isVisible)
-        return null;
-    const containerStyles = {
-        position: 'fixed',
-        top: 0,
-        left: 0,
-        width: '100%',
-        height: '100%',
-        pointerEvents: 'none',
-        zIndex: 10001,
-        overflow: 'hidden',
-    };
-    // Generate particles
-    const particles = Array.from({ length: particleCount }, (_, i) => {
-        const color = colors[Math.floor(Math.random() * colors.length)];
-        const startX = Math.random() * width;
-        const rotation = Math.random() * 360;
-        const fallDuration = 3 + Math.random() * 2; // 3-5 seconds
-        const delay = Math.random() * 0.5; // 0-0.5s delay
-        const shape = Math.random() > 0.5 ? 'circle' : 'square';
-        const particleStyles = {
-            position: 'absolute',
-            top: '-20px',
-            left: `${startX}px`,
-            width: '10px',
-            height: '10px',
-            backgroundColor: color,
-            borderRadius: shape === 'circle' ? '50%' : '0',
-            transform: `rotate(${rotation}deg)`,
-            animation: `confettiFall ${fallDuration}s linear ${delay}s forwards`,
-            opacity: 0.9,
-        };
-        return React.createElement("div", { key: i, style: particleStyles, "data-testid": "confetti-particle" });
-    });
-    return (React.createElement(React.Fragment, null,
-        React.createElement("style", null, `
-          @keyframes confettiFall {
-            0% {
-              transform: translateY(0) rotate(0deg);
-              opacity: 1;
-            }
-            100% {
-              transform: translateY(${height + 50}px) rotate(720deg);
-              opacity: 0;
-            }
-          }
-        `),
-        React.createElement("div", { style: containerStyles, "data-testid": "built-in-confetti" }, particles)));
-};
-
-/**
- * Legacy UI library detection system
- * Attempts to dynamically import external UI libraries
- * Shows deprecation warnings when detected
- */
-let cachedLibraries = null;
-let detectionAttempted = false;
-let deprecationWarningShown = false;
-/**
- * Attempts to dynamically import legacy UI libraries
- * Uses try/catch to gracefully handle missing dependencies
- * Caches result to avoid multiple import attempts
- *
- * @returns Promise resolving to LegacyLibraries object
- */
-function detectLegacyLibraries() {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (detectionAttempted && cachedLibraries !== null) {
-            return cachedLibraries;
-        }
-        detectionAttempted = true;
-        const libraries = {};
-        // Try to import react-toastify
-        try {
-            const toastifyModule = yield import('react-toastify');
-            libraries.toast = toastifyModule.toast;
-            libraries.ToastContainer = toastifyModule.ToastContainer;
-        }
-        catch (_a) {
-            // Not installed, will use built-in notification
-        }
-        // Try to import react-modal
-        try {
-            const modalModule = yield import('react-modal');
-            libraries.Modal = modalModule.default;
-        }
-        catch (_b) {
-            // Not installed, will use built-in modal
-        }
-        // Try to import react-confetti
-        try {
-            const confettiModule = yield import('react-confetti');
-            libraries.Confetti = confettiModule.default;
-        }
-        catch (_c) {
-            // Not installed, will use built-in confetti
-        }
-        // Try to import react-use (only for useWindowSize)
-        try {
-            const reactUseModule = yield import('react-use');
-            libraries.useWindowSize = reactUseModule.useWindowSize;
-        }
-        catch (_d) {
-            // Not installed, will use built-in useWindowSize
-        }
-        cachedLibraries = libraries;
-        // Show deprecation warning if ANY legacy library is found
-        if (!deprecationWarningShown && Object.keys(libraries).length > 0) {
-            const foundLibraries = [];
-            if (libraries.toast)
-                foundLibraries.push('react-toastify');
-            if (libraries.Modal)
-                foundLibraries.push('react-modal');
-            if (libraries.Confetti)
-                foundLibraries.push('react-confetti');
-            if (libraries.useWindowSize)
-                foundLibraries.push('react-use');
-            console.warn(`[react-achievements] DEPRECATION WARNING: External UI dependencies (${foundLibraries.join(', ')}) are deprecated and will become fully optional in v4.0.0.\n\n` +
-                `The library now includes built-in UI components with modern design and theme support.\n\n` +
-                `To migrate:\n` +
-                `1. Add "useBuiltInUI={true}" to your AchievementProvider\n` +
-                `2. Test your application (UI will change to modern theme)\n` +
-                `3. Optionally customize with theme="minimal" or theme="gamified"\n` +
-                `4. Remove external dependencies from package.json\n\n` +
-                `To silence this warning, set useBuiltInUI={true} in AchievementProvider.\n\n` +
-                `Learn more: https://github.com/dave-b-b/react-achievements#migration-guide`);
-            deprecationWarningShown = true;
-        }
-        return libraries;
-    });
-}
-
-/**
- * Built-in modal component
- * Modern, theme-aware achievement modal with smooth animations
- */
-const BuiltInModal = ({ isOpen, onClose, achievements, icons = {}, theme = 'modern', }) => {
-    // Merge custom icons with defaults
-    const mergedIcons = Object.assign(Object.assign({}, defaultAchievementIcons), icons);
-    // Get theme configuration
-    const themeConfig = getTheme(theme) || builtInThemes.modern;
-    const { modal: themeStyles } = themeConfig;
-    useEffect(() => {
-        if (isOpen) {
-            // Lock body scroll when modal is open
-            document.body.style.overflow = 'hidden';
-        }
-        else {
-            // Restore body scroll
-            document.body.style.overflow = '';
-        }
-        return () => {
-            document.body.style.overflow = '';
-        };
-    }, [isOpen]);
-    if (!isOpen)
-        return null;
-    const overlayStyles = {
-        position: 'fixed',
-        top: 0,
-        left: 0,
-        right: 0,
-        bottom: 0,
-        backgroundColor: themeStyles.overlayColor,
-        display: 'flex',
-        alignItems: 'center',
-        justifyContent: 'center',
-        zIndex: 10000,
-        animation: 'fadeIn 0.3s ease-in-out',
-    };
-    const modalStyles = {
-        background: themeStyles.background,
-        borderRadius: themeStyles.borderRadius,
-        padding: '32px',
-        maxWidth: '600px',
-        width: '90%',
-        maxHeight: '80vh',
-        overflow: 'auto',
-        boxShadow: '0 20px 60px rgba(0, 0, 0, 0.5)',
-        animation: 'scaleIn 0.3s cubic-bezier(0.4, 0, 0.2, 1)',
-        position: 'relative',
-    };
-    const headerStyles = {
-        display: 'flex',
-        justifyContent: 'space-between',
-        alignItems: 'center',
-        marginBottom: '24px',
-    };
-    const titleStyles = {
-        margin: 0,
-        color: themeStyles.textColor,
-        fontSize: themeStyles.headerFontSize || '28px',
-        fontWeight: 'bold',
-    };
-    const closeButtonStyles = {
-        background: 'none',
-        border: 'none',
-        fontSize: '32px',
-        cursor: 'pointer',
-        color: themeStyles.textColor,
-        opacity: 0.6,
-        transition: 'opacity 0.2s',
-        padding: 0,
-        lineHeight: 1,
-    };
-    const isBadgeLayout = themeStyles.achievementLayout === 'badge';
-    const listStyles = isBadgeLayout
-        ? {
-            display: 'grid',
-            gridTemplateColumns: 'repeat(auto-fill, minmax(140px, 1fr))',
-            gap: '16px',
-        }
-        : {
-            display: 'flex',
-            flexDirection: 'column',
-            gap: '12px',
-        };
-    const getAchievementItemStyles = (isUnlocked) => {
-        const baseStyles = {
-            borderRadius: themeStyles.achievementCardBorderRadius || '12px',
-            backgroundColor: isUnlocked
-                ? `${themeStyles.accentColor}1A` // 10% opacity
-                : 'rgba(255, 255, 255, 0.05)',
-            border: `2px solid ${isUnlocked ? themeStyles.accentColor : 'rgba(255, 255, 255, 0.1)'}`,
-            opacity: isUnlocked ? 1 : 0.5,
-            transition: 'all 0.2s',
-        };
-        if (isBadgeLayout) {
-            // Badge layout: vertical, centered, square-ish
-            return Object.assign(Object.assign({}, baseStyles), { display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', textAlign: 'center', padding: '20px 12px', aspectRatio: '1 / 1.1', minHeight: '160px' });
-        }
-        else {
-            // Horizontal layout (default)
-            return Object.assign(Object.assign({}, baseStyles), { display: 'flex', gap: '16px', padding: '16px' });
-        }
-    };
-    const getIconContainerStyles = (isUnlocked) => {
-        if (isBadgeLayout) {
-            return {
-                fontSize: '48px',
-                lineHeight: 1,
-                marginBottom: '8px',
-                opacity: isUnlocked ? 1 : 0.3,
-            };
-        }
-        return {
-            fontSize: '40px',
-            flexShrink: 0,
-            lineHeight: 1,
-            opacity: isUnlocked ? 1 : 0.3,
-        };
-    };
-    const contentStyles = isBadgeLayout
-        ? {
-            width: '100%',
-        }
-        : {
-            flex: 1,
-            minWidth: 0,
-        };
-    const achievementTitleStyles = isBadgeLayout
-        ? {
-            margin: '0 0 4px 0',
-            color: themeStyles.textColor,
-            fontSize: '14px',
-            fontWeight: 'bold',
-            lineHeight: '1.3',
-        }
-        : {
-            margin: '0 0 8px 0',
-            color: themeStyles.textColor,
-            fontSize: '18px',
-            fontWeight: 'bold',
-            overflow: 'hidden',
-            textOverflow: 'ellipsis',
-            whiteSpace: 'nowrap',
-        };
-    const achievementDescriptionStyles = isBadgeLayout
-        ? {
-            margin: 0,
-            color: themeStyles.textColor,
-            opacity: 0.7,
-            fontSize: '11px',
-            lineHeight: '1.3',
-        }
-        : {
-            margin: 0,
-            color: themeStyles.textColor,
-            opacity: 0.8,
-            fontSize: '14px',
-        };
-    const getLockIconStyles = () => {
-        if (isBadgeLayout) {
-            return {
-                position: 'absolute',
-                top: '8px',
-                right: '8px',
-                fontSize: '18px',
-                opacity: 0.6,
-            };
-        }
-        return {
-            fontSize: '24px',
-            flexShrink: 0,
-            opacity: 0.5,
-        };
-    };
-    return (React.createElement(React.Fragment, null,
-        React.createElement("style", null, `
-          @keyframes fadeIn {
-            from { opacity: 0; }
-            to { opacity: 1; }
-          }
-          @keyframes scaleIn {
-            from {
-              transform: scale(0.9);
-              opacity: 0;
-            }
-            to {
-              transform: scale(1);
-              opacity: 1;
-            }
-          }
-        `),
-        React.createElement("div", { style: overlayStyles, onClick: onClose, "data-testid": "built-in-modal-overlay" },
-            React.createElement("div", { style: modalStyles, onClick: (e) => e.stopPropagation(), "data-testid": "built-in-modal" },
-                React.createElement("div", { style: headerStyles },
-                    React.createElement("h2", { style: titleStyles }, "\uD83C\uDFC6 Achievements"),
-                    React.createElement("button", { onClick: onClose, style: closeButtonStyles, onMouseEnter: (e) => (e.currentTarget.style.opacity = '1'), onMouseLeave: (e) => (e.currentTarget.style.opacity = '0.6'), "aria-label": "Close modal" }, "\u00D7")),
-                React.createElement("div", { style: listStyles }, achievements.length === 0 ? (React.createElement("div", { style: { textAlign: 'center', padding: '40px 20px', color: themeStyles.textColor, opacity: 0.6 } }, "No achievements yet. Start exploring to unlock them!")) : (achievements.map((achievement) => {
-                    const icon = (achievement.achievementIconKey &&
-                        mergedIcons[achievement.achievementIconKey]) ||
-                        mergedIcons.default ||
-                        '⭐';
-                    return (React.createElement("div", { key: achievement.achievementId, style: Object.assign(Object.assign({}, getAchievementItemStyles(achievement.isUnlocked)), { position: isBadgeLayout ? 'relative' : 'static' }) },
-                        React.createElement("div", { style: getIconContainerStyles(achievement.isUnlocked) }, icon),
-                        React.createElement("div", { style: contentStyles },
-                            React.createElement("h3", { style: achievementTitleStyles }, achievement.achievementTitle),
-                            React.createElement("p", { style: achievementDescriptionStyles }, achievement.achievementDescription)),
-                        !achievement.isUnlocked && (React.createElement("div", { style: getLockIconStyles() }, "\uD83D\uDD12"))));
-                })))))));
-};
-
-/**
- * Legacy library wrappers for backwards compatibility
- * Wraps external UI libraries to match our component interfaces
- */
-/**
- * Wrapper for react-toastify toast notifications
- * Falls back to built-in notification if not available
- */
-const createLegacyToastNotification = (libraries) => {
-    return ({ achievement, onClose }) => {
-        const { toast } = libraries;
-        useEffect(() => {
-            if (!toast)
-                return;
-            // Call toast.success with achievement content
-            toast.success(React.createElement("div", { style: { display: 'flex', alignItems: 'center' } },
-                React.createElement("span", { style: { fontSize: '2em', marginRight: '10px' } }, achievement.icon),
-                React.createElement("div", null,
-                    React.createElement("div", { style: { fontSize: '12px', opacity: 0.8, marginBottom: '4px' } }, "Achievement Unlocked!"),
-                    React.createElement("div", { style: { fontWeight: 'bold', marginBottom: '4px' } }, achievement.title),
-                    achievement.description && (React.createElement("div", { style: { fontSize: '13px', opacity: 0.9 } }, achievement.description)))), {
-                position: 'top-right',
-                autoClose: 5000,
-                hideProgressBar: false,
-                closeOnClick: true,
-                pauseOnHover: true,
-                draggable: true,
-                toastId: achievement.id,
-                onClose,
-            });
-        }, [achievement, toast, onClose]);
-        return null; // Toast handles its own rendering
-    };
-};
-/**
- * Wrapper for react-confetti Confetti component
- * Falls back to built-in confetti if not available
- */
-const createLegacyConfettiWrapper = (libraries) => {
-    return ({ show, duration = 5000, particleCount = 200, colors }) => {
-        const { Confetti, useWindowSize: legacyUseWindowSize } = libraries;
-        // If Confetti not available, use built-in
-        if (!Confetti) {
-            return (React.createElement(BuiltInConfetti, { show: show, duration: duration, particleCount: particleCount, colors: colors }));
-        }
-        // Use react-confetti with react-use's useWindowSize if available
-        // Otherwise fall back to default dimensions
-        let width = 0;
-        let height = 0;
-        if (legacyUseWindowSize) {
-            const size = legacyUseWindowSize();
-            width = size.width;
-            height = size.height;
-        }
-        else if (typeof window !== 'undefined') {
-            width = window.innerWidth;
-            height = window.innerHeight;
-        }
-        if (!show)
-            return null;
-        return (React.createElement(Confetti, { width: width, height: height, numberOfPieces: particleCount, recycle: false, colors: colors, style: {
-                position: 'fixed',
-                top: 0,
-                left: 0,
-                zIndex: 10001,
-                pointerEvents: 'none',
-            } }));
-    };
-};
-
-const AchievementContext = createContext(undefined);
-const AchievementProvider = ({ achievements: achievementsConfig, storage = StorageType.Local, children, icons = {}, onError, restApiConfig, ui = {}, useBuiltInUI = false, }) => {
-    // Normalize the configuration to the complex format
-    const achievements = normalizeAchievements(achievementsConfig);
-    const [achievementState, setAchievementState] = useState({
-        unlocked: [],
-        all: achievements,
-    });
-    const [metrics, setMetrics] = useState({});
-    const seenAchievementsRef = useRef(new Set());
-    const initialLoadRef = useRef(false);
-    const storageRef = useRef(null);
-    const metricsUpdatedRef = useRef(false);
-    const [showConfetti, setShowConfetti] = useState(false);
-    const [_currentAchievement, setCurrentAchievement] = useState(null);
-    // NEW: UI component resolution state (v3.6.0)
-    const [legacyLibraries, setLegacyLibraries] = useState(null);
-    const [uiReady, setUiReady] = useState(useBuiltInUI); // Ready immediately if forcing built-in
-    const [currentNotification, setCurrentNotification] = useState(null);
-    if (!storageRef.current) {
-        if (typeof storage === 'string') {
-            // StorageType enum
-            switch (storage) {
-                case StorageType.Local:
-                    storageRef.current = new LocalStorage('achievements');
-                    break;
-                case StorageType.Memory:
-                    storageRef.current = new MemoryStorage();
-                    break;
-                case StorageType.IndexedDB: {
-                    // Wrap async storage with adapter
-                    const indexedDB = new IndexedDBStorage('react-achievements');
-                    storageRef.current = new AsyncStorageAdapter(indexedDB, { onError });
-                    break;
-                }
-                case StorageType.RestAPI: {
-                    if (!restApiConfig) {
-                        throw new ConfigurationError('restApiConfig is required when using StorageType.RestAPI');
-                    }
-                    // Wrap async storage with adapter
-                    const restApi = new RestApiStorage(restApiConfig);
-                    storageRef.current = new AsyncStorageAdapter(restApi, { onError });
-                    break;
-                }
-                default:
-                    throw new ConfigurationError(`Unsupported storage type: ${storage}`);
-            }
-        }
-        else {
-            // Custom storage instance
-            // Check if it's async storage and wrap with adapter
-            if (isAsyncStorage(storage)) {
-                storageRef.current = new AsyncStorageAdapter(storage, { onError });
-            }
-            else {
-                storageRef.current = storage;
-            }
-        }
-    }
-    const storageImpl = storageRef.current;
-    const getNotifiedAchievementsKey = () => {
-        return 'notifiedAchievements';
-    };
-    const loadNotifiedAchievements = () => {
-        var _a, _b;
-        try {
-            if (storageImpl instanceof LocalStorage) {
-                const data = localStorage.getItem(`achievements_${getNotifiedAchievementsKey()}`);
-                if (data) {
-                    const notifiedAchievements = JSON.parse(data);
-                    return new Set(notifiedAchievements);
-                }
-            }
-            else {
-                const data = (_b = (_a = storageImpl).getItem) === null || _b === void 0 ? void 0 : _b.call(_a, getNotifiedAchievementsKey());
-                if (data) {
-                    return new Set(JSON.parse(data));
-                }
-            }
-        }
-        catch (e) {
-            console.error('Error loading notified achievements', e);
-        }
-        return new Set();
-    };
-    const saveNotifiedAchievements = (achievements) => {
-        var _a, _b;
-        try {
-            const achievementsArray = Array.from(achievements);
-            if (storageImpl instanceof LocalStorage) {
-                localStorage.setItem(`achievements_${getNotifiedAchievementsKey()}`, JSON.stringify(achievementsArray));
-            }
-            else {
-                (_b = (_a = storageImpl).setItem) === null || _b === void 0 ? void 0 : _b.call(_a, getNotifiedAchievementsKey(), JSON.stringify(achievementsArray));
-            }
-        }
-        catch (e) {
-            console.error('Error saving notified achievements', e);
-        }
-    };
-    // NEW: Detect legacy UI libraries on mount (v3.6.0)
-    useEffect(() => {
-        if (useBuiltInUI) {
-            // User explicitly wants built-in UI, skip detection
-            setUiReady(true);
-            return;
-        }
-        // Attempt to detect legacy libraries
-        detectLegacyLibraries().then((libs) => {
-            setLegacyLibraries(libs);
-            setUiReady(true);
-        });
-    }, [useBuiltInUI]);
-    // NEW: Resolve UI components based on detection and config (v3.6.0)
-    const NotificationComponent = ui.NotificationComponent ||
-        (useBuiltInUI ? BuiltInNotification :
-            legacyLibraries && Object.keys(legacyLibraries).length > 0 && legacyLibraries.toast
-                ? createLegacyToastNotification(legacyLibraries)
-                : BuiltInNotification);
-    const ConfettiComponentResolved = ui.ConfettiComponent ||
-        (useBuiltInUI ? BuiltInConfetti :
-            legacyLibraries && Object.keys(legacyLibraries).length > 0 && legacyLibraries.Confetti
-                ? createLegacyConfettiWrapper(legacyLibraries)
-                : BuiltInConfetti);
-    useEffect(() => {
-        if (!initialLoadRef.current) {
-            const savedUnlocked = storageImpl.getUnlockedAchievements() || [];
-            const savedMetrics = storageImpl.getMetrics() || {};
-            seenAchievementsRef.current = loadNotifiedAchievements();
-            if (savedUnlocked.length > 0 || Object.keys(savedMetrics).length > 0) {
-                setAchievementState(prev => (Object.assign(Object.assign({}, prev), { unlocked: savedUnlocked })));
-                setMetrics(savedMetrics);
-                savedUnlocked.forEach(id => {
-                    seenAchievementsRef.current.add(id);
-                });
-                saveNotifiedAchievements(seenAchievementsRef.current);
-            }
-            initialLoadRef.current = true;
-        }
-    }, []);
-    useEffect(() => {
-        if (Object.keys(metrics).length === 0 || !metricsUpdatedRef.current)
-            return;
-        metricsUpdatedRef.current = false;
-        const newlyUnlockedAchievements = [];
-        let achievementToShow = null;
-        Object.entries(achievements).forEach(([metricName, metricAchievements]) => {
-            metricAchievements.forEach((achievement) => {
-                const state = { metrics, unlockedAchievements: achievementState.unlocked };
-                const achievementId = achievement.achievementDetails.achievementId;
-                // For custom conditions, we always check against all metrics
-                // For threshold-based conditions, we check against the specific metric
-                const currentValue = metrics[metricName];
-                const shouldCheckAchievement = currentValue !== undefined ||
-                    achievement.achievementDetails.achievementId.includes('_custom_');
-                if (shouldCheckAchievement) {
-                    const valueToCheck = currentValue;
-                    if (achievement.isConditionMet(valueToCheck, state)) {
-                        if (!achievementState.unlocked.includes(achievementId) &&
-                            !newlyUnlockedAchievements.includes(achievementId)) {
-                            newlyUnlockedAchievements.push(achievementId);
-                            if (!seenAchievementsRef.current.has(achievementId)) {
-                                achievementToShow = achievement.achievementDetails;
-                            }
-                        }
-                    }
-                }
-            });
-        });
-        if (newlyUnlockedAchievements.length > 0) {
-            const allUnlocked = [...achievementState.unlocked, ...newlyUnlockedAchievements];
-            setAchievementState(prev => (Object.assign(Object.assign({}, prev), { unlocked: allUnlocked })));
-            storageImpl.setUnlockedAchievements(allUnlocked);
-            if (achievementToShow && (ui.enableNotifications !== false)) {
-                const achievement = achievementToShow;
-                // Get icon to display
-                let iconToDisplay = '🏆';
-                if (achievement.achievementIconKey && achievement.achievementIconKey in icons) {
-                    iconToDisplay = icons[achievement.achievementIconKey];
-                }
-                // NEW: Use resolved notification component (v3.6.0)
-                setCurrentNotification({
-                    achievement: {
-                        id: achievement.achievementId || `achievement-${Date.now()}`,
-                        title: achievement.achievementTitle || 'Achievement Unlocked!',
-                        description: achievement.achievementDescription || '',
-                        icon: iconToDisplay,
-                    },
-                });
-                // Update seen achievements
-                if (achievement.achievementId) {
-                    seenAchievementsRef.current.add(achievement.achievementId);
-                    saveNotifiedAchievements(seenAchievementsRef.current);
-                }
-                // Show confetti
-                setCurrentAchievement(achievement);
-                setShowConfetti(true);
-                // Hide confetti after 5 seconds
-                const timer = setTimeout(() => {
-                    setShowConfetti(false);
-                    setCurrentAchievement(null);
-                }, 5000);
-                return () => clearTimeout(timer);
-            }
-        }
-    }, [metrics, achievementState.unlocked, achievements, icons]);
-    const getAllAchievements = () => {
-        const result = [];
-        // Iterate through all normalized achievements
-        Object.entries(achievements).forEach(([_metricName, metricAchievements]) => {
-            metricAchievements.forEach((achievement) => {
-                const { achievementDetails } = achievement;
-                const isUnlocked = achievementState.unlocked.includes(achievementDetails.achievementId);
-                result.push({
-                    achievementId: achievementDetails.achievementId,
-                    achievementTitle: achievementDetails.achievementTitle,
-                    achievementDescription: achievementDetails.achievementDescription,
-                    achievementIconKey: achievementDetails.achievementIconKey,
-                    isUnlocked,
-                });
-            });
-        });
-        return result;
-    };
-    const update = (newMetrics) => {
-        metricsUpdatedRef.current = true;
-        const updatedMetrics = Object.assign({}, metrics);
-        Object.entries(newMetrics).forEach(([key, value]) => {
-            updatedMetrics[key] = value;
-        });
-        setMetrics(updatedMetrics);
-        const storageMetrics = Object.entries(updatedMetrics).reduce((acc, [key, value]) => (Object.assign(Object.assign({}, acc), { [key]: Array.isArray(value) ? value : [value] })), {});
-        try {
-            storageImpl.setMetrics(storageMetrics);
-        }
-        catch (error) {
-            if (error instanceof AchievementError) {
-                if (onError) {
-                    onError(error);
-                }
-                else {
-                    console.error('Achievement storage error:', error.message, error.remedy);
-                }
-            }
-            else {
-                console.error('Unexpected error saving metrics:', error);
-            }
-        }
-    };
-    const reset = () => {
-        var _a, _b;
-        storageImpl.clear();
-        if (storageImpl instanceof LocalStorage) {
-            localStorage.removeItem(`achievements_${getNotifiedAchievementsKey()}`);
-        }
-        else {
-            (_b = (_a = storageImpl).removeItem) === null || _b === void 0 ? void 0 : _b.call(_a, getNotifiedAchievementsKey());
-        }
-        setAchievementState({
-            unlocked: [],
-            all: achievements,
-        });
-        setMetrics({});
-        seenAchievementsRef.current.clear();
-        setShowConfetti(false);
-        setCurrentAchievement(null);
-    };
-    const getState = () => {
-        const metricsInArrayFormat = Object.entries(metrics).reduce((acc, [key, value]) => (Object.assign(Object.assign({}, acc), { [key]: Array.isArray(value) ? value : [value] })), {});
-        return {
-            metrics: metricsInArrayFormat,
-            unlocked: achievementState.unlocked,
-        };
-    };
-    const exportData = () => {
-        const state = getState();
-        const configHash = createConfigHash(achievementsConfig);
-        return exportAchievementData(state.metrics, state.unlocked, configHash);
-    };
-    const importData = (jsonString, options) => {
-        const state = getState();
-        const configHash = createConfigHash(achievementsConfig);
-        const result = importAchievementData(jsonString, state.metrics, state.unlocked, Object.assign(Object.assign({}, options), { expectedConfigHash: configHash }));
-        if (result.success && 'mergedMetrics' in result && 'mergedUnlocked' in result) {
-            // Apply the imported data
-            const mergedResult = result;
-            // Update metrics state
-            const metricsFromArrayFormat = Object.entries(mergedResult.mergedMetrics).reduce((acc, [key, value]) => (Object.assign(Object.assign({}, acc), { [key]: Array.isArray(value) ? value[0] : value })), {});
-            setMetrics(metricsFromArrayFormat);
-            // Update unlocked achievements state
-            setAchievementState(prev => (Object.assign(Object.assign({}, prev), { unlocked: mergedResult.mergedUnlocked })));
-            // Persist to storage
-            storageImpl.setMetrics(mergedResult.mergedMetrics);
-            storageImpl.setUnlockedAchievements(mergedResult.mergedUnlocked);
-            // Update seen achievements to prevent duplicate notifications
-            mergedResult.mergedUnlocked.forEach(id => {
-                seenAchievementsRef.current.add(id);
-            });
-            saveNotifiedAchievements(seenAchievementsRef.current);
-        }
-        return result;
-    };
-    return (React.createElement(AchievementContext.Provider, { value: {
-            update,
-            achievements: achievementState,
-            reset,
-            getState,
-            exportData,
-            importData,
-            getAllAchievements,
-        } },
-        children,
-        uiReady && currentNotification && ui.enableNotifications !== false && (React.createElement(NotificationComponent, { achievement: currentNotification.achievement, onClose: () => setCurrentNotification(null), duration: 5000, position: ui.notificationPosition || 'top-center', theme: ui.theme || 'modern' })),
-        uiReady && ui.enableConfetti !== false && (React.createElement(ConfettiComponentResolved, { show: showConfetti, duration: 5000 }))));
-};
-
-const useAchievements = () => {
-    const context = useContext(AchievementContext);
-    if (!context) {
-        throw new Error('useAchievements must be used within an AchievementProvider');
-    }
-    return context;
-};
-
-/**
- * A simplified hook for achievement tracking.
- * Provides an easier API for common use cases while maintaining access to advanced features.
- */
-const useSimpleAchievements = () => {
-    const { update, achievements, reset, getState, exportData, importData, getAllAchievements } = useAchievements();
-    return {
-        /**
-         * Track a metric value for achievements
-         * @param metric - The metric name (e.g., 'score', 'level')
-         * @param value - The metric value
-         */
-        track: (metric, value) => update({ [metric]: value }),
-        /**
-         * Increment a numeric metric by a specified amount
-         * @param metric - The metric name (e.g., 'buttonClicks', 'score')
-         * @param amount - The amount to increment by (defaults to 1)
-         */
-        increment: (metric, amount = 1) => {
-            const currentState = getState();
-            const currentMetricArray = currentState.metrics[metric] || [0];
-            const currentValue = Array.isArray(currentMetricArray) ? currentMetricArray[0] : currentMetricArray;
-            const newValue = (typeof currentValue === 'number' ? currentValue : 0) + amount;
-            update({ [metric]: newValue });
-        },
-        /**
-         * Track multiple metrics at once
-         * @param metrics - Object with metric names as keys and values
-         */
-        trackMultiple: (metrics) => update(metrics),
-        /**
-         * Array of unlocked achievement IDs
-         */
-        unlocked: achievements.unlocked,
-        /**
-         * All available achievements
-         */
-        all: achievements.all,
-        /**
-         * Number of unlocked achievements
-         */
-        unlockedCount: achievements.unlocked.length,
-        /**
-         * Reset all achievement progress
-         */
-        reset,
-        /**
-         * Get current state (advanced usage)
-         */
-        getState,
-        /**
-         * Export achievement data to JSON string
-         * @returns JSON string containing all achievement data
-         */
-        exportData,
-        /**
-         * Import achievement data from JSON string
-         * @param jsonString - JSON string containing exported achievement data
-         * @param options - Import options (merge strategy, validation)
-         * @returns Import result with success status and any errors
-         */
-        importData,
-        /**
-         * Get all achievements with their unlock status
-         * @returns Array of achievements with isUnlocked boolean property
-         */
-        getAllAchievements,
-    };
-};
-
-/**
- * Base class for chainable achievement configuration (Tier 2)
- */
-class Achievement {
-    constructor(metric, defaultAward) {
-        this.metric = metric;
-        this.award = defaultAward;
-    }
-    /**
-     * Customize the award details for this achievement
-     * @param award - Custom award details
-     * @returns This achievement for chaining
-     */
-    withAward(award) {
-        this.award = Object.assign(Object.assign({}, this.award), award);
-        return this;
-    }
-}
-/**
- * Threshold-based achievement (score, level, etc.)
- */
-class ThresholdAchievement extends Achievement {
-    constructor(metric, threshold, defaultAward) {
-        super(metric, defaultAward);
-        this.threshold = threshold;
-    }
-    toConfig() {
-        return {
-            [this.metric]: {
-                [this.threshold]: {
-                    title: this.award.title,
-                    description: this.award.description,
-                    icon: this.award.icon
-                }
-            }
-        };
-    }
-}
-/**
- * Boolean achievement (tutorial completion, first login, etc.)
- */
-class BooleanAchievement extends Achievement {
-    toConfig() {
-        return {
-            [this.metric]: {
-                true: {
-                    title: this.award.title,
-                    description: this.award.description,
-                    icon: this.award.icon
-                }
-            }
-        };
-    }
-}
-/**
- * Value-based achievement (character class, difficulty, etc.)
- */
-class ValueAchievement extends Achievement {
-    constructor(metric, value, defaultAward) {
-        super(metric, defaultAward);
-        this.value = value;
-    }
-    toConfig() {
-        return {
-            [this.metric]: {
-                [this.value]: {
-                    title: this.award.title,
-                    description: this.award.description,
-                    icon: this.award.icon
-                }
-            }
-        };
-    }
-}
-/**
- * Complex achievement builder for power users (Tier 3)
- */
-class ComplexAchievementBuilder {
-    constructor() {
-        this.id = '';
-        this.metric = '';
-        this.condition = null;
-        this.award = {};
-    }
-    /**
-     * Set the unique identifier for this achievement
-     */
-    withId(id) {
-        this.id = id;
-        return this;
-    }
-    /**
-     * Set the metric this achievement tracks
-     */
-    withMetric(metric) {
-        this.metric = metric;
-        return this;
-    }
-    /**
-     * Set the condition function that determines if achievement is unlocked
-     */
-    withCondition(fn) {
-        this.condition = fn;
-        return this;
-    }
-    /**
-     * Set the award details for this achievement
-     */
-    withAward(award) {
-        this.award = Object.assign(Object.assign({}, this.award), award);
-        return this;
-    }
-    /**
-     * Build the final achievement configuration
-     */
-    build() {
-        if (!this.id || !this.metric || !this.condition) {
-            throw new Error('Complex achievement requires id, metric, and condition');
-        }
-        // Convert our two-parameter condition function to the single-parameter format
-        // expected by the existing CustomAchievementDetails type
-        const compatibleCondition = (metrics) => {
-            const state = {
-                metrics: {}, // We don't have access to the full metrics structure here
-                unlockedAchievements: []
-            };
-            return this.condition(metrics[this.metric], state);
-        };
-        return {
-            [this.id]: {
-                custom: {
-                    title: this.award.title || this.id,
-                    description: this.award.description || `Achieve ${this.award.title || this.id}`,
-                    icon: this.award.icon || '💎',
-                    condition: compatibleCondition
-                }
-            }
-        };
-    }
-}
-/**
- * Main AchievementBuilder with three-tier API
- * Tier 1: Simple static methods with smart defaults
- * Tier 2: Chainable customization
- * Tier 3: Full builder for complex logic
- */
-class AchievementBuilder {
-    // TIER 1: Simple Static Methods (90% of use cases)
-    /**
-     * Create a single score achievement with smart defaults
-     * @param threshold - Score threshold to achieve
-     * @returns Chainable ThresholdAchievement
-     */
-    static createScoreAchievement(threshold) {
-        return new ThresholdAchievement('score', threshold, {
-            title: `Score ${threshold}!`,
-            description: `Score ${threshold} points`,
-            icon: '🏆'
-        });
-    }
-    /**
-     * Create multiple score achievements
-     * @param thresholds - Array of thresholds or [threshold, award] tuples
-     * @returns Complete SimpleAchievementConfig
-     */
-    static createScoreAchievements(thresholds) {
-        const config = { score: {} };
-        thresholds.forEach(item => {
-            if (typeof item === 'number') {
-                // Use default award
-                config.score[item] = {
-                    title: `Score ${item}!`,
-                    description: `Score ${item} points`,
-                    icon: '🏆'
-                };
-            }
-            else {
-                // Custom award
-                const [threshold, award] = item;
-                config.score[threshold] = {
-                    title: award.title || `Score ${threshold}!`,
-                    description: award.description || `Score ${threshold} points`,
-                    icon: award.icon || '🏆'
-                };
-            }
-        });
-        return config;
-    }
-    /**
-     * Create a single level achievement with smart defaults
-     * @param level - Level threshold to achieve
-     * @returns Chainable ThresholdAchievement
-     */
-    static createLevelAchievement(level) {
-        return new ThresholdAchievement('level', level, {
-            title: `Level ${level}!`,
-            description: `Reach level ${level}`,
-            icon: '📈'
-        });
-    }
-    /**
-     * Create multiple level achievements
-     * @param levels - Array of levels or [level, award] tuples
-     * @returns Complete SimpleAchievementConfig
-     */
-    static createLevelAchievements(levels) {
-        const config = { level: {} };
-        levels.forEach(item => {
-            if (typeof item === 'number') {
-                // Use default award
-                config.level[item] = {
-                    title: `Level ${item}!`,
-                    description: `Reach level ${item}`,
-                    icon: '📈'
-                };
-            }
-            else {
-                // Custom award
-                const [level, award] = item;
-                config.level[level] = {
-                    title: award.title || `Level ${level}!`,
-                    description: award.description || `Reach level ${level}`,
-                    icon: award.icon || '📈'
-                };
-            }
-        });
-        return config;
-    }
-    /**
-     * Create a boolean achievement with smart defaults
-     * @param metric - The metric name (e.g., 'completedTutorial')
-     * @returns Chainable BooleanAchievement
-     */
-    static createBooleanAchievement(metric) {
-        // Convert camelCase to Title Case
-        const formattedMetric = metric.replace(/([A-Z])/g, ' $1').toLowerCase();
-        const titleCase = formattedMetric.charAt(0).toUpperCase() + formattedMetric.slice(1);
-        return new BooleanAchievement(metric, {
-            title: `${titleCase}!`,
-            description: `Complete ${formattedMetric}`,
-            icon: '✅'
-        });
-    }
-    /**
-     * Create a value-based achievement with smart defaults
-     * @param metric - The metric name (e.g., 'characterClass')
-     * @param value - The value to match (e.g., 'wizard')
-     * @returns Chainable ValueAchievement
-     */
-    static createValueAchievement(metric, value) {
-        const formattedValue = value.charAt(0).toUpperCase() + value.slice(1);
-        return new ValueAchievement(metric, value, {
-            title: `${formattedValue}!`,
-            description: `Choose ${formattedValue.toLowerCase()} for ${metric}`,
-            icon: '🎯'
-        });
-    }
-    // TIER 3: Full Builder for Complex Logic
-    /**
-     * Create a complex achievement builder for power users
-     * @returns ComplexAchievementBuilder for full control
-     */
-    static create() {
-        return new ComplexAchievementBuilder();
-    }
-    // UTILITY METHODS
-    /**
-     * Combine multiple achievement configurations
-     * @param achievements - Array of SimpleAchievementConfig objects or Achievement instances
-     * @returns Combined SimpleAchievementConfig
-     */
-    static combine(achievements) {
-        const combined = {};
-        achievements.forEach(achievement => {
-            const config = achievement instanceof Achievement ? achievement.toConfig() : achievement;
-            Object.keys(config).forEach(key => {
-                if (!combined[key]) {
-                    combined[key] = {};
-                }
-                Object.assign(combined[key], config[key]);
-            });
-        });
-        return combined;
-    }
-}
-
-export { AchievementBuilder, AchievementContext, AchievementError, AchievementProvider, AsyncStorageAdapter, BadgesButton, BadgesModal, BuiltInConfetti, BuiltInModal, BuiltInNotification, ConfettiWrapper, ConfigurationError, ImportValidationError, IndexedDBStorage, LocalStorage, MemoryStorage, OfflineQueueStorage, RestApiStorage, StorageError, StorageQuotaError, StorageType, SyncError, createConfigHash, defaultAchievementIcons, defaultStyles, exportAchievementData, importAchievementData, isAchievementError, isAsyncStorage, isRecoverableError, isSimpleConfig, normalizeAchievements, useAchievements, useSimpleAchievements, useWindowSize };
-//# sourceMappingURL=index.js.map