@barocss/kit 0.0.2 → 0.4.0

package/dist/index.js

@@ -34,16 +34,203 @@ function property(name, initialValue, syntax, source) {
   }
   return atRule("property", name, nodes, source);
 }
+class AstCache {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = 1e3;
+  }
+  // Prevent memory leaks
+  set(key, ast) {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, ast);
+  }
+  get(key) {
+    return this.cache.get(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hitRate: this.cache.size / this.maxSize
+    };
+  }
+}
+const astCache = new AstCache();
+class ParseResultCache {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = 2e3;
+  }
+  // Prevent memory leaks
+  set(key, result) {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, result);
+  }
+  get(key) {
+    return this.cache.get(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hitRate: this.cache.size / this.maxSize
+    };
+  }
+}
+const parseResultCache = new ParseResultCache();
+class UtilityCache {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = 1e3;
+  }
+  // Prevent memory leaks
+  set(key, value) {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  get(key) {
+    return this.cache.get(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hitRate: this.cache.size / this.maxSize
+    };
+  }
+}
+const utilityCache = new UtilityCache();
+let resetContextCaches;
+function setContextCacheReset(reset) {
+  resetContextCaches = reset;
+}
+function clearAllCaches() {
+  astCache.clear();
+  parseResultCache.clear();
+  utilityCache.clear();
+  resetContextCaches?.();
+  console.log("[clearAllCaches] All caches cleared");
+}
+class WeakCache {
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+    this.keyMap = /* @__PURE__ */ new Map();
+    this.maxSize = 1e3;
+  }
+  set(key, value) {
+    if (this.keyMap.size >= this.maxSize) {
+      const firstKey = this.keyMap.keys().next().value;
+      if (firstKey) {
+        const obj2 = this.keyMap.get(firstKey);
+        if (obj2) {
+          this.cache.delete(obj2);
+        }
+        this.keyMap.delete(firstKey);
+      }
+    }
+    const obj = { key };
+    this.cache.set(obj, value);
+    this.keyMap.set(key, obj);
+  }
+  get(key) {
+    const obj = this.keyMap.get(key);
+    if (obj) {
+      return this.cache.get(obj);
+    }
+    return void 0;
+  }
+  has(key) {
+    return this.keyMap.has(key);
+  }
+  clear() {
+    this.keyMap.clear();
+  }
+  getStats() {
+    return {
+      size: this.keyMap.size,
+      maxSize: this.maxSize,
+      hitRate: this.keyMap.size / this.maxSize
+    };
+  }
+}
+const states = /* @__PURE__ */ new WeakMap();
+let cacheGeneration = 0;
+setContextCacheReset(() => {
+  cacheGeneration += 1;
+});
+function initializeContextState(ctx, utilities, modifiers) {
+  states.set(ctx, {
+    utilities: [...utilities],
+    modifiers: [...modifiers],
+    astCache: new AstCache(),
+    parseResultCache: new ParseResultCache(),
+    utilityCache: new UtilityCache(),
+    failures: /* @__PURE__ */ new Set(),
+    cacheGeneration
+  });
+}
+function getContextState(ctx) {
+  const state = states.get(ctx);
+  if (state && state.cacheGeneration !== cacheGeneration) {
+    clearContextCaches(ctx);
+    state.cacheGeneration = cacheGeneration;
+  }
+  return state;
+}
+function clearContextCaches(ctx) {
+  const state = states.get(ctx);
+  if (!state) return;
+  state.astCache.clear();
+  state.parseResultCache.clear();
+  state.utilityCache.clear();
+  state.failures.clear();
+}
 const utilityRegistry = [];
