tailwind-unwind 0.1.0

package/dist/chunk-N7HD4T2I.js

@@ -0,0 +1,1469 @@
+// src/analyzer/suggestions.ts
+var BREAKPOINT_PREFIX = /^(sm|md|lg|xl|2xl):/;
+function baseClass(cls) {
+  return cls.replace(BREAKPOINT_PREFIX, "");
+}
+function has(classes, name) {
+  return classes.some((cls) => baseClass(cls) === name);
+}
+function hasPrefix(classes, prefix) {
+  return classes.some((cls) => baseClass(cls).startsWith(prefix));
+}
+function hasAll(classes, names) {
+  return names.every((name) => has(classes, name));
+}
+function hasAny(classes, names) {
+  return names.some((name) => has(classes, name));
+}
+function hasAnyPrefix(classes, prefixes) {
+  return prefixes.some((prefix) => hasPrefix(classes, prefix));
+}
+function hasPadding(classes) {
+  return hasAnyPrefix(classes, ["p-", "px-", "py-", "pt-", "pb-", "pl-", "pr-"]);
+}
+function hasMargin(classes) {
+  return hasAnyPrefix(classes, ["m-", "mx-", "my-", "mt-", "mb-", "ml-", "mr-"]);
+}
+function hasGap(classes) {
+  return hasPrefix(classes, "gap-") || hasPrefix(classes, "gap-x-") || hasPrefix(classes, "gap-y-");
+}
+function hasShadow(classes) {
+  return hasPrefix(classes, "shadow-");
+}
+function hasRing(classes) {
+  return hasPrefix(classes, "ring-");
+}
+function isFullWidth(classes) {
+  return has(classes, "w-full");
+}
+function gridColumnCount(classes) {
+  const colClass = classes.find((cls) => baseClass(cls).startsWith("grid-cols-"));
+  if (!colClass) return null;
+  return baseClass(colClass).replace("grid-cols-", "");
+}
+function iconSize(classes) {
+  return hasAny(classes, ["w-4", "h-4", "w-5", "h-5", "w-6", "h-6", "size-4", "size-5", "size-6"]);
+}
+var SEMANTIC_RULES = [
+  // ── Navigation & chrome ──────────────────────────────────────────
+  {
+    name: "page-header",
+    match: (c) => hasAll(c, ["flex", "items-center", "justify-between"]) && (hasPadding(c) || hasPrefix(c, "border-b"))
+  },
+  {
+    name: "toolbar",
+    match: (c) => hasAll(c, ["flex", "items-center", "justify-between"])
+  },
+  {
+    name: "footer-bar",
+    match: (c) => has(c, "flex") && hasPrefix(c, "border-t") && hasPadding(c)
+  },
+  {
+    name: "action-bar",
+    match: (c) => hasAll(c, ["flex", "items-center", "justify-end"]) && hasPadding(c)
+  },
+  {
+    name: "breadcrumb",
+    match: (c) => hasAll(c, ["flex", "items-center"]) && hasGap(c) && hasAny(c, ["text-sm", "text-xs"])
+  },
+  {
+    name: "nav-item",
+    match: (c) => hasAll(c, ["flex", "items-center"]) && hasGap(c) && hasPadding(c)
+  },
+  {
+    name: "sidebar",
+    match: (c) => hasAll(c, ["flex", "flex-col"]) && (has(c, "h-full") || has(c, "h-screen") || hasPrefix(c, "w-"))
+  },
+  {
+    name: "tab-bar",
+    match: (c) => has(c, "flex") && hasPrefix(c, "border-b") && hasGap(c)
+  },
+  // ── Flex layout ──────────────────────────────────────────────────
+  {
+    name: "centered-row",
+    match: (c) => hasAll(c, ["flex", "items-center", "justify-center"])
+  },
+  {
+    name: "spread-row",
+    match: (c) => has(c, "flex") && has(c, "justify-between")
+  },
+  {
+    name: "aligned-row",
+    match: (c) => hasAll(c, ["flex", "items-center"])
+  },
+  {
+    name: "inline-actions",
+    match: (c) => has(c, "inline-flex") && has(c, "items-center")
+  },
+  {
+    name: "wrap-row",
+    match: (c) => has(c, "flex") && has(c, "flex-wrap")
+  },
+  {
+    name: "form-row",
+    match: (c) => hasAll(c, ["flex", "flex-col"]) && hasGap(c)
+  },
+  {
+    name: "stack",
+    match: (c) => hasAll(c, ["flex", "flex-col"])
+  },
+  {
+    name: "row",
+    match: (c) => has(c, "flex")
+  },
+  // ── Grid layout ──────────────────────────────────────────────────
+  {
+    name: "photo-grid",
+    match: (c) => has(c, "grid") && hasPrefix(c, "grid-cols-") && has(c, "object-cover")
+  },
+  {
+    name: "card-grid",
+    match: (c) => has(c, "grid") && hasGap(c) && hasPrefix(c, "grid-cols-")
+  },
+  {
+    name: "grid",
+    match: (c) => has(c, "grid")
+  },
+  // ── Media & images ───────────────────────────────────────────────
+  {
+    name: "media-cover",
+    match: (c) => has(c, "object-cover") && isFullWidth(c)
+  },
+  {
+    name: "media-contain",
+    match: (c) => has(c, "object-contain") && isFullWidth(c)
+  },
+  {
+    name: "aspect-video",
+    match: (c) => has(c, "aspect-video")
+  },
+  {
+    name: "aspect-square",
+    match: (c) => has(c, "aspect-square")
+  },
+  {
+    name: "avatar",
+    match: (c) => has(c, "rounded-full") && (hasPrefix(c, "w-") || hasPrefix(c, "h-") || hasPrefix(c, "size-")) && hasPrefix(c, "object-")
+  },
+  {
+    name: "thumbnail",
+    match: (c) => has(c, "object-cover") && hasAnyPrefix(c, ["w-16", "w-12", "w-20", "h-16", "h-12", "h-20"])
+  },
+  {
+    name: "icon",
+    match: (c) => iconSize(c) && !has(c, "flex")
+  },
+  {
+    name: "logo",
+    match: (c) => hasAny(c, ["h-8", "h-6", "h-10"]) && has(c, "w-auto")
+  },
+  {
+    name: "media-frame",
+    match: (c) => isFullWidth(c) && has(c, "h-auto")
+  },
+  // ── Interactive (before surfaces — shares bg-/rounded-/px-) ─────
+  {
+    name: "badge",
+    match: (c) => has(c, "rounded-full") && hasAnyPrefix(c, ["px-", "py-"]) && hasAny(c, ["text-xs", "text-sm"])
+  },
+  {
+    name: "chip",
+    match: (c) => hasAnyPrefix(c, ["px-", "py-"]) && !has(c, "rounded-full") && hasPrefix(c, "rounded-") && hasAny(c, ["text-xs", "text-sm"])
+  },
+  {
+    name: "tag",
+    match: (c) => hasAnyPrefix(c, ["px-2", "px-3"]) && hasAnyPrefix(c, ["py-0", "py-1"]) && hasPrefix(c, "rounded-md")
+  },
+  {
+    name: "icon-button",
+    match: (c) => hasAnyPrefix(c, ["p-1", "p-1.5", "p-2", "p-3"]) && hasPrefix(c, "rounded-") && !hasAnyPrefix(c, ["px-4", "px-5", "px-6", "px-8"])
+  },
+  {
+    name: "primary-button",
+    match: (c) => hasAnyPrefix(c, ["px-", "py-"]) && hasPrefix(c, "rounded-") && hasAnyPrefix(c, ["bg-blue", "bg-indigo", "bg-primary", "bg-violet"])
+  },
+  {
+    name: "danger-button",
+    match: (c) => hasAnyPrefix(c, ["px-", "py-"]) && hasPrefix(c, "rounded-") && hasAnyPrefix(c, ["bg-red", "bg-rose", "bg-destructive"])
+  },
+  {
+    name: "ghost-button",
+    match: (c) => hasAnyPrefix(c, ["px-", "py-"]) && hasPrefix(c, "rounded-") && hasAnyPrefix(c, ["hover:bg-", "bg-transparent"])
+  },
+  {
+    name: "input",
+    match: (c) => hasAnyPrefix(c, ["px-", "py-"]) && hasPrefix(c, "border") && hasPrefix(c, "rounded-")
+  },
+  {
+    name: "textarea",
+    match: (c) => hasPrefix(c, "border") && hasPrefix(c, "rounded-") && hasAny(c, ["resize-none", "min-h-"])
+  },
+  {
+    name: "select",
+    match: (c) => hasPrefix(c, "border") && hasPrefix(c, "rounded-") && has(c, "appearance-none")
+  },
+  {
+    name: "checkbox-row",
+    match: (c) => hasAll(c, ["flex", "items-center"]) && hasGap(c) && hasAny(c, ["text-sm", "text-base"])
+  },
+  {
+    name: "button",
+    match: (c) => hasAnyPrefix(c, ["px-", "py-"]) && hasPrefix(c, "rounded-")
+  },
+  // ── Surfaces & containers ────────────────────────────────────────
+  {
+    name: "page-container",
+    match: (c) => has(c, "mx-auto") && hasPrefix(c, "max-w-")
+  },
+  {
+    name: "section",
+    match: (c) => hasPadding(c) && hasMargin(c) && !has(c, "flex") && !has(c, "grid")
+  },
+  {
+    name: "hero",
+    match: (c) => hasPadding(c) && hasAny(c, ["text-center", "justify-center"]) && hasAnyPrefix(c, ["text-3xl", "text-4xl", "text-5xl"])
+  },
+  {
+    name: "alert",
+    match: (c) => hasAnyPrefix(c, ["border-l-4", "border-l-2"]) && hasPadding(c) && hasPrefix(c, "bg-")
+  },
+  {
+    name: "callout",
+    match: (c) => hasPrefix(c, "bg-") && hasPadding(c) && hasPrefix(c, "border") && hasPrefix(c, "rounded-")
+  },
+  {
+    name: "panel",
+    match: (c) => hasPrefix(c, "rounded-") && hasPadding(c) && hasPrefix(c, "border")
+  },
+  {
+    name: "card",
+    match: (c) => hasPrefix(c, "rounded-") && hasPadding(c) && hasPrefix(c, "bg-")
+  },
+  {
+    name: "elevated-card",
+    match: (c) => hasShadow(c) && hasPrefix(c, "rounded-") && hasPadding(c)
+  },
+  {
+    name: "surface",
+    match: (c) => hasPrefix(c, "bg-") && hasPadding(c)
+  },
+  // ── Overlays & positioning ───────────────────────────────────────
+  {
+    name: "backdrop",
+    match: (c) => has(c, "fixed") && has(c, "inset-0") && hasAnyPrefix(c, ["bg-black", "bg-white", "bg-gray"])
+  },
+  {
+    name: "overlay",
+    match: (c) => has(c, "fixed") && has(c, "inset-0")
+  },
+  {
+    name: "modal-shell",
+    match: (c) => has(c, "fixed") && hasAll(c, ["flex", "items-center", "justify-center"])
+  },
+  {
+    name: "drawer",
+    match: (c) => has(c, "fixed") && hasAny(c, ["inset-y-0", "top-0", "bottom-0"]) && hasPrefix(c, "w-")
+  },
+  {
+    name: "sticky-header",
+    match: (c) => has(c, "sticky") && hasPrefix(c, "top-") && hasPrefix(c, "z-")
+  },
+  {
+    name: "dropdown",
+    match: (c) => has(c, "absolute") && hasPrefix(c, "z-") && hasPrefix(c, "rounded-") && hasShadow(c)
+  },
+  // ── Typography ───────────────────────────────────────────────────
+  {
+    name: "prose",
+    match: (c) => hasPrefix(c, "prose")
+  },
+  {
+    name: "heading",
+    match: (c) => hasAnyPrefix(c, ["text-xl", "text-2xl", "text-3xl", "text-4xl", "text-5xl"]) && hasPrefix(c, "font-")
+  },
+  {
+    name: "title",
+    match: (c) => hasAnyPrefix(c, ["text-lg", "text-xl", "text-2xl"]) && hasPrefix(c, "font-semibold")
+  },
+  {
+    name: "subtitle",
+    match: (c) => hasAnyPrefix(c, ["text-base", "text-lg"]) && hasPrefix(c, "text-gray")
+  },
+  {
+    name: "label",
+    match: (c) => hasAny(c, ["text-xs", "text-sm"]) && hasAnyPrefix(c, ["font-medium", "font-semibold"])
+  },
+  {
+    name: "caption",
+    match: (c) => hasAny(c, ["text-sm", "text-xs"]) && hasPrefix(c, "font-") && !hasAnyPrefix(c, ["font-medium", "font-semibold"])
+  },
+  {
+    name: "muted",
+    match: (c) => hasAnyPrefix(c, ["text-gray", "text-slate", "text-zinc", "text-neutral"])
+  },
+  {
+    name: "error-text",
+    match: (c) => hasAnyPrefix(c, ["text-red", "text-rose", "text-destructive"])
+  },
+  {
+    name: "link",
+    match: (c) => has(c, "underline") || hasAnyPrefix(c, ["text-blue", "text-indigo", "text-primary"])
+  },
+  {
+    name: "truncate",
+    match: (c) => has(c, "truncate") || has(c, "line-clamp-1")
+  },
+  // ── Lists & tables ───────────────────────────────────────────────
+  {
+    name: "table-header",
+    match: (c) => hasAnyPrefix(c, ["text-xs", "uppercase"]) && hasAnyPrefix(c, ["font-medium", "font-semibold", "tracking-"])
+  },
+  {
+    name: "table-row",
+    match: (c) => hasPrefix(c, "border-b") && hasAll(c, ["flex", "items-center"])
+  },
+  {
+    name: "list-item",
+    match: (c) => hasAll(c, ["flex", "items-center"]) && hasGap(c) && hasPadding(c)
+  },
+  {
+    name: "menu-item",
+    match: (c) => hasAll(c, ["flex", "items-center"]) && hasGap(c) && hasAnyPrefix(c, ["px-", "py-"]) && hasAnyPrefix(c, ["hover:bg-", "rounded-"])
+  },
+  {
+    name: "divider",
+    match: (c) => hasPrefix(c, "border-") && (isFullWidth(c) || hasMargin(c))
+  },
+  // ── States & effects ─────────────────────────────────────────────
+  {
+    name: "skeleton",
+    match: (c) => has(c, "animate-pulse") && hasPrefix(c, "bg-")
+  },
+  {
+    name: "loading",
+    match: (c) => has(c, "animate-spin") || has(c, "animate-pulse")
+  },
+  {
+    name: "disabled",
+    match: (c) => has(c, "opacity-50") || has(c, "cursor-not-allowed")
+  },
+  {
+    name: "focus-ring",
+    match: (c) => hasRing(c) || hasAnyPrefix(c, ["focus:ring-", "focus-visible:ring-"])
+  },
+  {
+    name: "hover-lift",
+    match: (c) => hasAnyPrefix(c, ["hover:shadow-", "hover:-translate-y-"]) && hasPrefix(c, "transition")
+  },
+  // ── Scroll & overflow ────────────────────────────────────────────
+  {
+    name: "scroll-panel",
+    match: (c) => hasAny(c, ["overflow-y-auto", "overflow-auto", "overflow-x-auto", "overflow-hidden"])
+  },
+  // ── Visual fallbacks ─────────────────────────────────────────────
+  {
+    name: "shadow-box",
+    match: (c) => hasShadow(c) && hasPrefix(c, "rounded-")
+  },
+  {
+    name: "bordered",
+    match: (c) => hasPrefix(c, "border") && hasPadding(c)
+  },
+  {
+    name: "rounded-box",
+    match: (c) => hasPrefix(c, "rounded-")
+  },
+  {
+    name: "padded",
+    match: (c) => hasPadding(c)
+  }
+];
+function buildCompositionalName(classes) {
+  const parts = [];
+  if (has(classes, "flex")) {
+    if (has(classes, "flex-col")) parts.push("stack");
+    else if (has(classes, "flex-wrap")) parts.push("wrap");
+    else if (has(classes, "justify-between")) parts.push("between");
+    else if (has(classes, "justify-center")) parts.push("centered");
+    else if (has(classes, "items-center")) parts.push("aligned");
+    else parts.push("row");
+  } else if (has(classes, "grid")) {
+    const cols = gridColumnCount(classes);
+    parts.push(cols ? `grid-${cols}` : "grid");
+  } else if (has(classes, "inline-flex")) {
+    parts.push("inline-row");
+  } else if (has(classes, "inline-block")) {
+    parts.push("inline");
+  } else if (has(classes, "block")) {
+    parts.push("block");
+  }
+  if (has(classes, "fixed")) parts.push("fixed");
+  else if (has(classes, "absolute")) parts.push("absolute");
+  else if (has(classes, "sticky")) parts.push("sticky");
+  else if (has(classes, "relative")) parts.push("relative");
+  if (has(classes, "object-cover")) parts.push("cover");
+  else if (has(classes, "object-contain")) parts.push("contain");
+  else if (has(classes, "aspect-video")) parts.push("video");
+  else if (has(classes, "rounded-full")) parts.push("circle");
+  else if (hasPrefix(classes, "rounded-")) parts.push("rounded");
+  if (hasShadow(classes)) parts.push("shadow");
+  else if (hasRing(classes)) parts.push("ring");
+  else if (hasPrefix(classes, "border")) parts.push("bordered");
+  if (hasPrefix(classes, "bg-")) parts.push("surface");
+  else if (hasPrefix(classes, "text-")) parts.push("text");
+  if (has(classes, "truncate")) parts.push("truncate");
+  if (has(classes, "animate-pulse")) parts.push("pulse");
+  if (has(classes, "transition")) parts.push("transition");
+  if (parts.length === 0 && hasPadding(classes)) parts.push("padded");
+  if (parts.length === 0 && hasMargin(classes)) parts.push("spaced");
+  const unique = [...new Set(parts)];
+  return unique.slice(0, 2).join("-") || "component";
+}
+function suggestClassName(classes) {
+  if (classes.length === 0) {
+    return "component";
+  }
+  for (const rule of SEMANTIC_RULES) {
+    if (rule.match(classes)) {
+      return rule.name;
+    }
+  }
+  return buildCompositionalName(classes);
+}
+
+// src/analyzer/dedupe.ts
+function isStrictSubset(smaller, larger) {
+  if (smaller.length >= larger.length) {
+    return false;
+  }
+  const largerSet = new Set(larger);
+  return smaller.every((cls) => largerSet.has(cls));
+}
+function dedupeSubsetCombinations(combinations) {
+  return combinations.filter((combo) => {
+    return !combinations.some(
+      (other) => other.normalized !== combo.normalized && isStrictSubset(combo.classes, other.classes)
+    );
+  });
+}
+
+// src/analyzer/combiner.ts
+function normalizeClasses(classes) {
+  return [...classes].sort().join(" ");
+}
+function splitClassString(classString) {
+  return classString.trim().split(/\s+/).filter((token) => token.length > 0);
+}
+function generateCombinations(classes, size) {
+  if (size < 1 || size > classes.length) {
+    return [];
+  }
+  const results = [];
+  const backtrack = (start, current) => {
+    if (current.length === size) {
+      results.push([...current]);
+      return;
+    }
+    for (let i = start; i <= classes.length - (size - current.length); i += 1) {
+      const item = classes[i];
+      if (item !== void 0) {
+        current.push(item);
+        backtrack(i + 1, current);
+        current.pop();
+      }
+    }
+  };
+  backtrack(0, []);
+  return results;
+}
+
+// src/analyzer/patternFinder.ts
+var DEFAULT_MIN_COMBINATION_SIZE = 2;
+var DEFAULT_MAX_COMBINATION_SIZE = 5;
+var DEFAULT_MIN_OCCURRENCES = 5;
+var DEFAULT_TOP_LIMIT = 10;
+function locationKey(location) {
+  return `${location.filePath}:${location.line ?? 0}`;
+}
+function findFrequentPatterns(occurrences, options = {}) {
+  const minOccurrences = options.minOccurrences ?? DEFAULT_MIN_OCCURRENCES;
+  const minSize = options.minSize ?? DEFAULT_MIN_COMBINATION_SIZE;
+  const maxSize = options.maxSize ?? DEFAULT_MAX_COMBINATION_SIZE;
+  const topLimit = options.topLimit ?? DEFAULT_TOP_LIMIT;
+  const dedupeSubsets = options.dedupeSubsets ?? true;
+  const frequency = /* @__PURE__ */ new Map();
+  for (const occurrence of occurrences) {
+    const uniqueInElement = [...new Set(occurrence.classes)];
+    if (uniqueInElement.length < minSize) {
+      continue;
+    }
+    const location = {
+      filePath: occurrence.filePath,
+      line: occurrence.line
+    };
+    const cappedMaxSize = Math.min(maxSize, uniqueInElement.length);
+    for (let size = minSize; size <= cappedMaxSize; size += 1) {
+      const combos = generateCombinations(uniqueInElement, size);
+      for (const combo of combos) {
+        const normalized = normalizeClasses(combo);
+        const existing = frequency.get(normalized);
+        if (existing) {
+          existing.count += 1;
+          const key = locationKey(location);
+          if (!existing.locations.some((loc) => locationKey(loc) === key)) {
+            existing.locations.push(location);
+          }
+        } else {
+          frequency.set(normalized, {
+            classes: [...combo].sort(),
+            count: 1,
+            locations: [location]
+          });
+        }
+      }
+    }
+  }
+  let frequent = [...frequency.entries()].filter(([, value]) => value.count > minOccurrences).map(([normalized, value]) => ({
+    normalized,
+    classes: value.classes,
+    occurrences: value.count,
+    suggestion: `.${suggestClassName(value.classes)}`,
+    locations: value.locations
+  })).sort((a, b) => {
+    if (b.occurrences !== a.occurrences) {
+      return b.occurrences - a.occurrences;
+    }
+    return b.classes.length - a.classes.length;
+  });
+  if (dedupeSubsets) {
+    frequent = dedupeSubsetCombinations(frequent);
+  }
+  return frequent.slice(0, topLimit);
+}
+function findRepeatedClassSets(occurrences, options = {}) {
+  const minOccurrences = options.minOccurrences ?? 3;
+  const minSize = options.minSize ?? 2;
+  const maxSize = options.maxSize ?? DEFAULT_MAX_COMBINATION_SIZE;
+  const topLimit = options.topLimit ?? DEFAULT_TOP_LIMIT;
+  const frequency = /* @__PURE__ */ new Map();
+  for (const occurrence of occurrences) {
+    const uniqueInElement = [...new Set(occurrence.classes)];
+    if (uniqueInElement.length < minSize || uniqueInElement.length > maxSize) {
+      continue;
+    }
+    const normalized = normalizeClasses(uniqueInElement);
+    const location = {
+      filePath: occurrence.filePath,
+      line: occurrence.line
+    };
+    const existing = frequency.get(normalized);
+    if (existing) {
+      existing.count += 1;
+      const key = locationKey(location);
+      if (!existing.locations.some((loc) => locationKey(loc) === key)) {
+        existing.locations.push(location);
+      }
+    } else {
+      frequency.set(normalized, {
+        classes: [...uniqueInElement].sort(),
+        count: 1,
+        locations: [location]
+      });
+    }
+  }
+  return [...frequency.entries()].filter(([, value]) => value.count >= minOccurrences).map(([normalized, value]) => ({
+    normalized,
+    classes: value.classes,
+    occurrences: value.count,
+    suggestion: `.${suggestClassName(value.classes)}`,
+    locations: value.locations
+  })).sort((a, b) => {
+    if (b.occurrences !== a.occurrences) {
+      return b.occurrences - a.occurrences;
+    }
+    return b.classes.length - a.classes.length;
+  }).slice(0, topLimit);
+}
+function calculatePotentialReduction(occurrences, topCombinations) {
+  const totalClassUsages = occurrences.reduce(
+    (sum, occurrence) => sum + occurrence.classes.length,
+    0
+  );
+  if (totalClassUsages === 0 || topCombinations.length === 0) {
+    return 0;
+  }
+  const best = [...topCombinations].sort((a, b) => {
+    if (b.classes.length !== a.classes.length) {
+      return b.classes.length - a.classes.length;
+    }
+    return b.occurrences - a.occurrences;
+  })[0];
+  if (!best || best.occurrences <= 1 || best.classes.length < 2) {
+    return 0;
+  }
+  const redundantInstances = best.occurrences - 1;
+  const utilitiesSavedPerInstance = best.classes.length - 1;
+  const savable = redundantInstances * utilitiesSavedPerInstance;
+  return Math.min(100, Math.round(savable / totalClassUsages * 100));
+}
+
+// src/parser/classHelpers.ts
+var CLASS_MERGE_CALLEES = /* @__PURE__ */ new Set([
+  "cn",
+  "clsx",
+  "classnames",
+  "classNames",
+  "twMerge",
+  "cx"
+]);
+function mergeExtractions(parts) {
+  const classes = [...new Set(parts.flatMap((part) => part.classes))];
+  const isDynamic = parts.some((part) => part.isDynamic);
+  return { classes, isDynamic };
+}
+function extractFromStringLiteral(value) {
+  return {
+    classes: splitClassString(value),
+    isDynamic: false
+  };
+}
+function extractFromTemplateLiteral(node) {
+  const parts = [];
+  for (const quasi of node.quasis) {
+    if (quasi.value.cooked) {
+      parts.push(quasi.value.cooked);
+    }
+  }
+  const combined = parts.join(" ").trim();
+  return {
+    classes: combined ? splitClassString(combined) : [],
+    isDynamic: node.expressions.length > 0
+  };
+}
+function isClassMergeCallee(expression) {
+  if (expression.type === "Identifier") {
+    return CLASS_MERGE_CALLEES.has(expression.name);
+  }
+  if (expression.type === "MemberExpression" && expression.property.type === "Identifier") {
+    return CLASS_MERGE_CALLEES.has(expression.property.name);
+  }
+  return false;
+}
+function extractFromCallArguments(args) {
+  const parts = [];
+  for (const arg of args) {
+    if (arg.type === "SpreadElement" || arg.type === "ArgumentPlaceholder") {
+      parts.push({ classes: [], isDynamic: true });
+      continue;
+    }
+    parts.push(extractClassesFromExpression(arg));
+  }
+  return mergeExtractions(parts);
+}
+function extractClassesFromExpression(expression) {
+  switch (expression.type) {
+    case "StringLiteral":
+      return extractFromStringLiteral(expression.value);
+    case "TemplateLiteral":
+      return extractFromTemplateLiteral(expression);
+    case "CallExpression": {
+      const { callee } = expression;
+      if (callee.type !== "V8IntrinsicIdentifier" && isClassMergeCallee(callee)) {
+        return extractFromCallArguments(expression.arguments);
+      }
+      return { classes: [], isDynamic: true };
+    }
+    case "ConditionalExpression": {
+      const merged = mergeExtractions([
+        extractClassesFromExpression(expression.consequent),
+        extractClassesFromExpression(expression.alternate)
+      ]);
+      return { ...merged, isDynamic: true };
+    }
+    case "LogicalExpression": {
+      const merged = mergeExtractions([
+        extractClassesFromExpression(expression.left),
+        extractClassesFromExpression(expression.right)
+      ]);
+      return { ...merged, isDynamic: true };
+    }
+    case "ArrayExpression":
+      return extractFromArrayExpression(expression);
+    case "ObjectExpression":
+      return extractFromObjectExpression(expression);
+    default:
+      return { classes: [], isDynamic: true };
+  }
+}
+function extractFromArrayExpression(node) {
+  const parts = [];
+  for (const element of node.elements) {
+    if (element === null || element.type === "SpreadElement") {
+      parts.push({ classes: [], isDynamic: true });
+      continue;
+    }
+    parts.push(extractClassesFromExpression(element));
+  }
+  return mergeExtractions(parts);
+}
+function extractFromObjectExpression(node) {
+  const classes = [];
+  let isDynamic = false;
+  for (const prop of node.properties) {
+    if (prop.type === "SpreadElement") {
+      isDynamic = true;
+      continue;
+    }
+    if (prop.type !== "ObjectProperty") {
+      isDynamic = true;
+      continue;
+    }
+    const key = prop.key;
+    if (key.type === "StringLiteral") {
+      classes.push(...splitClassString(key.value));
+    } else if (key.type === "Identifier") {
+      classes.push(...splitClassString(key.name));
+    }
+    if (prop.value.type !== "BooleanLiteral" || prop.value.value !== true) {
+      isDynamic = true;
+    }
+  }
+  return {
+    classes: [...new Set(classes)],
+    isDynamic
+  };
+}
+
+// src/parser/ast.ts
+import { parse } from "@babel/parser";
+var PARSER_PLUGINS = [
+  "jsx",
+  "typescript",
+  "decorators-legacy",
+  "classProperties",
+  "classPrivateProperties",
+  "classPrivateMethods",
+  "dynamicImport",
+  "importMeta"
+];
+var CLASS_ATTRIBUTES = /* @__PURE__ */ new Set(["className", "class"]);
+function getAttributeName(attr) {
+  if (attr.name.type === "JSXIdentifier") {
+    return attr.name.name;
+  }
+  return null;
+}
+function isClassAttribute(attr) {
+  const name = getAttributeName(attr);
+  return name !== null && CLASS_ATTRIBUTES.has(name);
+}
+function extractFromJSXAttribute(attr) {
+  if (!isClassAttribute(attr)) {
+    return null;
+  }
+  const line = attr.loc?.start.line;
+  const value = attr.value;
+  if (value == null) {
+    return { classes: [], isDynamic: true, line };
+  }
+  if (value.type === "StringLiteral") {
+    const result = extractClassesFromExpression(value);
+    return { classes: result.classes, isDynamic: result.isDynamic, line };
+  }
+  if (value.type === "JSXExpressionContainer") {
+    const expr = value.expression;
+    if (expr.type === "JSXEmptyExpression") {
+      return { classes: [], isDynamic: true, line };
+    }
+    const result = extractClassesFromExpression(expr);
+    return { classes: result.classes, isDynamic: result.isDynamic, line };
+  }
+  return { classes: [], isDynamic: true, line };
+}
+function parseSourceToAst(source) {
+  return parse(source, {
+    sourceType: "module",
+    plugins: [...PARSER_PLUGINS],
+    errorRecovery: true,
+    allowReturnOutsideFunction: true,
+    ranges: false,
+    tokens: false
+  });
+}
+
+// src/parser/jsxParser.ts
+import babelTraverse from "@babel/traverse";
+import fs from "fs/promises";
+function resolveTraverse(module) {
+  if (typeof module === "function") {
+    return module;
+  }
+  const withDefault = module;
+  if (typeof withDefault.default === "function") {
+    return withDefault.default;
+  }
+  throw new Error("Failed to load @babel/traverse");
+}
+var traverse = resolveTraverse(babelTraverse);
+function isJSXElementWithClassAttribute(path5) {
+  const opening = path5.node.openingElement;
+  return opening.attributes.some(
+    (attr) => attr.type === "JSXAttribute" && isClassAttribute(attr)
+  );
+}
+function collectExtractionsFromAst(ast, filePath) {
+  const extractions = [];
+  const warnings = [];
+  traverse(ast, {
+    JSXElement(path5) {
+      if (!isJSXElementWithClassAttribute(path5)) {
+        return;
+      }
+      const opening = path5.node.openingElement;
+      for (const attr of opening.attributes) {
+        if (attr.type !== "JSXAttribute") continue;
+        const extraction = extractFromJSXAttribute(attr);
+        if (!extraction) continue;
+        if (extraction.isDynamic && extraction.classes.length === 0) {
+          const lineInfo = extraction.line ? `:${extraction.line}` : "";
+          warnings.push(
+            `Dynamic className skipped in ${filePath}${lineInfo}`
+          );
+          continue;
+        }
+        if (extraction.classes.length > 0) {
+          extractions.push(extraction);
+        }
+      }
+    }
+  });
+  return { extractions, warnings };
+}
+function parseSource(source, filePath = "unknown") {
+  const extractions = [];
+  const warnings = [];
+  try {
+    const ast = parseSourceToAst(source);
+    const collected = collectExtractionsFromAst(ast, filePath);
+    extractions.push(...collected.extractions);
+    warnings.push(...collected.warnings);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warnings.push(`Failed to parse ${filePath}: ${message}`);
+  }
+  return { filePath, extractions, warnings };
+}
+async function parseFile(filePath) {
+  const source = await fs.readFile(filePath, "utf-8");
+  return parseSource(source, filePath);
+}
+
+// src/scanner/ignore.ts
+var IGNORED_DIRECTORIES = [
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  ".git"
+];
+var IGNORE_PATTERNS = IGNORED_DIRECTORIES.map(
+  (dir) => `**/${dir}/**`
+);
+
+// src/scanner/fileWalker.ts
+import fg from "fast-glob";
+import path from "path";
+var SOURCE_EXTENSIONS = ["tsx", "jsx", "ts", "js"];
+async function walkSourceFiles(targetPath) {
+  const absolutePath = path.resolve(targetPath);
+  const patterns = SOURCE_EXTENSIONS.map(
+    (ext) => path.join(absolutePath, `**/*.${ext}`).replace(/\\/g, "/")
+  );
+  const files = await fg(patterns, {
+    absolute: true,
+    onlyFiles: true,
+    unique: true,
+    ignore: IGNORE_PATTERNS,
+    dot: false
+  });
+  return files.sort();
+}
+
+// src/core/scanProject.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+async function pathExists(targetPath) {
+  try {
+    await fs2.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scanProject(options) {
+  const resolvedPath = path2.resolve(options.targetPath);
+  if (!await pathExists(resolvedPath)) {
+    throw new Error(`Path does not exist: ${resolvedPath}`);
+  }
+  const files = await walkSourceFiles(resolvedPath);
+  if (files.length === 0) {
+    throw new Error(
+      `No source files (.tsx, .jsx, .ts, .js) found in: ${resolvedPath}`
+    );
+  }
+  const occurrences = [];
+  const warnings = [];
+  for (const file of files) {
+    const result = await parseFile(file);
+    warnings.push(...result.warnings);
+    for (const extraction of result.extractions) {
+      if (extraction.classes.length > 0) {
+        occurrences.push({
+          classes: extraction.classes,
+          filePath: file,
+          line: extraction.line
+        });
+      }
+    }
+  }
+  const uniqueCombinationKeys = new Set(
+    occurrences.map(
+      (occurrence) => normalizeClasses([...new Set(occurrence.classes)])
+    )
+  );
+  const topCombinations = findFrequentPatterns(occurrences, {
+    minOccurrences: options.minOccurrences,
+    minSize: options.minSize,
+    maxSize: options.maxSize,
+    topLimit: options.topLimit,
+    dedupeSubsets: options.dedupeSubsets
+  });
+  const potentialReductionPercent = calculatePotentialReduction(
+    occurrences,
+    topCombinations
+  );
+  const report = {
+    targetPath: resolvedPath,
+    stats: {
+      filesScanned: files.length,
+      componentsWithClassName: occurrences.length,
+      uniqueCombinations: uniqueCombinationKeys.size,
+      totalClassUsages: occurrences.reduce(
+        (sum, occurrence) => sum + occurrence.classes.length,
+        0
+      ),
+      topCombinations,
+      potentialReductionPercent
+    },
+    parseWarnings: warnings
+  };
+  return {
+    resolvedPath,
+    files,
+    occurrences,
+    warnings,
+    report
+  };
+}
+
+// src/reporters/consoleReporter.ts
+import chalk from "chalk";
+function formatNumber(value) {
+  return value.toLocaleString("en-US");
+}
+function formatLocations(locations) {
+  const preview = locations.slice(0, 3).map((loc) => {
+    const line = loc.line ? `:${loc.line}` : "";
+    return `${loc.filePath}${line}`;
+  });
+  const suffix = locations.length > 3 ? ` (+${locations.length - 3} more)` : "";
+  return preview.join(", ") + suffix;
+}
+function printConsoleReport(report, options = {}) {
+  const { stats } = report;
+  const topLimit = options.topLimit ?? 10;
+  console.log("");
+  console.log(chalk.bold.cyan("\u{1F4CA} Tailwind Analysis Report"));
+  console.log(chalk.cyan("\u2501".repeat(41)));
+  console.log(`Files scanned: ${chalk.white(formatNumber(stats.filesScanned))}`);
+  console.log(
+    `Components with className: ${chalk.white(formatNumber(stats.componentsWithClassName))}`
+  );
+  console.log(
+    `Unique class combinations: ${chalk.white(formatNumber(stats.uniqueCombinations))}`
+  );
+  console.log("");
+  if (stats.topCombinations.length === 0) {
+    console.log(
+      chalk.yellow(
+        "No frequent class combinations found matching the current filters."
+      )
+    );
+  } else {
+    console.log(
+      chalk.bold.green(`\u{1F3C6} Top ${Math.min(topLimit, stats.topCombinations.length)} most frequent combinations:`)
+    );
+    console.log("");
+    stats.topCombinations.forEach((combo, index) => {
+      const displayClasses = normalizeClasses(combo.classes);
+      console.log(
+        chalk.white(`${index + 1}. `) + chalk.yellow(`"${displayClasses}"`)
+      );
+      console.log(
+        chalk.gray(`   Occurrences: `) + chalk.white(String(combo.occurrences))
+      );
+      console.log(
+        chalk.gray(`   Suggestion: `) + chalk.green(combo.suggestion)
+      );
+      console.log(
+        chalk.gray(`   Found in: `) + chalk.dim(formatLocations(combo.locations))
+      );
+      console.log("");
+    });
+  }
+  console.log(
+    chalk.magenta(
+      `\u{1F4A1} Potential code reduction: ${stats.potentialReductionPercent}%`
+    )
+  );
+  console.log(
+    chalk.magenta(
+      "\u{1F4A1} Generate CSS: npx tailwind-unwind generate <path> --output styles.css"
+    )
+  );
+  console.log(
+    chalk.magenta(
+      "\u{1F4A1} Apply classes: npx tailwind-unwind apply <path> --output styles.css"
+    )
+  );
+  console.log("");
+}
+
+// src/reporters/jsonReporter.ts
+function printJsonReport(report) {
+  console.log(JSON.stringify(report, null, 2));
+}
+
+// src/commands/analyze.ts
+import chalk2 from "chalk";
+async function analyzeCommand(targetPath, options = {}) {
+  let scanResult;
+  try {
+    scanResult = await scanProject({
+      targetPath,
+      minOccurrences: options.minOccurrences,
+      minSize: options.minSize,
+      maxSize: options.maxSize,
+      topLimit: options.top,
+      dedupeSubsets: options.dedupeSubsets
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(chalk2.red(`Error: ${message}`));
+    process.exit(1);
+  }
+  if (options.format !== "json") {
+    for (const warning of scanResult.warnings) {
+      console.warn(chalk2.yellow(`\u26A0 ${warning}`));
+    }
+  }
+  const report = scanResult.report;
+  if (options.format === "json") {
+    printJsonReport(report);
+  } else {
+    printConsoleReport(report, { topLimit: options.top });
+  }
+  return report;
+}
+
+// src/codemod/replaceClassNames.ts
+import babelGenerate from "@babel/generator";
+import babelTraverse2 from "@babel/traverse";
+import * as t from "@babel/types";
+function resolveTraverse2(module) {
+  if (typeof module === "function") {
+    return module;
+  }
+  const withDefault = module;
+  if (typeof withDefault.default === "function") {
+    return withDefault.default;
+  }
+  throw new Error("Failed to load @babel/traverse");
+}
+function resolveGenerator(module) {
+  if (typeof module === "function") {
+    return module;
+  }
+  const withDefault = module;
+  if (typeof withDefault.default === "function") {
+    return withDefault.default;
+  }
+  throw new Error("Failed to load @babel/generator");
+}
+var traverse2 = resolveTraverse2(babelTraverse2);
+var generate = resolveGenerator(babelGenerate);
+function lookupReplacement(extraction, replacementMap) {
+  if (extraction.isDynamic || extraction.classes.length === 0) {
+    return null;
+  }
+  const key = normalizeClasses([...new Set(extraction.classes)]);
+  return replacementMap.get(key) ?? null;
+}
+function setStringClassAttribute(attr, className) {
+  attr.value = t.stringLiteral(className);
+}
+function replaceClassNamesInSource(source, replacementMap, filePath) {
+  const replacements = [];
+  const skipped = [];
+  if (replacementMap.size === 0) {
+    return { source, replacements, skipped, changed: false };
+  }
+  let ast;
+  try {
+    ast = parseSourceToAst(source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse ${filePath}: ${message}`);
+  }
+  traverse2(ast, {
+    JSXElement(path5) {
+      const opening = path5.node.openingElement;
+      for (const attr of opening.attributes) {
+        if (attr.type !== "JSXAttribute" || !isClassAttribute(attr)) {
+          continue;
+        }
+        const extraction = extractFromJSXAttribute(attr);
+        if (!extraction) continue;
+        const replacement = lookupReplacement(extraction, replacementMap);
+        if (!replacement) {
+          if (extraction.classes.length > 0) {
+            const key = normalizeClasses([...new Set(extraction.classes)]);
+            if (replacementMap.size > 0 && !replacementMap.has(key)) {
+              if (extraction.isDynamic) {
+                skipped.push({
+                  filePath,
+                  line: extraction.line,
+                  reason: "dynamic className",
+                  classes: extraction.classes
+                });
+              }
+            }
+          }
+          continue;
+        }
+        const from = normalizeClasses([...new Set(extraction.classes)]);
+        setStringClassAttribute(attr, replacement);
+        replacements.push({
+          filePath,
+          line: extraction.line,
+          from,
+          to: replacement
+        });
+      }
+    }
+  });
+  if (replacements.length === 0) {
+    return { source, replacements, skipped, changed: false };
+  }
+  const output = generate(ast, { retainLines: true }, source);
+  return {
+    source: output.code,
+    replacements,
+    skipped,
+    changed: true
+  };
+}
+
+// src/generator/classPrefix.ts
+var DEFAULT_CLASS_PREFIX = "twu-";
+function normalizeClassPrefix(prefix) {
+  if (!prefix || prefix.trim().length === 0) {
+    return DEFAULT_CLASS_PREFIX;
+  }
+  const trimmed = prefix.trim();
+  return trimmed.endsWith("-") ? trimmed : `${trimmed}-`;
+}
+function withClassPrefix(baseName, prefix) {
+  const normalizedPrefix = normalizeClassPrefix(prefix);
+  if (baseName.startsWith(normalizedPrefix)) {
+    return baseName;
+  }
+  return `${normalizedPrefix}${baseName}`;
+}
+
+// src/generator/cssGenerator.ts
+function assignComponentClassNames(combinations, options = {}) {
+  const used = /* @__PURE__ */ new Set();
+  return combinations.map((combo) => {
+    const base = suggestClassName(combo.classes);
+    let className = withClassPrefix(base, options.prefix);
+    let suffix = 2;
+    while (used.has(className)) {
+      className = withClassPrefix(`${base}-${suffix}`, options.prefix);
+      suffix += 1;
+    }
+    used.add(className);
+    return {
+      className,
+      classes: combo.classes,
+      occurrences: combo.occurrences
+    };
+  });
+}
+function generateComponentCss(options) {
+  const components = assignComponentClassNames(options.combinations, {
+    prefix: options.prefix
+  });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const classPrefix = normalizeClassPrefix(options.prefix);
+  const header = [
+    "/**",
+    " * Generated by tailwind-unwind",
+    ` * Source: ${options.sourcePath}`,
+    ` * Generated at: ${timestamp}`,
+    ` * Class prefix: ${classPrefix}`,
+    " */",
+    ""
+  ].join("\n");
+  if (components.length === 0) {
+    return {
+      css: `${header}
+/* No frequent class combinations found. Try lowering --min-occurrences. */
+`,
+      components: []
+    };
+  }
+  const rules = components.map((component) => {
+    const applyClasses = component.classes.join(" ");
+    return `  .${component.className} {
+    @apply ${applyClasses};
+  }`;
+  }).join("\n\n");
+  const css = `${header}
+@layer components {
+${rules}
+}
+`;
+  return { css, components };
+}
+
+// src/core/buildComponents.ts
+function buildComponents(occurrences, options) {
+  const combinations = findRepeatedClassSets(occurrences, {
+    minOccurrences: options.minOccurrences,
+    minSize: options.minSize,
+    maxSize: options.maxSize,
+    topLimit: options.topLimit
+  });
+  const { css, components } = generateComponentCss({
+    sourcePath: options.sourcePath,
+    combinations,
+    prefix: options.prefix
+  });
+  const replacementMap = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    const key = [...component.classes].sort().join(" ");
+    replacementMap.set(key, component.className);
+  }
+  return { components, css, replacementMap };
+}
+
+// src/commands/apply.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import chalk3 from "chalk";
+async function applyCommand(targetPath, options) {
+  let scanResult;
+  try {
+    scanResult = await scanProject({ targetPath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(chalk3.red(`Error: ${message}`));
+    process.exit(1);
+  }
+  for (const warning of scanResult.warnings) {
+    console.warn(chalk3.yellow(`\u26A0 ${warning}`));
+  }
+  const { components, css, replacementMap } = buildComponents(
+    scanResult.occurrences,
+    {
+      sourcePath: scanResult.resolvedPath,
+      minOccurrences: options.minOccurrences ?? 3,
+      minSize: options.minSize,
+      maxSize: options.maxSize,
+      topLimit: options.top,
+      prefix: options.prefix
+    }
+  );
+  if (components.length === 0) {
+    console.error(
+      chalk3.yellow(
+        "No repeated className sets found. Try lowering --min-occurrences."
+      )
+    );
+    process.exit(1);
+  }
+  const outputPath = path3.resolve(options.output);
+  let filesModified = 0;
+  let replacementsTotal = 0;
+  const allReplacements = [];
+  for (const file of scanResult.files) {
+    const original = await fs3.readFile(file, "utf-8");
+    const result = replaceClassNamesInSource(
+      original,
+      replacementMap,
+      file
+    );
+    replacementsTotal += result.replacements.length;
+    allReplacements.push(...result.replacements);
+    if (result.changed) {
+      filesModified += 1;
+      if (!options.dryRun) {
+        await fs3.writeFile(file, result.source, "utf-8");
+      }
+    }
+  }
+  if (!options.dryRun) {
+    await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
+    await fs3.writeFile(outputPath, css, "utf-8");
+  }
+  console.log("");
+  if (options.dryRun) {
+    console.log(chalk3.bold.yellow("\u{1F50D} Dry run \u2014 no files were modified"));
+  } else {
+    console.log(chalk3.bold.green("\u2705 Classes applied successfully"));
+  }
+  console.log(chalk3.gray(`   CSS output: `) + chalk3.white(outputPath));
+  console.log(
+    chalk3.gray(`   Component classes: `) + chalk3.white(String(components.length))
+  );
+  console.log(
+    chalk3.gray(`   Files modified: `) + chalk3.white(String(filesModified))
+  );
+  console.log(
+    chalk3.gray(`   Replacements: `) + chalk3.white(String(replacementsTotal))
+  );
+  if (allReplacements.length > 0) {
+    console.log("");
+    console.log(chalk3.bold("Replacements:"));
+    for (const item of allReplacements) {
+      const line = item.line ? `:${item.line}` : "";
+      console.log(
+        chalk3.gray(`  ${item.filePath}${line}`) + chalk3.white(` "${item.from}" `) + chalk3.cyan("\u2192") + chalk3.green(` "${item.to}"`)
+      );
+    }
+  }
+  console.log("");
+  if (!options.dryRun) {
+    console.log(
+      chalk3.cyan(
+        `Import ${path3.basename(outputPath)} in your global CSS if you haven't already.`
+      )
+    );
+    console.log("");
+  }
+  return {
+    filesModified,
+    replacementsTotal,
+    outputPath,
+    componentsGenerated: components.length
+  };
+}
+
+// src/commands/generate.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import chalk4 from "chalk";
+async function generateCommand(targetPath, options) {
+  let scanResult;
+  try {
+    scanResult = await scanProject({ targetPath });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(chalk4.red(`Error: ${message}`));
+    process.exit(1);
+  }
+  for (const warning of scanResult.warnings) {
+    console.warn(chalk4.yellow(`\u26A0 ${warning}`));
+  }
+  const { css, components } = buildComponents(scanResult.occurrences, {
+    sourcePath: scanResult.resolvedPath,
+    minOccurrences: options.minOccurrences ?? 3,
+    minSize: options.minSize,
+    maxSize: options.maxSize,
+    topLimit: options.top,
+    prefix: options.prefix
+  });
+  const outputPath = path4.resolve(options.output);
+  await fs4.mkdir(path4.dirname(outputPath), { recursive: true });
+  await fs4.writeFile(outputPath, css, "utf-8");
+  console.log("");
+  console.log(chalk4.bold.green("\u2705 CSS generated successfully"));
+  console.log(chalk4.gray(`   Output: `) + chalk4.white(outputPath));
+  console.log(
+    chalk4.gray(`   Components: `) + chalk4.white(String(components.length))
+  );
+  if (components.length > 0) {
+    console.log("");
+    console.log(chalk4.bold("Generated classes:"));
+    for (const component of components) {
+      console.log(
+        chalk4.green(`  .${component.className}`) + chalk4.gray(` \u2014 ${component.occurrences} occurrences, `) + chalk4.dim(component.classes.join(" "))
+      );
+    }
+    console.log("");
+    console.log(
+      chalk4.cyan(
+        "Run apply to replace className strings: npx tailwind-unwind apply <path> --output styles.css"
+      )
+    );
+  } else {
+    console.log(
+      chalk4.yellow(
+        "\nNo repeated className sets matched the filters. Try lowering --min-occurrences."
+      )
+    );
+  }
+  console.log("");
+  return {
+    outputPath,
+    componentsGenerated: components.length,
+    report: scanResult.report
+  };
+}
+
+export {
+  suggestClassName,
+  isStrictSubset,
+  dedupeSubsetCombinations,
+  normalizeClasses,
+  splitClassString,
+  generateCombinations,
+  findFrequentPatterns,
+  findRepeatedClassSets,
+  calculatePotentialReduction,
+  CLASS_MERGE_CALLEES,
+  extractClassesFromExpression,
+  isClassAttribute,
+  extractFromJSXAttribute,
+  parseSourceToAst,
+  parseSource,
+  parseFile,
+  IGNORED_DIRECTORIES,
+  IGNORE_PATTERNS,
+  walkSourceFiles,
+  scanProject,
+  printConsoleReport,
+  printJsonReport,
+  analyzeCommand,
+  replaceClassNamesInSource,
+  DEFAULT_CLASS_PREFIX,
+  normalizeClassPrefix,
+  withClassPrefix,
+  assignComponentClassNames,
+  generateComponentCss,
+  buildComponents,
+  applyCommand,
+  generateCommand
+};
+//# sourceMappingURL=chunk-N7HD4T2I.js.map