@robosophy/ui-react 1.0.0

package/dist/vite.js

@@ -0,0 +1,1026 @@
+// AUTO-GENERATED FILE. DO NOT EDIT MANUALLY.
+import {
+  GRADE_VARIANTS,
+  clampGrade
+} from "./chunk-D4ZW5VUU.js";
+
+// src/vite.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { extname, join } from "path";
+import { fileURLToPath } from "url";
+var families = ["outlined", "rounded", "sharp"];
+var defaultFamily = "outlined";
+var iconNamePattern = /^[a-z0-9_]+$/;
+var sourceExtensions = /* @__PURE__ */ new Set([".js", ".jsx", ".mjs", ".ts", ".tsx"]);
+var skippedDirs = /* @__PURE__ */ new Set([".git", "dist", "node_modules", "storybook-static"]);
+var cssPropertyValues = /* @__PURE__ */ new Set([
+  "auto",
+  "block",
+  "center",
+  "contain",
+  "cover",
+  "flex",
+  "grid",
+  "hidden",
+  "inherit",
+  "initial",
+  "left",
+  "middle",
+  "none",
+  "normal",
+  "pointer",
+  "relative",
+  "right",
+  "solid",
+  "static",
+  "stretch",
+  "text",
+  "top",
+  "unset"
+]);
+var internalIconNames = [
+  "arrow_drop_down",
+  "arrow_drop_up",
+  "arrow_left",
+  "chevron_right",
+  "close",
+  "login",
+  "nest_eco_leaf"
+];
+var GITHUB_RAW = "https://raw.githubusercontent.com/google/material-design-icons/master/symbols/web";
+var CACHE_BASE = join("node_modules", ".cache", "robosophy-svgs");
+var BASE_OPSZ = 24;
+var DEFAULT_WEIGHT = 400;
+function variantKey(grade, fill, weight) {
+  return `${clampGrade(grade)}:${fill ? 1 : 0}:${weight}`;
+}
+function parseVariantKey(key) {
+  const [grade, fill, weight] = key.split(":").map(Number);
+  return { grade, fill: fill === 1, weight };
+}
+function robosophyMaterialSymbols(options = {}) {
+  const raw = (options.outputDir ?? "").trim().replace(/^\/+/, "");
+  const outputDir = raw.split("/").filter((part) => part && part !== "..").join("/") || "assets";
+  let config;
+  let cacheDir;
+  let cachedAssets = null;
+  let cachedUsagesKey = "";
+  let needsRegeneration = true;
+  function usageMapKey(usages) {
+    const parts = [];
+    for (const family of families) {
+      const iconVariants = usages.get(family);
+      if (!iconVariants || iconVariants.size === 0) continue;
+      const entries = [...iconVariants.entries()].map(([name, variants]) => `${name}[${[...variants].sort().join(";")}]`).sort();
+      parts.push(`${family}:${entries.join(",")}`);
+    }
+    return parts.join("|") || "(empty)";
+  }
+  async function getAssets() {
+    if (!needsRegeneration && cachedAssets) return cachedAssets;
+    const usages = await collectMaterialSymbolUsages(config, options);
+    const newKey = usageMapKey(usages);
+    if (newKey === cachedUsagesKey && cachedAssets) {
+      needsRegeneration = false;
+      return cachedAssets;
+    }
+    if (config.command !== "build" && cachedUsagesKey !== "") {
+      config.logger.info(
+        "[robosophy-material-symbols] icon usage changed, regenerating SVG sprite"
+      );
+    }
+    cachedUsagesKey = newKey;
+    cachedAssets = await generateSpriteAssets(usages, cacheDir, config);
+    needsRegeneration = false;
+    return cachedAssets;
+  }
+  return {
+    name: "robosophy-material-symbols",
+    async configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      cacheDir = join(config.root, CACHE_BASE);
+      await mkdir(cacheDir, { recursive: true });
+    },
+    async buildStart() {
+      if (config.command === "serve" || config.command === "build") {
+        await getAssets();
+      }
+    },
+    async transformIndexHtml() {
+      const assets = await getAssets();
+      const tag = {
+        tag: "svg",
+        attrs: {
+          xmlns: "http://www.w3.org/2000/svg",
+          style: "display:none;",
+          "aria-hidden": "true"
+        },
+        children: assets.spriteContent,
+        injectTo: "body-prepend"
+      };
+      return [tag, ...buildMaterialSymbolsCss(assets.css)];
+    },
+    configureServer(server) {
+      server.watcher.on("all", (_event, file) => {
+        if (sourceExtensions.has(extname(file))) {
+          needsRegeneration = true;
+        }
+      });
+      server.middlewares.use(async (request, response, next) => {
+        if (!request.url?.startsWith("/@robosophy-material-symbols/")) {
+          next();
+          return;
+        }
+        try {
+          const assets = await getAssets();
+          const fileName = decodeURIComponent(
+            request.url.replace("/@robosophy-material-symbols/", "").split("?")[0] ?? ""
+          );
+          if (fileName === "rs-material-symbols.svg") {
+            response.setHeader("Content-Type", "image/svg+xml; charset=utf-8");
+            response.setHeader("Cache-Control", "no-cache");
+            response.end(assets.fullSprite);
+            return;
+          }
+          next();
+        } catch (error) {
+          next(error);
+        }
+      });
+    },
+    async generateBundle() {
+    }
+  };
+}
+function buildSvgVariant(grade, fill, weight = DEFAULT_WEIGHT) {
+  const clampedGrade = clampGrade(grade);
+  const gradeSuffix = clampedGrade === 0 ? "" : clampedGrade > 0 ? `grad${clampedGrade}` : `gradN${Math.abs(clampedGrade)}`;
+  const symbolGradeSuffix = clampedGrade === 0 ? "" : `-${gradeSuffix}`;
+  const fillSuffix = fill ? "fill1" : "";
+  const symbolFillSuffix = fill ? "-fill" : "";
+  const weightSuffix = weight !== DEFAULT_WEIGHT ? `wght${weight}` : "";
+  const weightSymbolSuffix = weight !== DEFAULT_WEIGHT ? `-wght${weight}` : "";
+  const parts = [gradeSuffix, fillSuffix, weightSuffix].filter(Boolean);
+  return {
+    suffix: parts.length > 0 ? `${parts.join("")}_${BASE_OPSZ}px` : `${BASE_OPSZ}px`,
+    symbolSuffix: `${symbolGradeSuffix}${symbolFillSuffix}${weightSymbolSuffix}`
+  };
+}
+function buildSvgUrl(name, family, suffix) {
+  const style = family === "outlined" ? "materialsymbolsoutlined" : family === "rounded" ? "materialsymbolsrounded" : "materialsymbolssharp";
+  return `${GITHUB_RAW}/${name.toLowerCase()}/${style}/${name.toLowerCase()}_${suffix}.svg`;
+}
+function buildSymbolId(name, family, symbolSuffix) {
+  return `rs-icon-${family}-${name}${symbolSuffix}`;
+}
+async function fetchSvg(url) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) return null;
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+async function loadSvgFromCache(cacheDir, cacheKey) {
+  const cachePath = join(cacheDir, `${cacheKey}.svg`);
+  try {
+    return await readFile(cachePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function saveSvgToCache(cacheDir, cacheKey, content) {
+  const cachePath = join(cacheDir, `${cacheKey}.svg`);
+  try {
+    await writeFile(cachePath, content, "utf8");
+  } catch {
+  }
+}
+function parseSvgPaths(svgContent) {
+  const viewBoxMatch = svgContent.match(/viewBox="([^"]+)"/i);
+  if (!viewBoxMatch) return null;
+  const paths = [];
+  const pathRegex = /<path\s+([^>]*)>/g;
+  let pathMatch;
+  while (pathMatch = pathRegex.exec(svgContent)) {
+    const attrs = pathMatch[1] ?? "";
+    const dMatch = attrs.match(/d="([^"]*)"/);
+    if (dMatch) {
+      paths.push(dMatch[1] ?? "");
+    }
+  }
+  if (paths.length === 0) return null;
+  return paths.map((d) => `<path fill="currentColor" d="${d}"/>`).join("");
+}
+async function generateSpriteAssets(usages, cacheDir, config) {
+  const symbols = [];
+  const iconClasses = [];
+  const skipped = /* @__PURE__ */ new Map();
+  let totalFetched = 0;
+  let totalBytes = 0;
+  for (const family of families) {
+    const iconVariants = usages.get(family);
+    if (!iconVariants || iconVariants.size === 0) continue;
+    for (const [name, variants] of [...iconVariants.entries()].sort()) {
+      for (const key of [...variants].sort()) {
+        const { grade, fill, weight } = parseVariantKey(key);
+        const variant = buildSvgVariant(grade, fill, weight);
+        const symbolId = buildSymbolId(name, family, variant.symbolSuffix);
+        const url = buildSvgUrl(name, family, variant.suffix);
+        const cacheKey = createHash("sha256").update(url).digest("hex").slice(0, 12);
+        let svgContent = cacheDir ? await loadSvgFromCache(cacheDir, cacheKey) : null;
+        if (!svgContent) {
+          svgContent = await fetchSvg(url);
+          if (!svgContent) {
+            skipped.set(`${family}/${name}`, "fetch fall\xF3");
+            continue;
+          }
+          if (cacheDir) {
+            await saveSvgToCache(cacheDir, cacheKey, svgContent);
+          }
+        }
+        const pathContent = parseSvgPaths(svgContent);
+        if (!pathContent) {
+          skipped.set(`${family}/${name}`, "sin viewBox / formato viejo");
+          continue;
+        }
+        symbols.push(
+          `<symbol id="${symbolId}" viewBox="0 -960 960 960" fill="currentColor">${pathContent}</symbol>`
+        );
+        totalFetched++;
+        totalBytes += svgContent.length;
+      }
+    }
+  }
+  const iconNames = /* @__PURE__ */ new Set();
+  for (const family of families) {
+    const iconVariants = usages.get(family);
+    if (iconVariants) {
+      for (const name of iconVariants.keys()) {
+        iconNames.add(name);
+      }
+    }
+  }
+  for (const name of [...iconNames].sort()) {
+    iconClasses.push(`.rs-icon-${name} { --rs-icon-content: "${name}"; }`);
+  }
+  const spriteContent = `<defs>${symbols.join("")}</defs>`;
+  const fullSprite = `<svg xmlns="http://www.w3.org/2000/svg" style="display:none" aria-hidden="true">${spriteContent}</svg>`;
+  const css = iconClasses.join("\n");
+  const totalIcons = [...usages.values()].reduce((sum, m) => sum + m.size, 0);
+  if (skipped.size > 0) {
+    const lines = [...skipped.entries()].map(([key, reason]) => `${key} (${reason})`);
+    config.logger.warn(
+      `[robosophy-material-symbols] ${skipped.size} \xEDconos omitidos, van a renderizar vac\xEDos:
+  ${lines.join("\n  ")}`
+    );
+  }
+  if (totalIcons > 0) {
+    const summary = formatDetectedMaterialSymbols(usages);
+    config.logger.info(
+      `[robosophy-material-symbols] ${totalIcons} icons detected, ${totalFetched} SVG variants (${(totalBytes / 1024).toFixed(1)} KB)
+${summary}`
+    );
+  } else {
+    config.logger.warn(
+      "[robosophy-material-symbols] No Material Symbols icons detected in source. Add them via the include option."
+    );
+  }
+  return { fullSprite, spriteContent, css };
+}
+async function collectMaterialSymbolUsages(config, options = {}) {
+  const usages = createUsageMap();
+  const manifest = await loadIconManifest();
+  if (manifest) {
+    for (const family of families) {
+      for (const name of manifest[family] ?? []) {
+        addUsage(usages, { family, name });
+      }
+    }
+  } else {
+    for (const name of internalIconNames) {
+      for (const family of families) {
+        addUsage(usages, { family, name });
+      }
+    }
+  }
+  for (const icon of options.include ?? []) {
+    const resolved = typeof icon === "string" ? { family: defaultFamily, name: icon } : icon;
+    addUsage(usages, resolved);
+  }
+  if (options.scan !== false) {
+    const roots = options.roots ?? [join(config.root, "src")];
+    const sources = await readAllSources(roots);
+    for (const source of sources.values()) {
+      collectFromSource(source, usages);
+    }
+    const proxyComponents = findIconProxyComponents(sources);
+    if (proxyComponents.size > 0) {
+      for (const source of sources.values()) {
+        collectProxyIconUsages(source, proxyComponents, usages);
+      }
+    }
+  }
+  return usages;
+}
+function buildMaterialSymbolsCss(iconClasses) {
+  if (!iconClasses) return [];
+  return [
+    {
+      tag: "style",
+      children: iconClasses,
+      injectTo: "head"
+    }
+  ];
+}
+function skipStringBackward(source, pos, quote) {
+  pos--;
+  while (pos >= 0) {
+    if (source[pos] === "\\") {
+      pos -= 2;
+      continue;
+    }
+    if (source[pos] === quote) {
+      let backslashCount = 0;
+      let k = pos - 1;
+      while (k >= 0 && source[k] === "\\") {
+        backslashCount++;
+        k--;
+      }
+      if (backslashCount % 2 === 1) {
+        pos = pos - backslashCount - 1;
+        continue;
+      }
+      return pos - 1;
+    }
+    pos--;
+  }
+  return -1;
+}
+function skipStringForward(source, pos, quote) {
+  pos++;
+  while (pos < source.length) {
+    if (source[pos] === "\\") {
+      pos += 2;
+      continue;
+    }
+    if (source[pos] === quote) {
+      return pos + 1;
+    }
+    pos++;
+  }
+  return source.length;
+}
+function findEnclosingObject(source, fromIndex) {
+  let depth = 0;
+  let i = fromIndex;
+  while (i >= 0) {
+    const char = source[i];
+    if (char === '"' || char === "'" || char === "`") {
+      i = skipStringBackward(source, i, char);
+      continue;
+    }
+    if (char === "/" && i > 0 && source[i - 1] === "/") {
+      i -= 2;
+      while (i >= 0 && source[i] !== "\n") i--;
+      continue;
+    }
+    if (char === "/" && i > 0 && source[i - 1] === "*") {
+      i -= 2;
+      while (i >= 0) {
+        if (source[i] === "/" && i + 1 < source.length && source[i + 1] === "*") {
+          i--;
+          break;
+        }
+        i--;
+      }
+      continue;
+    }
+    if (char === "}") {
+      depth++;
+    } else if (char === "{") {
+      if (depth === 0) {
+        const start = i;
+        let j = i + 1;
+        let innerDepth = 1;
+        while (j < source.length) {
+          const c = source[j];
+          if (c === '"' || c === "'" || c === "`") {
+            j = skipStringForward(source, j, c);
+            continue;
+          }
+          if (c === "/") {
+            if (j + 1 < source.length && source[j + 1] === "/") {
+              j += 2;
+              while (j < source.length && source[j] !== "\n") j++;
+              continue;
+            }
+            if (j + 1 < source.length && source[j + 1] === "*") {
+              j += 2;
+              while (j + 1 < source.length) {
+                if (source[j] === "*" && source[j + 1] === "/") {
+                  j += 2;
+                  break;
+                }
+                j++;
+              }
+              continue;
+            }
+          }
+          if (c === "{") innerDepth++;
+          else if (c === "}") {
+            innerDepth--;
+            if (innerDepth === 0) {
+              return {
+                start,
+                end: j,
+                body: source.slice(start + 1, j)
+              };
+            }
+          }
+          j++;
+        }
+        return null;
+      }
+      depth--;
+    }
+    i--;
+  }
+  return null;
+}
+function isDynamicNonLiteral(attrs, name) {
+  const bound = attrs[`:${name}`];
+  if (bound === void 0) return false;
+  if (bound === "true" || bound === "false" || /^-?\d+$/.test(bound.trim())) return false;
+  return true;
+}
+function collectFromSource(source, usages) {
+  const rsIconTagPattern = /<RsIcon\b([\s\S]*?)\/?>/g;
+  let tagMatch;
+  while (tagMatch = rsIconTagPattern.exec(source)) {
+    const attrsSource = tagMatch[1] ?? "";
+    const attrs = parseStaticAttributes(attrsSource);
+    const jsxAttrs = parseJsxAttributes(attrsSource);
+    const rawName = attrs.name ?? attrs[":name"] ?? jsxAttrs.name;
+    const hasFamily = "family" in attrs || ":family" in attrs || "family" in jsxAttrs;
+    const rawFamily = attrs.family ?? attrs[":family"] ?? jsxAttrs.family ?? "";
+    const weight = jsxAttrs.weight ?? parseNumberAttr(attrs, "weight", DEFAULT_WEIGHT);
+    const resolvedWeight = weight > 0 ? weight : DEFAULT_WEIGHT;
+    const fill = parseBooleanAttr(attrs, attrsSource, "fill") || jsxAttrs.fill === true;
+    const grade = jsxAttrs.grade ?? parseNumberAttr(attrs, "grade", 0);
+    if (rawName) {
+      const isNameDynamic = ":name" in attrs || jsxAttrs.nameDynamic === true;
+      const familyList = resolveFamilies(rawFamily, hasFamily);
+      const names = resolveNames(rawName, isNameDynamic);
+      const isFillDynamic = isDynamicNonLiteral(attrs, "fill") || jsxAttrs.fillDynamic === true;
+      const isGradeDynamic = isDynamicNonLiteral(attrs, "grade") || jsxAttrs.gradeDynamic === true;
+      const isWeightDynamic = isDynamicNonLiteral(attrs, "weight") || jsxAttrs.weightDynamic === true;
+      const fills = isFillDynamic ? [false, true] : [fill];
+      const grades = isGradeDynamic ? [...GRADE_VARIANTS] : [grade];
+      const weights = isWeightDynamic ? [...VALID_WEIGHTS] : [resolvedWeight];
+      for (const family of familyList) {
+        for (const name of names) {
+          for (const g of grades) {
+            for (const f of fills) {
+              for (const w of weights) {
+                addUsage(usages, { family, name, grade: g, fill: f, weight: w });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const primeHelperPattern = /\brsPrimeIcon\(\s*["'`]([a-z0-9_]+)["'`](?:\s*,\s*\{([^)]*)\})?/g;
+  let helperMatch;
+  while (helperMatch = primeHelperPattern.exec(source)) {
+    const family = toFamily(helperMatch[2]?.match(/\bfamily\s*:\s*["'](\w+)["']/)?.[1]);
+    addUsage(usages, {
+      family: family ?? defaultFamily,
+      name: helperMatch[1] ?? ""
+    });
+  }
+  const objectIconPattern = /\bicon\s*:\s*["'`]([a-z0-9_]+)["'`]/g;
+  let objectMatch;
+  while (objectMatch = objectIconPattern.exec(source)) {
+    const name = objectMatch[1] ?? "";
+    const obj = findEnclosingObject(source, objectMatch.index);
+    if (obj) {
+      const cleanBody = obj.body.replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+      const weightMatch = cleanBody.match(/\bweight\s*:\s*(\d+)/);
+      const familyMatch = cleanBody.match(/\bfamily\s*:\s*["'](\w+)["']/);
+      const fillMatch = cleanBody.match(/\bfill\s*:\s*(true|false)/);
+      const gradeMatch = cleanBody.match(/\bgrade\s*:\s*(-?\d+)/);
+      addUsage(usages, {
+        family: familyMatch ? familyMatch[1] : defaultFamily,
+        name,
+        weight: weightMatch ? parseInt(weightMatch[1], 10) : void 0,
+        fill: fillMatch ? fillMatch[1] === "true" : void 0,
+        grade: gradeMatch ? parseInt(gradeMatch[1], 10) : void 0
+      });
+    } else {
+      addUsage(usages, { family: defaultFamily, name });
+    }
+  }
+  const magicCommentPattern = /(?:\/\/|\/\*)\s*@robosophy-icon:\s*([a-z0-9_]+)/g;
+  let magicMatch;
+  while (magicMatch = magicCommentPattern.exec(source)) {
+    const name = magicMatch[1] ?? "";
+    const lineEnd = source.indexOf("\n", magicMatch.index);
+    const line = lineEnd === -1 ? source.slice(magicMatch.index) : source.slice(magicMatch.index, lineEnd);
+    const familyMatch = line.match(/\bfamily\s*=\s*["']?(\w+)["']?/);
+    const weightMatch = line.match(/\bweight\s*=\s*(\d+)/);
+    const fillMatch = line.match(/\bfill\s*=\s*(true|false)/);
+    const gradeMatch = line.match(/\bgrade\s*=\s*(-?\d+)/);
+    addUsage(usages, {
+      family: familyMatch ? familyMatch[1] : defaultFamily,
+      name,
+      weight: weightMatch ? parseInt(weightMatch[1], 10) : void 0,
+      fill: fillMatch ? fillMatch[1] === "true" : void 0,
+      grade: gradeMatch ? parseInt(gradeMatch[1], 10) : void 0
+    });
+  }
+  const iconArrayPattern = /(?:const|let|var)\s+(\w*[Ii]con\w*)\s*=\s*\[/g;
+  let arrayMatch;
+  while (arrayMatch = iconArrayPattern.exec(source)) {
+    const bracketStart = arrayMatch.index + arrayMatch[0].length - 1;
+    let depth = 1;
+    let j = bracketStart + 1;
+    while (j < source.length) {
+      const c = source[j];
+      if (c === '"' || c === "'" || c === "`") {
+        j = skipStringForward(source, j, c);
+        continue;
+      }
+      if (c === "/") {
+        if (j + 1 < source.length && source[j + 1] === "/") {
+          j += 2;
+          while (j < source.length && source[j] !== "\n") j++;
+          continue;
+        }
+        if (j + 1 < source.length && source[j + 1] === "*") {
+          j += 2;
+          while (j + 1 < source.length) {
+            if (source[j] === "*" && source[j + 1] === "/") {
+              j += 2;
+              break;
+            }
+            j++;
+          }
+          continue;
+        }
+      }
+      if (c === "[") depth++;
+      else if (c === "]") {
+        depth--;
+        if (depth === 0) break;
+      }
+      j++;
+    }
+    if (depth === 0) {
+      const arrayContent = source.slice(bracketStart + 1, j);
+      let braceDepth = 0;
+      let bracketDepth = 0;
+      let k = 0;
+      while (k < arrayContent.length) {
+        const c = arrayContent[k];
+        if (c === '"' || c === "'" || c === "`") {
+          if (braceDepth === 0) {
+            const quote = c;
+            let strEnd = k + 1;
+            while (strEnd < arrayContent.length) {
+              if (arrayContent[strEnd] === "\\") {
+                strEnd += 2;
+                continue;
+              }
+              if (arrayContent[strEnd] === quote) break;
+              strEnd++;
+            }
+            const iconName = arrayContent.slice(k + 1, strEnd);
+            if (iconNamePattern.test(iconName) && !cssPropertyValues.has(iconName) && !/^\d/.test(iconName)) {
+              addUsage(usages, { family: defaultFamily, name: iconName });
+            }
+            k = strEnd + 1;
+            continue;
+          } else {
+            k = skipStringForward(arrayContent, k, c);
+            continue;
+          }
+        }
+        if (c === "{") braceDepth++;
+        else if (c === "}") braceDepth--;
+        else if (c === "[") bracketDepth++;
+        else if (c === "]") bracketDepth--;
+        k++;
+      }
+    }
+  }
+  const iconObjectPattern = /(?:const|let|var)\s+(\w*(?:[Ii]cons|[Ii]con(?:Map|List|Names?|Array|Set|Data|Items|Entries))\w*)[^=]*=\s*\{/g;
+  let objMatch;
+  while (objMatch = iconObjectPattern.exec(source)) {
+    const braceStart = objMatch.index + objMatch[0].length - 1;
+    let depth = 1;
+    let j = braceStart + 1;
+    while (j < source.length) {
+      const c = source[j];
+      if (c === '"' || c === "'" || c === "`") {
+        j = skipStringForward(source, j, c);
+        continue;
+      }
+      if (c === "/") {
+        if (j + 1 < source.length && source[j + 1] === "/") {
+          j += 2;
+          while (j < source.length && source[j] !== "\n") j++;
+          continue;
+        }
+        if (j + 1 < source.length && source[j + 1] === "*") {
+          j += 2;
+          while (j + 1 < source.length) {
+            if (source[j] === "*" && source[j + 1] === "/") {
+              j += 2;
+              break;
+            }
+            j++;
+          }
+          continue;
+        }
+      }
+      if (c === "{") depth++;
+      else if (c === "}") {
+        depth--;
+        if (depth === 0) break;
+      }
+      j++;
+    }
+    if (depth === 0) {
+      const bodyContent = source.slice(braceStart + 1, j);
+      let braceDepth = 0;
+      let k = 0;
+      while (k < bodyContent.length) {
+        const c = bodyContent[k];
+        if (c === '"' || c === "'" || c === "`") {
+          if (braceDepth === 0) {
+            const quote = c;
+            let strEnd = k + 1;
+            while (strEnd < bodyContent.length) {
+              if (bodyContent[strEnd] === "\\") {
+                strEnd += 2;
+                continue;
+              }
+              if (bodyContent[strEnd] === quote) break;
+              strEnd++;
+            }
+            const iconName = bodyContent.slice(k + 1, strEnd);
+            if (iconNamePattern.test(iconName) && !cssPropertyValues.has(iconName) && !/^\d/.test(iconName)) {
+              addUsage(usages, { family: defaultFamily, name: iconName });
+            }
+            k = strEnd + 1;
+            continue;
+          } else {
+            k = skipStringForward(bodyContent, k, c);
+            continue;
+          }
+        }
+        if (c === "{") braceDepth++;
+        else if (c === "}") braceDepth--;
+        k++;
+      }
+    }
+  }
+  const componentIconPattern = /<([A-Z][a-zA-Z0-9_]*)\b([\s\S]*?)\/?>/g;
+  let compMatch;
+  while (compMatch = componentIconPattern.exec(source)) {
+    const tagName = compMatch[1];
+    if (tagName === "RsIcon") continue;
+    const attrs = parseStaticAttributes(compMatch[2] ?? "");
+    const jsxAttrs = parseJsxAttributes(compMatch[2] ?? "");
+    const iconValue = attrs.icon ?? attrs.iconName ?? attrs["icon-name"];
+    if (iconValue && iconNamePattern.test(iconValue)) {
+      addUsage(usages, { family: defaultFamily, name: iconValue });
+    }
+  }
+}
+async function readAllSources(roots) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const root of roots) {
+    for (const filePath of await listSourceFiles(root)) {
+      if (!sources.has(filePath)) {
+        sources.set(filePath, await readFile(filePath, "utf8"));
+      }
+    }
+  }
+  return sources;
+}
+function findIconProxyComponents(sources) {
+  const proxyComponents = /* @__PURE__ */ new Map();
+  for (const source of sources.values()) {
+    const explicitProxyPattern = /\/\/\s*@robosophy-icon-proxy:\s*([A-Z][a-zA-Z0-9_]*)\s+([a-zA-Z_][a-zA-Z0-9_]*)/g;
+    let explicitMatch;
+    while (explicitMatch = explicitProxyPattern.exec(source)) {
+      proxyComponents.set(explicitMatch[1], explicitMatch[2]);
+    }
+    const rsIconPattern = /<RsIcon[^>]*?name\s*=\s*\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+    let match;
+    while (match = rsIconPattern.exec(source)) {
+      const internalVarName = match[1];
+      const rsIconPos = match.index;
+      const sourceBefore = source.slice(0, rsIconPos);
+      const componentDefs = [];
+      const funcPattern = /function\s+([A-Z][a-zA-Z0-9_]*)\s*\(([^)]*)\)/g;
+      let funcMatch;
+      while (funcMatch = funcPattern.exec(sourceBefore)) {
+        componentDefs.push({ name: funcMatch[1], pos: funcMatch.index, isDefault: false, params: funcMatch[2] ?? "" });
+      }
+      const constPattern = /const\s+([A-Z][a-zA-Z0-9_]*)\s*=\s*(?:function\s*\(([^)]*)\)|forwardRef\s*\(([^)]*)\)|\(([^)]*)\))/g;
+      let constMatch;
+      while (constMatch = constPattern.exec(sourceBefore)) {
+        const params = constMatch[2] ?? constMatch[3] ?? constMatch[4] ?? "";
+        componentDefs.push({ name: constMatch[1], pos: constMatch.index, isDefault: false, params });
+      }
+      const defaultExportPattern = /export\s+default\s+(?:function\s+)?([A-Z][a-zA-Z0-9_]*)/;
+      const defaultMatch = source.match(defaultExportPattern);
+      if (defaultMatch) {
+        const defaultName = defaultMatch[1];
+        const def = componentDefs.find((d) => d.name === defaultName);
+        if (def) {
+          def.isDefault = true;
+        }
+      }
+      if (componentDefs.length > 0) {
+        componentDefs.sort((a, b) => b.pos - a.pos);
+        const defaultExport = componentDefs.find((d) => d.isDefault);
+        const closestComponent = defaultExport ?? componentDefs[0];
+        const resolvedProp = resolvePropFromDestructuring(closestComponent.params, internalVarName);
+        if (resolvedProp) {
+          proxyComponents.set(closestComponent.name, resolvedProp);
+        }
+      }
+    }
+  }
+  return proxyComponents;
+}
+function resolvePropFromDestructuring(params, internalVarName) {
+  const trimmed = params.trim();
+  if (!trimmed) return null;
+  if (!trimmed.startsWith("{")) return null;
+  const braceEnd = findMatchingBrace(trimmed, 0);
+  if (braceEnd === -1) return null;
+  const body = trimmed.slice(1, braceEnd);
+  const aliasPattern = new RegExp(
+    `\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*${escapeRegex(internalVarName)}\\b`
+  );
+  const aliasMatch = body.match(aliasPattern);
+  if (aliasMatch) return aliasMatch[1] ?? null;
+  const shorthandPattern = new RegExp(`\\b${escapeRegex(internalVarName)}\\b`);
+  if (shorthandPattern.test(body)) return internalVarName;
+  return null;
+}
+function findMatchingBrace(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    if (s[i] === "{") depth++;
+    else if (s[i] === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function collectProxyIconUsages(source, proxyComponents, usages) {
+  for (const [compName, propName] of proxyComponents) {
+    const pattern = new RegExp(
+      `<${compName}\\b([\\s\\S]*?)>`,
+      "g"
+    );
+    let tagMatch;
+    while (tagMatch = pattern.exec(source)) {
+      const attrs = parseStaticAttributes(tagMatch[1] ?? "");
+      const value = attrs[propName];
+      if (value && iconNamePattern.test(value)) {
+        addUsage(usages, { family: defaultFamily, name: value });
+      }
+    }
+  }
+}
+function parseBooleanAttr(attrs, raw, name) {
+  const bound = attrs[`:${name}`];
+  if (bound === "false") return false;
+  if (bound === "true" || bound === "") return true;
+  const staticVal = attrs[name];
+  if (staticVal === "false") return false;
+  if (staticVal === "true" || staticVal === "") return true;
+  return new RegExp(`(?:^|\\s)${name}(?:\\s|$|(?==))`).test(raw);
+}
+function parseNumberAttr(attrs, name, fallback) {
+  const raw = attrs[name] ?? attrs[`:${name}`] ?? "";
+  const parsed = parseInt(raw, 10);
+  return !isNaN(parsed) ? parsed : fallback;
+}
+function parseStaticAttributes(source) {
+  const attrs = {};
+  const attrPattern = /([:@\w-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+  let match;
+  while (match = attrPattern.exec(source)) {
+    attrs[match[1] ?? ""] = match[2] ?? match[3] ?? "";
+  }
+  return attrs;
+}
+function parseJsxAttributes(source) {
+  const result = {};
+  const nameStaticMatch = source.match(/\bname\s*=\s*["']([a-z0-9_]+)["']/i);
+  if (nameStaticMatch) {
+    result.name = nameStaticMatch[1];
+  }
+  const nameDynamicMatch = source.match(/\bname\s*=\s*\{([^}]+)\}/);
+  if (nameDynamicMatch) {
+    const value = nameDynamicMatch[1]?.trim() ?? "";
+    const stringLiteralMatch = value.match(/^["'`]([a-z0-9_]+)["'`]$/);
+    if (stringLiteralMatch) {
+      result.name = stringLiteralMatch[1];
+    } else {
+      const ternaryStrings = value.match(/["'`]([a-z0-9_]+)["'`]/g);
+      if (ternaryStrings && ternaryStrings.length > 0) {
+        const names = ternaryStrings.map((s) => s.replace(/^["'`]|["'`]$/g, "")).filter((n) => iconNamePattern.test(n));
+        if (names.length > 0) {
+          result.name = names.join("|");
+        } else {
+          result.nameDynamic = true;
+        }
+      } else {
+        result.nameDynamic = true;
+      }
+    }
+  }
+  const familyStaticMatch = source.match(/\bfamily\s*=\s*["'](\w+)["']/);
+  if (familyStaticMatch) {
+    result.family = familyStaticMatch[1];
+  } else {
+    const familyDynamicMatch = source.match(/\bfamily\s*=\s*\{([^}]+)\}/);
+    if (familyDynamicMatch) {
+      const value = familyDynamicMatch[1]?.trim() ?? "";
+      const stringLiteralMatch = value.match(/^["'](\w+)["']$/);
+      if (stringLiteralMatch) {
+        result.family = stringLiteralMatch[1];
+      } else {
+        const ternaryStrings = value.match(/["'`](\w+)["'`]/g);
+        if (ternaryStrings && ternaryStrings.length > 0) {
+          const familyValues = ternaryStrings.map((s) => s.replace(/^["'`]|["'`]$/g, "")).filter((f) => families.includes(f));
+          if (familyValues.length > 0) {
+            result.family = familyValues.join("|");
+          } else {
+            result.family = "__dynamic__";
+          }
+        } else {
+          result.family = "__dynamic__";
+        }
+      }
+    }
+  }
+  const fillMatch = source.match(/\bfill\s*=\s*\{?(true|false)\}?/);
+  if (fillMatch) {
+    result.fill = fillMatch[1] === "true";
+  } else if (/\bfill\s*=\s*\{[^}]*\}/.test(source)) {
+    result.fillDynamic = true;
+  } else if (/\bfill\b/.test(source) && !/\bfill\s*=/.test(source)) {
+    result.fill = true;
+  }
+  const weightMatch = source.match(/\bweight\s*=\s*\{(-?\d+)\}/);
+  if (weightMatch) {
+    result.weight = parseInt(weightMatch[1] ?? "", 10);
+  } else if (/\bweight\s*=\s*\{[^}]*\}/.test(source)) {
+    result.weightDynamic = true;
+  }
+  const gradeMatch = source.match(/\bgrade\s*=\s*\{(-?\d+)\}/);
+  if (gradeMatch) {
+    result.grade = parseInt(gradeMatch[1] ?? "", 10);
+  } else if (/\bgrade\s*=\s*\{[^}]*\}/.test(source)) {
+    result.gradeDynamic = true;
+  }
+  return result;
+}
+function unwrapStaticValue(value) {
+  return value.replace(/^['"`](.+)['"`]$/, "$1");
+}
+var VALID_WEIGHTS = [100, 200, 300, 400, 500, 600, 700];
+function addUsage(usages, icon) {
+  const family = icon.family ?? defaultFamily;
+  const name = icon.name.trim();
+  const weight = icon.weight ?? DEFAULT_WEIGHT;
+  const fill = icon.fill ?? false;
+  const grade = icon.grade ?? 0;
+  if (!families.includes(family) || !iconNamePattern.test(name)) {
+    return;
+  }
+  if (!VALID_WEIGHTS.includes(weight)) return;
+  const iconMap = usages.get(family);
+  if (!iconMap) return;
+  const key = variantKey(grade, fill, weight);
+  const existing = iconMap.get(name);
+  if (existing) {
+    existing.add(key);
+  } else {
+    iconMap.set(name, /* @__PURE__ */ new Set([key]));
+  }
+}
+async function loadIconManifest() {
+  try {
+    const dir = join(fileURLToPath(import.meta.url), "..");
+    const manifestPath = join(dir, "icon-manifest.json");
+    const source = await readFile(manifestPath, "utf8");
+    return JSON.parse(source);
+  } catch {
+    return null;
+  }
+}
+function toFamily(value) {
+  const normalized = value ? unwrapStaticValue(value) : "";
+  return families.includes(normalized) ? normalized : void 0;
+}
+function resolveNames(rawName, isDynamic = false) {
+  if (rawName.includes("|")) {
+    const parts = rawName.split("|").map((p) => p.trim());
+    const validNames = parts.filter((p) => iconNamePattern.test(p));
+    if (validNames.length > 0) return validNames;
+  }
+  const stringLiterals = /["'`]([a-z0-9_]+)["'`]/g;
+  let strMatch;
+  const names = [];
+  while (strMatch = stringLiterals.exec(rawName)) {
+    const candidate = strMatch[1] ?? "";
+    if (iconNamePattern.test(candidate)) {
+      names.push(candidate);
+    }
+  }
+  if (names.length === 0) {
+    if (isDynamic) return names;
+    const name = unwrapStaticValue(rawName);
+    if (iconNamePattern.test(name)) {
+      names.push(name);
+    }
+  }
+  return names;
+}
+function resolveFamilies(rawFamily, hasFamily = true) {
+  if (rawFamily === "__dynamic__") return [...families];
+  if (rawFamily.includes("|")) {
+    const parts = rawFamily.split("|").map((p) => p.trim());
+    const validFamilies = parts.filter(
+      (p) => families.includes(p)
+    );
+    if (validFamilies.length > 0) return validFamilies;
+  }
+  const family = toFamily(rawFamily);
+  if (family) return [family];
+  const stringLiterals = /["'`](\w+)["'`]/g;
+  let strMatch;
+  const found = /* @__PURE__ */ new Set();
+  while (strMatch = stringLiterals.exec(rawFamily)) {
+    const candidate = strMatch[1] ?? "";
+    const f = toFamily(candidate);
+    if (f) {
+      found.add(f);
+    }
+  }
+  if (found.size > 0) return [...found];
+  if (!hasFamily) return [defaultFamily];
+  return [...families];
+}
+function createUsageMap() {
+  return new Map(families.map((family) => [family, /* @__PURE__ */ new Map()]));
+}
+async function listSourceFiles(root) {
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    const files = await Promise.all(
+      entries.map(async (entry) => {
+        const path = join(root, entry.name);
+        if (entry.isDirectory()) {
+          return skippedDirs.has(entry.name) ? [] : listSourceFiles(path);
+        }
+        return sourceExtensions.has(extname(entry.name)) ? [path] : [];
+      })
+    );
+    return files.flat();
+  } catch {
+    return [];
+  }
+}
+function formatDetectedMaterialSymbols(usages) {
+  return families.map((family) => {
+    const iconVariants = usages.get(family);
+    if (!iconVariants || iconVariants.size === 0) return `${family}: (none)`;
+    const entries = [...iconVariants.entries()].map(([name, variants]) => `${name}[${[...variants].sort().join(";")}]`).sort().join(", ");
+    return `${family}: ${entries}`;
+  }).join("\n");
+}
+export {
+  buildMaterialSymbolsCss,
+  collectMaterialSymbolUsages,
+  formatDetectedMaterialSymbols,
+  robosophyMaterialSymbols
+};