nuxt-og-image 5.1.13 → 6.0.0-beta.10

package/README.md

@@ -28,7 +28,7 @@ need this module.
 
 - ✨ Create an `og:image` using the built-in templates or make your own with Vue components
 - 🎨 Design and test your `og:image` in the Nuxt DevTools OG Image Playground with full HMR
-- ▲ Render using [Satori](https://github.com/vercel/satori): Tailwind / UnoCSS with your theme, Google fonts, 6 emoji families supported and more!
+- ▲ Render using [Satori](https://github.com/vercel/satori) or [Takumi](https://github.com/kane50613/takumi): Tailwind / UnoCSS with your theme, Google fonts, 6 emoji families and more!
 - 🤖 Or prerender using the Browser: Supporting painless, complex templates
 - 📸 Feeling lazy? Just generate screenshots for every page: hide elements, wait for animations, and more
 - ⚙️ Works on the edge: Vercel Edge, Netlify Edge and Cloudflare Workers

package/bin/cli.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/cli.mjs')

package/dist/chunks/css-classes.cjs

@@ -0,0 +1,307 @@
+'use strict';
+
+const fs = require('node:fs');
+const promises = require('node:fs/promises');
+const pathe = require('pathe');
+const module$1 = require('../shared/nuxt-og-image.DJ4fZgE4.cjs');
+require('@nuxt/kit');
+require('defu');
+require('jiti');
+require('nuxt-site-config/kit');
+require('ohash');
+require('pkg-types');
+require('std-env');
+require('node:crypto');
+require('../../dist/runtime/logger.js');
+require('chrome-launcher');
+require('exsolve');
+require('tailwindcss/colors');
+require('culori');
+require('node:path');
+require('@nuxt/devtools-kit');
+require('node:url');
+require('magic-string');
+require('strip-literal');
+require('ufo');
+require('unplugin');
+require('ofetch');
+require('../../dist/runtime/server/og-image/satori/transforms/emojis/emoji-utils.js');
+require('@vue/compiler-sfc');
+require('magicast');
+require('magicast/helpers');
+require('nypm');
+
+let parseSfc;
+async function loadParser() {
+  if (!parseSfc)
+    parseSfc = (await import('@vue/compiler-sfc')).parse;
+  return parseSfc;
+}
+const FONT_WEIGHT_CLASSES = {
+  "font-thin": 100,
+  "font-extralight": 200,
+  "font-light": 300,
+  "font-normal": 400,
+  "font-medium": 500,
+  "font-semibold": 600,
+  "font-bold": 700,
+  "font-extrabold": 800,
+  "font-black": 900
+};
+const INLINE_FONT_WEIGHT_REGEX = /font-weight:\s*(\d+)/g;
+const ELEMENT_NODE = 1;
+const ATTRIBUTE_NODE = 6;
+const DIRECTIVE_NODE = 7;
+async function extractClassesFromVue(code) {
+  const parse = await loadParser();
+  const { descriptor } = parse(code);
+  if (!descriptor.template?.ast)
+    return [];
+  const classes = [];
+  module$1.walkTemplateAst(descriptor.template.ast.children, (node) => {
+    if (node.type !== ELEMENT_NODE)
+      return;
+    const el = node;
+    for (const prop of el.props) {
+      if (prop.type === ATTRIBUTE_NODE && prop.name === "class" && prop.value) {
+        for (const cls of prop.value.content.split(/\s+/)) {
+          if (cls && !cls.includes("{") && !cls.includes("$"))
+            classes.push(cls);
+        }
+      }
+      if (prop.type === DIRECTIVE_NODE && prop.name === "bind" && prop.arg?.type === 4 && prop.arg.content === "class") {
+        const expr = prop.exp;
+        if (expr?.type === 4) {
+          const content = expr.content;
+          extractClassesFromExpression(content, classes);
+        }
+      }
+    }
+  });
+  return classes;
+}
+function extractClassesFromExpression(expr, classes) {
+  for (const match of expr.matchAll(/['"`]([\w:.\-/]+)['"`]/g)) {
+    const cls = match[1];
+    if (cls && !cls.includes("{") && !cls.includes("$") && !cls.includes("/"))
+      classes.push(cls);
+  }
+}
+async function scanComponentClasses(components, logger, cacheDir) {
+  const classes = /* @__PURE__ */ new Set();
+  const cacheFile = cacheDir ? pathe.join(cacheDir, "cache", "og-image", "css-classes.json") : null;
+  let cache = { files: {} };
+  if (cacheFile && fs.existsSync(cacheFile)) {
+    cache = await promises.readFile(cacheFile, "utf-8").then((c) => JSON.parse(c)).catch(() => ({ files: {} }));
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const seenPaths = /* @__PURE__ */ new Set();
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  for (const component of components) {
+    if (!component.path)
+      continue;
+    if (seenPaths.has(component.path))
+      continue;
+    seenPaths.add(component.path);
+    const cacheKey = component.hash || component.path;
+    seenKeys.add(cacheKey);
+    const cached = cache.files[cacheKey];
+    if (cached) {
+      cacheHits++;
+      for (const cls of cached)
+        classes.add(cls);
+      continue;
+    }
+    cacheMisses++;
+    logger?.debug(`CSS: Scanning component ${component.path}`);
+    const content = await promises.readFile(component.path, "utf-8").catch(() => null);
+    if (!content) {
+      cache.files[cacheKey] = [];
+      continue;
+    }
+    const fileClasses = await extractClassesFromVue(content);
+    cache.files[cacheKey] = fileClasses;
+    for (const cls of fileClasses)
+      classes.add(cls);
+  }
+  for (const key of Object.keys(cache.files)) {
+    if (!seenKeys.has(key))
+      delete cache.files[key];
+  }
+  if (cacheFile) {
+    const cacheParent = pathe.join(cacheDir, "cache", "og-image");
+    fs.mkdirSync(cacheParent, { recursive: true });
+    await promises.writeFile(cacheFile, JSON.stringify(cache));
+  }
+  if (cacheHits > 0 || cacheMisses > 0)
+    logger?.debug(`CSS: Class cache - ${cacheHits} hits, ${cacheMisses} misses`);
+  return classes;
+}
+function filterProcessableClasses(classes) {
+  const processable = [];
+  const responsivePrefixes = ["sm:", "md:", "lg:", "xl:", "2xl:"];
+  for (const cls of classes) {
+    if (responsivePrefixes.some((p) => cls.startsWith(p))) {
+      const baseClass = cls.replace(/^(sm|md|lg|xl|2xl):/, "");
+      if (baseClass)
+        processable.push(baseClass);
+      continue;
+    }
+    if (cls.includes("hover:") || cls.includes("focus:") || cls.includes("active:"))
+      continue;
+    if (cls.startsWith("dark:"))
+      continue;
+    processable.push(cls);
+  }
+  return [...new Set(processable)];
+}
+async function extractFontRequirementsFromVue(code) {
+  const parse = await loadParser();
+  const { descriptor } = parse(code);
+  const weights = /* @__PURE__ */ new Set();
+  const styles = /* @__PURE__ */ new Set(["normal"]);
+  let isComplete = true;
+  if (!descriptor.template?.ast)
+    return { weights, styles, isComplete };
+  module$1.walkTemplateAst(descriptor.template.ast.children, (node) => {
+    if (node.type !== ELEMENT_NODE)
+      return;
+    const el = node;
+    for (const prop of el.props) {
+      if (prop.type === ATTRIBUTE_NODE && prop.name === "class" && prop.value) {
+        for (const cls of prop.value.content.split(/\s+/)) {
+          extractFontWeightFromClass(cls, weights, styles);
+        }
+      }
+      if (prop.type === ATTRIBUTE_NODE && prop.name === "style" && prop.value) {
+        extractFontWeightFromStyle(prop.value.content, weights, styles);
+      }
+      if (prop.type === DIRECTIVE_NODE && prop.name === "bind" && prop.arg?.type === 4) {
+        const argContent = prop.arg.content;
+        const expr = prop.exp;
+        if (argContent === "class" && expr?.type === 4) {
+          const content = expr.content;
+          if (content.includes("props.") || content.includes("$props") || /\bfont(?:Weight|-weight)\b/i.test(content)) {
+            isComplete = false;
+          }
+          for (const match of content.matchAll(/['"`]([\w:.\-]+)['"`]/g)) {
+            extractFontWeightFromClass(match[1], weights, styles);
+          }
+        }
+        if (argContent === "style" && expr?.type === 4) {
+          const content = expr.content;
+          if (/font-?weight/i.test(content) && (content.includes("props.") || content.includes("$props") || content.includes("?"))) {
+            isComplete = false;
+          }
+          extractFontWeightFromStyle(content, weights, styles);
+        }
+      }
+    }
+  });
+  return { weights, styles, isComplete };
+}
+function extractFontWeightFromClass(cls, weights, styles) {
+  const baseClass = cls.replace(/^(?:sm:|md:|lg:|xl:|2xl:|dark:|hover:|focus:|active:)+/, "");
+  const weight = FONT_WEIGHT_CLASSES[baseClass];
+  if (weight !== void 0) {
+    weights.add(weight);
+  }
+  if (baseClass === "italic") {
+    styles.add("italic");
+  }
+}
+function extractFontWeightFromStyle(style, weights, styles) {
+  for (const match of style.matchAll(INLINE_FONT_WEIGHT_REGEX)) {
+    const weight = Number.parseInt(match[1], 10);
+    if (weight >= 100 && weight <= 900) {
+      weights.add(weight);
+    }
+  }
+  if (/font-style:\s*italic/i.test(style)) {
+    styles.add("italic");
+  }
+}
+async function scanFontRequirements(components, logger, cacheDir) {
+  const allWeights = /* @__PURE__ */ new Set();
+  const allStyles = /* @__PURE__ */ new Set(["normal"]);
+  let isComplete = true;
+  const componentMap = {};
+  const cacheFile = cacheDir ? pathe.join(cacheDir, "cache", "og-image", "font-requirements.json") : null;
+  let cache = { files: {} };
+  if (cacheFile && fs.existsSync(cacheFile)) {
+    cache = await promises.readFile(cacheFile, "utf-8").then((c) => JSON.parse(c)).catch(() => ({ files: {} }));
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    if (!component.path)
+      continue;
+    if (seenPaths.has(component.path))
+      continue;
+    seenPaths.add(component.path);
+    const cacheKey = component.hash || component.path;
+    seenKeys.add(cacheKey);
+    const cached = cache.files[cacheKey];
+    if (cached) {
+      for (const w of cached.weights) allWeights.add(w);
+      for (const s of cached.styles) allStyles.add(s);
+      if (!cached.isComplete)
+        isComplete = false;
+      const compWeights2 = cached.weights.length ? [...cached.weights] : [400];
+      if (!compWeights2.includes(400))
+        compWeights2.push(400);
+      componentMap[component.pascalName] = {
+        weights: compWeights2.sort((a, b) => a - b),
+        styles: [...cached.styles],
+        isComplete: cached.isComplete
+      };
+      continue;
+    }
+    const content = await promises.readFile(component.path, "utf-8").catch(() => null);
+    if (!content) {
+      cache.files[cacheKey] = { weights: [], styles: ["normal"], isComplete: true };
+      componentMap[component.pascalName] = { weights: [400], styles: ["normal"], isComplete: true };
+      continue;
+    }
+    const result = await extractFontRequirementsFromVue(content);
+    cache.files[cacheKey] = {
+      weights: [...result.weights],
+      styles: [...result.styles],
+      isComplete: result.isComplete
+    };
+    for (const w of result.weights) allWeights.add(w);
+    for (const s of result.styles) allStyles.add(s);
+    if (!result.isComplete)
+      isComplete = false;
+    const compWeights = [...result.weights];
+    if (!compWeights.includes(400))
+      compWeights.push(400);
+    componentMap[component.pascalName] = {
+      weights: compWeights.sort((a, b) => a - b),
+      styles: [...result.styles],
+      isComplete: result.isComplete
+    };
+  }
+  for (const key of Object.keys(cache.files)) {
+    if (!seenKeys.has(key))
+      delete cache.files[key];
+  }
+  if (cacheFile) {
+    const cacheParent = pathe.join(cacheDir, "cache", "og-image");
+    fs.mkdirSync(cacheParent, { recursive: true });
+    await promises.writeFile(cacheFile, JSON.stringify(cache));
+  }
+  allWeights.add(400);
+  const weights = [...allWeights].sort((a, b) => a - b);
+  const styles = [...allStyles];
+  logger?.debug(`Fonts: Detected weights [${weights.join(", ")}], styles [${styles.join(", ")}]${isComplete ? "" : " (incomplete analysis)"}`);
+  return {
+    global: { weights, styles, isComplete },
+    components: componentMap
+  };
+}
+
+exports.filterProcessableClasses = filterProcessableClasses;
+exports.scanComponentClasses = scanComponentClasses;
+exports.scanFontRequirements = scanFontRequirements;

package/dist/chunks/css-classes.mjs

@@ -0,0 +1,303 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'pathe';
+import { w as walkTemplateAst } from '../shared/nuxt-og-image.vDJ3zH1b.mjs';
+import '@nuxt/kit';
+import 'defu';
+import 'jiti';
+import 'nuxt-site-config/kit';
+import 'ohash';
+import 'pkg-types';
+import 'std-env';
+import 'node:crypto';
+import '../../dist/runtime/logger.js';
+import 'chrome-launcher';
+import 'exsolve';
+import 'tailwindcss/colors';
+import 'culori';
+import 'node:path';
+import '@nuxt/devtools-kit';
+import 'node:url';
+import 'magic-string';
+import 'strip-literal';
+import 'ufo';
+import 'unplugin';
+import 'ofetch';
+import '../../dist/runtime/server/og-image/satori/transforms/emojis/emoji-utils.js';
+import '@vue/compiler-sfc';
+import 'magicast';
+import 'magicast/helpers';
+import 'nypm';
+
+let parseSfc;
+async function loadParser() {
+  if (!parseSfc)
+    parseSfc = (await import('@vue/compiler-sfc')).parse;
+  return parseSfc;
+}
+const FONT_WEIGHT_CLASSES = {
+  "font-thin": 100,
+  "font-extralight": 200,
+  "font-light": 300,
+  "font-normal": 400,
+  "font-medium": 500,
+  "font-semibold": 600,
+  "font-bold": 700,
+  "font-extrabold": 800,
+  "font-black": 900
+};
+const INLINE_FONT_WEIGHT_REGEX = /font-weight:\s*(\d+)/g;
+const ELEMENT_NODE = 1;
+const ATTRIBUTE_NODE = 6;
+const DIRECTIVE_NODE = 7;
+async function extractClassesFromVue(code) {
+  const parse = await loadParser();
+  const { descriptor } = parse(code);
+  if (!descriptor.template?.ast)
+    return [];
+  const classes = [];
+  walkTemplateAst(descriptor.template.ast.children, (node) => {
+    if (node.type !== ELEMENT_NODE)
+      return;
+    const el = node;
+    for (const prop of el.props) {
+      if (prop.type === ATTRIBUTE_NODE && prop.name === "class" && prop.value) {
+        for (const cls of prop.value.content.split(/\s+/)) {
+          if (cls && !cls.includes("{") && !cls.includes("$"))
+            classes.push(cls);
+        }
+      }
+      if (prop.type === DIRECTIVE_NODE && prop.name === "bind" && prop.arg?.type === 4 && prop.arg.content === "class") {
+        const expr = prop.exp;
+        if (expr?.type === 4) {
+          const content = expr.content;
+          extractClassesFromExpression(content, classes);
+        }
+      }
+    }
+  });
+  return classes;
+}
+function extractClassesFromExpression(expr, classes) {
+  for (const match of expr.matchAll(/['"`]([\w:.\-/]+)['"`]/g)) {
+    const cls = match[1];
+    if (cls && !cls.includes("{") && !cls.includes("$") && !cls.includes("/"))
+      classes.push(cls);
+  }
+}
+async function scanComponentClasses(components, logger, cacheDir) {
+  const classes = /* @__PURE__ */ new Set();
+  const cacheFile = cacheDir ? join(cacheDir, "cache", "og-image", "css-classes.json") : null;
+  let cache = { files: {} };
+  if (cacheFile && existsSync(cacheFile)) {
+    cache = await readFile(cacheFile, "utf-8").then((c) => JSON.parse(c)).catch(() => ({ files: {} }));
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const seenPaths = /* @__PURE__ */ new Set();
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  for (const component of components) {
+    if (!component.path)
+      continue;
+    if (seenPaths.has(component.path))
+      continue;
+    seenPaths.add(component.path);
+    const cacheKey = component.hash || component.path;
+    seenKeys.add(cacheKey);
+    const cached = cache.files[cacheKey];
+    if (cached) {
+      cacheHits++;
+      for (const cls of cached)
+        classes.add(cls);
+      continue;
+    }
+    cacheMisses++;
+    logger?.debug(`CSS: Scanning component ${component.path}`);
+    const content = await readFile(component.path, "utf-8").catch(() => null);
+    if (!content) {
+      cache.files[cacheKey] = [];
+      continue;
+    }
+    const fileClasses = await extractClassesFromVue(content);
+    cache.files[cacheKey] = fileClasses;
+    for (const cls of fileClasses)
+      classes.add(cls);
+  }
+  for (const key of Object.keys(cache.files)) {
+    if (!seenKeys.has(key))
+      delete cache.files[key];
+  }
+  if (cacheFile) {
+    const cacheParent = join(cacheDir, "cache", "og-image");
+    mkdirSync(cacheParent, { recursive: true });
+    await writeFile(cacheFile, JSON.stringify(cache));
+  }
+  if (cacheHits > 0 || cacheMisses > 0)
+    logger?.debug(`CSS: Class cache - ${cacheHits} hits, ${cacheMisses} misses`);
+  return classes;
+}
+function filterProcessableClasses(classes) {
+  const processable = [];
+  const responsivePrefixes = ["sm:", "md:", "lg:", "xl:", "2xl:"];
+  for (const cls of classes) {
+    if (responsivePrefixes.some((p) => cls.startsWith(p))) {
+      const baseClass = cls.replace(/^(sm|md|lg|xl|2xl):/, "");
+      if (baseClass)
+        processable.push(baseClass);
+      continue;
+    }
+    if (cls.includes("hover:") || cls.includes("focus:") || cls.includes("active:"))
+      continue;
+    if (cls.startsWith("dark:"))
+      continue;
+    processable.push(cls);
+  }
+  return [...new Set(processable)];
+}
+async function extractFontRequirementsFromVue(code) {
+  const parse = await loadParser();
+  const { descriptor } = parse(code);
+  const weights = /* @__PURE__ */ new Set();
+  const styles = /* @__PURE__ */ new Set(["normal"]);
+  let isComplete = true;
+  if (!descriptor.template?.ast)
+    return { weights, styles, isComplete };
+  walkTemplateAst(descriptor.template.ast.children, (node) => {
+    if (node.type !== ELEMENT_NODE)
+      return;
+    const el = node;
+    for (const prop of el.props) {
+      if (prop.type === ATTRIBUTE_NODE && prop.name === "class" && prop.value) {
+        for (const cls of prop.value.content.split(/\s+/)) {
+          extractFontWeightFromClass(cls, weights, styles);
+        }
+      }
+      if (prop.type === ATTRIBUTE_NODE && prop.name === "style" && prop.value) {
+        extractFontWeightFromStyle(prop.value.content, weights, styles);
+      }
+      if (prop.type === DIRECTIVE_NODE && prop.name === "bind" && prop.arg?.type === 4) {
+        const argContent = prop.arg.content;
+        const expr = prop.exp;
+        if (argContent === "class" && expr?.type === 4) {
+          const content = expr.content;
+          if (content.includes("props.") || content.includes("$props") || /\bfont(?:Weight|-weight)\b/i.test(content)) {
+            isComplete = false;
+          }
+          for (const match of content.matchAll(/['"`]([\w:.\-]+)['"`]/g)) {
+            extractFontWeightFromClass(match[1], weights, styles);
+          }
+        }
+        if (argContent === "style" && expr?.type === 4) {
+          const content = expr.content;
+          if (/font-?weight/i.test(content) && (content.includes("props.") || content.includes("$props") || content.includes("?"))) {
+            isComplete = false;
+          }
+          extractFontWeightFromStyle(content, weights, styles);
+        }
+      }
+    }
+  });
+  return { weights, styles, isComplete };
+}
+function extractFontWeightFromClass(cls, weights, styles) {
+  const baseClass = cls.replace(/^(?:sm:|md:|lg:|xl:|2xl:|dark:|hover:|focus:|active:)+/, "");
+  const weight = FONT_WEIGHT_CLASSES[baseClass];
+  if (weight !== void 0) {
+    weights.add(weight);
+  }
+  if (baseClass === "italic") {
+    styles.add("italic");
+  }
+}
+function extractFontWeightFromStyle(style, weights, styles) {
+  for (const match of style.matchAll(INLINE_FONT_WEIGHT_REGEX)) {
+    const weight = Number.parseInt(match[1], 10);
+    if (weight >= 100 && weight <= 900) {
+      weights.add(weight);
+    }
+  }
+  if (/font-style:\s*italic/i.test(style)) {
+    styles.add("italic");
+  }
+}
+async function scanFontRequirements(components, logger, cacheDir) {
+  const allWeights = /* @__PURE__ */ new Set();
+  const allStyles = /* @__PURE__ */ new Set(["normal"]);
+  let isComplete = true;
+  const componentMap = {};
+  const cacheFile = cacheDir ? join(cacheDir, "cache", "og-image", "font-requirements.json") : null;
+  let cache = { files: {} };
+  if (cacheFile && existsSync(cacheFile)) {
+    cache = await readFile(cacheFile, "utf-8").then((c) => JSON.parse(c)).catch(() => ({ files: {} }));
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    if (!component.path)
+      continue;
+    if (seenPaths.has(component.path))
+      continue;
+    seenPaths.add(component.path);
+    const cacheKey = component.hash || component.path;
+    seenKeys.add(cacheKey);
+    const cached = cache.files[cacheKey];
+    if (cached) {
+      for (const w of cached.weights) allWeights.add(w);
+      for (const s of cached.styles) allStyles.add(s);
+      if (!cached.isComplete)
+        isComplete = false;
+      const compWeights2 = cached.weights.length ? [...cached.weights] : [400];
+      if (!compWeights2.includes(400))
+        compWeights2.push(400);
+      componentMap[component.pascalName] = {
+        weights: compWeights2.sort((a, b) => a - b),
+        styles: [...cached.styles],
+        isComplete: cached.isComplete
+      };
+      continue;
+    }
+    const content = await readFile(component.path, "utf-8").catch(() => null);
+    if (!content) {
+      cache.files[cacheKey] = { weights: [], styles: ["normal"], isComplete: true };
+      componentMap[component.pascalName] = { weights: [400], styles: ["normal"], isComplete: true };
+      continue;
+    }
+    const result = await extractFontRequirementsFromVue(content);
+    cache.files[cacheKey] = {
+      weights: [...result.weights],
+      styles: [...result.styles],
+      isComplete: result.isComplete
+    };
+    for (const w of result.weights) allWeights.add(w);
+    for (const s of result.styles) allStyles.add(s);
+    if (!result.isComplete)
+      isComplete = false;
+    const compWeights = [...result.weights];
+    if (!compWeights.includes(400))
+      compWeights.push(400);
+    componentMap[component.pascalName] = {
+      weights: compWeights.sort((a, b) => a - b),
+      styles: [...result.styles],
+      isComplete: result.isComplete
+    };
+  }
+  for (const key of Object.keys(cache.files)) {
+    if (!seenKeys.has(key))
+      delete cache.files[key];
+  }
+  if (cacheFile) {
+    const cacheParent = join(cacheDir, "cache", "og-image");
+    mkdirSync(cacheParent, { recursive: true });
+    await writeFile(cacheFile, JSON.stringify(cache));
+  }
+  allWeights.add(400);
+  const weights = [...allWeights].sort((a, b) => a - b);
+  const styles = [...allStyles];
+  logger?.debug(`Fonts: Detected weights [${weights.join(", ")}], styles [${styles.join(", ")}]${isComplete ? "" : " (incomplete analysis)"}`);
+  return {
+    global: { weights, styles, isComplete },
+    components: componentMap
+  };
+}
+
+export { filterProcessableClasses, scanComponentClasses, scanFontRequirements };

package/dist/chunks/css-provider.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const exsolve = require('exsolve');
+
+function detectCssProvider(nuxt) {
+  const modules = nuxt.options.modules.flat();
+  if (modules.some((m) => typeof m === "string" && m.includes("@unocss/nuxt")))
+    return "unocss";
+  if (exsolve.resolveModulePath("tailwindcss", { from: nuxt.options.rootDir }))
+    return "tailwind";
+  return null;
+}
+
+exports.detectCssProvider = detectCssProvider;

package/dist/chunks/css-provider.mjs

@@ -0,0 +1,12 @@
+import { resolveModulePath } from 'exsolve';
+
+function detectCssProvider(nuxt) {
+  const modules = nuxt.options.modules.flat();
+  if (modules.some((m) => typeof m === "string" && m.includes("@unocss/nuxt")))
+    return "unocss";
+  if (resolveModulePath("tailwindcss", { from: nuxt.options.rootDir }))
+    return "tailwind";
+  return null;
+}
+
+export { detectCssProvider };