-function registerUtility(util) {
-  utilityRegistry.push(util);
+function registerUtility(util, ctx) {
+  const state = ctx && getContextState(ctx);
+  if (ctx && !state) throw new Error("Utility registration requires a context from createContext");
+  (state?.utilities || utilityRegistry).push(util);
+  if (ctx) clearContextCaches(ctx);
 }
-function getUtility() {
-  return utilityRegistry;
+function getUtility(ctx) {
+  return ctx && getContextState(ctx)?.utilities || utilityRegistry;
 }
 const modifierRegistry = [];
-function staticModifier(name, selectors, options = {}) {
-  modifierRegistry.push({
+function staticModifier(name, selectors, options = {}, ctx) {
+  registerModifier({
     match: (mod) => mod === name,
     modifySelector: ({ ..._rest }) => {
       return selectors.map((sel) => ({
@@ -52,13 +239,19 @@ function staticModifier(name, selectors, options = {}) {
       }));
     },
     ...options
-  });
+  }, ctx);
+}
+function functionalModifier(match, modifySelector, wrap, options = {}, ctx) {
+  registerModifier({ match, modifySelector, wrap, ...options }, ctx);
 }
-function functionalModifier(match, modifySelector, wrap, options = {}) {
-  modifierRegistry.push({ match, modifySelector, wrap, ...options });
+function registerModifier(modifier, ctx) {
+  const state = ctx && getContextState(ctx);
+  if (ctx && !state) throw new Error("Modifier registration requires a context from createContext");
+  (state?.modifiers || modifierRegistry).push(modifier);
+  if (ctx) clearContextCaches(ctx);
 }
-function getModifier() {
-  return modifierRegistry;
+function getModifier(ctx) {
+  return ctx && getContextState(ctx)?.modifiers || modifierRegistry;
 }
 const ESCAPE_REGEX = /[^A-Za-z0-9_-]/g;
 function escapeClassName(className) {
@@ -97,7 +290,7 @@ function escapeClassName(className) {
     return "\\" + c;
   });
 }
-function staticUtility(name, decls, opts) {
+function staticUtility(name, decls, opts, ctx) {
   registerUtility({
     name,
     match: (className) => {
@@ -124,13 +317,13 @@ function staticUtility(name, decls, opts) {
     description: opts?.description,
     category: opts?.category,
     priority: opts?.priority
-  });
+  }, ctx);
 }
-function functionalUtility(opts) {
+function functionalUtility(opts, ctx) {
   registerUtility({
     name: opts.name,
     match: (className) => className.startsWith(opts.name + "-"),
-    handler: (value, ctx, token, _options) => {
+    handler: (value, ctx2, token, _options) => {
       let finalValue = value;
       const parsedUtility = token;
       const extra = {
@@ -146,7 +339,7 @@ function functionalUtility(opts) {
       if (opts.supportsArbitrary && parsedUtility.arbitrary) {
         const processedValue = finalValue.replace(/_/g, " ");
         if (opts.handle) {
-          const result = opts.handle(processedValue, ctx, token, extra);
+          const result = opts.handle(processedValue, ctx2, token, extra);
           if (result) return result;
         }
         if (opts.prop) {
@@ -156,12 +349,12 @@ function functionalUtility(opts) {
       }
       if (opts.supportsCustomProperty && parsedUtility.customProperty) {
         if (opts.handleCustomProperty) {
-          const result = opts.handleCustomProperty(finalValue, ctx, token, extra);
+          const result = opts.handleCustomProperty(finalValue, ctx2, token, extra);
           return result;
         }
         const customValue = `var(${finalValue})`;
         if (opts.handle) {
-          const result = opts.handle(customValue, ctx, token, extra);
+          const result = opts.handle(customValue, ctx2, token, extra);
           if (result) return result;
         }
         if (opts.prop) {
@@ -170,12 +363,12 @@ function functionalUtility(opts) {
         return [];
       }
       let themeValue;
-      if (opts.themeKey && ctx.theme) {
-        themeValue = ctx.theme(opts.themeKey, finalValue);
+      if (opts.themeKey && ctx2.theme) {
+        themeValue = ctx2.theme(opts.themeKey, finalValue);
       }
-      if (!themeValue && opts.themeKeys && ctx.theme) {
+      if (!themeValue && opts.themeKeys && ctx2.theme) {
         for (const key of opts.themeKeys) {
-          themeValue = ctx.theme(key, finalValue);
+          themeValue = ctx2.theme(key, finalValue);
           if (themeValue !== void 0) break;
         }
       }
@@ -186,7 +379,7 @@ function functionalUtility(opts) {
           return [decl(opts.prop, finalValue)];
         }
         if (opts.handle) {
-          const result = opts.handle(finalValue, ctx, token, extra);
+          const result = opts.handle(finalValue, ctx2, token, extra);
           if (result) return result;
         }
         return [];
@@ -195,16 +388,16 @@ function functionalUtility(opts) {
         finalValue = value;
       }
       if (parsedUtility.negative && opts.supportsNegative && opts.handleNegativeBareValue) {
-        const bare = opts.handleNegativeBareValue({ value: String(finalValue).replace(/^-/, ""), ctx, token, extra });
+        const bare = opts.handleNegativeBareValue({ value: String(finalValue).replace(/^-/, ""), ctx: ctx2, token, extra });
         if (bare == null) return [];
         finalValue = bare;
       } else if (opts.handleBareValue) {
-        const bare = opts.handleBareValue({ value: finalValue, ctx, token, extra });
+        const bare = opts.handleBareValue({ value: finalValue, ctx: ctx2, token, extra });
         if (bare == null) return [];
         finalValue = bare;
       }
       if (opts.handle) {
-        const result = opts.handle(finalValue, ctx, token, extra);
+        const result = opts.handle(finalValue, ctx2, token, extra);
         if (result) return result;
       }
       if (opts.prop) {
@@ -215,7 +408,7 @@ function functionalUtility(opts) {
     description: opts.description,
     category: opts.category,
     priority: opts.priority
-  });
+  }, ctx);
 }
 function tokenize(className) {
   const tokens = [];
@@ -252,159 +445,13 @@ function tokenize(className) {
   }
   return tokens;
 }
-class AstCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = 1e3;
-  }
-  // Prevent memory leaks
-  set(key, ast) {
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, ast);
-  }
-  get(key) {
-    return this.cache.get(key);
-  }
-  has(key) {
-    return this.cache.has(key);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  getStats() {
-    return {
-      size: this.cache.size,
-      maxSize: this.maxSize,
-      hitRate: this.cache.size / this.maxSize
-    };
-  }
-}
-const astCache = new AstCache();
-class ParseResultCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = 2e3;
-  }
-  // Prevent memory leaks
-  set(key, result) {
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, result);
-  }
-  get(key) {
-    return this.cache.get(key);
-  }
-  has(key) {
-    return this.cache.has(key);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  getStats() {
-    return {
-      size: this.cache.size,
-      maxSize: this.maxSize,
-      hitRate: this.cache.size / this.maxSize
-    };
-  }
-}
-const parseResultCache = new ParseResultCache();
-class UtilityCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = 1e3;
-  }
-  // Prevent memory leaks
-  set(key, value) {
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, value);
-  }
-  get(key) {
-    return this.cache.get(key);
-  }
-  has(key) {
-    return this.cache.has(key);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  getStats() {
-    return {
-      size: this.cache.size,
-      maxSize: this.maxSize,
-      hitRate: this.cache.size / this.maxSize
-    };
-  }
-}
-const utilityCache = new UtilityCache();
-function clearAllCaches() {
-  astCache.clear();
-  parseResultCache.clear();
-  utilityCache.clear();
-  console.log("[clearAllCaches] All caches cleared");
-}
-class WeakCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new WeakMap();
-    this.keyMap = /* @__PURE__ */ new Map();
-    this.maxSize = 1e3;
+function isUtilityPrefix(str, ctx) {
+  const cache = ctx && getContextState(ctx)?.utilityCache || utilityCache;
+  if (cache.has(str)) {
+    return cache.get(str);
   }
-  set(key, value) {
-    if (this.keyMap.size >= this.maxSize) {
-      const firstKey = this.keyMap.keys().next().value;
-      if (firstKey) {
-        const obj2 = this.keyMap.get(firstKey);
-        if (obj2) {
-          this.cache.delete(obj2);
-        }
-        this.keyMap.delete(firstKey);
-      }
-    }
-    const obj = { key };
-    this.cache.set(obj, value);
-    this.keyMap.set(key, obj);
-  }
-  get(key) {
-    const obj = this.keyMap.get(key);
-    if (obj) {
-      return this.cache.get(obj);
-    }
-    return void 0;
-  }
-  has(key) {
-    return this.keyMap.has(key);
-  }
-  clear() {
-    this.keyMap.clear();
-  }
-  getStats() {
-    return {
-      size: this.keyMap.size,
-      maxSize: this.maxSize,
-      hitRate: this.keyMap.size / this.maxSize
-    };
-  }
-}
-function isUtilityPrefix(str) {
-  if (utilityCache.has(str)) {
-    return utilityCache.get(str);
-  }
-  const utilities = getUtility();
-  const modifiers = getModifier();
+  const utilities = getUtility(ctx);
+  const modifiers = getModifier(ctx);
   const candidateUtilities = utilities.filter((util) => {
     const prefix = util.name;
     return str.startsWith(prefix + "-") || str === prefix || str.startsWith(prefix);
@@ -416,12 +463,13 @@ function isUtilityPrefix(str) {
   });
   const isModifier = candidateModifiers.some((mod) => mod.match(str, {}));
   const result = isUtility && !isModifier;
-  utilityCache.set(str, result);
+  cache.set(str, result);
   return result;
 }
-function parseClassName(className) {
-  if (parseResultCache.has(className)) {
-    return parseResultCache.get(className);
+function parseClassName(className, ctx) {
+  const cache = ctx && getContextState(ctx)?.parseResultCache || parseResultCache;
+  if (cache.has(className)) {
+    return cache.get(className);
   }
   let important = false;
   let realClassName = className;
@@ -430,38 +478,38 @@ function parseClassName(className) {
     realClassName = className.slice(1);
   }
   const tokens = tokenize(realClassName);
-  const result = parseTokens(tokens);
+  const result = parseTokens(tokens, ctx);
   if (result.utility) {
     result.utility.important = important;
   }
-  parseResultCache.set(className, result);
+  cache.set(className, result);
   return result;
 }
-function parseTokens(tokens) {
+function parseTokens(tokens, ctx) {
   const modifiers = [];
   let utility = null;
   if (tokens.length === 0) {
     return { modifiers, utility: null };
   }
   if (tokens.length === 1) {
-    utility = parseUtility(tokens[0].value);
+    utility = parseUtility(tokens[0].value, ctx);
   } else if (tokens.length === 2) {
     const firstToken = tokens[0];
     const secondToken = tokens[1];
-    const isFirstUtility = isUtilityPrefix(firstToken.value);
+    const isFirstUtility = isUtilityPrefix(firstToken.value, ctx);
     if (isFirstUtility) {
-      utility = parseUtility(firstToken.value);
+      utility = parseUtility(firstToken.value, ctx);
       const parsed = parseModifier(secondToken.value);
       if (parsed) modifiers.push(parsed);
     } else {
       const parsed = parseModifier(firstToken.value);
       if (parsed) modifiers.push(parsed);
-      utility = parseUtility(secondToken.value);
+      utility = parseUtility(secondToken.value, ctx);
     }
   } else {
-    const isFirstUtility = isUtilityPrefix(tokens[0].value);
+    const isFirstUtility = isUtilityPrefix(tokens[0].value, ctx);
     if (isFirstUtility) {
-      utility = parseUtility(tokens[0].value);
+      utility = parseUtility(tokens[0].value, ctx);
       for (let i = 1; i < tokens.length; i++) {
         const parsed = parseModifier(tokens[i].value);
         if (parsed) modifiers.push(parsed);
@@ -471,7 +519,7 @@ function parseTokens(tokens) {
         const parsed = parseModifier(tokens[i].value);
         if (parsed) modifiers.push(parsed);
       }
-      utility = parseUtility(tokens[tokens.length - 1].value);
+      utility = parseUtility(tokens[tokens.length - 1].value, ctx);
     }
   }
   return { modifiers, utility };
@@ -491,7 +539,7 @@ function parseModifier(value) {
 function nameSort(a, b) {
   return b.name.length - a.name.length;
 }
-function parseUtility(value) {
+function parseUtility(value, ctx) {
   let prefix = "";
   let utilityValue = "";
   let arbitrary = false;
@@ -518,8 +566,7 @@ function parseUtility(value) {
     utilityValue = utilityValue.replace(/\)$/, "");
     customProperty = true;
   } else {
-    const utilities = getUtility();
-    const sortedUtilities = utilities.sort(nameSort);
+    const sortedUtilities = [...getUtility(ctx)].sort(nameSort);
     let matchedUtility = sortedUtilities.find((p) => value === p.name);
     if (matchedUtility) {
       prefix = matchedUtility.name;
@@ -730,7 +777,7 @@ ${node.nodes.map((node2) => {
   }).join("\n");
   return result;
 }
-const failureCache = /* @__PURE__ */ new Map();
+const failureCache = /* @__PURE__ */ new Set();
 function collectDeclPaths(nodes = [], path = []) {
   let result = [];
   for (const node of nodes) {
@@ -894,32 +941,29 @@ function extractAtRootNodes(nodes, parent, atRootNodes = []) {
   }
 }
 function parseClassToAst(fullClassName, ctx) {
-  if (failureCache.has(fullClassName)) {
+  const state = getContextState(ctx);
+  const failures = state?.failures || failureCache;
+  const cache = state?.astCache || astCache;
+  if (failures.has(fullClassName)) {
     return [];
   }
-  const contextHash = JSON.stringify({
-    darkMode: ctx.config("darkMode"),
-    darkModeSelector: ctx.config("darkModeSelector"),
-    theme: ctx.theme
-  });
-  const cacheKey = `${fullClassName}:${contextHash}`;
-  if (astCache.has(cacheKey)) {
-    return astCache.get(cacheKey);
+  if (cache.has(fullClassName)) {
+    return cache.get(fullClassName);
   }
-  const { modifiers, utility } = parseClassName(fullClassName);
+  const { modifiers, utility } = parseClassName(fullClassName, ctx);
   if (!utility) {
     console.warn(`[BAROCSS] Invalid class name format: "${fullClassName}"`);
-    failureCache.set(fullClassName, true);
+    failures.add(fullClassName);
     return [];
   }
-  const utilReg = getUtility().find((u) => {
+  const utilReg = getUtility(ctx).find((u) => {
     const fullClassName2 = utility.value ? `${utility.prefix}-${utility.value}` : utility.prefix;
     return u.match(fullClassName2);
   });
   if (!utilReg) {
     const utilityName = utility.value ? `${utility.prefix}-${utility.value}` : utility.prefix;
     console.warn(`[BAROCSS] Unknown utility class: "${utilityName}" in "${fullClassName}"`);
-    failureCache.set(fullClassName, true);
+    failures.add(fullClassName);
     return [];
   }
   let value = utility.value;
@@ -929,10 +973,11 @@ function parseClassToAst(fullClassName, ctx) {
   const selector = "&";
   for (let i = 0; i < modifiers.length; i++) {
     const variant = modifiers[i];
-    const plugin = getModifier().find((p) => p.match(variant.type, ctx));
+    const plugin = getModifier(ctx).find((p) => p.match(variant.type, ctx));
     if (!plugin) {
       console.warn(`[BAROCSS] Unknown variant: "${variant.type}" in "${fullClassName}"`);
-      continue;
+      failures.add(fullClassName);
+      return [];
     }
     if (plugin.wrap) {
       const items = plugin.wrap(variant, ctx);
@@ -940,7 +985,6 @@ function parseClassToAst(fullClassName, ctx) {
         type: "wrap",
         items
       });
-      continue;
     }
     if (plugin.modifySelector) {
       const result = plugin.modifySelector({
@@ -951,9 +995,10 @@ function parseClassToAst(fullClassName, ctx) {
         variantChain: modifiers,
         index: i
       });
+      if (plugin.wrap && (result === "&" || typeof result === "object" && !Array.isArray(result) && result.selector === "&" || Array.isArray(result) && result.length === 1 && result[0].selector === "&")) continue;
       if (typeof result === "string" && result.includes("&")) {
         wrappers.push({ type: "rule", selector: result });
-      } else if (typeof result === "object" && result.selector) {
+      } else if (typeof result === "object" && !Array.isArray(result) && result.selector) {
         const wrappingType = result.wrappingType || "rule";
         wrappers.push({
           type: wrappingType,
@@ -977,10 +1022,7 @@ function parseClassToAst(fullClassName, ctx) {
   for (let i = wrappers.length - 1; i >= 0; i--) {
     const wrap = wrappers[i];
     if (wrap.type === "wrap") {
-      ast = wrap.items.map((item) => ({
-        ...item,
-        nodes: Array.isArray(ast) ? ast : [ast]
-      }));
+      ast = wrap.items.map((item) => item.type === "rule" || item.type === "style-rule" || item.type === "at-rule" || item.type === "at-root" ? { ...item, nodes: [...item.nodes || [], ...ast] } : item);
     } else if (wrap.type === "style-rule") {
       ast = [
         {
@@ -1014,12 +1056,19 @@ function parseClassToAst(fullClassName, ctx) {
   const atRootNodes = [];
   extractAtRootNodes(ast, void 0, atRootNodes);
   ast = [...atRootNodes, ...ast].filter(Boolean);
-  astCache.set(cacheKey, ast);
+  cache.set(fullClassName, ast);
   return ast;
 }
-function clearAstCache() {
-  clearAllCaches();
-  failureCache.clear();
+function clearAstCache(ctx) {
+  if (ctx) {
+    clearContextCaches(ctx);
+  } else {
+    clearAllCaches();
+    failureCache.clear();
+  }
+}
+function getAstCacheStats(ctx) {
+  return (ctx && getContextState(ctx)?.astCache || astCache).getStats();
 }
 function generateCss(classList, ctx, opts) {
   const seen = /* @__PURE__ */ new Set();
@@ -1033,7 +1082,7 @@ function generateCss(classList, ctx, opts) {
     return true;
   }).map((cls) => {
     const ast = parseClassToAst(cls, ctx);
-    const parsedResult = parseResultCache.get(cls);
+    const parsedResult = (getContextState(ctx)?.parseResultCache || parseResultCache).get(cls);
     const cleanAst = optimizeAst(ast);
     cleanAst.forEach((node) => {
       if (node.type === "at-root") {
@@ -1041,24 +1090,28 @@ function generateCss(classList, ctx, opts) {
       }
     });
     const hasStyleRule = cleanAst.some((node) => node.type === "style-rule");
-    const css = astToCss(cleanAst, hasStyleRule ? void 0 : cls, {
+    const css = astToCss(cleanAst.filter((node) => node.type !== "at-root"), hasStyleRule ? void 0 : cls, {
       minify: opts?.minify,
       important: parsedResult?.utility?.important ?? false
     });
-    const rootCss = rootToCss(allAtRootNodes);
-    const result = `${rootCss ? `:root,:host {${rootCss}}` : ""}${css}`;
+    const result = css;
     if (!result || result.trim() === "") {
       console.warn("[generateCss] Empty CSS generated for class:", {
         class: cls,
         ast: cleanAst,
         hasStyleRule,
         css,
-        rootCss,
         result
       });
     }
     return result;
   }).join(opts?.minify ? "" : "\n");
+  const rootRules = [...new Set(allAtRootNodes.filter((node) => node.type === "at-rule").map((node) => rootToCss([node])))];
+  const rootDeclarations = [...new Set(allAtRootNodes.filter((node) => node.type === "decl").map((node) => rootToCss([node])))];
+  const rootCss = [
+    ...rootRules,
+    ...rootDeclarations.length ? [`:root,:host {${rootDeclarations.join("\n")}}`] : []
+  ].join(opts?.minify ? "" : "\n");
   if (allAtRootNodes.length > 0) {
     console.log("[generateCss] All collected atRoot nodes:", allAtRootNodes);
   }
@@ -1069,14 +1122,10 @@ function generateCss(classList, ctx, opts) {
       allAtRootNodes
     });
   }
-  return results;
+  return `${rootCss}${rootCss && results ? opts?.minify ? "" : "\n" : ""}${results}`;
 }
 function generateCssRules(classList, ctx, opts) {
   const seen = /* @__PURE__ */ new Set();
-  const options = {
-    minify: opts?.minify,
-    dedup: opts?.dedup
-  };
   return classList.split(/\s+/).filter((cls) => {
     if (!cls) return false;
     if (opts?.dedup) {
@@ -1086,6 +1135,11 @@ function generateCssRules(classList, ctx, opts) {
     return true;
   }).map((cls) => {
     const ast = parseClassToAst(cls, ctx);
+    const parsedResult = (getContextState(ctx)?.parseResultCache || parseResultCache).get(cls);
+    const options = {
+      minify: opts?.minify,
+      important: parsedResult?.utility?.important ?? false
+    };
     const cleanAst = optimizeAst(ast);
     const allAtRootNodes = cleanAst.filter(
       (node) => node.type === "at-root" && !node.source
@@ -1199,7 +1253,7 @@ class IncrementalParser {
       return null;
     }
     try {
-      const parseResult = parseClassName(className);
+      const parseResult = parseClassName(className, this.ctx);
       if (!parseResult.utility) {
         return null;
       }
@@ -1332,7 +1386,7 @@ class IncrementalParser {
       processedClasses: this.processedClasses.size,
       pendingClasses: this.pendingClasses.size,
       cacheStats: {
-        ast: astCache.getStats(),
+        ast: (getContextState(this.ctx)?.astCache || astCache).getStats(),
         css: {}
         // No CSS cache, so return empty object
       }
@@ -1391,18 +1445,6 @@ class IncrementalParser {
     return Array.from(this.processedClasses);
   }
 }
-function normalizePrefix(prefix) {
-  let p = prefix.trim();
-  if (!p.startsWith("--")) p = `--${p}`;
-  if (!p.endsWith("-")) p = `${p}-`;
-  return p;
-}
-function setVarPrefix(prefix) {
-  if (typeof prefix !== "string" || prefix.trim() === "") {
-    return;
-  }
-  normalizePrefix(prefix);
-}
 function escapeKey(key) {
   return key.replace(".", "\\.");
 }
@@ -2310,7 +2352,7 @@ function deepMerge(base, override) {
   }
   return result;
 }
-let staticInProgress;
+const themeLookupsInProgress = /* @__PURE__ */ new WeakMap();
 function themeGetter(themeObj, ...path) {
   const theme = (...args) => themeGetter(themeObj, ...args);
   let keys = [];
@@ -2330,26 +2372,28 @@ function themeGetter(themeObj, ...path) {
     }
   }
   if (keys.length === 0) return void 0;
-  staticInProgress = staticInProgress || /* @__PURE__ */ new Set();
-  const pathKey = keys.join(".");
-  if (staticInProgress?.has(pathKey)) return void 0;
-  staticInProgress?.add(pathKey);
-  let value = themeObj[keys[0]];
-  if (typeof value === "function") {
-    value = value(theme);
-  }
-  for (let i = 1; i < keys.length; i++) {
-    if (value == null) {
-      staticInProgress?.delete(pathKey);
-      return void 0;
-    }
-    value = value[keys[i]];
+  let inProgress = themeLookupsInProgress.get(themeObj);
+  if (!inProgress) {
+    inProgress = /* @__PURE__ */ new Set();
+    themeLookupsInProgress.set(themeObj, inProgress);
   }
-  staticInProgress?.delete(pathKey);
-  if (typeof value === "function") {
-    return void 0;
+  const pathKey = keys.join(".");
+  if (inProgress.has(pathKey)) return void 0;
+  inProgress.add(pathKey);
+  try {
+    let value = themeObj[keys[0]];
+    if (typeof value === "function") {
+      value = value(theme);
+    }
+    for (let i = 1; i < keys.length; i++) {
+      if (value == null) return void 0;
+      value = value[keys[i]];
+    }
+    if (typeof value === "function") return void 0;
+    return value;
+  } finally {
+    inProgress.delete(pathKey);
   }
-  return value;
 }
 function configGetter(config, ...path) {
   let keys = [];
@@ -2397,11 +2441,7 @@ function createContext(configObj) {
     ],
     ...configObj
   };
-  setVarPrefix(configWithDefaults.cssVarPrefix || "--bcss-");
   const themeObj = resolveTheme(configWithDefaults);
-  if (configObj.clearCacheOnContextChange !== false) {
-    clearAllCaches();
-  }
   const ctx = {
     hasPreset: (category, preset) => {
       const result = hasPreset(themeObj, category, preset);
@@ -2435,13 +2475,182 @@ function createContext(configObj) {
           ...values
         };
       } else ;
+      clearContextCaches(ctx);
     },
     getPreflightCSS: (level = true) => {
       return getPreflightCSS(level);
     }
   };
+  initializeContextState(ctx, getUtility(), getModifier());
   return ctx;
 }
+function jsonToAst(input, ctx) {
+  let utilReg = getUtility(ctx).find((u) => u.name === input.utility.name);
+  if (input.utility.value && !input.utility.arbitrary && !input.utility.customProperty) {
+    const fullName = `${input.utility.name}-${input.utility.value}`;
+    const exactMatch = getUtility(ctx).find((u) => u.name === fullName);
+    if (exactMatch) {
+      utilReg = exactMatch;
+    }
+  }
+  if (!utilReg) {
+    console.warn(`[jsonToAst] Unknown utility: "${input.utility.name}"`);
+    return [];
+  }
+  const parsedUtility = {
+    prefix: input.utility.name,
+    value: input.utility.value,
+    arbitrary: input.utility.arbitrary,
+    negative: input.utility.negative,
+    opacity: input.utility.opacity,
+    important: input.utility.important,
+    customProperty: input.utility.customProperty,
+    category: utilReg.category,
+    priority: utilReg.priority
+  };
+  let value = input.utility.value;
+  if (input.utility.negative && value) {
+    value = "-" + value;
+  }
+  let ast = utilReg.handler(value || "", ctx, parsedUtility, utilReg) || [];
+  if (input.variants && input.variants.length > 0) {
+    const wrappers = [];
+    const selector = "&";
+    for (let i = input.variants.length - 1; i >= 0; i--) {
+      const variantInput = input.variants[i];
+      const variantName = typeof variantInput === "string" ? variantInput : variantInput.name;
+      const variantValue = typeof variantInput === "string" ? void 0 : variantInput.value;
+      const variantArbitrary = typeof variantInput === "string" ? false : variantInput.arbitrary;
+      const parsedModifier = {
+        type: variantName,
+        value: variantValue,
+        arbitrary: variantArbitrary
+      };
+      let matchKey = variantName;
+      if (variantArbitrary && variantValue) {
+        if (variantName) {
+          matchKey = `${variantName}-[${variantValue}]`;
+          parsedModifier.type = matchKey;
+        } else {
+          matchKey = `[${variantValue}]`;
+          parsedModifier.type = matchKey;
+        }
+      } else if (variantValue) {
+        matchKey = `${variantName}-[${variantValue}]`;
+        parsedModifier.type = matchKey;
+      }
+      const plugin = getModifier(ctx).find((p) => p.match(matchKey, ctx));
+      if (!plugin) {
+        console.warn(`[jsonToAst] Unknown variant: "${matchKey}"`);
+        continue;
+      }
+      if (plugin.modifySelector) {
+        const result = plugin.modifySelector({
+          selector,
+          fullClassName: "JSON_GENERATED",
+          // Placeholder
+          mod: parsedModifier,
+          context: ctx,
+          variantChain: [],
+          // We might need to pass the full chain if needed
+          index: i
+        });
+        const identityWithWrap = plugin.wrap && (result === "&" || typeof result === "object" && !Array.isArray(result) && result.selector === "&" || Array.isArray(result) && result.length === 1 && result[0].selector === "&");
+        if (identityWithWrap) ;
+        else if (typeof result === "string" && result.includes("&")) {
+          wrappers.push({ type: "rule", selector: result });
+        } else if (typeof result === "object" && !Array.isArray(result) && result.selector) {
+          const r = result;
+          const wrappingType = r.wrappingType || "rule";
+          wrappers.push({
+            type: wrappingType,
+            selector: r.selector,
+            flatten: r.flatten,
+            source: r.source
+          });
+        } else if (Array.isArray(result)) {
+          wrappers.push({
+            type: "wrap",
+            items: result.map((r) => ({
+              type: r.wrappingType || "rule",
+              selector: r.selector,
+              source: r.source,
+              nodes: []
+              // Placeholder, will be filled when wrapping
+            }))
+          });
+        }
+      }
+      if (plugin.wrap) {
+        wrappers.push({ type: "wrap", items: plugin.wrap(parsedModifier, ctx) });
+      }
+    }
+    for (let i = 0; i < wrappers.length; i++) {
+      const wrap = wrappers[i];
+      if (wrap.type === "wrap") {
+        ast = wrap.items.map((item) => item.type === "rule" || item.type === "style-rule" || item.type === "at-rule" || item.type === "at-root" ? { ...item, nodes: [...item.nodes || [], ...ast] } : item);
+      } else if (wrap.type === "style-rule") {
+        ast = [
+          {
+            type: "style-rule",
+            selector: wrap.selector,
+            source: wrap.source,
+            nodes: Array.isArray(ast) ? ast : [ast]
+          }
+        ];
+      } else if (wrap.type === "at-rule") {
+        ast = [
+          {
+            type: "at-rule",
+            name: wrap.name || "media",
+            params: wrap.params,
+            source: wrap.source,
+            nodes: Array.isArray(ast) ? ast : [ast]
+          }
+        ];
+      } else if (wrap.type === "rule") {
+        ast = [
+          {
+            type: "rule",
+            selector: wrap.selector,
+            source: wrap.source,
+            nodes: Array.isArray(ast) ? ast : [ast]
+          }
+        ];
+      }
+    }
+  }
+  return ast;
+}
+function generateCssFromJson(inputs, ctx, opts) {
+  const allAtRootNodes = [];
+  const cssList = [];
+  inputs.forEach((input) => {
+    const ast = jsonToAst(input, ctx);
+    const cleanAst = optimizeAst(ast);
+    cleanAst.forEach((node) => {
+      if (node.type === "at-root") {
+        allAtRootNodes.push(...node.nodes);
+      }
+    });
+    let reconstructedName = input.utility.name;
+    if (input.utility.value) reconstructedName += `-${input.utility.value}`;
+    if (input.utility.arbitrary) reconstructedName = `${input.utility.name}-[${input.utility.value}]`;
+    if (input.variants) {
+      const variantsStr = input.variants.map((v) => typeof v === "string" ? v : v.name).join(":");
+      reconstructedName = `${variantsStr}:${reconstructedName}`;
+    }
+    const hasStyleRule = cleanAst.some((node) => node.type === "style-rule");
+    const css = astToCss(cleanAst, hasStyleRule ? void 0 : `.${reconstructedName.replace(/[^a-zA-Z0-9-_]/g, "\\$&")}`, {
+      minify: opts?.minify,
+      important: input.utility.important ?? false
+    });
+    if (css) cssList.push(css);
+  });
+  const rootCss = rootToCss(allAtRootNodes);
+  const finalCss = `${rootCss ? `:root,:host {${rootCss}}` : ""}${cssList.join(opts?.minify ? "" : "\n")}`;
+  return finalCss;
+}
 function parseFraction(input) {
   if (input.includes("/")) {
     const [num, denom] = input.split("/").map(Number);
@@ -3779,7 +3988,7 @@ functionalUtility({
     ["--baro-ring-inset", "inset"],
     ["--baro-ring-offset-width", "0px"],
     ["--baro-ring-offset-color", "#fff"],
-    ["--baro-inset-ring-color", "rgb(59 130 246 / 0.5)"],
+    ["--baro-inset-ring-color", "currentcolor"],
     [
       "--baro-inset-ring-shadow",
       `var(--baro-ring-inset) 0 0 0 calc(${px} + var(--baro-ring-offset-width)) var(--baro-inset-ring-color, currentcolor)`
@@ -3787,7 +3996,7 @@ functionalUtility({
     ["--baro-ring-offset-shadow", `0 0 #0000`],
     [
       "box-shadow",
-      "var(--baro-inset-shadow), var(--baro-inset-ring-shadow), var(--baro-ring-offset-shadow), var(--baro-ring-shadow), var(--baro-shadow)"
+      "var(--baro-inset-shadow, 0 0 #0000), var(--baro-inset-ring-shadow), var(--baro-ring-offset-shadow, 0 0 #0000), var(--baro-ring-shadow, 0 0 #0000), var(--baro-shadow, 0 0 #0000)"
     ]
   ]);
 });
@@ -4105,6 +4314,18 @@ functionalUtility({
   description: "mask-size utility (static, arbitrary, custom property supported)",
   category: "effects"
 });
+functionalUtility({
+  name: "mask-linear-from",
+  handleBareValue: ({ value }) => /^(?:100|[1-9]?\d)%$/.test(value) ? value : null,
+  handle: (value) => [
+    decl("mask-image", "var(--tw-mask-linear), var(--tw-mask-radial, linear-gradient(#fff, #fff)), var(--tw-mask-conic, linear-gradient(#fff, #fff))"),
+    decl("mask-composite", "intersect"),
+    decl("--tw-mask-linear-stops", "var(--tw-mask-linear-position, 0deg), var(--tw-mask-linear-from-color, black) var(--tw-mask-linear-from-position, 0%), var(--tw-mask-linear-to-color, transparent) var(--tw-mask-linear-to-position, 100%)"),
+    decl("--tw-mask-linear", "linear-gradient(var(--tw-mask-linear-stops))"),
+    decl("--tw-mask-linear-from-position", value)
+  ],
+  category: "effects"
+});
 functionalUtility({
   name: "mask",
   supportsArbitrary: true,
@@ -6895,7 +7116,11 @@ functionalUtility({
 });
 staticUtility("forced-color-adjust-auto", [["forced-color-adjust", "auto"]], { category: "accessibility" });
 staticUtility("forced-color-adjust-none", [["forced-color-adjust", "none"]], { category: "accessibility" });
-staticModifier("hover", ["&:hover"], { order: 50, source: "pseudo" });
+staticModifier("hover", ["&:hover"], {
+  order: 50,
+  source: "pseudo",
+  wrap: () => [atRule("media", "(hover: hover)", [])]
+});
 staticModifier("focus", ["&:focus"], { order: 50, source: "pseudo" });
 staticModifier("active", ["&:active"], { order: 50, source: "pseudo" });
 staticModifier("visited", ["&:visited"], { order: 50, source: "pseudo" });
@@ -7735,11 +7960,14 @@ export {
   functionalModifier,
   functionalUtility,
   generateCss,
+  generateCssFromJson,
   generateCssRules,
+  getAstCacheStats,
   getModifier,
   getPreflightCSS,
   getUtility,
   hasPreset,
+  jsonToAst,
   mergeAstTreeList,
   modifierRegistry,
   optimizeAst,
@@ -7748,10 +7976,12 @@ export {
   parseResultCache,
   property,
   raw,
+  registerModifier,
   registerUtility,
   resolveTheme,
   rootToCss,
   rule,
+  setContextCacheReset,
   staticModifier,
   staticUtility,
   styleRule,