tailwind-styled-v4 4.0.0 → 5.0.1

package/dist/analyzer.mjs

@@ -0,0 +1,1544 @@
+import fs2 from 'fs';
+import { createRequire } from 'module';
+import os from 'os';
+import path5 from 'path';
+import { pathToFileURL, fileURLToPath } from 'url';
+import { Worker } from 'worker_threads';
+
+/* tailwind-styled-v4 v5.0.1 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+function getPlatformExtension() {
+  const platform = os.platform();
+  switch (platform) {
+    case "win32":
+      return ".node";
+    case "darwin":
+      return ".dylib";
+    case "linux":
+      return ".so";
+    default:
+      return ".node";
+  }
+}
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function resolveRuntimeDir(dirnameValue, moduleImportUrl) {
+  if (typeof dirnameValue === "string" && dirnameValue.length > 0) return dirnameValue;
+  return path5.dirname(fileURLToPath(moduleImportUrl));
+}
+function resolveNativeBindingCandidates(options) {
+  const out = [];
+  const envVarNames = options.envVarNames ?? ["TWS_NATIVE_PATH"];
+  for (const envVarName of envVarNames) {
+    const raw = process.env[envVarName]?.trim();
+    if (!raw) continue;
+    const resolved = path5.resolve(raw);
+    if (options.enforceNodeExtensionForEnvPath) {
+      if (path5.extname(resolved).toLowerCase() !== ".node") {
+        throw new Error(
+          `Invalid native binding path from ${envVarName}="${raw}". Expected a .node file.`
+        );
+      }
+    }
+    out.push(resolved);
+  }
+  if (options.includeDefaultCandidates !== false) {
+    const ext = options.platformExtension ?? getPlatformExtension();
+    const defaultBindingName = `tailwind_styled_parser${ext}`;
+    out.push(path5.resolve(process.cwd(), "native", defaultBindingName));
+    out.push(path5.resolve(options.runtimeDir, "..", "..", "..", "native", defaultBindingName));
+  }
+  return Array.from(new Set(out));
+}
+function parseDebugToken(namespace, token) {
+  if (token === "*" || token === namespace || token === "tailwind-styled:*") return true;
+  return token.endsWith("*") && namespace.startsWith(token.slice(0, -1));
+}
+function isDebugNamespaceEnabled(namespace) {
+  if (process.env.TWS_DEBUG === "1" || process.env.TAILWIND_STYLED_DEBUG === "1") return true;
+  const raw = process.env.DEBUG;
+  if (!raw) return false;
+  return raw.split(",").map((token) => token.trim()).some((token) => parseDebugToken(namespace, token));
+}
+function createDebugLogger(namespace, label = namespace) {
+  const debugEnabled = isDebugNamespaceEnabled(namespace);
+  return (message) => {
+    if (!debugEnabled) return;
+    console.debug(`[${label}] ${message}`);
+  };
+}
+function loadNativeBinding(options) {
+  const req = createRequire(path5.join(options.runtimeDir, "noop.cjs"));
+  const loadErrors = [];
+  for (const candidate of options.candidates) {
+    if (!fs2.existsSync(candidate)) continue;
+    try {
+      const mod = req(candidate);
+      if (options.isValid(mod)) {
+        return {
+          binding: mod,
+          loadedPath: candidate,
+          loadErrors
+        };
+      }
+      loadErrors.push({
+        path: candidate,
+        message: options.invalidExportMessage
+      });
+    } catch (error) {
+      loadErrors.push({
+        path: candidate,
+        message: formatErrorMessage(error)
+      });
+    }
+  }
+  return {
+    binding: null,
+    loadedPath: null,
+    loadErrors
+  };
+}
+var init_nativeBinding = __esm({
+  "packages/shared/src/nativeBinding.ts"() {
+  }
+});
+
+// packages/shared/src/logger.ts
+function getEnvLevel() {
+  const env = process.env.TWS_LOG_LEVEL?.toLowerCase();
+  if (env && env in LEVELS) return env;
+  return process.env.TWS_DEBUG_SCANNER === "1" ? "debug" : "info";
+}
+function createLogger(prefix, level) {
+  let currentLevel = getEnvLevel();
+  const log3 = (msgLevel, stream, args) => {
+    if (LEVELS[msgLevel] > LEVELS[currentLevel]) return;
+    const line = `[${prefix}] ${args.map(String).join(" ")}
+`;
+    process[stream].write(line);
+  };
+  return {
+    error: (...a) => log3("error", "stderr", a),
+    warn: (...a) => log3("warn", "stderr", a),
+    info: (...a) => log3("info", "stdout", a),
+    debug: (...a) => log3("debug", "stderr", a),
+    setLevel: (l) => {
+      currentLevel = l;
+    }
+  };
+}
+var LEVELS;
+var init_logger = __esm({
+  "packages/shared/src/logger.ts"() {
+    LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+    createLogger("tailwind-styled");
+  }
+});
+
+// packages/shared/src/index.ts
+var init_src = __esm({
+  "packages/shared/src/index.ts"() {
+    init_nativeBinding();
+    init_logger();
+  }
+});
+
+// packages/compiler/src/nativeBridge.ts
+var nativeBridge_exports = {};
+__export(nativeBridge_exports, {
+  adaptNativeResult: () => adaptNativeResult,
+  getNativeBridge: () => getNativeBridge,
+  resetNativeBridgeCache: () => resetNativeBridgeCache
+});
+function tryRequire(id) {
+  try {
+    const mod = requireFromRuntime(id);
+    return mod ?? null;
+  } catch (error) {
+    log.debug(
+      `native bridge load miss ${id}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function getNativeBridge() {
+  if (cachedBridge !== void 0) {
+    if (cachedBridge === null) {
+      throw new Error(
+        `[tailwind-styled/compiler v5] Native binding is required but not available.
+Please ensure:
+  1. The native module is properly installed
+  2. You have run: npm run build:native (or use prebuilt binary)
+  3. TWS_NO_NATIVE environment variable is not set
+
+For help, see: https://tailwind-styled.dev/docs/install`
+      );
+    }
+    return cachedBridge;
+  }
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    cachedBridge = null;
+    throw new Error(
+      `[tailwind-styled/compiler v5] Native binding is required.
+The TWS_NO_NATIVE or TWS_NO_RUST environment variable is set, which disables native binding.
+Please unset this environment variable to use the native compiler.`
+    );
+  }
+  const candidates = [
+    "@tailwind-styled/native",
+    path5.resolve(process.cwd(), "native", "index.mjs"),
+    path5.resolve(runtimeDir, "..", "..", "native", "index.mjs"),
+    path5.resolve(runtimeDir, "..", "..", "..", "native", "index.mjs"),
+    path5.resolve(process.cwd(), "native", "index.node"),
+    path5.resolve(runtimeDir, "..", "..", "native", "index.node"),
+    path5.resolve(runtimeDir, "..", "..", "..", "native", "index.node")
+  ];
+  for (const candidate of candidates) {
+    const bridge = tryRequire(candidate);
+    if (bridge) {
+      log.debug(`native bridge loaded from ${candidate}`);
+      cachedBridge = bridge;
+      return cachedBridge;
+    }
+  }
+  cachedBridge = null;
+  throw new Error(
+    `[tailwind-styled/compiler v5] Native binding not found.
+Tried loading from:
+` + candidates.map((c) => `  - ${c}`).join("\n") + `
+
+Please build the native module:
+  npm run build:native
+
+Or install a prebuilt binary for your platform.`
+  );
+}
+function resetNativeBridgeCache() {
+  cachedBridge = void 0;
+}
+function adaptNativeResult(raw) {
+  let rsc;
+  if (raw.rscJson) {
+    try {
+      const parsed = JSON.parse(raw.rscJson);
+      rsc = {
+        isServer: parsed.isServer,
+        needsClientDirective: parsed.needsClientDirective,
+        clientReasons: []
+      };
+    } catch {
+    }
+  }
+  let metadata;
+  if (raw.metadataJson) {
+    try {
+      metadata = JSON.parse(raw.metadataJson);
+    } catch {
+    }
+  }
+  return {
+    code: raw.code,
+    classes: raw.classes,
+    changed: raw.changed,
+    rsc,
+    metadata
+  };
+}
+var runtimeDir, requireFromRuntime, cachedBridge, log;
+var init_nativeBridge = __esm({
+  "packages/compiler/src/nativeBridge.ts"() {
+    init_src();
+    runtimeDir = typeof __dirname === "string" && __dirname.length > 0 ? __dirname : process.cwd();
+    requireFromRuntime = typeof module !== "undefined" && typeof module.require === "function" ? module.require.bind(module) : createRequire(path5.join(runtimeDir, "noop.cjs"));
+    log = createLogger("compiler:native");
+  }
+});
+
+// packages/scanner/src/native-bridge.ts
+var native_bridge_exports = {};
+__export(native_bridge_exports, {
+  cachePriorityNative: () => cachePriorityNative,
+  cacheReadNative: () => cacheReadNative,
+  cacheWriteNative: () => cacheWriteNative,
+  extractClassesNative: () => extractClassesNative,
+  hasNativeScannerBinding: () => hasNativeScannerBinding,
+  hashContentNative: () => hashContentNative,
+  isRustCacheAvailable: () => isRustCacheAvailable,
+  scanWorkspaceNative: () => scanWorkspaceNative
+});
+function getBinding() {
+  if (_binding !== void 0) {
+    if (_binding === null) {
+      throwNativeBindingError();
+    }
+    return _binding;
+  }
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    _loadError = "Native loading is disabled by TWS_NO_NATIVE or TWS_NO_RUST environment variable.";
+    _binding = null;
+    _candidatePaths = [];
+    throwNativeBindingError();
+  }
+  const runtimeDir2 = typeof __dirname === "string" ? __dirname : process.cwd();
+  _candidatePaths = [
+    path5.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path5.resolve(runtimeDir2, "..", "..", "..", "native", "tailwind_styled_parser.node")
+  ];
+  const req = typeof __require === "function" ? __require : createRequire(path5.join(runtimeDir2, "noop.cjs"));
+  for (const c of _candidatePaths) {
+    try {
+      const mod = req(c);
+      if (mod?.scanWorkspace || mod?.extractClassesFromSource || mod?.hashFileContent || mod?.cacheRead || mod?.cacheWrite) {
+        _binding = mod;
+        return _binding;
+      }
+    } catch (error) {
+      _loadError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  _binding = null;
+  throwNativeBindingError();
+}
+function throwNativeBindingError() {
+  const lines = [
+    "FATAL: Native scanner binding not found.",
+    "",
+    "This package requires the Rust native binding 'tailwind_styled_parser.node'.",
+    "The binding was not found in any of these paths:",
+    ..._candidatePaths.map((p) => `  - ${p}`),
+    ""
+  ];
+  if (_loadError) {
+    lines.push("Load error:", `  ${_loadError}`, "");
+  }
+  lines.push(
+    "To fix this, run:",
+    "  npm run build:rust",
+    "",
+    "This will build the native Rust module from the 'native/' directory.",
+    "If you're using this package in a CI/CD environment, ensure Rust toolchain is installed",
+    "and 'npm run build:rust' is executed before running tests or building."
+  );
+  throw new Error(lines.join("\n"));
+}
+function scanWorkspaceNative(root, extensions) {
+  return getBinding().scanWorkspace(root, extensions ?? null);
+}
+function extractClassesNative(source) {
+  const result = getBinding().extractClassesFromSource?.(source);
+  if (result === null || result === void 0) {
+    throw new Error("Native extractClassesFromSource returned null/undefined");
+  }
+  return result;
+}
+function hashContentNative(content) {
+  const result = getBinding().hashFileContent?.(content);
+  if (result === null || result === void 0) {
+    throw new Error("Native hashFileContent returned null/undefined");
+  }
+  return result;
+}
+function isRustCacheAvailable() {
+  return true;
+}
+function hasNativeScannerBinding() {
+  try {
+    getBinding();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cacheReadNative(cachePath) {
+  const result = getBinding().cacheRead?.(cachePath);
+  if (result === null || result === void 0) {
+    throw new Error("Native cacheRead returned null/undefined");
+  }
+  return result;
+}
+function cacheWriteNative(cachePath, entries) {
+  const result = getBinding().cacheWrite?.(cachePath, entries);
+  if (result === null || result === void 0) {
+    throw new Error("Native cacheWrite returned null/undefined");
+  }
+  return result;
+}
+function cachePriorityNative(mtimeMs, size, cachedMtimeMs, cachedSize, cachedHitCount, cachedLastSeenMs, nowMs = Date.now()) {
+  const result = getBinding().cachePriority?.(
+    mtimeMs,
+    size,
+    cachedMtimeMs,
+    cachedSize,
+    cachedHitCount,
+    cachedLastSeenMs,
+    nowMs
+  );
+  if (result === null || result === void 0) {
+    throw new Error("Native cachePriority returned null/undefined");
+  }
+  return result;
+}
+var _binding, _loadError, _candidatePaths;
+var init_native_bridge = __esm({
+  "packages/scanner/src/native-bridge.ts"() {
+    _binding = void 0;
+    _loadError = null;
+    _candidatePaths = [];
+  }
+});
+function extractAllClasses(source) {
+  const { getNativeBridge: getNativeBridge2 } = (init_nativeBridge(), __toCommonJS(nativeBridge_exports));
+  const native = getNativeBridge2();
+  if (!native?.extractClassesFromSourceNative) {
+    throw new Error(
+      `[tailwind-styled/compiler v5] extractClassesFromSourceNative is required but not available.
+Please ensure the native module is properly built.`
+    );
+  }
+  const result = native.extractClassesFromSourceNative(source);
+  if (!result || result.length < 0) {
+    throw new Error(
+      `[tailwind-styled/compiler v5] extractClassesFromSourceNative returned invalid result.`
+    );
+  }
+  return result.sort();
+}
+
+// packages/scanner/src/index.ts
+init_src();
+
+// packages/scanner/src/cache-native.ts
+init_native_bridge();
+function defaultCachePath(rootDir, cacheDir) {
+  const dir = cacheDir ? path5.resolve(rootDir, cacheDir) : path5.join(process.cwd(), ".cache", "tailwind-styled");
+  return path5.join(dir, "scanner-cache.json");
+}
+function readCache(rootDir, cacheDir) {
+  const cachePath = defaultCachePath(rootDir, cacheDir);
+  const result = cacheReadNative(cachePath);
+  return result.entries.map((e) => ({
+    file: e.file,
+    classes: e.classes,
+    hash: e.hash,
+    mtimeMs: e.mtimeMs,
+    size: e.size,
+    hitCount: e.hitCount
+  }));
+}
+function writeCache(rootDir, entries, cacheDir) {
+  const cachePath = defaultCachePath(rootDir, cacheDir);
+  const success = cacheWriteNative(cachePath, entries);
+  if (!success) {
+    throw new Error(
+      "Native cacheWrite failed. Run 'npm run build:rust' to rebuild native bindings."
+    );
+  }
+}
+function filePriority(mtimeMs, size, cached, nowMs = Date.now()) {
+  return cachePriorityNative(
+    mtimeMs,
+    size,
+    cached?.mtimeMs ?? 0,
+    cached?.size ?? 0,
+    cached?.hitCount ?? 0,
+    cached?.lastSeenMs ?? 0,
+    nowMs
+  );
+}
+
+// packages/scanner/src/index.ts
+init_native_bridge();
+var log2 = createLogger("scanner");
+var SCAN_WORKER_TIMEOUT_MS = 12e4;
+var SCAN_WORKER_BOOTSTRAP = `
+const { parentPort, workerData } = require("node:worker_threads")
+try {
+  const scanner = require(workerData.modulePath)
+  const result = scanner.scanWorkspace(workerData.rootDir, workerData.options ?? {})
+  parentPort.postMessage({ ok: true, result })
+} catch (error) {
+  parentPort.postMessage({
+    ok: false,
+    error: error instanceof Error ? error.message : String(error),
+  })
+}
+`;
+var nativeParserBinding;
+var nativeParserInitError = null;
+function canUseCjsRequire() {
+  return typeof __require === "function";
+}
+function debugNative(message) {
+  log2.debug(`[native] ${message}`);
+}
+function loadNativeParserBinding() {
+  if (nativeParserBinding !== void 0) return nativeParserBinding;
+  if (!canUseCjsRequire()) {
+    nativeParserBinding = null;
+    nativeParserInitError = "require is unavailable in current module format";
+    debugNative(`fallback to JS: ${nativeParserInitError}`);
+    return nativeParserBinding;
+  }
+  const candidates = [
+    path5.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+    path5.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node")
+  ];
+  for (const fullPath of candidates) {
+    if (!fs2.existsSync(fullPath)) continue;
+    try {
+      const required = __require(fullPath);
+      if (required && typeof required.parse_classes === "function") {
+        nativeParserBinding = required;
+        debugNative(`using native parser from ${fullPath}`);
+        return nativeParserBinding;
+      }
+    } catch (error) {
+      nativeParserInitError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  nativeParserBinding = null;
+  if (!nativeParserInitError) {
+    nativeParserInitError = "native .node binding not found";
+  }
+  debugNative(`fallback to JS: ${nativeParserInitError}`);
+  return nativeParserBinding;
+}
+function normalizeWithNativeParser(tokens) {
+  const binding = loadNativeParserBinding();
+  if (!binding || typeof binding.parse_classes !== "function") {
+    throw new Error(
+      "Native parser binding is required but not available. Run 'npm run build:rust' to build it."
+    );
+  }
+  try {
+    const parsed = binding.parse_classes(tokens.join(" "));
+    const normalized = parsed.map((item) => item.raw?.trim() ?? "").filter(Boolean);
+    return Array.from(new Set(normalized));
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Native parser failed: ${errorMessage}. Run 'npm run build:rust' to rebuild.`);
+  }
+}
+var DEFAULT_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
+var DEFAULT_IGNORES = ["node_modules", ".git", ".next", "dist", "out", ".turbo", ".cache"];
+function resolveScannerWorkerModulePath() {
+  const runtimeDir2 = typeof __dirname === "string" && __dirname.length > 0 ? __dirname : path5.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path5.resolve(runtimeDir2, "index.cjs"),
+    path5.resolve(runtimeDir2, "index.js"),
+    path5.resolve(runtimeDir2, "index.ts")
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function scanWorkspaceInWorker(rootDir, options) {
+  const modulePath = resolveScannerWorkerModulePath();
+  if (!modulePath) {
+    return Promise.reject(new Error("scanner worker module path could not be resolved"));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const worker = new Worker(SCAN_WORKER_BOOTSTRAP, {
+      eval: true,
+      workerData: { modulePath, rootDir, options }
+    });
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      void worker.terminate();
+      reject(new Error(`scanner worker timed out after ${SCAN_WORKER_TIMEOUT_MS}ms`));
+    }, SCAN_WORKER_TIMEOUT_MS);
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      callback();
+    };
+    worker.once("message", (payload) => {
+      const message = payload;
+      finish(() => {
+        if (message?.ok) {
+          resolve(message.result);
+          return;
+        }
+        reject(new Error(message?.error ?? "scanner worker failed without an error message"));
+      });
+    });
+    worker.once("error", (error) => {
+      finish(() => reject(error));
+    });
+    worker.once("exit", (code) => {
+      if (code !== 0) {
+        finish(() => reject(new Error(`scanner worker exited with code ${code}`)));
+      }
+    });
+  });
+}
+function buildExtensionSet(includeExtensions) {
+  return new Set(includeExtensions);
+}
+function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
+  const candidates = [];
+  const directories = [rootDir];
+  while (directories.length > 0) {
+    const currentDir = directories.pop();
+    if (!currentDir) continue;
+    let entries = [];
+    try {
+      entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path5.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!extensionSet.has(path5.extname(entry.name))) continue;
+      candidates.push(fullPath);
+    }
+  }
+  return candidates;
+}
+function toCacheSize(size) {
+  if (!Number.isFinite(size)) return 0;
+  const normalized = Math.max(0, Math.trunc(size));
+  return Math.min(normalized, 4294967295);
+}
+function extractClassesJs(source) {
+  return extractAllClasses(source);
+}
+function scanSource(source) {
+  const nativeBinding = loadNativeParserBinding();
+  if (nativeBinding && typeof nativeBinding.parse_classes === "function") {
+    try {
+      const baseClasses = extractClassesJs(source);
+      const nativeNormalized = normalizeWithNativeParser(baseClasses);
+      return nativeNormalized;
+    } catch (error) {
+      throw error;
+    }
+  }
+  throw new Error(
+    "Native parser binding is required but not available. Run 'npm run build:rust' to build it."
+  );
+}
+function scanFile(filePath) {
+  const source = fs2.readFileSync(filePath, "utf8");
+  const hash = hashContentNative(source) ?? void 0;
+  return {
+    file: filePath,
+    classes: scanSource(source),
+    ...hash ? { hash } : {}
+  };
+}
+function scanWorkspace(rootDir, options = {}) {
+  const includeExtensions = options.includeExtensions ?? DEFAULT_EXTENSIONS;
+  const extensionSet = buildExtensionSet(includeExtensions);
+  const ignoreDirectories = new Set(options.ignoreDirectories ?? DEFAULT_IGNORES);
+  const useCache = options.useCache ?? true;
+  options.smartInvalidation ?? true;
+  const files = [];
+  const unique = /* @__PURE__ */ new Set();
+  const candidates = collectCandidates(rootDir, ignoreDirectories, extensionSet);
+  const processResult = (result) => {
+    files.push(result);
+    for (const cls of result.classes) unique.add(cls);
+  };
+  const { scanWorkspaceNative: scanWorkspaceNative2 } = (init_native_bridge(), __toCommonJS(native_bridge_exports));
+  if (!options.cacheDir && !useCache) {
+    const nativeResult = scanWorkspaceNative2(rootDir, includeExtensions);
+    if (nativeResult) {
+      return {
+        files: nativeResult.files.map((f) => ({
+          file: f.file,
+          classes: f.classes
+        })),
+        totalFiles: nativeResult.totalFiles,
+        uniqueClasses: nativeResult.uniqueClasses
+      };
+    }
+  }
+  if (useCache && isRustCacheAvailable()) {
+    let cacheEntries = [];
+    try {
+      cacheEntries = readCache(rootDir, options.cacheDir);
+    } catch (error) {
+      cacheEntries = [];
+      log2.debug(
+        `cache read failed, continuing without persisted cache: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const cacheMap = new Map(cacheEntries.map((entry) => [entry.file, entry]));
+    const nowMs = Date.now();
+    const ranked = [];
+    for (const filePath of candidates) {
+      let stat;
+      try {
+        stat = fs2.statSync(filePath);
+      } catch {
+        continue;
+      }
+      const size = toCacheSize(stat.size);
+      const cached = cacheMap.get(filePath);
+      const priority = filePriority(
+        stat.mtimeMs,
+        size,
+        cached ? {
+          mtimeMs: cached.mtimeMs,
+          size: cached.size,
+          hitCount: cached.hitCount,
+          lastSeenMs: 0
+        } : void 0,
+        nowMs
+      );
+      ranked.push({ filePath, stat, size, cached, priority });
+    }
+    ranked.sort((a, b) => b.priority - a.priority);
+    const updatedEntries = [];
+    for (const { filePath, stat, size, cached } of ranked) {
+      let content;
+      try {
+        content = fs2.readFileSync(filePath, "utf8");
+      } catch {
+        continue;
+      }
+      const hash = hashContentNative(content);
+      if (cached && cached.hash === hash && cached.mtimeMs === stat.mtimeMs && cached.size === size) {
+        log2.debug(`cache HIT ${filePath}`);
+        processResult({ file: filePath, classes: cached.classes });
+        updatedEntries.push({
+          file: filePath,
+          classes: cached.classes,
+          hash: cached.hash,
+          mtimeMs: stat.mtimeMs,
+          size,
+          hitCount: (cached.hitCount ?? 0) + 1
+        });
+        continue;
+      }
+      log2.debug(`cache MISS ${filePath}`);
+      const classes = scanSource(content);
+      processResult({ file: filePath, classes });
+      updatedEntries.push({
+        file: filePath,
+        classes,
+        hash,
+        mtimeMs: stat.mtimeMs,
+        size,
+        hitCount: 1
+      });
+    }
+    try {
+      writeCache(rootDir, updatedEntries, options.cacheDir);
+    } catch (error) {
+      log2.debug(`cache write failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return {
+      files,
+      totalFiles: files.length,
+      uniqueClasses: Array.from(unique).sort()
+    };
+  }
+  for (const filePath of candidates) {
+    processResult(scanFile(filePath));
+  }
+  return {
+    files,
+    totalFiles: files.length,
+    uniqueClasses: Array.from(unique).sort()
+  };
+}
+async function scanWorkspaceAsync(rootDir, options = {}) {
+  if (process.env.TWS_DISABLE_SCANNER_WORKER === "1") {
+    return scanWorkspace(rootDir, options);
+  }
+  try {
+    return await scanWorkspaceInWorker(rootDir, options);
+  } catch (error) {
+    log2.debug(
+      `worker scan failed, falling back to sync scanner: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return scanWorkspace(rootDir, options);
+  }
+}
+
+// packages/analyzer/src/binding.ts
+init_src();
+
+// packages/analyzer/src/utils.ts
+init_src();
+var DEFAULT_TOP_LIMIT = 10;
+var DEFAULT_FREQUENT_THRESHOLD = 2;
+var DEBUG_NAMESPACE = "tailwind-styled:analyzer";
+function formatErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+async function pathExists(filePath) {
+  try {
+    await fs2.promises.access(filePath, fs2.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var debugLog = createDebugLogger(DEBUG_NAMESPACE, "tailwind-styled/analyzer");
+function sanitizeTopLimit(value) {
+  if (!Number.isFinite(value)) return DEFAULT_TOP_LIMIT;
+  return Math.max(1, Math.trunc(value));
+}
+function sanitizeFrequentThreshold(value) {
+  if (!Number.isFinite(value)) return DEFAULT_FREQUENT_THRESHOLD;
+  return Math.max(1, Math.trunc(value));
+}
+
+// packages/analyzer/src/binding.ts
+var bindingCache;
+var bindingCandidateCache = [];
+var bindingLoadErrorsCache = [];
+var loadedBindingPathCache = null;
+function isAnalyzerModule(module2) {
+  const candidate = module2;
+  return typeof candidate?.analyzeClasses === "function";
+}
+function getNativeBinding() {
+  if (bindingCache !== void 0) return bindingCache;
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    bindingCandidateCache = [];
+    bindingLoadErrorsCache = [];
+    loadedBindingPathCache = null;
+    debugLog("native binding disabled by TWS_NO_NATIVE/TWS_NO_RUST");
+    bindingCache = null;
+    return bindingCache;
+  }
+  const runtimeDir2 = resolveRuntimeDir(
+    typeof __dirname === "string" ? __dirname : void 0,
+    import.meta.url
+  );
+  const candidates = resolveNativeBindingCandidates({
+    runtimeDir: runtimeDir2,
+    envVarNames: ["TWS_NATIVE_PATH"]
+  });
+  const { binding, loadErrors, loadedPath } = loadNativeBinding({
+    runtimeDir: runtimeDir2,
+    candidates,
+    isValid: isAnalyzerModule,
+    invalidExportMessage: "Module loaded but missing `analyzeClasses` export."
+  });
+  bindingCandidateCache = candidates;
+  bindingLoadErrorsCache = loadErrors;
+  loadedBindingPathCache = loadedPath;
+  if (binding) {
+    debugLog(`native binding loaded from: ${loadedPath}`);
+    bindingCache = binding;
+    return bindingCache;
+  }
+  if (bindingLoadErrorsCache.length > 0) {
+    debugLog(
+      `native binding load failed for ${bindingLoadErrorsCache.length} candidate(s): ${bindingLoadErrorsCache.map((entry) => `${entry.path} (${entry.message})`).join("; ")}`
+    );
+  } else {
+    debugLog("native binding not found in any candidate path");
+  }
+  bindingCache = null;
+  return bindingCache;
+}
+function requireNativeBinding() {
+  const binding = getNativeBinding();
+  if (binding?.analyzeClasses) return binding;
+  const lines = [
+    "Native analyzer binding not found. Ensure `tailwind_styled_parser.node` is built."
+  ];
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    lines.push("Native loading is disabled by TWS_NO_NATIVE/TWS_NO_RUST.");
+  } else {
+    lines.push("Checked paths:");
+    for (const candidate of bindingCandidateCache) lines.push(`- ${candidate}`);
+    if (bindingLoadErrorsCache.length > 0) {
+      lines.push("Load errors:");
+      for (const failure of bindingLoadErrorsCache) {
+        lines.push(`- ${failure.path}: ${failure.message}`);
+      }
+    }
+  }
+  throw new Error(lines.join("\n"));
+}
+function requireNativeCssCompiler() {
+  const binding = requireNativeBinding();
+  if (typeof binding.compileCss === "function") return binding;
+  const loadedPathText = loadedBindingPathCache ? ` (${loadedBindingPathCache})` : "";
+  throw new Error(`Native analyzer compileCss binding is missing in v5${loadedPathText}.`);
+}
+var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs"]);
+var KNOWN_UTILITY_PREFIXES = /* @__PURE__ */ new Set([
+  "absolute",
+  "align",
+  "animate",
+  "arbitrary",
+  "aspect",
+  "backdrop",
+  "basis",
+  "bg",
+  "block",
+  "border",
+  "bottom",
+  "col",
+  "container",
+  "contents",
+  "cursor",
+  "dark",
+  "display",
+  "divide",
+  "fill",
+  "fixed",
+  "flex",
+  "float",
+  "font",
+  "from",
+  "gap",
+  "grid",
+  "grow",
+  "h",
+  "hidden",
+  "inset",
+  "inline",
+  "isolate",
+  "items",
+  "justify",
+  "left",
+  "leading",
+  "line",
+  "list",
+  "m",
+  "max-h",
+  "max-w",
+  "mb",
+  "min-h",
+  "min-w",
+  "ml",
+  "mr",
+  "mt",
+  "mx",
+  "my",
+  "object",
+  "opacity",
+  "order",
+  "origin",
+  "outline",
+  "overflow",
+  "overscroll",
+  "p",
+  "pb",
+  "pe",
+  "perspective",
+  "place",
+  "pl",
+  "pointer",
+  "position",
+  "pr",
+  "ps",
+  "pt",
+  "px",
+  "py",
+  "relative",
+  "right",
+  "ring",
+  "rotate",
+  "rounded",
+  "row",
+  "scale",
+  "shadow",
+  "shrink",
+  "size",
+  "skew",
+  "snap",
+  "space-x",
+  "space-y",
+  "sr",
+  "start",
+  "static",
+  "sticky",
+  "stroke",
+  "table",
+  "text",
+  "to",
+  "top",
+  "touch",
+  "tracking",
+  "transform",
+  "transition",
+  "translate",
+  "truncate",
+  "underline",
+  "via",
+  "visible",
+  "w",
+  "whitespace",
+  "z"
+]);
+var tailwindConfigCache = /* @__PURE__ */ new Map();
+function splitVariantAndBase(className) {
+  const parts = className.split(":");
+  if (parts.length <= 1) return { variantKey: "", base: className };
+  const base = parts.pop() ?? className;
+  return { variantKey: parts.join(":"), base };
+}
+function isArbitraryUtility(baseClass) {
+  return baseClass.includes("[") && baseClass.includes("]");
+}
+function resolveConflictGroup(base) {
+  if (isArbitraryUtility(base)) return null;
+  if (["block", "inline", "inline-block", "inline-flex", "flex", "grid", "hidden"].includes(base))
+    return "display";
+  if (base.startsWith("bg-")) return "bg";
+  if (base.startsWith("text-")) return "text";
+  if (base.startsWith("font-")) return "font";
+  if (base.startsWith("rounded")) return "rounded";
+  if (base.startsWith("shadow")) return "shadow";
+  if (base.startsWith("border-")) return "border";
+  if (base.startsWith("opacity-")) return "opacity";
+  if (base.startsWith("w-") || base.startsWith("min-w-") || base.startsWith("max-w-"))
+    return "width";
+  if (base.startsWith("h-") || base.startsWith("min-h-") || base.startsWith("max-h-"))
+    return "height";
+  if (base.startsWith("p-") || base.startsWith("px-") || base.startsWith("py-")) return "padding";
+  if (base.startsWith("m-") || base.startsWith("mx-") || base.startsWith("my-")) return "margin";
+  return null;
+}
+function detectConflicts(usages) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    const { variantKey, base } = splitVariantAndBase(usage.name);
+    const group = resolveConflictGroup(base);
+    if (!group) continue;
+    const key = `${variantKey}::${group}`;
+    const bucket = buckets.get(key) ?? {
+      variantKey,
+      group,
+      classes: /* @__PURE__ */ new Set()
+    };
+    bucket.classes.add(usage.name);
+    buckets.set(key, bucket);
+  }
+  const conflicts = [];
+  const conflictedClassNames = /* @__PURE__ */ new Set();
+  for (const bucket of buckets.values()) {
+    if (bucket.classes.size <= 1) continue;
+    const classes = Array.from(bucket.classes).sort();
+    for (const className of classes) conflictedClassNames.add(className);
+    const variantLabel = bucket.variantKey.length > 0 ? bucket.variantKey : "base";
+    conflicts.push({
+      className: bucket.group,
+      variants: bucket.variantKey.length > 0 ? bucket.variantKey.split(":") : [],
+      classes,
+      message: `Multiple ${bucket.group} utilities detected for "${variantLabel}".`
+    });
+  }
+  conflicts.sort((left, right) => {
+    if (right.classes.length !== left.classes.length)
+      return right.classes.length - left.classes.length;
+    return left.className.localeCompare(right.className);
+  });
+  return { conflicts, conflictedClassNames };
+}
+function isSupportedTailwindConfigPath(configPath) {
+  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path5.extname(configPath).toLowerCase());
+}
+async function resolveTailwindConfigPath(root, explicitPath) {
+  if (explicitPath) {
+    const resolved = path5.resolve(root, explicitPath);
+    if (!await pathExists(resolved)) return null;
+    return resolved;
+  }
+  const candidates = [
+    "tailwind.config.ts",
+    "tailwind.config.js",
+    "tailwind.config.cjs",
+    "tailwind.config.mjs"
+  ];
+  for (const candidate of candidates) {
+    const fullPath = path5.resolve(root, candidate);
+    if (await pathExists(fullPath)) return fullPath;
+  }
+  return null;
+}
+function collectSafelistFromConfig(config) {
+  const raw = config.safelist;
+  if (!Array.isArray(raw)) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const entry of raw) {
+    if (typeof entry === "string" && entry.length > 0) {
+      out.add(entry);
+      continue;
+    }
+    if (!entry || typeof entry !== "object") continue;
+    const pattern = entry.pattern;
+    if (typeof pattern === "string" && pattern.length > 0) {
+      out.add(pattern);
+    }
+  }
+  return Array.from(out);
+}
+function collectCustomUtilities(config) {
+  const out = /* @__PURE__ */ new Set();
+  const theme = config.theme;
+  if (!theme || typeof theme !== "object") return out;
+  const extend = theme.extend;
+  if (!extend || typeof extend !== "object") return out;
+  for (const [section, value] of Object.entries(extend)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    for (const key of Object.keys(value)) {
+      out.add(`${section}-${key}`);
+      if (section === "colors") {
+        out.add(`bg-${key}`);
+        out.add(`text-${key}`);
+        out.add(`border-${key}`);
+      } else if (section === "spacing") {
+        out.add(`p-${key}`);
+        out.add(`m-${key}`);
+        out.add(`gap-${key}`);
+        out.add(`w-${key}`);
+        out.add(`h-${key}`);
+      } else if (section === "fontSize") {
+        out.add(`text-${key}`);
+      } else if (section === "borderRadius") {
+        out.add(`rounded-${key}`);
+      } else if (section === "boxShadow") {
+        out.add(`shadow-${key}`);
+      }
+    }
+  }
+  return out;
+}
+async function collectSafelistFromSource(configPath) {
+  const source = await fs2.promises.readFile(configPath, "utf8");
+  const safelistBlock = source.match(/safelist\s*:\s*\[([\s\S]*?)\]/m)?.[1];
+  if (!safelistBlock) return [];
+  const out = /* @__PURE__ */ new Set();
+  const tokenRegex = /["'`]([^"'`]+)["'`]/g;
+  let token = tokenRegex.exec(safelistBlock);
+  while (token) {
+    const value = token[1].trim();
+    if (value.length > 0) out.add(value);
+    token = tokenRegex.exec(safelistBlock);
+  }
+  return Array.from(out);
+}
+async function loadTailwindConfig(root, semanticOption) {
+  const startMs = Date.now();
+  const configPath = await resolveTailwindConfigPath(root, semanticOption?.tailwindConfigPath);
+  if (!configPath) return null;
+  if (!isSupportedTailwindConfigPath(configPath)) {
+    return {
+      path: configPath,
+      loaded: false,
+      warning: `Unsupported Tailwind config extension at "${configPath}". Supported extensions: .ts, .js, .cjs, .mjs.`,
+      safelist: /* @__PURE__ */ new Set(),
+      customUtilities: /* @__PURE__ */ new Set()
+    };
+  }
+  const configStat = await fs2.promises.stat(configPath).catch(() => null);
+  if (configStat) {
+    const cached = tailwindConfigCache.get(configPath);
+    if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
+      debugLog(
+        `tailwind config cache hit: ${configPath} (${cached.config.safelist.size} safelist entries)`
+      );
+      return cached.config;
+    }
+  }
+  let config = null;
+  let warning;
+  try {
+    const cacheBustToken = Math.trunc(configStat?.mtimeMs ?? Date.now());
+    const imported = await import(`${pathToFileURL(configPath).href}?tws_mtime=${cacheBustToken}`);
+    const candidate = imported.default ?? imported;
+    if (isRecord(candidate)) {
+      config = candidate;
+    } else if (typeof candidate === "function") {
+      const evaluated = candidate();
+      if (isRecord(evaluated)) {
+        config = evaluated;
+      } else {
+        warning = "Tailwind config export function must return an object.";
+      }
+    } else {
+      warning = "Tailwind config export must be an object or a function returning an object.";
+    }
+  } catch (error) {
+    warning = formatErrorMessage2(error);
+  }
+  const safelist = /* @__PURE__ */ new Set();
+  const customUtilities = /* @__PURE__ */ new Set();
+  if (config) {
+    for (const item of collectSafelistFromConfig(config)) safelist.add(item);
+    for (const item of collectCustomUtilities(config)) customUtilities.add(item);
+  }
+  if (safelist.size === 0) {
+    try {
+      for (const item of await collectSafelistFromSource(configPath)) safelist.add(item);
+    } catch (error) {
+      debugLog(
+        `failed to parse safelist from source at "${configPath}": ${formatErrorMessage2(error)}`
+      );
+    }
+  }
+  const loaded = {
+    path: configPath,
+    loaded: config !== null,
+    warning,
+    safelist,
+    customUtilities
+  };
+  if (configStat) {
+    tailwindConfigCache.set(configPath, {
+      mtimeMs: configStat.mtimeMs,
+      size: configStat.size,
+      config: loaded
+    });
+  }
+  debugLog(
+    `tailwind config loaded from "${configPath}" in ${Date.now() - startMs}ms (loaded=${loaded.loaded}, safelist=${loaded.safelist.size}, custom=${loaded.customUtilities.size})`
+  );
+  return loaded;
+}
+function utilityPrefix(baseClass) {
+  const normalized = baseClass.startsWith("-") ? baseClass.slice(1) : baseClass;
+  if (normalized.includes("[") && normalized.includes("]")) return "arbitrary";
+  if (normalized.startsWith("min-w-")) return "min-w";
+  if (normalized.startsWith("max-w-")) return "max-w";
+  if (normalized.startsWith("min-h-")) return "min-h";
+  if (normalized.startsWith("max-h-")) return "max-h";
+  if (normalized.startsWith("space-x-")) return "space-x";
+  if (normalized.startsWith("space-y-")) return "space-y";
+  if (normalized.startsWith("inline-")) return "inline";
+  if (normalized.startsWith("border-")) return "border";
+  if (normalized.startsWith("text-")) return "text";
+  if (normalized.startsWith("bg-")) return "bg";
+  if (normalized.startsWith("rounded")) return "rounded";
+  if (normalized.startsWith("shadow")) return "shadow";
+  const hyphen = normalized.indexOf("-");
+  if (hyphen < 0) return normalized;
+  return normalized.slice(0, hyphen);
+}
+function isKnownTailwindClass(className, safelist, customUtilities) {
+  if (safelist.has(className) || customUtilities.has(className)) return true;
+  const { base } = splitVariantAndBase(className);
+  if (customUtilities.has(base)) return true;
+  const prefix = utilityPrefix(base);
+  return KNOWN_UTILITY_PREFIXES.has(prefix);
+}
+async function buildSemanticReport(usages, root, semanticOption) {
+  const loadedConfig = await loadTailwindConfig(root, semanticOption);
+  const safelist = loadedConfig?.safelist ?? /* @__PURE__ */ new Set();
+  const customUtilities = loadedConfig?.customUtilities ?? /* @__PURE__ */ new Set();
+  const usageNames = new Set(usages.map((usage) => usage.name));
+  const unusedClasses = Array.from(safelist).filter((className) => !usageNames.has(className)).sort().map((className) => ({ name: className, count: 0, isUnused: true }));
+  const unknownClasses = usages.filter((usage) => !isKnownTailwindClass(usage.name, safelist, customUtilities)).map((usage) => ({ ...usage, isUnused: true }));
+  const { conflicts } = detectConflicts(usages);
+  return {
+    unusedClasses,
+    unknownClasses,
+    conflicts,
+    ...loadedConfig ? {
+      tailwindConfig: {
+        path: loadedConfig.path,
+        loaded: loadedConfig.loaded,
+        safelistCount: loadedConfig.safelist.size,
+        customUtilityCount: loadedConfig.customUtilities.size,
+        ...loadedConfig.warning ? { warning: loadedConfig.warning } : {}
+      }
+    } : {}
+  };
+}
+
+// packages/analyzer/src/analyzeWorkspace.ts
+function normalizeScan(scan, includeClass) {
+  if (!includeClass) return scan;
+  const filteredFiles = scan.files.map((file) => ({
+    file: file.file,
+    classes: file.classes.filter((className) => includeClass(className))
+  }));
+  const unique = /* @__PURE__ */ new Set();
+  for (const file of filteredFiles) {
+    for (const className of file.classes) unique.add(className);
+  }
+  return {
+    files: filteredFiles,
+    totalFiles: scan.totalFiles,
+    uniqueClasses: Array.from(unique).sort()
+  };
+}
+function collectClassCounts(scan) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of scan.files) {
+    for (const className of file.classes) {
+      counts.set(className, (counts.get(className) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function buildClassUsage(counts) {
+  return Array.from(counts.entries()).map(([name, count]) => ({ name, count })).sort((left, right) => {
+    if (right.count !== left.count) return right.count - left.count;
+    return left.name.localeCompare(right.name);
+  });
+}
+function buildDistribution(usages) {
+  const distribution = {
+    "1": 0,
+    "2-3": 0,
+    "4-7": 0,
+    "8+": 0
+  };
+  for (const usage of usages) {
+    if (usage.count === 1) {
+      distribution["1"] += 1;
+      continue;
+    }
+    if (usage.count <= 3) {
+      distribution["2-3"] += 1;
+      continue;
+    }
+    if (usage.count <= 7) {
+      distribution["4-7"] += 1;
+      continue;
+    }
+    distribution["8+"] += 1;
+  }
+  return distribution;
+}
+async function analyzeWorkspace(root, options = {}) {
+  const startedAtMs = Date.now();
+  const resolvedRoot = path5.resolve(root);
+  const scanStartedAtMs = Date.now();
+  let scan;
+  try {
+    scan = await scanWorkspaceAsync(resolvedRoot, options.scanner);
+  } catch (error) {
+    throw new Error(`Failed to scan workspace at "${resolvedRoot}": ${formatErrorMessage2(error)}`, {
+      cause: error
+    });
+  }
+  debugLog(
+    `scanWorkspaceAsync processed ${scan.totalFiles} files in ${Date.now() - scanStartedAtMs}ms`
+  );
+  const normalizedScan = normalizeScan(scan, options.includeClass);
+  const topLimit = sanitizeTopLimit(options.classStats?.top);
+  const frequentThreshold = sanitizeFrequentThreshold(options.classStats?.frequentThreshold);
+  const binding = requireNativeBinding();
+  const filesJson = JSON.stringify(
+    normalizedScan.files.map((file) => ({ file: file.file, classes: file.classes }))
+  );
+  let nativeReport = null;
+  try {
+    nativeReport = binding.analyzeClasses(filesJson, resolvedRoot, topLimit);
+  } catch (error) {
+    throw new Error(`Native analyzer failed for "${resolvedRoot}": ${formatErrorMessage2(error)}`, {
+      cause: error
+    });
+  }
+  if (!nativeReport) {
+    throw new Error(`Native analyzer returned no report for "${resolvedRoot}".`);
+  }
+  const counts = collectClassCounts(normalizedScan);
+  let all = buildClassUsage(counts);
+  let semanticReport;
+  if (options.semantic) {
+    const semanticOption = typeof options.semantic === "object" ? options.semantic : void 0;
+    const semanticStartedAtMs = Date.now();
+    try {
+      semanticReport = await buildSemanticReport(all, resolvedRoot, semanticOption);
+    } catch (error) {
+      throw new Error(
+        `Failed to build semantic report for "${resolvedRoot}": ${formatErrorMessage2(error)}`,
+        { cause: error }
+      );
+    }
+    debugLog(`semantic report built in ${Date.now() - semanticStartedAtMs}ms`);
+    if (semanticReport.conflicts.length > 0) {
+      const conflicted = new Set(semanticReport.conflicts.flatMap((conflict) => conflict.classes));
+      all = all.map(
+        (usage) => conflicted.has(usage.name) ? { ...usage, isConflict: true } : usage
+      );
+    }
+  }
+  const top = all.slice(0, topLimit);
+  const frequent = all.filter((usage) => usage.count >= frequentThreshold).slice(0, topLimit);
+  const unique = all.filter((usage) => usage.count === 1);
+  const totalClassOccurrences = all.reduce((sum, usage) => sum + usage.count, 0);
+  debugLog(
+    `analyzeWorkspace completed in ${Date.now() - startedAtMs}ms (files=${normalizedScan.totalFiles}, uniqueClasses=${all.length})`
+  );
+  return {
+    root: nativeReport.root || resolvedRoot,
+    totalFiles: nativeReport.totalFiles,
+    uniqueClassCount: all.length,
+    totalClassOccurrences,
+    classStats: {
+      all,
+      top,
+      frequent,
+      unique,
+      distribution: buildDistribution(all)
+    },
+    safelist: all.map((usage) => usage.name),
+    ...semanticReport ? { semantic: semanticReport } : {}
+  };
+}
+
+// packages/analyzer/src/classToCss.ts
+function normalizeClassInput(input) {
+  if (typeof input === "string") {
+    return input.split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  if (!Array.isArray(input)) {
+    throw new TypeError("classToCss input must be a string or an array of strings.");
+  }
+  const out = [];
+  for (const item of input) {
+    if (typeof item !== "string") {
+      throw new TypeError("classToCss input array must contain only strings.");
+    }
+    const value = item.trim();
+    if (value.length > 0) out.push(value);
+  }
+  return out;
+}
+function normalizeClassToCssOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError("classToCss options must be an object.");
+  }
+  const strict = options.strict ?? false;
+  if (typeof strict !== "boolean") {
+    throw new TypeError("classToCss options.strict must be a boolean when provided.");
+  }
+  const prefix = options.prefix ?? null;
+  if (prefix !== null && typeof prefix !== "string") {
+    throw new TypeError("classToCss options.prefix must be a string or null when provided.");
+  }
+  return { prefix, strict };
+}
+function mergeDeclarationMap(target, css) {
+  const ruleRegex = /\{([^}]*)\}/g;
+  let ruleMatch = ruleRegex.exec(css);
+  while (ruleMatch) {
+    const body = ruleMatch[1];
+    for (const raw of body.split(";")) {
+      const declaration = raw.trim();
+      if (declaration.length === 0) continue;
+      const colonIndex = declaration.indexOf(":");
+      if (colonIndex <= 0) continue;
+      const property = declaration.slice(0, colonIndex).trim();
+      const value = declaration.slice(colonIndex + 1).trim();
+      if (property.length === 0 || value.length === 0) continue;
+      if (target.has(property)) target.delete(property);
+      target.set(property, value);
+    }
+    ruleMatch = ruleRegex.exec(css);
+  }
+}
+function declarationMapToString(declarationMap) {
+  return Array.from(declarationMap.entries()).map(([property, value]) => `${property}: ${value}`).join("; ");
+}
+async function classToCss(input, options = {}) {
+  const inputClasses = normalizeClassInput(input);
+  const normalizedOptions = normalizeClassToCssOptions(options);
+  if (inputClasses.length === 0) {
+    return {
+      inputClasses: [],
+      css: "",
+      declarations: "",
+      resolvedClasses: [],
+      unknownClasses: [],
+      sizeBytes: 0
+    };
+  }
+  const binding = requireNativeCssCompiler();
+  const prefix = normalizedOptions.prefix;
+  const cssChunks = [];
+  const resolvedClasses = [];
+  const unknownClasses = [];
+  let sizeBytes = 0;
+  const declarationMap = /* @__PURE__ */ new Map();
+  for (const className of inputClasses) {
+    let compiled = null;
+    try {
+      compiled = binding.compileCss([className], prefix);
+    } catch (error) {
+      throw new Error(
+        `Native analyzer failed while compiling class "${className}": ${formatErrorMessage2(error)}`,
+        { cause: error }
+      );
+    }
+    if (!compiled) {
+      throw new Error(`Native analyzer returned no result for class "${className}".`);
+    }
+    cssChunks.push(compiled.css);
+    resolvedClasses.push(...compiled.resolvedClasses);
+    unknownClasses.push(...compiled.unknownClasses);
+    sizeBytes += compiled.sizeBytes;
+    mergeDeclarationMap(declarationMap, compiled.css);
+  }
+  const uniqueUnknown = Array.from(new Set(unknownClasses));
+  if (normalizedOptions.strict && uniqueUnknown.length > 0) {
+    throw new Error(`Unknown Tailwind classes: ${uniqueUnknown.join(", ")}`);
+  }
+  return {
+    inputClasses,
+    css: cssChunks.filter((chunk) => chunk.length > 0).join("\n"),
+    declarations: declarationMapToString(declarationMap),
+    resolvedClasses: Array.from(new Set(resolvedClasses)),
+    unknownClasses: uniqueUnknown,
+    sizeBytes
+  };
+}
+
+// packages/analyzer/src/index.ts
+var __internal = {
+  normalizeClassInput,
+  splitVariantAndBase,
+  resolveConflictGroup,
+  collectClassCounts,
+  buildDistribution,
+  utilityPrefix
+};
+
+export { __internal, analyzeWorkspace, classToCss };
+//# sourceMappingURL=analyzer.mjs.map
+//# sourceMappingURL=analyzer.mjs.map