tailwind-styled-v4 5.0.2 → 5.0.3

package/dist/next.mjs

@@ -16231,21 +16231,23 @@ try {
             var __toCommonJS = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
             var require_compiler22 = __commonJS222({
               "dist/compiler.js"(exports$122, module2) {
-                var crypto = __require222("crypto");
-                var fs322 = __require222("fs");
                 var module$122 = __require222("module");
                 var path7 = __require222("path");
                 var url222 = __require222("url");
                 var tailwindMerge = __require222("tailwind-merge");
+                var fs22 = __require222("fs");
+                var crypto = __require222("crypto");
                 var _documentCurrentScript22 = typeof document !== "undefined" ? document.currentScript : null;
                 function _interopDefault222(e) {
                   return e && e.__esModule ? e : { default: e };
                 }
-                var fs3__default = /* @__PURE__ */ _interopDefault222(fs322);
                 var path7__default = /* @__PURE__ */ _interopDefault222(path7);
+                var fs2__default2 = /* @__PURE__ */ _interopDefault222(fs22);
+                var __create222 = Object.create;
                 var __defProp222 = Object.defineProperty;
                 var __getOwnPropDesc222 = Object.getOwnPropertyDescriptor;
                 var __getOwnPropNames2222 = Object.getOwnPropertyNames;
+                var __getProtoOf222 = Object.getPrototypeOf;
                 var __hasOwnProp222 = Object.prototype.hasOwnProperty;
                 var __require2222 = /* @__PURE__ */ ((x) => typeof __require222 !== "undefined" ? __require222 : typeof Proxy !== "undefined" ? new Proxy(x, {
                   get: (a, b) => (typeof __require222 !== "undefined" ? __require222 : a)[b]
@@ -16256,6 +16258,9 @@ try {
                 var __esm2 = (fn, res) => function __init() {
                   return fn && (res = (0, fn[__getOwnPropNames2222(fn)[0]])(fn = 0)), res;
                 };
+                var __commonJS2222 = (cb, mod) => function __require22222() {
+                  return mod || (0, cb[__getOwnPropNames2222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+                };
                 var __export2 = (target, all) => {
                   for (var name in all)
                     __defProp222(target, name, { get: all[name], enumerable: true });
@@ -16268,48 +16273,438 @@ try {
                   }
                   return to;
                 };
+                var __toESM222 = (mod, isNodeMode, target) => (target = mod != null ? __create222(__getProtoOf222(mod)) : {}, __copyProps222(
+                  // If the importer is in node compatibility mode or this is not an ESM
+                  // file that has been converted to a CommonJS file using a Babel-
+                  // compatible transform (i.e. "__esModule" has not been set), then set
+                  // "default" to the CommonJS "module.exports" for node compatibility.
+                  __defProp222(target, "default", { value: mod, enumerable: true }),
+                  mod
+                ));
                 var __toCommonJS2 = (mod) => __copyProps222(__defProp222({}, "__esModule", { value: true }), mod);
-                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 createLogger22(prefix, level) {
-                  let currentLevel = getEnvLevel();
-                  const log222 = (msgLevel, stream, args) => {
-                    if (LEVELS[msgLevel] > LEVELS[currentLevel]) return;
-                    const line = `[${prefix}] ${args.map(String).join(" ")}
-`;
-                    process[stream].write(line);
-                  };
-                  return {
-                    error: (...a) => log222("error", "stderr", a),
-                    warn: (...a) => log222("warn", "stderr", a),
-                    info: (...a) => log222("info", "stdout", a),
-                    debug: (...a) => log222("debug", "stderr", a),
-                    setLevel: (l) => {
-                      currentLevel = l;
+                var require_plugin2 = __commonJS2222({
+                  "dist/plugin.js"(exports$1222) {
+                    var TOKEN_ENGINE_KEY = "__TW_TOKEN_ENGINE__";
+                    function resolveTokenEngine() {
+                      if (typeof globalThis !== "undefined") {
+                        return globalThis[TOKEN_ENGINE_KEY];
+                      }
+                      return null;
                     }
-                  };
-                }
-                var LEVELS;
-                var init_logger = __esm2({
-                  "packages/shared/src/logger.ts"() {
-                    LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
-                    createLogger22("tailwind-styled");
-                  }
-                });
-                function hashContent(content, algorithm = "md5", length = 8) {
-                  return crypto.createHash(algorithm).update(content).digest("hex").slice(0, length);
-                }
-                var init_hash = __esm2({
-                  "packages/shared/src/hash.ts"() {
+                    function readToken(engine, name) {
+                      if (!engine) return void 0;
+                      if (typeof engine.getToken === "function") return engine.getToken(name);
+                      if (typeof engine.getTokens === "function") {
+                        const tokens = engine.getTokens();
+                        return tokens?.[name];
+                      }
+                      return void 0;
+                    }
+                    function createTwPlugin(options = {}) {
+                      return {
+                        async resolveId(source, importer) {
+                          if (!source.startsWith("tw.") && !source.startsWith("tw:")) return null;
+                          const importPath = source.replace(/^tw[.:]/, "");
+                          const resolved = await this.resolve(importPath, importer, { skipSelf: true });
+                          if (resolved) return { id: resolved.id };
+                          return null;
+                        },
+                        async load(id) {
+                          return null;
+                        },
+                        async transform(code, id) {
+                          return null;
+                        },
+                        getToken(name) {
+                          const engine = resolveTokenEngine();
+                          return readToken(engine, name);
+                        },
+                        subscribeTokens(callback) {
+                          const engine = resolveTokenEngine();
+                          if (!engine) return () => {
+                          };
+                          if (typeof engine.subscribeTokens === "function") return engine.subscribeTokens(callback);
+                          if (typeof engine.subscribe === "function") return engine.subscribe(callback);
+                          return () => {
+                          };
+                        }
+                      };
+                    }
+                    var globalRegistry = {
+                      transforms: [],
+                      tokens: {}
+                    };
+                    function getGlobalRegistry2() {
+                      return globalRegistry;
+                    }
+                    function registerTransform(transform) {
+                      globalRegistry.transforms.push(transform);
+                    }
+                    function registerToken(name, value) {
+                      globalRegistry.tokens[name] = value;
+                    }
+                    function createRegistry() {
+                      return {
+                        variants: /* @__PURE__ */ new Map(),
+                        utilities: /* @__PURE__ */ new Map(),
+                        tokens: /* @__PURE__ */ new Map(),
+                        transforms: [],
+                        cssHooks: [],
+                        buildHooks: [],
+                        plugins: /* @__PURE__ */ new Set()
+                      };
+                    }
+                    var _globalRegistry = createRegistry();
+                    function resetGlobalRegistry() {
+                      _globalRegistry = createRegistry();
+                    }
+                    function createContext(registry, config = {}) {
+                      return {
+                        config,
+                        addVariant(name, resolver) {
+                          registry.variants.set(name, resolver);
+                        },
+                        addUtility(name, styles) {
+                          registry.utilities.set(name, styles);
+                        },
+                        addToken(name, value) {
+                          const normalized = name.replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
+                          registry.tokens.set(normalized, value);
+                        },
+                        addTransform(fn) {
+                          registry.transforms.push(fn);
+                        },
+                        onGenerateCSS(hook) {
+                          registry.cssHooks.push(hook);
+                        },
+                        onBuildEnd(hook) {
+                          registry.buildHooks.push(hook);
+                        },
+                        getToken(name) {
+                          return readToken(resolveTokenEngine(), name);
+                        },
+                        subscribeTokens(callback) {
+                          const engine = resolveTokenEngine();
+                          if (!engine) return () => {
+                          };
+                          if (typeof engine.subscribeTokens === "function") return engine.subscribeTokens(callback);
+                          if (typeof engine.subscribe === "function") return engine.subscribe(callback);
+                          return () => {
+                          };
+                        }
+                      };
+                    }
+                    function createTw(config = {}) {
+                      const registry = createRegistry();
+                      const ctx = createContext(registry, config);
+                      const result = ctx;
+                      result.registry = {
+                        plugins: registry.plugins,
+                        variants: registry.variants,
+                        utilities: registry.utilities,
+                        tokens: registry.tokens
+                      };
+                      result.use = (plugin) => {
+                        plugin.setup(ctx);
+                        registry.plugins.add(plugin.name);
+                      };
+                      if (config.plugins && Array.isArray(config.plugins)) {
+                        for (const plugin of config.plugins) {
+                          if (plugin && plugin.name) {
+                            result.use(plugin);
+                          }
+                        }
+                      }
+                      return result;
+                    }
+                    function use(plugin) {
+                      const ctx = createContext(_globalRegistry);
+                      plugin.setup(ctx);
+                    }
+                    function presetTokens(tokens) {
+                      return {
+                        name: "preset-tokens",
+                        setup(ctx) {
+                          for (const [name, value] of Object.entries(tokens)) {
+                            ctx.addToken(name, value);
+                          }
+                        }
+                      };
+                    }
+                    function presetVariants(variants) {
+                      return {
+                        name: "preset-variants",
+                        setup(ctx) {
+                          for (const [name, resolver] of Object.entries(variants)) {
+                            ctx.addVariant(name, resolver);
+                          }
+                        }
+                      };
+                    }
+                    function presetScrollbar() {
+                      return {
+                        name: "preset-scrollbar",
+                        setup(ctx) {
+                          ctx.addVariant("scrollbar-thin", () => "::-webkit-scrollbar{width:8px;height:8px}");
+                          ctx.addVariant("scrollbar-none", () => "::-webkit-scrollbar{display:none}");
+                          ctx.addUtility("scrollbar-hide", { "-ms-overflow-style": "none", "scrollbar-width": "none" });
+                        }
+                      };
+                    }
+                    exports$1222.createTw = createTw;
+                    exports$1222.createTwPlugin = createTwPlugin;
+                    exports$1222.getGlobalRegistry = getGlobalRegistry2;
+                    exports$1222.presetScrollbar = presetScrollbar;
+                    exports$1222.presetTokens = presetTokens;
+                    exports$1222.presetVariants = presetVariants;
+                    exports$1222.registerToken = registerToken;
+                    exports$1222.registerTransform = registerTransform;
+                    exports$1222.resetGlobalRegistry = resetGlobalRegistry;
+                    exports$1222.use = use;
                   }
                 });
-                var init_src = __esm2({
-                  "packages/shared/src/index.ts"() {
-                    init_logger();
-                    init_hash();
+                var require_shared222 = __commonJS2222({
+                  "dist/shared.js"(exports$1222) {
+                    var fs5 = __require2222("fs");
+                    var module$1222 = __require2222("module");
+                    var os = __require2222("os");
+                    var path9 = __require2222("path");
+                    var url2222 = __require2222("url");
+                    var crypto2 = __require2222("crypto");
+                    function _interopDefault2222(e) {
+                      return e && e.__esModule ? e : { default: e };
+                    }
+                    var fs__default22 = /* @__PURE__ */ _interopDefault2222(fs5);
+                    var os__default = /* @__PURE__ */ _interopDefault2222(os);
+                    var path__default2 = /* @__PURE__ */ _interopDefault2222(path9);
+                    var LRUCache = class {
+                      constructor(max = 256, ttlMs = null) {
+                        this.map = /* @__PURE__ */ new Map();
+                        this.max = max;
+                        this.ttlMs = ttlMs;
+                      }
+                      get(key) {
+                        const entry = this.map.get(key);
+                        if (!entry) return void 0;
+                        if (this.ttlMs !== null && Date.now() - entry.ts > this.ttlMs) {
+                          this.map.delete(key);
+                          return void 0;
+                        }
+                        this.map.delete(key);
+                        this.map.set(key, entry);
+                        return entry.value;
+                      }
+                      set(key, value) {
+                        if (this.map.has(key)) this.map.delete(key);
+                        else if (this.map.size >= this.max) {
+                          this.map.delete(this.map.keys().next().value);
+                        }
+                        this.map.set(key, { value, ts: Date.now() });
+                      }
+                      has(key) {
+                        return this.get(key) !== void 0;
+                      }
+                      delete(key) {
+                        this.map.delete(key);
+                      }
+                      clear() {
+                        this.map.clear();
+                      }
+                      get size() {
+                        return this.map.size;
+                      }
+                      keys() {
+                        return this.map.keys();
+                      }
+                      *values() {
+                        for (const entry of this.map.values()) {
+                          yield entry.value;
+                        }
+                      }
+                      *entries() {
+                        for (const [key, entry] of this.map.entries()) {
+                          yield [key, entry.value];
+                        }
+                      }
+                    };
+                    function getPlatformExtension() {
+                      const platform = os__default.default.platform();
+                      switch (platform) {
+                        case "win32":
+                          return ".node";
+                        case "darwin":
+                          return ".dylib";
+                        case "linux":
+                          return ".so";
+                        default:
+                          return ".node";
+                      }
+                    }
+                    function formatErrorMessage2(error) {
+                      return error instanceof Error ? error.message : String(error);
+                    }
+                    function resolveRuntimeDir2(dirnameValue, moduleImportUrl) {
+                      if (typeof dirnameValue === "string" && dirnameValue.length > 0) return dirnameValue;
+                      return path__default2.default.dirname(url2222.fileURLToPath(moduleImportUrl));
+                    }
+                    function resolveNativeBindingCandidates2(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 = path__default2.default.resolve(raw);
+                        if (options.enforceNodeExtensionForEnvPath) {
+                          if (path__default2.default.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(path__default2.default.resolve(process.cwd(), "native", defaultBindingName));
+                        out.push(path__default2.default.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 createDebugLogger2(namespace, label = namespace) {
+                      const debugEnabled = isDebugNamespaceEnabled(namespace);
+                      return (message) => {
+                        if (!debugEnabled) return;
+                        console.debug(`[${label}] ${message}`);
+                      };
+                    }
+                    function loadNativeBinding2(options) {
+                      const req = module$1222.createRequire(path__default2.default.join(options.runtimeDir, "noop.cjs"));
+                      const loadErrors2 = [];
+                      for (const candidate of options.candidates) {
+                        if (!fs__default22.default.existsSync(candidate)) continue;
+                        try {
+                          const mod = req(candidate);
+                          if (options.isValid(mod)) {
+                            return {
+                              binding: mod,
+                              loadedPath: candidate,
+                              loadErrors: loadErrors2
+                            };
+                          }
+                          loadErrors2.push({
+                            path: candidate,
+                            message: options.invalidExportMessage
+                          });
+                        } catch (error) {
+                          loadErrors2.push({
+                            path: candidate,
+                            message: formatErrorMessage2(error)
+                          });
+                        }
+                      }
+                      return {
+                        binding: null,
+                        loadedPath: null,
+                        loadErrors: loadErrors2
+                      };
+                    }
+                    var LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+                    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 createLogger22(prefix, level) {
+                      let currentLevel = level ?? getEnvLevel();
+                      const log222 = (msgLevel, stream, args) => {
+                        if (LEVELS[msgLevel] > LEVELS[currentLevel]) return;
+                        const line = `[${prefix}] ${args.map(String).join(" ")}
+`;
+                        process[stream].write(line);
+                      };
+                      return {
+                        error: (...a) => log222("error", "stderr", a),
+                        warn: (...a) => log222("warn", "stderr", a),
+                        info: (...a) => log222("info", "stdout", a),
+                        debug: (...a) => log222("debug", "stderr", a),
+                        setLevel: (l) => {
+                          currentLevel = l;
+                        }
+                      };
+                    }
+                    var logger = createLogger22("tailwind-styled");
+                    function hashContent2(content, algorithm = "md5", length = 8) {
+                      return crypto2.createHash(algorithm).update(content).digest("hex").slice(0, length);
+                    }
+                    function hashFile(filePath, algorithm = "md5", length = 8) {
+                      try {
+                        const content = fs__default22.default.readFileSync(filePath, "utf8");
+                        return hashContent2(content, algorithm, length);
+                      } catch {
+                        return "00000000";
+                      }
+                    }
+                    function debounce(fn, ms) {
+                      let timer = null;
+                      return ((...args) => {
+                        if (timer) clearTimeout(timer);
+                        timer = setTimeout(() => {
+                          timer = null;
+                          fn(...args);
+                        }, ms);
+                      });
+                    }
+                    function throttle(fn, ms) {
+                      let last = 0;
+                      return ((...args) => {
+                        const now = Date.now();
+                        if (now - last >= ms) {
+                          last = now;
+                          fn(...args);
+                        }
+                      });
+                    }
+                    function parseVersion(v) {
+                      const parts = v.replace(/^v/, "").split(".").map((p) => {
+                        const n = Number(p);
+                        return Number.isNaN(n) ? 0 : n;
+                      });
+                      const [major = 0, minor = 0, patch = 0] = parts;
+                      return { major, minor, patch };
+                    }
+                    function satisfiesMinVersion(version, minVersion) {
+                      const v = parseVersion(version);
+                      const min = parseVersion(minVersion);
+                      if (v.major !== min.major) return v.major > min.major;
+                      if (v.minor !== min.minor) return v.minor > min.minor;
+                      return v.patch >= min.patch;
+                    }
+                    exports$1222.LRUCache = LRUCache;
+                    exports$1222.createDebugLogger = createDebugLogger2;
+                    exports$1222.createLogger = createLogger22;
+                    exports$1222.debounce = debounce;
+                    exports$1222.formatErrorMessage = formatErrorMessage2;
+                    exports$1222.hashContent = hashContent2;
+                    exports$1222.hashFile = hashFile;
+                    exports$1222.isDebugNamespaceEnabled = isDebugNamespaceEnabled;
+                    exports$1222.loadNativeBinding = loadNativeBinding2;
+                    exports$1222.logger = logger;
+                    exports$1222.parseVersion = parseVersion;
+                    exports$1222.resolveNativeBindingCandidates = resolveNativeBindingCandidates2;
+                    exports$1222.resolveRuntimeDir = resolveRuntimeDir2;
+                    exports$1222.satisfiesMinVersion = satisfiesMinVersion;
+                    exports$1222.throttle = throttle;
                   }
                 });
                 var nativeBridge_exports = {};
@@ -16412,6 +16807,7 @@ Or install a prebuilt binary for your platform.`
                     metadata
                   };
                 }
+                var import_shared222;
                 var getDirname22;
                 var runtimeDir;
                 var requireFromRuntime;
@@ -16419,7 +16815,7 @@ Or install a prebuilt binary for your platform.`
                 var log22;
                 var init_nativeBridge = __esm2({
                   "packages/compiler/src/nativeBridge.ts"() {
-                    init_src();
+                    import_shared222 = __toESM222(require_shared222());
                     getDirname22 = () => {
                       if (typeof __dirname !== "undefined") {
                         return __dirname;
@@ -16431,7 +16827,7 @@ Or install a prebuilt binary for your platform.`
                     };
                     runtimeDir = getDirname22();
                     requireFromRuntime = typeof module2 !== "undefined" && typeof module2.require === "function" ? module2.require.bind(module2) : module$122.createRequire(path7__default.default.join(runtimeDir, "noop.cjs"));
-                    log22 = createLogger22("compiler:native");
+                    log22 = (0, import_shared222.createLogger)("compiler:native");
                   }
                 });
                 function requireNative() {
@@ -18156,13 +18552,7 @@ body {
 `;
                   }
                 });
-                var globalRegistry = {
-                  transforms: [],
-                  tokens: {}
-                };
-                function getGlobalRegistry() {
-                  return globalRegistry;
-                }
+                var import_plugin = __toESM222(require_plugin2());
                 function mergeClassesStatic2(classes) {
                   return tailwindMerge.twMerge(classes);
                 }
@@ -18901,7 +19291,7 @@ ${subAssignments}
                         compoundVariants: compounds,
                         defaultVariants: defaults
                       };
-                      const registry = getGlobalRegistry();
+                      const registry = (0, import_plugin.getGlobalRegistry)();
                       if (registry.transforms.length > 0) {
                         const componentName = `Tw${tag}`;
                         for (const transform of registry.transforms) {
@@ -19081,8 +19471,8 @@ Please ensure the native module is properly built.`
                 function scanFiles(dir) {
                   const files = [];
                   function walk(current) {
-                    if (!fs3__default.default.existsSync(current)) return;
-                    const entries = fs3__default.default.readdirSync(current, { withFileTypes: true });
+                    if (!fs2__default2.default.existsSync(current)) return;
+                    const entries = fs2__default2.default.readdirSync(current, { withFileTypes: true });
                     for (const entry of entries) {
                       if (SKIP_DIRS.has(entry.name)) continue;
                       const fullPath = path7__default.default.join(current, entry.name);
@@ -19103,7 +19493,7 @@ Please ensure the native module is properly built.`
                     const files = scanFiles(absDir);
                     for (const file of files) {
                       try {
-                        const source = fs3__default.default.readFileSync(file, "utf-8");
+                        const source = fs2__default2.default.readFileSync(file, "utf-8");
                         const usage = extractComponentUsage(source);
                         for (const [comp, props] of Object.entries(usage)) {
                           if (!combined[comp]) combined[comp] = {};
@@ -19242,19 +19632,19 @@ Please ensure the native module is properly built.`
                   }
                   return { css, report };
                 }
-                init_src();
+                var import_shared2222 = __toESM222(require_shared222());
                 var CACHE_DIR = ".tw-cache";
                 var HASH_CACHE_FILE = path7__default.default.join(CACHE_DIR, "file-hashes.json");
                 var GRAPH_CACHE_FILE = path7__default.default.join(CACHE_DIR, "dep-graph.json");
                 function ensureCacheDir() {
-                  if (!fs3__default.default.existsSync(CACHE_DIR)) {
-                    fs3__default.default.mkdirSync(CACHE_DIR, { recursive: true });
+                  if (!fs2__default2.default.existsSync(CACHE_DIR)) {
+                    fs2__default2.default.mkdirSync(CACHE_DIR, { recursive: true });
                   }
                 }
                 function loadHashCache() {
                   try {
-                    if (fs3__default.default.existsSync(HASH_CACHE_FILE)) {
-                      const raw = fs3__default.default.readFileSync(HASH_CACHE_FILE, "utf-8");
+                    if (fs2__default2.default.existsSync(HASH_CACHE_FILE)) {
+                      const raw = fs2__default2.default.readFileSync(HASH_CACHE_FILE, "utf-8");
                       return new Map(Object.entries(JSON.parse(raw)));
                     }
                   } catch {
@@ -19265,14 +19655,14 @@ Please ensure the native module is properly built.`
                   try {
                     ensureCacheDir();
                     const obj = Object.fromEntries(cache);
-                    fs3__default.default.writeFileSync(HASH_CACHE_FILE, JSON.stringify(obj, null, 2));
+                    fs2__default2.default.writeFileSync(HASH_CACHE_FILE, JSON.stringify(obj, null, 2));
                   } catch {
                   }
                 }
                 function loadGraphCache() {
                   try {
-                    if (fs3__default.default.existsSync(GRAPH_CACHE_FILE)) {
-                      const raw = fs3__default.default.readFileSync(GRAPH_CACHE_FILE, "utf-8");
+                    if (fs2__default2.default.existsSync(GRAPH_CACHE_FILE)) {
+                      const raw = fs2__default2.default.readFileSync(GRAPH_CACHE_FILE, "utf-8");
                       const data = JSON.parse(raw);
                       return new Map(Object.entries(data));
                     }
@@ -19284,7 +19674,7 @@ Please ensure the native module is properly built.`
                   try {
                     ensureCacheDir();
                     const obj = Object.fromEntries(graph);
-                    fs3__default.default.writeFileSync(GRAPH_CACHE_FILE, JSON.stringify(obj, null, 2));
+                    fs2__default2.default.writeFileSync(GRAPH_CACHE_FILE, JSON.stringify(obj, null, 2));
                   } catch {
                   }
                 }
@@ -19307,7 +19697,7 @@ Please ensure the native module is properly built.`
                   return result;
                 }
                 function hashFileContent(content) {
-                  return hashContent(content, "md5", 8);
+                  return (0, import_shared2222.hashContent)(content, "md5", 8);
                 }
                 function makeAtomicClass(declaration, modifier) {
                   const key = modifier ? `${declaration}::${modifier}` : declaration;
@@ -19389,8 +19779,8 @@ Please ensure the native module is properly built.`
                   }
                   loadFromDisk() {
                     try {
-                      if (fs3__default.default.existsSync(this.outputPath)) {
-                        const css = fs3__default.default.readFileSync(this.outputPath, "utf-8");
+                      if (fs2__default2.default.existsSync(this.outputPath)) {
+                        const css = fs2__default2.default.readFileSync(this.outputPath, "utf-8");
                         const ruleRe = /(\.tw-[a-z0-9]+(?::[\w-]+)?)\{([^}]+)\}|(@[^{]+)\{(\.tw-[a-z0-9]+)\{([^}]+)\}\}/g;
                         let m;
                         while ((m = ruleRe.exec(css)) !== null) {
@@ -19420,7 +19810,7 @@ Please ensure the native module is properly built.`
                     try {
                       ensureCacheDir();
                       const css = Array.from(this.ruleMap.values()).join("\n");
-                      await fs3__default.default.promises.writeFile(this.outputPath, css, "utf-8");
+                      await fs2__default2.default.promises.writeFile(this.outputPath, css, "utf-8");
                       this.dirty = false;
                     } catch {
                     }
@@ -19431,7 +19821,7 @@ Please ensure the native module is properly built.`
                     try {
                       ensureCacheDir();
                       const css = Array.from(this.ruleMap.values()).join("\n");
-                      fs3__default.default.writeFileSync(this.outputPath, css, "utf-8");
+                      fs2__default2.default.writeFileSync(this.outputPath, css, "utf-8");
                       this.dirty = false;
                     } catch {
                     }
@@ -20388,7 +20778,7 @@ The native binding is required for all transformations.`
                   _cachedCwd = cwd;
                   for (const file of CONFIG_FILES) {
                     const fullPath = path7__default.default.join(cwd, file);
-                    if (fs3__default.default.existsSync(fullPath)) {
+                    if (fs2__default2.default.existsSync(fullPath)) {
                       try {
                         const mod = __require2222(fullPath);
                         const config = mod.default ?? mod;
@@ -20416,14 +20806,14 @@ The native binding is required for all transformations.`
                   if (config.content?.files) {
                     return config.content.files.filter((f) => typeof f === "string");
                   }
-                  return ["src", "app", "pages", "components"].filter((d) => fs3__default.default.existsSync(path7__default.default.join(cwd, d))).map((d) => `./${d}/**/*.{tsx,ts,jsx,js}`);
+                  return ["src", "app", "pages", "components"].filter((d) => fs2__default2.default.existsSync(path7__default.default.join(cwd, d))).map((d) => `./${d}/**/*.{tsx,ts,jsx,js}`);
                 }
                 function invalidateConfigCache() {
                   _cachedConfig = null;
                   _cachedCwd = "";
                 }
                 function isZeroConfig(cwd = process.cwd()) {
-                  return !CONFIG_FILES.some((f) => fs3__default.default.existsSync(path7__default.default.join(cwd, f)));
+                  return !CONFIG_FILES.some((f) => fs2__default2.default.existsSync(path7__default.default.join(cwd, f)));
                 }
                 function bootstrapZeroConfig(cwd = process.cwd()) {
                   let generatedConfig = false;
@@ -20435,13 +20825,13 @@ The native binding is required for all transformations.`
                     "src/index.css",
                     "src/styles/globals.css"
                   ];
-                  const hasGlobalCss = cssPaths.some((p) => fs3__default.default.existsSync(path7__default.default.join(cwd, p)));
+                  const hasGlobalCss = cssPaths.some((p) => fs2__default2.default.existsSync(path7__default.default.join(cwd, p)));
                   if (!hasGlobalCss) {
                     const { defaultGlobalCss: defaultGlobalCss2 } = (init_defaultPreset(), __toCommonJS2(defaultPreset_exports));
-                    const appDir = fs3__default.default.existsSync(path7__default.default.join(cwd, "src/app")) ? "src/app" : fs3__default.default.existsSync(path7__default.default.join(cwd, "app")) ? "app" : "src";
+                    const appDir = fs2__default2.default.existsSync(path7__default.default.join(cwd, "src/app")) ? "src/app" : fs2__default2.default.existsSync(path7__default.default.join(cwd, "app")) ? "app" : "src";
                     const cssPath = path7__default.default.join(cwd, appDir, "globals.css");
-                    if (fs3__default.default.existsSync(path7__default.default.dirname(cssPath))) {
-                      fs3__default.default.writeFileSync(cssPath, defaultGlobalCss2);
+                    if (fs2__default2.default.existsSync(path7__default.default.dirname(cssPath))) {
+                      fs2__default2.default.writeFileSync(cssPath, defaultGlobalCss2);
                       generatedCss = true;
                       console.log(`[tailwind-styled-v4] Generated ${cssPath}`);
                     }
@@ -20514,8 +20904,8 @@ Please build the native module.`
                 }
                 var SCAN_EXTENSIONS2 = [".tsx", ".ts", ".jsx", ".js"];
                 function scanDir(dir, files = []) {
-                  if (!fs3__default.default.existsSync(dir)) return files;
-                  const entries = fs3__default.default.readdirSync(dir, { withFileTypes: true });
+                  if (!fs2__default2.default.existsSync(dir)) return files;
+                  const entries = fs2__default2.default.readdirSync(dir, { withFileTypes: true });
                   for (const entry of entries) {
                     if (entry.name === "node_modules" || entry.name === ".next" || entry.name === "dist") continue;
                     const fullPath = path7__default.default.join(dir, entry.name);
@@ -20534,7 +20924,7 @@ Please build the native module.`
                     const files = scanDir(absDir);
                     for (const file of files) {
                       try {
-                        const source = fs3__default.default.readFileSync(file, "utf-8");
+                        const source = fs2__default2.default.readFileSync(file, "utf-8");
                         const classes = extractAllClasses2(source);
                         classes.forEach((c) => allClasses.add(c));
                       } catch {
@@ -20543,13 +20933,13 @@ Please build the native module.`
                   }
                   const sorted = Array.from(allClasses).sort();
                   const absOutput = path7__default.default.isAbsolute(outputPath) ? outputPath : path7__default.default.resolve(cwd, outputPath);
-                  fs3__default.default.writeFileSync(absOutput, JSON.stringify(sorted, null, 2));
+                  fs2__default2.default.writeFileSync(absOutput, JSON.stringify(sorted, null, 2));
                   console.log(`[tailwind-styled-v4] Safelist: ${sorted.length} classes \u2192 ${absOutput}`);
                   return sorted;
                 }
                 function loadSafelist(safelistPath) {
                   try {
-                    const content = fs3__default.default.readFileSync(safelistPath, "utf-8");
+                    const content = fs2__default2.default.readFileSync(safelistPath, "utf-8");
                     return JSON.parse(content);
                   } catch {
                     return [];
@@ -20562,7 +20952,7 @@ Please build the native module.`
                     const files = scanDir(absDir);
                     for (const file of files) {
                       try {
-                        const source = fs3__default.default.readFileSync(file, "utf-8");
+                        const source = fs2__default2.default.readFileSync(file, "utf-8");
                         const classes = extractAllClasses2(source);
                         classes.forEach((c) => allClasses.add(c));
                       } catch {
@@ -20571,13 +20961,13 @@ Please build the native module.`
                   }
                   const sorted = Array.from(allClasses).sort();
                   const absOutput = path7__default.default.isAbsolute(outputPath) ? outputPath : path7__default.default.resolve(cwd, outputPath);
-                  fs3__default.default.mkdirSync(path7__default.default.dirname(absOutput), { recursive: true });
+                  fs2__default2.default.mkdirSync(path7__default.default.dirname(absOutput), { recursive: true });
                   const css = sorted.length > 0 ? `/* Auto-generated by tailwind-styled-v4 \u2014 DO NOT EDIT */
 @source inline("${sorted.join(" ")}");
 ` : `/* Auto-generated by tailwind-styled-v4 \u2014 DO NOT EDIT */
 /* No safelist classes found */
 `;
-                  fs3__default.default.writeFileSync(absOutput, css);
+                  fs2__default2.default.writeFileSync(absOutput, css);
                   console.log(`[tailwind-styled-v4] Safelist: ${sorted.length} classes \u2192 ${absOutput}`);
                   return sorted;
                 }
@@ -20685,13 +21075,13 @@ Please build the native module.`
                     }
                   }
                   if (outputDir) {
-                    const fs6 = __require2222("fs");
-                    fs6.mkdirSync(outputDir, { recursive: true });
+                    const fs5 = __require2222("fs");
+                    fs5.mkdirSync(outputDir, { recursive: true });
                     for (const result of results) {
                       const filename = routeToFilename(result.route);
                       const filepath = path7__default.default.join(outputDir, filename);
-                      fs6.mkdirSync(path7__default.default.dirname(filepath), { recursive: true });
-                      fs6.writeFileSync(filepath, result.css);
+                      fs5.mkdirSync(path7__default.default.dirname(filepath), { recursive: true });
+                      fs5.writeFileSync(filepath, result.css);
                     }
                     const totalSize = results.reduce((sum, r) => sum + r.sizeBytes, 0);
                     console.log(