@nice2dev/icons 1.3.14 → 1.3.16

package/dist/cjs/advancedIconSearch.js

@@ -1,563 +1,426 @@
-'use strict';
-
-var React = require('react');
-
-/**
- * @file advancedIconSearch.ts
- * @module @nice2dev/icons
- * @description PRO-28.3 — Advanced Icon Search with fuzzy matching,
- * filters, semantic search support, and analytics.
- */
-/* ══════════════════════════════════════════════════════════════════════════════
-   Fuzzy Match Utilities
-   ══════════════════════════════════════════════════════════════════════════════ */
-/**
- * Calculate Levenshtein distance between two strings.
- */
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const React = require("react");
 function levenshteinDistance(a, b) {
-    const matrix = [];
-    // Handle empty strings
-    if (a.length === 0) {
-        return b.length;
-    }
-    if (b.length === 0) {
-        return a.length;
-    }
-    // Initialize matrix
-    for (let i = 0; i <= b.length; i++) {
-        matrix[i] = [i];
-    }
-    for (let j = 0; j <= a.length; j++) {
-        matrix[0][j] = j;
-    }
-    // Fill matrix
-    for (let i = 1; i <= b.length; i++) {
-        for (let j = 1; j <= a.length; j++) {
-            if (b.charAt(i - 1) === a.charAt(j - 1)) {
-                matrix[i][j] = matrix[i - 1][j - 1];
-            }
-            else {
-                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
-                matrix[i][j - 1] + 1, // insertion
-                matrix[i - 1][j] + 1);
-            }
-        }
-    }
-    return matrix[b.length][a.length];
+  const matrix = [];
+  if (a.length === 0) {
+    return b.length;
+  }
+  if (b.length === 0) {
+    return a.length;
+  }
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
 }
-/**
- * Calculate fuzzy match score (0-100).
- */
 function fuzzyMatchScore(query, target) {
-    const q = query.toLowerCase();
-    const t = target.toLowerCase();
-    // Exact match
-    if (q === t) {
-        return 100;
-    }
-    // Contains exact
-    if (t.includes(q)) {
-        return 90 - (t.length - q.length) / 2;
-    }
-    // Starts with
-    if (t.startsWith(q)) {
-        return 85;
-    }
-    // Calculate Levenshtein-based similarity
-    const distance = levenshteinDistance(q, t);
-    const maxLen = Math.max(q.length, t.length);
-    const similarity = ((maxLen - distance) / maxLen) * 100;
-    return Math.max(0, Math.round(similarity));
+  const q = query.toLowerCase();
+  const t = target.toLowerCase();
+  if (q === t) {
+    return 100;
+  }
+  if (t.includes(q)) {
+    return 90 - (t.length - q.length) / 2;
+  }
+  if (t.startsWith(q)) {
+    return 85;
+  }
+  const distance = levenshteinDistance(q, t);
+  const maxLen = Math.max(q.length, t.length);
+  const similarity = (maxLen - distance) / maxLen * 100;
+  return Math.max(0, Math.round(similarity));
 }
-/**
- * Tokenize a search query.
- */
 function tokenizeQuery(query) {
-    return query
-        .toLowerCase()
-        .replace(/[^\w\s-]/g, ' ')
-        .split(/\s+/)
-        .filter((token) => token.length > 1);
+  return query.toLowerCase().replace(/[^\w\s-]/g, " ").split(/\s+/).filter((token) => token.length > 1);
 }
-/* ══════════════════════════════════════════════════════════════════════════════
-   Extended Icon Registry
-   ══════════════════════════════════════════════════════════════════════════════ */
-const extendedRegistry = new Map();
-const favoriteIcons = new Set();
+const extendedRegistry = /* @__PURE__ */ new Map();
+const favoriteIcons = /* @__PURE__ */ new Set();
 const recentlyUsedIcons = [];
 const searchHistory = [];
