tailwind-styled-v4 4.0.0 → 5.0.1

package/dist/scanner.mjs

@@ -0,0 +1,703 @@
+import { createRequire } from 'module';
+import path4 from 'path';
+import fs from 'fs';
+import { 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);
+
+// 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_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",
+    path4.resolve(process.cwd(), "native", "index.mjs"),
+    path4.resolve(runtimeDir, "..", "..", "native", "index.mjs"),
+    path4.resolve(runtimeDir, "..", "..", "..", "native", "index.mjs"),
+    path4.resolve(process.cwd(), "native", "index.node"),
+    path4.resolve(runtimeDir, "..", "..", "native", "index.node"),
+    path4.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(path4.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 = [
+    path4.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path4.resolve(runtimeDir2, "..", "..", "..", "native", "tailwind_styled_parser.node")
+  ];
+  const req = typeof __require === "function" ? __require : createRequire(path4.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 ? path4.resolve(rootDir, cacheDir) : path4.join(process.cwd(), ".cache", "tailwind-styled");
+  return path4.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 = [
+    path4.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+    path4.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node")
+  ];
+  for (const fullPath of candidates) {
+    if (!fs.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 : path4.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path4.resolve(runtimeDir2, "index.cjs"),
+    path4.resolve(runtimeDir2, "index.js"),
+    path4.resolve(runtimeDir2, "index.ts")
+  ];
+  for (const candidate of candidates) {
+    if (fs.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 = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = path4.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!extensionSet.has(path4.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 isScannableFile(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
+  return includeExtensions.includes(path4.extname(filePath));
+}
+function scanFile(filePath) {
+  const source = fs.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 = fs.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 = fs.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);
+  }
+}
+
+export { DEFAULT_EXTENSIONS, DEFAULT_IGNORES, isScannableFile, scanFile, scanSource, scanWorkspace, scanWorkspaceAsync };
+//# sourceMappingURL=scanner.mjs.map
+//# sourceMappingURL=scanner.mjs.map