stera-ui 0.8.1 → 0.9.0

package/dist/chunk-RQ7T7RF5.js

@@ -1,880 +0,0 @@
-import {
-  fetchRegistryItem
-} from "./chunk-BJNLGEZJ.js";
-
-// src/utils/transform.ts
-function applyTransforms(content, ctx, transforms) {
-  return transforms.reduce((acc, fn) => fn(acc, ctx), content);
-}
-
-// src/utils/transform-imports.ts
-var DEFAULT_ALIASES = {
-  utils: "@/lib/utils",
-  ui: "@/components/ui",
-  components: "@/components",
-  lib: "@/lib",
-  hooks: "@/hooks"
-};
-var transformImports = (content, ctx) => {
-  if (!ctx.filename.endsWith(".ts") && !ctx.filename.endsWith(".tsx")) {
-    return content;
-  }
-  const { aliases } = ctx.config;
-  const rules = [];
-  if (aliases.utils !== DEFAULT_ALIASES.utils) {
-    rules.push({
-      type: "exact",
-      from: DEFAULT_ALIASES.utils,
-      to: aliases.utils
-    });
-  }
-  if (aliases.ui !== DEFAULT_ALIASES.ui) {
-    rules.push({ type: "prefix", from: DEFAULT_ALIASES.ui, to: aliases.ui });
-  }
-  if (aliases.components !== DEFAULT_ALIASES.components) {
-    rules.push({
-      type: "prefix",
-      from: DEFAULT_ALIASES.components,
-      to: aliases.components
-    });
-  }
-  if (aliases.lib !== DEFAULT_ALIASES.lib) {
-    rules.push({ type: "prefix", from: DEFAULT_ALIASES.lib, to: aliases.lib });
-  }
-  if (aliases.hooks !== DEFAULT_ALIASES.hooks) {
-    rules.push({
-      type: "prefix",
-      from: DEFAULT_ALIASES.hooks,
-      to: aliases.hooks
-    });
-  }
-  if (rules.length === 0) {
-    return content;
-  }
-  return content.replace(
-    /from\s+(["'])([^"']+)\1/g,
-    (match, quote, importPath) => {
-      for (const rule of rules) {
-        if (rule.type === "exact" && importPath === rule.from) {
-          return `from ${quote}${rule.to}${quote}`;
-        }
-        if (rule.type === "prefix" && importPath.startsWith(rule.from + "/")) {
-          const rest = importPath.slice(rule.from.length);
-          return `from ${quote}${rule.to}${rest}${quote}`;
-        }
-        if (rule.type === "prefix" && importPath === rule.from) {
-          return `from ${quote}${rule.to}${quote}`;
-        }
-      }
-      return match;
-    }
-  );
-};
-
-// src/utils/resolve-paths.ts
-import path from "path";
-import { loadConfig, createMatchPath } from "tsconfig-paths";
-var TYPE_TO_ALIAS = {
-  "registry:ui": "ui",
-  "registry:lib": "lib",
-  "registry:hook": "hooks",
-  "registry:component": "components"
-};
-var matcherCache = /* @__PURE__ */ new Map();
-function getTsConfigMatcher(projectRoot) {
-  let matcher = matcherCache.get(projectRoot);
-  if (matcher !== void 0) return matcher;
-  const tsConfig = loadConfig(projectRoot);
-  matcher = tsConfig.resultType === "success" && Object.keys(tsConfig.paths).length > 0 ? {
-    paths: tsConfig.paths,
-    match: createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths)
-  } : null;
-  matcherCache.set(projectRoot, matcher);
-  return matcher;
-}
-function resolveAlias(alias, projectRoot) {
-  const matcher = getTsConfigMatcher(projectRoot);
-  if (matcher) {
-    const hasMatchingPrefix = Object.keys(matcher.paths).some((key) => {
-      const prefix = key.replace(/\/\*$/, "");
-      return alias === prefix || alias.startsWith(`${prefix}/`);
-    });
-    if (hasMatchingPrefix) {
-      const resolved = matcher.match(alias, void 0, () => true, [
-        ".ts",
-        ".tsx"
-      ]);
-      if (resolved) {
-        return path.relative(projectRoot, resolved);
-      }
-    }
-  }
-  throw new Error(
-    `Could not resolve alias "${alias}" from tsconfig.json. Ensure compilerOptions.paths defines a mapping for it (e.g. "${alias}/*"), then re-run. See https://ui.stera.sh/docs/installation.`
-  );
-}
-function resolveOutputPath(config, projectRoot, file) {
-  const alias = TYPE_TO_ALIAS[file.type];
-  if (alias) {
-    const dir = resolveAlias(config.aliases[alias], projectRoot);
-    const filename = path.basename(file.path);
-    return path.join(projectRoot, dir, filename);
-  }
-  if (file.type === "registry:style") {
-    const cssDir = path.dirname(config.css);
-    const filename = path.basename(file.path);
-    return path.join(projectRoot, cssDir, filename);
-  }
-  return path.join(projectRoot, file.path);
-}
-
-// src/utils/resolve-config.ts
-import fs from "fs";
-import path2 from "path";
-var CONFIG_FILE = "stera.config.json";
-var LEGACY_CONFIG_FILE = "components.json";
-function migrateConfig(raw) {
-  if (!("version" in raw) && "tailwind" in raw) {
-    const legacy = raw;
-    return {
-      version: 1,
-      css: legacy.tailwind.css || "src/styles/globals.css",
-      aliases: legacy.aliases
-    };
-  }
-  return raw;
-}
-var warnedLegacyFilename = false;
-function warnLegacyFilenameOnce(legacyPath) {
-  if (warnedLegacyFilename) return;
-  warnedLegacyFilename = true;
-  console.warn(
-    `  \u26A0 Found ${LEGACY_CONFIG_FILE}. Rename to ${CONFIG_FILE} \u2014 legacy filename support will be removed in a future release.
-    (${legacyPath})`
-  );
-}
-function findConfigPath(cwd) {
-  let dir = path2.resolve(cwd);
-  while (true) {
-    const configPath = path2.join(dir, CONFIG_FILE);
-    if (fs.existsSync(configPath)) return configPath;
-    const legacyPath = path2.join(dir, LEGACY_CONFIG_FILE);
-    if (fs.existsSync(legacyPath)) return legacyPath;
-    const parent = path2.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function loadConfig2(cwd) {
-  const configPath = findConfigPath(cwd);
-  if (!configPath) return null;
-  if (path2.basename(configPath) === LEGACY_CONFIG_FILE) {
-    warnLegacyFilenameOnce(configPath);
-  }
-  try {
-    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    return migrateConfig(raw);
-  } catch {
-    return null;
-  }
-}
-
-// src/utils/detect-project.ts
-import fs2 from "fs";
-import path3 from "path";
-import { loadConfig as loadConfig3 } from "tsconfig-paths";
-function hasFile(cwd, filenames) {
-  return filenames.some((f) => fs2.existsSync(path3.join(cwd, f)));
-}
-function findTailwindCssFile(cwd) {
-  const candidates = [
-    "src/app/globals.css",
-    "src/styles/globals.css",
-    "src/index.css",
-    "app/globals.css",
-    "styles/globals.css",
-    "index.css"
-  ];
-  for (const candidate of candidates) {
-    const fullPath = path3.join(cwd, candidate);
-    if (!fs2.existsSync(fullPath)) continue;
-    const content = fs2.readFileSync(fullPath, "utf-8");
-    if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'") || content.includes("@tailwind base")) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function detectProject(cwd) {
-  const hasSrc = fs2.existsSync(path3.join(cwd, "src"));
-  let framework = "other";
-  if (hasFile(cwd, ["next.config.ts", "next.config.js", "next.config.mjs"])) {
-    framework = "next";
-  } else if (hasFile(cwd, ["vite.config.ts", "vite.config.js", "vite.config.mjs"])) {
-    framework = "vite";
-  }
-  let rsc = false;
-  if (framework === "next") {
-    const appDir = hasSrc ? "src/app" : "app";
-    rsc = fs2.existsSync(path3.join(cwd, appDir));
-  }
-  const existingCssFile = findTailwindCssFile(cwd);
-  let layoutFile = null;
-  if (framework === "next") {
-    const appDir = hasSrc ? "src/app" : "app";
-    for (const ext of ["tsx", "jsx", "ts", "js"]) {
-      const candidate = `${appDir}/layout.${ext}`;
-      if (fs2.existsSync(path3.join(cwd, candidate))) {
-        layoutFile = candidate;
-        break;
-      }
-    }
-  } else if (framework === "vite") {
-    if (fs2.existsSync(path3.join(cwd, "index.html"))) {
-      layoutFile = "index.html";
-    }
-  }
-  return { hasSrc, framework, rsc, existingCssFile, layoutFile };
-}
-function detectAliasPrefix(cwd) {
-  let tsConfig;
-  try {
-    tsConfig = loadConfig3(cwd);
-  } catch {
-    return null;
-  }
-  if (tsConfig.resultType !== "success" || Object.keys(tsConfig.paths).length === 0) {
-    return null;
-  }
-  for (const [alias, targets] of Object.entries(tsConfig.paths)) {
-    if (targets.includes("./*") || targets.includes("./src/*") || targets.includes("./app/*")) {
-      return alias.replace(/\/\*$/, "");
-    }
-  }
-  const first = Object.keys(tsConfig.paths)[0];
-  return first ? first.replace(/\/\*$/, "") : null;
-}
-
-// src/utils/write-styles.ts
-import fs6 from "fs/promises";
-import { existsSync } from "fs";
-import path5 from "path";
-
-// src/utils/css-imports.ts
-import fs3 from "fs/promises";
-async function insertImportLine(filePath, importStatement) {
-  const content = await fs3.readFile(filePath, "utf-8");
-  const importPath = importStatement.match(/["']([^"']+)["']/)?.[1];
-  if (importPath) {
-    const escaped = importPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    if (new RegExp(`@import\\s+["']${escaped}["']`).test(content)) return;
-  }
-  const lines = content.split("\n");
-  let lastImportIndex = -1;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim().startsWith("@import")) {
-      lastImportIndex = i;
-    }
-  }
-  if (lastImportIndex >= 0) {
-    lines.splice(lastImportIndex + 1, 0, importStatement);
-  } else {
-    lines.unshift(importStatement);
-  }
-  await fs3.writeFile(filePath, lines.join("\n"), "utf-8");
-}
-
-// src/utils/patch-css-vars.ts
-import fs4 from "fs";
-function removeCssImport(filePath, importPath) {
-  const content = fs4.readFileSync(filePath, "utf-8");
-  const pattern = new RegExp(
-    `@import\\s+['"]${escapeRegex(importPath)}['"]\\s*;?\\n?`
-  );
-  if (!pattern.test(content)) return false;
-  fs4.writeFileSync(filePath, content.replace(pattern, ""), "utf-8");
-  return true;
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/utils/write-files.ts
-import fs5 from "fs";
-import path4 from "path";
-import { confirm } from "@inquirer/prompts";
-async function confirmOverwrite(relativePath) {
-  if (!process.stdin.isTTY) {
-    console.log(
-      `  Skipping ${relativePath} (already exists, use --overwrite to replace)`
-    );
-    return false;
-  }
-  return confirm({
-    message: `${relativePath} already exists. Overwrite?`,
-    default: false
-  });
-}
-async function writeComponentFiles(items, config, projectRoot, options = {}) {
-  const written = [];
-  const skipped = [];
-  for (const item of items) {
-    for (const file of item.files ?? []) {
-      const outputPath = resolveOutputPath(config, projectRoot, file);
-      const relativePath = path4.relative(projectRoot, outputPath);
-      if (fs5.existsSync(outputPath)) {
-        const existing = fs5.readFileSync(outputPath, "utf-8");
-        if (existing === file.content) {
-          skipped.push({ path: relativePath, reason: "unchanged" });
-          continue;
-        }
-        if (!options.overwrite) {
-          const confirmed = await confirmOverwrite(relativePath);
-          if (!confirmed) {
-            skipped.push({ path: relativePath, reason: "declined" });
-            continue;
-          }
-        }
-      }
-      const dir = path4.dirname(outputPath);
-      fs5.mkdirSync(dir, { recursive: true });
-      fs5.writeFileSync(outputPath, file.content ?? "", "utf-8");
-      written.push(relativePath);
-    }
-  }
-  return { written, skipped };
-}
-
-// src/utils/write-styles.ts
-var INDEX_TARGET = "ui/index.css";
-var TYPOGRAPHY_TARGET = "ui/typography.css";
-var PROTECTED_TARGETS = /* @__PURE__ */ new Set([TYPOGRAPHY_TARGET, "ui/colors.css"]);
-var LEGACY_FILENAME = "stera-ui.css";
-var LEGACY_IMPORT = "./stera-ui.css";
-function partitionImports(content) {
-  const lines = content.split("\n");
-  const hoisted = [];
-  const kept = [];
-  for (const line of lines) {
-    const specifier = line.trim().match(/^@import\s+["'](.+?)["']/)?.[1];
-    if (specifier === void 0) {
-      kept.push(line);
-    } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      kept.push(line);
-    } else if (specifier !== "tailwindcss") {
-      hoisted.push(line.trim());
-    }
-  }
-  const cleaned = kept.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
-  return { content: cleaned, hoisted };
-}
-async function migrateLegacyStyles(config, cwd) {
-  const globalsPath = path5.resolve(cwd, config.css);
-  const legacyPath = path5.join(path5.dirname(globalsPath), LEGACY_FILENAME);
-  if (!existsSync(legacyPath)) return null;
-  await fs6.rm(legacyPath);
-  if (existsSync(globalsPath)) {
-    removeCssImport(globalsPath, LEGACY_IMPORT);
-    await insertImportLine(globalsPath, `@import "./${INDEX_TARGET}";`);
-  }
-  return legacyPath;
-}
-async function writeStyles(config, cwd, options = {}) {
-  const item = await fetchRegistryItem("globals");
-  const cssDir = path5.dirname(path5.resolve(cwd, config.css));
-  const written = [];
-  const skipped = [];
-  let extraImports = [];
-  for (const file of item.files ?? []) {
-    const target = file.target ?? path5.basename(file.path);
-    const outputPath = path5.join(cssDir, target);
-    let content = file.content ?? "";
-    if (target === INDEX_TARGET) {
-      const partitioned = partitionImports(content);
-      content = partitioned.content;
-      extraImports = partitioned.hoisted;
-    }
-    if (PROTECTED_TARGETS.has(target) && existsSync(outputPath)) {
-      const existing = await fs6.readFile(outputPath, "utf-8");
-      if (existing === content) {
-        skipped.push({ path: target, reason: "unchanged" });
-        continue;
-      }
-      if (!options.overwrite && !await confirmOverwrite(target)) {
-        skipped.push({ path: target, reason: "declined" });
-        continue;
-      }
-    }
-    await fs6.mkdir(path5.dirname(outputPath), { recursive: true });
-    await fs6.writeFile(outputPath, content, "utf-8");
-    written.push(target);
-  }
-  return {
-    indexPath: path5.join(cssDir, INDEX_TARGET),
-    typographyPath: path5.join(cssDir, TYPOGRAPHY_TARGET),
-    extraImports,
-    dependencies: item.dependencies ?? [],
-    written,
-    skipped
-  };
-}
-
-// src/utils/install-deps.ts
-import fs7 from "fs";
-import path6 from "path";
-import { detect } from "@antfu/ni";
-import { execa } from "execa";
-
-// src/utils/format.ts
-var BRAND = "\x1B[38;2;166;244;48m";
-var DIM = "\x1B[2m";
-var RESET = "\x1B[0m";
-var enabled = process.stdout.isTTY && !process.env.NO_COLOR;
-var wrap = (code, text) => enabled ? `${code}${text}${RESET}` : text;
-var brand = (text) => wrap(BRAND, text);
-var dim = (text) => wrap(DIM, text);
-var LOGO = brand("\u273B");
-var CHECK = brand("\u2713");
-var CROSS = "\u2717";
-var WARN = "!";
-
-// src/utils/spinner.ts
-var FRAMES = ["\u2022", "\u2726", "\u2736", "\u273B"].map(brand);
-var INTERVAL_MS = 150;
-function createSpinner(text) {
-  const isTTY = process.stdout.isTTY;
-  if (!isTTY) {
-    process.stdout.write(`  ${text}...
-`);
-    return {
-      succeed(msg) {
-        process.stdout.write(`  ${CHECK}  ${msg}
-`);
-      },
-      fail(msg) {
-        process.stdout.write(`  ${CROSS}  ${msg}
-`);
-      }
-    };
-  }
-  let frameIndex = 0;
-  const interval = setInterval(() => {
-    process.stdout.write(`\r  ${FRAMES[frameIndex % FRAMES.length]}  ${text}`);
-    frameIndex++;
-  }, INTERVAL_MS);
-  const clear = () => {
-    clearInterval(interval);
-    process.stdout.write("\r" + " ".repeat(text.length + 6) + "\r");
-  };
-  return {
-    succeed(msg) {
-      clear();
-      process.stdout.write(`  ${CHECK}  ${msg}
-`);
-    },
-    fail(msg) {
-      clear();
-      process.stdout.write(`  ${CROSS}  ${msg}
-`);
-    }
-  };
-}
-
-// src/utils/install-deps.ts
-async function detectPackageManager(cwd) {
-  const detected = await detect({ programmatic: true, cwd });
-  if (detected === "pnpm@6" || detected === "pnpm") return "pnpm";
-  if (detected === "yarn@berry" || detected === "yarn") return "yarn";
-  if (detected === "bun") return "bun";
-  if (detected === "npm") return "npm";
-  const userAgent = process.env.npm_config_user_agent || "";
-  if (userAgent.startsWith("pnpm")) return "pnpm";
-  if (userAgent.startsWith("yarn")) return "yarn";
-  if (userAgent.startsWith("bun")) return "bun";
-  return "npm";
-}
-function getInstallArgs(pm, deps) {
-  switch (pm) {
-    case "pnpm":
-      return ["pnpm", ["add", ...deps]];
-    case "yarn":
-      return ["yarn", ["add", ...deps]];
-    case "bun":
-      return ["bun", ["add", ...deps]];
-    default:
-      return ["npm", ["install", ...deps]];
-  }
-}
-async function installDependencies(deps, cwd) {
-  if (deps.length === 0) return;
-  const pkgPath = path6.join(cwd, "package.json");
-  let existing = /* @__PURE__ */ new Set();
-  if (fs7.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
-      existing = new Set(
-        Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })
-      );
-    } catch {
-    }
-  }
-  const toInstall = deps.filter((dep) => !existing.has(dep));
-  if (toInstall.length === 0) return;
-  const pm = await detectPackageManager(cwd);
-  const [cmd, args] = getInstallArgs(pm, toInstall);
-  const spinner = createSpinner(`Installing with ${pm}`);
-  try {
-    await execa(cmd, args, { cwd });
-    spinner.succeed(`Installed ${toInstall.join(", ")} with ${pm}`);
-  } catch (error) {
-    spinner.fail(`Install failed`);
-    if (error instanceof Error && "stdout" in error && typeof error.stdout === "string" && error.stdout.includes("ERR_PNPM_ADDING_TO_ROOT")) {
-      throw new Error(
-        `Cannot install dependencies at a pnpm workspace root.
-Run stera-ui init from within a specific workspace package instead,
-or use "pnpm add -w <package>" manually to install at the root.`
-      );
-    }
-    throw error;
-  }
-}
-
-// src/utils/update-fonts.ts
-import { existsSync as existsSync2, promises as fs8 } from "fs";
-import path7 from "path";
-import {
-  Project,
-  ScriptKind,
-  SyntaxKind,
-  VariableDeclarationKind
-} from "ts-morph";
-var ROOT_FONT_VARIABLES = /* @__PURE__ */ new Set([
-  "--font-sans",
-  "--font-serif",
-  "--font-mono"
-]);
-function massageTreeForFonts(fonts, project) {
-  const result = {
-    cssVars: {},
-    dependencies: [],
-    cssImports: []
-  };
-  if (fonts.length === 0) return result;
-  const isNext = project.framework === "next";
-  for (const font of fonts) {
-    if (isNext) {
-      result.cssVars[font.font.variable] = `var(${font.font.variable})`;
-    } else {
-      const fontName = font.name.replace(/^font-/, "");
-      const fontSourceDep = font.font.dependency ?? `@fontsource-variable/${fontName}`;
-      result.dependencies.push(fontSourceDep);
-      result.cssImports.push(`@import "${fontSourceDep}";`);
-      result.cssVars[font.font.variable] = font.font.family;
-    }
-  }
-  return result;
-}
-async function updateFonts(fonts, project, cwd, options = {}) {
-  if (fonts.length === 0) return;
-  if (project.framework !== "next") return;
-  const layoutPath = findLayoutFile(project, cwd);
-  if (!layoutPath) return;
-  if (options.silent) {
-    try {
-      const layoutContent = await fs8.readFile(layoutPath, "utf-8");
-      const updatedContent = transformLayoutFonts(layoutContent, fonts);
-      if (updatedContent !== layoutContent) {
-        await fs8.writeFile(layoutPath, updatedContent, "utf-8");
-      }
-    } catch {
-    }
-    return;
-  }
-  const spinner = createSpinner("Updating fonts");
-  try {
-    const layoutContent = await fs8.readFile(layoutPath, "utf-8");
-    const updatedContent = transformLayoutFonts(layoutContent, fonts);
-    if (updatedContent !== layoutContent) {
-      await fs8.writeFile(layoutPath, updatedContent, "utf-8");
-    }
-    spinner.succeed("Updated layout with font imports");
-  } catch {
-    spinner.fail("Failed to update fonts");
-  }
-}
-function findLayoutFile(project, cwd) {
-  if (!project.layoutFile) return null;
-  const fullPath = path7.join(cwd, project.layoutFile);
-  return existsSync2(fullPath) ? fullPath : null;
-}
-function transformLayoutFonts(input, fonts) {
-  const project = new Project({ compilerOptions: {} });
-  const sourceFile = project.createSourceFile("layout.tsx", input, {
-    scriptKind: ScriptKind.TSX
-  });
-  const googleFonts = fonts.filter((f) => f.font.provider === "google");
-  const fontVariableNames = [];
-  const fontUtilityClasses = [];
-  for (const font of googleFonts) {
-    const importName = font.font.import;
-    if (!importName) continue;
-    const existingImport = sourceFile.getImportDeclaration(
-      (decl) => decl.getModuleSpecifierValue() === "next/font/google"
-    );
-    let hasExistingImport = false;
-    if (existingImport) {
-      const namedImports = existingImport.getNamedImports();
-      hasExistingImport = namedImports.some(
-        (imp) => imp.getName() === importName
-      );
-      if (!hasExistingImport) {
-        existingImport.addNamedImport(importName);
-      }
-    } else {
-      sourceFile.addImportDeclaration({
-        moduleSpecifier: "next/font/google",
-        namedImports: [importName]
-      });
-    }
-    const varName = getFontVariableName(importName, font.font.variable);
-    const fontOptions = buildFontOptions(font);
-    const existingVarDecl = findFontVariableDeclaration(
-      sourceFile,
-      font.font.variable
-    );
-    if (hasExistingImport && !existingVarDecl && isRootFontVariable(font.font.variable)) {
-      continue;
-    }
-    if (existingVarDecl) {
-      existingVarDecl.setInitializer(`${importName}(${fontOptions})`);
-      if (existingVarDecl.getName() !== varName) {
-        existingVarDecl.rename(varName);
-      }
-    } else {
-      const insertPosition = findInsertPosition(sourceFile);
-      const statement = sourceFile.insertVariableStatement(insertPosition, {
-        declarationKind: VariableDeclarationKind.Const,
-        declarations: [
-          {
-            name: varName,
-            initializer: `${importName}(${fontOptions})`
-          }
-        ]
-      });
-      statement.appendWhitespace("\n");
-    }
-    fontVariableNames.push(varName);
-    if (shouldApplyFontUtilityToHtml(font)) {
-      fontUtilityClasses.push(font.font.variable.replace("--", ""));
-    }
-  }
-  const fontFamilyClasses = /* @__PURE__ */ new Set(["font-sans", "font-serif", "font-mono"]);
-  const lastFontFamilyClass = [...fontUtilityClasses].reverse().find((cls) => fontFamilyClasses.has(cls));
-  const filteredUtilityClasses = fontUtilityClasses.filter(
-    (cls) => !fontFamilyClasses.has(cls)
-  );
-  if (lastFontFamilyClass) {
-    filteredUtilityClasses.unshift(lastFontFamilyClass);
-  }
-  if (fontVariableNames.length > 0) {
-    updateHtmlClassName(sourceFile, fontVariableNames, filteredUtilityClasses);
-  }
-  return sourceFile.getFullText();
-}
-function buildFontOptions(font) {
-  const options = {};
-  if (font.font.subsets?.length) options.subsets = font.font.subsets;
-  if (font.font.weight?.length) options.weight = font.font.weight;
-  options.variable = font.font.variable;
-  return JSON.stringify(options).replace(/"([^"]+)":/g, "$1:").replace(/"/g, "'");
-}
-function isRootFontVariable(variable) {
-  return ROOT_FONT_VARIABLES.has(variable);
-}
-function shouldApplyFontUtilityToHtml(font) {
-  return !font.font.selector && isRootFontVariable(font.font.variable);
-}
-function getFontVariableName(importName, variable) {
-  const baseName = toCamelCase(importName);
-  if (isRootFontVariable(variable)) return baseName;
-  return `${baseName}${toPascalCase(variable.replace(/^--font-/, ""))}`;
-}
-function toCamelCase(str) {
-  return str.split("_").map(
-    (part, index) => index === 0 ? part.toLowerCase() : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
-  ).join("");
-}
-function toPascalCase(str) {
-  return str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function findFontVariableDeclaration(sourceFile, variable) {
-  for (const statement of sourceFile.getVariableStatements()) {
-    for (const declaration of statement.getDeclarations()) {
-      const initializer = declaration.getInitializer();
-      if (!initializer || initializer.getKind() !== SyntaxKind.CallExpression)
-        continue;
-      const args = initializer.getArguments();
-      if (args.length === 0) continue;
-      const argText = args[0].getText();
-      if (argText.includes("variable:") && argText.includes(variable)) {
-        return declaration;
-      }
-    }
-  }
-  return null;
-}
-function findInsertPosition(sourceFile) {
-  const imports = sourceFile.getImportDeclarations();
-  if (imports.length > 0) {
-    return imports[imports.length - 1].getChildIndex() + 1;
-  }
-  return 0;
-}
-function updateHtmlClassName(sourceFile, fontVariableNames, fontUtilityClasses) {
-  const jsxElements = sourceFile.getDescendantsOfKind(
-    SyntaxKind.JsxOpeningElement
-  );
-  for (const element of jsxElements) {
-    if (element.getTagNameNode().getText() !== "html") continue;
-    const newUtilityClasses = fontUtilityClasses.map((cls) => `"${cls}"`);
-    const newVarExpressions = fontVariableNames.map(
-      (name) => `${name}.variable`
-    );
-    const allNewArgs = [...newUtilityClasses, ...newVarExpressions];
-    const classNameAttr = element.getAttribute("className");
-    if (!classNameAttr) {
-      element.addAttribute({
-        name: "className",
-        initializer: `{cn(${allNewArgs.join(", ")})}`
-      });
-      ensureCnImport(sourceFile);
-      return;
-    }
-    if (classNameAttr.getKind() !== SyntaxKind.JsxAttribute) return;
-    const jsxAttr = classNameAttr.asKindOrThrow(SyntaxKind.JsxAttribute);
-    const initializer = jsxAttr.getInitializer();
-    if (!initializer) return;
-    if (initializer.getKind() === SyntaxKind.StringLiteral) {
-      const currentValue = initializer.getText().slice(1, -1);
-      ensureCnImport(sourceFile);
-      jsxAttr.setInitializer(
-        `{cn("${currentValue}", ${allNewArgs.join(", ")})}`
-      );
-    } else if (initializer.getKind() === SyntaxKind.JsxExpression) {
-      const jsxExpr = initializer.asKindOrThrow(SyntaxKind.JsxExpression);
-      const expr = jsxExpr.getExpression();
-      if (!expr) return;
-      const exprText = expr.getText();
-      if (exprText.startsWith("cn(")) {
-        const hasAllFontVars = newVarExpressions.every(
-          (v) => exprText.includes(v)
-        );
-        const hasAllUtilityClasses = fontUtilityClasses.every(
-          (cls) => exprText.includes(`"${cls}"`)
-        );
-        if (hasAllFontVars && hasAllUtilityClasses) continue;
-        let cleanedExpr = exprText;
-        for (const varExpr of newVarExpressions) {
-          cleanedExpr = cleanedExpr.replace(
-            new RegExp(`,?\\s*${varExpr.replace(".", "\\.")}`, "g"),
-            ""
-          );
-        }
-        cleanedExpr = cleanedExpr.replace(/cn\(\s*,/, "cn(");
-        const newExpr = cleanedExpr.replace(
-          /\)$/,
-          `, ${allNewArgs.join(", ")})`
-        );
-        jsxExpr.replaceWithText(`{${newExpr}}`);
-      } else if (/^\w+\.variable$/.test(exprText)) {
-        ensureCnImport(sourceFile);
-        jsxExpr.replaceWithText(`{cn(${allNewArgs.join(", ")})}`);
-      } else if (exprText.startsWith("`") && exprText.endsWith("`")) {
-        const cnArgs = parseTemplateLiteralToCnArgs(exprText);
-        ensureCnImport(sourceFile);
-        const allNewArgsSet = new Set(allNewArgs);
-        const fontFamilyLiterals = new Set(
-          ["font-sans", "font-serif", "font-mono"].map((c) => `"${c}"`)
-        );
-        const cleanedCnArgs = cnArgs.filter(
-          (arg) => !allNewArgsSet.has(arg) && !fontFamilyLiterals.has(arg)
-        );
-        jsxExpr.replaceWithText(
-          `{cn(${[...cleanedCnArgs, ...allNewArgs].join(", ")})}`
-        );
-      } else {
-        ensureCnImport(sourceFile);
-        jsxExpr.replaceWithText(`{cn(${exprText}, ${allNewArgs.join(", ")})}`);
-      }
-    }
-  }
-}
-function ensureCnImport(sourceFile) {
-  const existingImport = sourceFile.getImportDeclaration(
-    (decl) => decl.getNamedImports().some((imp) => imp.getName() === "cn")
-  );
-  if (!existingImport) {
-    const utilsImport = sourceFile.getImportDeclaration(
-      (decl) => decl.getModuleSpecifierValue().includes("/lib/utils")
-    );
-    if (utilsImport) {
-      const namedImports = utilsImport.getNamedImports();
-      if (!namedImports.some((imp) => imp.getName() === "cn")) {
-        utilsImport.addNamedImport("cn");
-      }
-    } else {
-      sourceFile.addImportDeclaration({
-        moduleSpecifier: "@/lib/utils",
-        namedImports: ["cn"]
-      });
-    }
-  }
-}
-function parseTemplateLiteralToCnArgs(templateLiteral) {
-  const staticArgs = [];
-  const variableArgs = [];
-  const content = templateLiteral.slice(1, -1);
-  const parts = content.split(/(\$\{[^}]+\})/);
-  for (const part of parts) {
-    if (!part) continue;
-    if (part.startsWith("${") && part.endsWith("}")) {
-      const expr = part.slice(2, -1).trim();
-      if (expr) variableArgs.push(expr);
-    } else {
-      const staticParts = part.trim().split(/\s+/).filter(Boolean);
-      for (const staticPart of staticParts) {
-        staticArgs.push(`"${staticPart}"`);
-      }
-    }
-  }
-  return [...staticArgs, ...variableArgs];
-}
-
-export {
-  applyTransforms,
-  transformImports,
-  resolveOutputPath,
-  CONFIG_FILE,
-  LEGACY_CONFIG_FILE,
-  findConfigPath,
-  loadConfig2 as loadConfig,
-  detectProject,
-  detectAliasPrefix,
-  insertImportLine,
-  writeComponentFiles,
-  INDEX_TARGET,
-  TYPOGRAPHY_TARGET,
-  migrateLegacyStyles,
-  writeStyles,
-  brand,
-  dim,
-  LOGO,
-  CHECK,
-  CROSS,
-  WARN,
-  createSpinner,
-  detectPackageManager,
-  installDependencies,
-  massageTreeForFonts,
-  updateFonts
-};