-/**
- * Register an icon with extended metadata.
- */
 function registerExtendedIcon(name, metadata) {
-    // Merge with defaults
-    const extended = {
-        name,
-        category: metadata.category || 'ui',
-        primaryCategory: metadata.primaryCategory || metadata.category || 'ui',
-        secondaryCategories: metadata.secondaryCategories || [],
-        domains: metadata.domains || ['general'],
-        useCases: metadata.useCases || ['action'],
-        styles: metadata.styles || ['solid', 'outline'],
-        tags: metadata.tags || [],
-        aliases: metadata.aliases || [],
-        description: metadata.description || '',
-        related: metadata.related || [],
-        relatedIcons: metadata.relatedIcons || metadata.related || [],
-        recommendedSizes: metadata.recommendedSizes || [16, 48],
-        localizedNames: metadata.localizedNames || { en: name },
-        searchKeywords: metadata.searchKeywords || [],
-        dateAdded: metadata.dateAdded,
-        versionAdded: metadata.versionAdded,
-        deprecated: metadata.deprecated,
-        deprecatedMessage: metadata.deprecatedMessage,
-    };
-    extendedRegistry.set(name, extended);
+  const extended = {
+    name,
+    category: metadata.category || "ui",
+    primaryCategory: metadata.primaryCategory || metadata.category || "ui",
+    secondaryCategories: metadata.secondaryCategories || [],
+    domains: metadata.domains || ["general"],
+    useCases: metadata.useCases || ["action"],
+    styles: metadata.styles || ["solid", "outline"],
+    tags: metadata.tags || [],
+    aliases: metadata.aliases || [],
+    description: metadata.description || "",
+    related: metadata.related || [],
+    relatedIcons: metadata.relatedIcons || metadata.related || [],
+    recommendedSizes: metadata.recommendedSizes || [16, 48],
+    localizedNames: metadata.localizedNames || { en: name },
+    searchKeywords: metadata.searchKeywords || [],
+    dateAdded: metadata.dateAdded,
+    versionAdded: metadata.versionAdded,
+    deprecated: metadata.deprecated,
+    deprecatedMessage: metadata.deprecatedMessage
+  };
+  extendedRegistry.set(name, extended);
 }
-/**
- * Get extended metadata for an icon.
- */
 function getExtendedMetadata(name) {
-    return extendedRegistry.get(name);
+  return extendedRegistry.get(name);
 }
-/**
- * Mark an icon as favorite.
- */
 function toggleFavorite(name) {
-    if (favoriteIcons.has(name)) {
-        favoriteIcons.delete(name);
-        return false;
-    }
-    favoriteIcons.add(name);
-    return true;
+  if (favoriteIcons.has(name)) {
+    favoriteIcons.delete(name);
+    return false;
+  }
+  favoriteIcons.add(name);
+  return true;
 }
-/**
- * Check if icon is favorite.
- */
 function isFavorite(name) {
-    return favoriteIcons.has(name);
+  return favoriteIcons.has(name);
 }
-/**
- * Get all favorite icons.
- */
 function getFavorites() {
-    return Array.from(favoriteIcons);
+  return Array.from(favoriteIcons);
 }
-/**
- * Record icon usage (for analytics).
- */
 function recordIconUsage(name) {
-    const existing = recentlyUsedIcons.findIndex((item) => item.name === name);
-    if (existing >= 0) {
-        recentlyUsedIcons.splice(existing, 1);
-    }
-    recentlyUsedIcons.unshift({ name, timestamp: Date.now() });
-    // Keep only last 100
-    if (recentlyUsedIcons.length > 100) {
-        recentlyUsedIcons.pop();
-    }
+  const existing = recentlyUsedIcons.findIndex((item) => item.name === name);
+  if (existing >= 0) {
+    recentlyUsedIcons.splice(existing, 1);
+  }
+  recentlyUsedIcons.unshift({ name, timestamp: Date.now() });
+  if (recentlyUsedIcons.length > 100) {
+    recentlyUsedIcons.pop();
+  }
 }
-/**
- * Get recently used icons.
- */
 function getRecentlyUsed(limit = 20) {
-    return recentlyUsedIcons.slice(0, limit).map((item) => item.name);
+  return recentlyUsedIcons.slice(0, limit).map((item) => item.name);
 }
-/* ══════════════════════════════════════════════════════════════════════════════
-   Advanced Search Engine
-   ══════════════════════════════════════════════════════════════════════════════ */
-/**
- * Perform advanced search with fuzzy matching and filters.
- */
 function advancedSearch(query, filters = {}, options = {}) {
-    const startTime = performance.now();
-    const { maxResults = 50, minScore = 30, locale = 'en' } = options;
-    const tokens = tokenizeQuery(query);
-    const results = [];
-    for (const [name, metadata] of extendedRegistry) {
-        // Apply filters first
-        if (!passesFilters(metadata, filters)) {
-            continue;
-        }
-        // Calculate match score
-        const { score, matchedIn, highlights } = calculateMatchScore(tokens, query, name, metadata, locale);
-        if (score >= minScore) {
-            results.push({ name, metadata, score, matchedIn, highlights });
-        }
-    }
-    // Sort by score descending
-    results.sort((a, b) => b.score - a.score);
-    // Track analytics
-    const duration = performance.now() - startTime;
-    searchHistory.push({
-        query,
-        duration,
-        totalResults: results.length,
-        filters,
-        timestamp: Date.now(),
-    });
-    return results.slice(0, maxResults);
+  const startTime = performance.now();
+  const { maxResults = 50, minScore = 30, locale = "en" } = options;
+  const tokens = tokenizeQuery(query);
+  const results = [];
+  for (const [name, metadata] of extendedRegistry) {
+    if (!passesFilters(metadata, filters)) {
+      continue;
+    }
+    const { score, matchedIn, highlights } = calculateMatchScore(
+      tokens,
+      query,
+      name,
+      metadata,
+      locale
+    );
+    if (score >= minScore) {
+      results.push({ name, metadata, score, matchedIn, highlights });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  const duration = performance.now() - startTime;
+  searchHistory.push({
+    query,
+    duration,
+    totalResults: results.length,
+    filters,
+    timestamp: Date.now()
+  });
+  return results.slice(0, maxResults);
 }
-/**
- * Check if metadata passes all filters.
- */
 function passesFilters(metadata, filters) {
-    var _a, _b, _c, _d;
-    // Category filter
-    if ((_a = filters.categories) === null || _a === void 0 ? void 0 : _a.length) {
-        const allCats = [metadata.primaryCategory, ...metadata.secondaryCategories];
-        if (!filters.categories.some((c) => allCats.includes(c))) {
-            return false;
-        }
-    }
-    // Domain filter
-    if ((_b = filters.domains) === null || _b === void 0 ? void 0 : _b.length) {
-        if (!filters.domains.some((d) => metadata.domains.includes(d))) {
-            return false;
-        }
-    }
-    // Use-case filter
-    if ((_c = filters.useCases) === null || _c === void 0 ? void 0 : _c.length) {
-        if (!filters.useCases.some((u) => metadata.useCases.includes(u))) {
-            return false;
-        }
-    }
-    // Style filter
-    if ((_d = filters.styles) === null || _d === void 0 ? void 0 : _d.length) {
-        if (!filters.styles.some((s) => metadata.styles.includes(s))) {
-            return false;
-        }
-    }
-    // Size filter
-    if (filters.minSize !== undefined) {
-        if (metadata.recommendedSizes[1] < filters.minSize) {
-            return false;
-        }
-    }
-    if (filters.maxSize !== undefined) {
-        if (metadata.recommendedSizes[0] > filters.maxSize) {
-            return false;
+  if (filters.categories?.length) {
+    const allCats = [metadata.primaryCategory, ...metadata.secondaryCategories];
+    if (!filters.categories.some((c) => allCats.includes(c))) {
+      return false;
+    }
+  }
+  if (filters.domains?.length) {
+    if (!filters.domains.some((d) => metadata.domains.includes(d))) {
+      return false;
+    }
+  }
+  if (filters.useCases?.length) {
+    if (!filters.useCases.some((u) => metadata.useCases.includes(u))) {
+      return false;
+    }
+  }
+  if (filters.styles?.length) {
+    if (!filters.styles.some((s) => metadata.styles.includes(s))) {
+      return false;
+    }
+  }
+  if (filters.minSize !== void 0) {
+    if (metadata.recommendedSizes[1] < filters.minSize) {
+      return false;
+    }
+  }
+  if (filters.maxSize !== void 0) {
+    if (metadata.recommendedSizes[0] > filters.maxSize) {
+      return false;
+    }
+  }
+  if (filters.excludeDeprecated && metadata.deprecated) {
+    return false;
+  }
+  if (filters.favoritesOnly && !favoriteIcons.has(metadata.name)) {
+    return false;
+  }
+  if (filters.recentlyUsedOnly) {
+    const isRecent = recentlyUsedIcons.some((r) => r.name === metadata.name);
+    if (!isRecent) {
+      return false;
+    }
+  }
+  if (filters.recentDays !== void 0 && metadata.dateAdded) {
+    const addedDate = new Date(metadata.dateAdded).getTime();
+    const cutoff = Date.now() - filters.recentDays * 24 * 60 * 60 * 1e3;
+    if (addedDate < cutoff) {
+      return false;
+    }
+  }
+  return true;
+}
+function calculateMatchScore(tokens, fullQuery, name, metadata, locale) {
+  let totalScore = 0;
+  const matchedIn = [];
+  const highlights = [];
+  const nameScore = fuzzyMatchScore(fullQuery, name);
+  if (nameScore > 30) {
+    totalScore += nameScore * 2;
+    matchedIn.push("name");
+    highlights.push({ field: "name", text: name });
+  }
+  for (const alias of metadata.aliases) {
+    const aliasScore = fuzzyMatchScore(fullQuery, alias);
+    if (aliasScore > 30) {
+      totalScore += aliasScore * 1.5;
+      if (!matchedIn.includes("alias")) {
+        matchedIn.push("alias");
+      }
+      highlights.push({ field: "alias", text: alias });
+    }
+  }
+  const localizedName = metadata.localizedNames[locale] || metadata.localizedNames.en;
+  if (localizedName && localizedName !== name) {
+    const localScore = fuzzyMatchScore(fullQuery, localizedName);
+    if (localScore > 30) {
+      totalScore += localScore * 1.3;
+      if (!matchedIn.includes("localized")) {
+        matchedIn.push("localized");
+      }
+      highlights.push({ field: "localized", text: localizedName });
+    }
+  }
+  for (const tag of metadata.tags) {
+    for (const token of tokens) {
+      const tagScore = fuzzyMatchScore(token, tag);
+      if (tagScore > 50) {
+        totalScore += tagScore * 0.7;
+        if (!matchedIn.includes("tag")) {
+          matchedIn.push("tag");
         }
-    }
-    // Deprecated filter
-    if (filters.excludeDeprecated && metadata.deprecated) {
-        return false;
-    }
-    // Favorites filter
-    if (filters.favoritesOnly && !favoriteIcons.has(metadata.name)) {
-        return false;
-    }
-    // Recently used filter
-    if (filters.recentlyUsedOnly) {
-        const isRecent = recentlyUsedIcons.some((r) => r.name === metadata.name);
-        if (!isRecent) {
-            return false;
+        highlights.push({ field: "tag", text: tag });
+      }
+    }
+  }
+  for (const keyword of metadata.searchKeywords) {
+    for (const token of tokens) {
+      const keywordScore = fuzzyMatchScore(token, keyword);
+      if (keywordScore > 50) {
+        totalScore += keywordScore * 0.8;
+        if (!matchedIn.includes("keyword")) {
+          matchedIn.push("keyword");
         }
-    }
-    // Recent days filter
-    if (filters.recentDays !== undefined && metadata.dateAdded) {
-        const addedDate = new Date(metadata.dateAdded).getTime();
-        const cutoff = Date.now() - filters.recentDays * 24 * 60 * 60 * 1000;
-        if (addedDate < cutoff) {
-            return false;
+        highlights.push({ field: "keyword", text: keyword });
+      }
+    }
+  }
+  if (metadata.description) {
+    for (const token of tokens) {
+      if (metadata.description.toLowerCase().includes(token)) {
+        totalScore += 15;
+        if (!matchedIn.includes("description")) {
+          matchedIn.push("description");
         }
+        highlights.push({ field: "description", text: metadata.description });
+        break;
+      }
     }
-    return true;
+  }
+  const normalizedScore = Math.min(100, Math.round(totalScore / (tokens.length || 1)));
+  return { score: normalizedScore, matchedIn, highlights };
 }
-/**
- * Calculate match score for an icon.
- */
-function calculateMatchScore(tokens, fullQuery, name, metadata, locale) {
-    let totalScore = 0;
-    const matchedIn = [];
-    const highlights = [];
-    // Match against name (highest weight)
-    const nameScore = fuzzyMatchScore(fullQuery, name);
-    if (nameScore > 30) {
-        totalScore += nameScore * 2; // 2x weight for name
-        matchedIn.push('name');
-        highlights.push({ field: 'name', text: name });
-    }
-    // Match against aliases
-    for (const alias of metadata.aliases) {
-        const aliasScore = fuzzyMatchScore(fullQuery, alias);
-        if (aliasScore > 30) {
-            totalScore += aliasScore * 1.5;
-            if (!matchedIn.includes('alias')) {
-                matchedIn.push('alias');
-            }
-            highlights.push({ field: 'alias', text: alias });
-        }
-    }
-    // Match against localized name
-    const localizedName = metadata.localizedNames[locale] || metadata.localizedNames.en;
-    if (localizedName && localizedName !== name) {
-        const localScore = fuzzyMatchScore(fullQuery, localizedName);
-        if (localScore > 30) {
-            totalScore += localScore * 1.3;
-            if (!matchedIn.includes('localized')) {
-                matchedIn.push('localized');
-            }
-            highlights.push({ field: 'localized', text: localizedName });
-        }
+function findSimilarIcons(iconName, limit = 10) {
+  const source = extendedRegistry.get(iconName);
+  if (!source) {
+    return [];
+  }
+  const similarities = [];
+  for (const [name, metadata] of extendedRegistry) {
+    if (name === iconName) {
+      continue;
+    }
+    let similarity = 0;
+    if (metadata.primaryCategory === source.primaryCategory) {
+      similarity += 30;
+    }
+    for (const cat of metadata.secondaryCategories) {
+      if (source.secondaryCategories.includes(cat)) {
+        similarity += 5;
+      }
+    }
+    for (const domain of metadata.domains) {
+      if (source.domains.includes(domain)) {
+        similarity += 10;
+      }
+    }
+    for (const useCase of metadata.useCases) {
+      if (source.useCases.includes(useCase)) {
+        similarity += 5;
+      }
     }
-    // Match against tags
     for (const tag of metadata.tags) {
-        for (const token of tokens) {
-            const tagScore = fuzzyMatchScore(token, tag);
-            if (tagScore > 50) {
-                totalScore += tagScore * 0.7;
-                if (!matchedIn.includes('tag')) {
-                    matchedIn.push('tag');
-                }
-                highlights.push({ field: 'tag', text: tag });
-            }
-        }
+      if (source.tags.includes(tag)) {
+        similarity += 3;
+      }
     }
-    // Match against keywords
-    for (const keyword of metadata.searchKeywords) {
-        for (const token of tokens) {
-            const keywordScore = fuzzyMatchScore(token, keyword);
-            if (keywordScore > 50) {
-                totalScore += keywordScore * 0.8;
-                if (!matchedIn.includes('keyword')) {
-                    matchedIn.push('keyword');
-                }
-                highlights.push({ field: 'keyword', text: keyword });
-            }
-        }
+    if (source.relatedIcons.includes(name)) {
+      similarity += 20;
     }
-    // Match against description
-    if (metadata.description) {
-        for (const token of tokens) {
-            if (metadata.description.toLowerCase().includes(token)) {
-                totalScore += 15;
-                if (!matchedIn.includes('description')) {
-                    matchedIn.push('description');
-                }
-                highlights.push({ field: 'description', text: metadata.description });
-                break; // Only count once for description
-            }
-        }
+    similarity += fuzzyMatchScore(iconName, name) / 5;
+    if (similarity > 20) {
+      similarities.push({ name, similarity: Math.min(100, similarity) });
     }
-    // Normalize score to 0-100
-    const normalizedScore = Math.min(100, Math.round(totalScore / (tokens.length || 1)));
-    return { score: normalizedScore, matchedIn, highlights };
+  }
+  similarities.sort((a, b) => b.similarity - a.similarity);
+  return similarities.slice(0, limit);
 }
-/* ══════════════════════════════════════════════════════════════════════════════
-   Similar Icons Finder
-   ══════════════════════════════════════════════════════════════════════════════ */
-/**
- * Find similar icons based on metadata overlap.
- */
-function findSimilarIcons(iconName, limit = 10) {
-    const source = extendedRegistry.get(iconName);
-    if (!source) {
-        return [];
+function getSearchSuggestions(partial, limit = 10) {
+  if (partial.length < 2) {
+    return [];
+  }
+  const p = partial.toLowerCase();
+  const suggestions = /* @__PURE__ */ new Set();
+  for (const [name, metadata] of extendedRegistry) {
+    if (name.toLowerCase().startsWith(p)) {
+      suggestions.add(name);
     }
-    const similarities = [];
-    for (const [name, metadata] of extendedRegistry) {
-        if (name === iconName) {
-            continue;
-        }
-        let similarity = 0;
-        // Same primary category (+30)
-        if (metadata.primaryCategory === source.primaryCategory) {
-            similarity += 30;
-        }
-        // Shared secondary categories (+5 each)
-        for (const cat of metadata.secondaryCategories) {
-            if (source.secondaryCategories.includes(cat)) {
-                similarity += 5;
-            }
-        }
-        // Shared domains (+10 each)
-        for (const domain of metadata.domains) {
-            if (source.domains.includes(domain)) {
-                similarity += 10;
-            }
-        }
-        // Shared use-cases (+5 each)
-        for (const useCase of metadata.useCases) {
-            if (source.useCases.includes(useCase)) {
-                similarity += 5;
-            }
-        }
-        // Shared tags (+3 each)
-        for (const tag of metadata.tags) {
-            if (source.tags.includes(tag)) {
-                similarity += 3;
-            }
-        }
-        // In related icons list (+20)
-        if (source.relatedIcons.includes(name)) {
-            similarity += 20;
-        }
-        // Similar name (+fuzzy score / 5)
-        similarity += fuzzyMatchScore(iconName, name) / 5;
-        if (similarity > 20) {
-            similarities.push({ name, similarity: Math.min(100, similarity) });
-        }
+    for (const alias of metadata.aliases) {
+      if (alias.toLowerCase().startsWith(p)) {
+        suggestions.add(alias);
+      }
     }
-    // Sort by similarity descending
-    similarities.sort((a, b) => b.similarity - a.similarity);
-    return similarities.slice(0, limit);
-}
-/* ══════════════════════════════════════════════════════════════════════════════
-   Search Suggestions / Autocomplete
-   ══════════════════════════════════════════════════════════════════════════════ */
-/**
- * Get search suggestions based on partial input.
- */
-function getSearchSuggestions(partial, limit = 10) {
-    if (partial.length < 2) {
-        return [];
+    for (const tag of metadata.tags) {
+      if (tag.toLowerCase().startsWith(p)) {
+        suggestions.add(tag);
+      }
     }
-    const p = partial.toLowerCase();
-    const suggestions = new Set();
-    for (const [name, metadata] of extendedRegistry) {
-        // Name starts with partial
-        if (name.toLowerCase().startsWith(p)) {
-            suggestions.add(name);
-        }
-        // Alias starts with partial
-        for (const alias of metadata.aliases) {
-            if (alias.toLowerCase().startsWith(p)) {
-                suggestions.add(alias);
-            }
-        }
-        // Tag starts with partial
-        for (const tag of metadata.tags) {
-            if (tag.toLowerCase().startsWith(p)) {
-                suggestions.add(tag);
-            }
-        }
-        if (suggestions.size >= limit * 2) {
-            break;
-        }
+    if (suggestions.size >= limit * 2) {
+      break;
     }
-    return Array.from(suggestions).slice(0, limit);
+  }
+  return Array.from(suggestions).slice(0, limit);
 }
-/* ══════════════════════════════════════════════════════════════════════════════
-   Analytics & Insights
-   ══════════════════════════════════════════════════════════════════════════════ */
-/**
- * Get search analytics summary.
- */
 function getSearchAnalytics() {
-    const queryCounts = new Map();
-    const zeroResults = [];
-    let totalDuration = 0;
-    for (const search of searchHistory) {
-        totalDuration += search.duration;
-        const count = queryCounts.get(search.query) || 0;
-        queryCounts.set(search.query, count + 1);
-        if (search.totalResults === 0) {
-            zeroResults.push(search.query);
-        }
-    }
-    // Top queries
-    const topQueries = Array.from(queryCounts.entries())
-        .map(([query, count]) => ({ query, count }))
-        .sort((a, b) => b.count - a.count)
-        .slice(0, 10);
-    return {
-        totalSearches: searchHistory.length,
-        averageDuration: searchHistory.length > 0 ? totalDuration / searchHistory.length : 0,
-        topQueries,
-        zeroResultQueries: [...new Set(zeroResults)].slice(0, 20),
-    };
+  const queryCounts = /* @__PURE__ */ new Map();
+  const zeroResults = [];
+  let totalDuration = 0;
+  for (const search of searchHistory) {
+    totalDuration += search.duration;
+    const count = queryCounts.get(search.query) || 0;
+    queryCounts.set(search.query, count + 1);
+    if (search.totalResults === 0) {
+      zeroResults.push(search.query);
+    }
+  }
+  const topQueries = Array.from(queryCounts.entries()).map(([query, count]) => ({ query, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+  return {
+    totalSearches: searchHistory.length,
+    averageDuration: searchHistory.length > 0 ? totalDuration / searchHistory.length : 0,
+    topQueries,
+    zeroResultQueries: [...new Set(zeroResults)].slice(0, 20)
+  };
 }
-/**
- * Get icon usage statistics.
- */
 function getIconUsageStats() {
-    // Count usage from history
-    const usageCounts = new Map();
-    for (const item of recentlyUsedIcons) {
-        const count = usageCounts.get(item.name) || 0;
-        usageCounts.set(item.name, count + 1);
-    }
-    // Most used
-    const mostUsed = Array.from(usageCounts.entries())
-        .map(([name, count]) => ({ name, count }))
-        .sort((a, b) => b.count - a.count)
-        .slice(0, 20);
-    // Find never used
-    const usedNames = new Set(recentlyUsedIcons.map((i) => i.name));
-    const neverUsed = [];
-    for (const name of extendedRegistry.keys()) {
-        if (!usedNames.has(name)) {
-            neverUsed.push(name);
-        }
-    }
-    // Least used (used once)
-    const leastUsed = Array.from(usageCounts.entries())
-        .filter(([_, count]) => count === 1)
-        .map(([name]) => name)
-        .slice(0, 20);
-    return { mostUsed, leastUsed, neverUsed };
+  const usageCounts = /* @__PURE__ */ new Map();
+  for (const item of recentlyUsedIcons) {
+    const count = usageCounts.get(item.name) || 0;
+    usageCounts.set(item.name, count + 1);
+  }
+  const mostUsed = Array.from(usageCounts.entries()).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count).slice(0, 20);
+  const usedNames = new Set(recentlyUsedIcons.map((i) => i.name));
+  const neverUsed = [];
+  for (const name of extendedRegistry.keys()) {
+    if (!usedNames.has(name)) {
+      neverUsed.push(name);
+    }
+  }
+  const leastUsed = Array.from(usageCounts.entries()).filter(([_, count]) => count === 1).map(([name]) => name).slice(0, 20);
+  return { mostUsed, leastUsed, neverUsed };
 }
-/**
- * Clear search history.
- */
 function clearSearchHistory() {
-    searchHistory.length = 0;
+  searchHistory.length = 0;
 }
-/**
- * Clear recently used.
- */
 function clearRecentlyUsed() {
-    recentlyUsedIcons.length = 0;
+  recentlyUsedIcons.length = 0;
 }
-/**
- * React hook for advanced icon search.
- */
-function useAdvancedIconSearch(debounceMs = 200, locale = 'en') {
-    const [query, setQuery] = React.useState('');
-    const [filters, setFilters] = React.useState({});
-    const [results, setResults] = React.useState([]);
-    const [isSearching, setIsSearching] = React.useState(false);
-    // Suggestions
-    const suggestions = React.useMemo(() => {
-        return query.length >= 2 ? getSearchSuggestions(query) : [];
-    }, [query]);
-    // Debounced search
-    React.useEffect(() => {
-        if (!query && !Object.keys(filters).length) {
-            setResults([]);
-            return;
-        }
-        setIsSearching(true);
-        const timer = setTimeout(() => {
-            const searchResults = advancedSearch(query, filters, { locale });
-            setResults(searchResults);
-            setIsSearching(false);
-        }, debounceMs);
-        return () => clearTimeout(timer);
-    }, [query, filters, debounceMs, locale]);
-    const search = React.useCallback(() => {
-        setIsSearching(true);
-        const searchResults = advancedSearch(query, filters, { locale });
-        setResults(searchResults);
-        setIsSearching(false);
-    }, [query, filters, locale]);
-    const clearFilters = React.useCallback(() => {
-        setFilters({});
-    }, []);
-    return {
-        query,
-        setQuery,
-        filters,
-        setFilters,
-        results,
-        isSearching,
-        suggestions,
-        search,
-        clearFilters,
-    };
+function useAdvancedIconSearch(debounceMs = 200, locale = "en") {
+  const [query, setQuery] = React.useState("");
+  const [filters, setFilters] = React.useState({});
+  const [results, setResults] = React.useState([]);
+  const [isSearching, setIsSearching] = React.useState(false);
+  const suggestions = React.useMemo(() => {
+    return query.length >= 2 ? getSearchSuggestions(query) : [];
+  }, [query]);
+  React.useEffect(() => {
+    if (!query && !Object.keys(filters).length) {
+      setResults([]);
+      return;
+    }
+    setIsSearching(true);
+    const timer = setTimeout(() => {
+      const searchResults = advancedSearch(query, filters, { locale });
+      setResults(searchResults);
+      setIsSearching(false);
+    }, debounceMs);
+    return () => clearTimeout(timer);
+  }, [query, filters, debounceMs, locale]);
+  const search = React.useCallback(() => {
+    setIsSearching(true);
+    const searchResults = advancedSearch(query, filters, { locale });
+    setResults(searchResults);
+    setIsSearching(false);
+  }, [query, filters, locale]);
+  const clearFilters = React.useCallback(() => {
+    setFilters({});
+  }, []);
+  return {
+    query,
+    setQuery,
+    filters,
+    setFilters,
+    results,
+    isSearching,
+    suggestions,
+    search,
+    clearFilters
+  };
 }
-
 exports.advancedSearch = advancedSearch;
 exports.clearRecentlyUsed = clearRecentlyUsed;
 exports.clearSearchHistory = clearSearchHistory;