rainbowindex 0.4.1 → 0.5.1

package/dist/{chunk-IYIUS7AE.mjs → chunk-4CTJLMYM.mjs}

@@ -1,6 +1,6 @@
 import {
   compileScannedProject
-} from "./chunk-53WD6U2X.mjs";
+} from "./chunk-F4VCBISU.mjs";
 import {
   APPLY_ALIASES,
   DIRECTIVE_NAMES_SET,
@@ -11,16 +11,16 @@ import {
   computeSortKey,
   expandVariantGroups,
   forEachApplyClass,
-  getCustomUtility,
   hasApplyLikeDirective,
   hasCSSFunctions,
   hasRIActivation,
+  matchCustomUtility,
   parseUtility,
   pushWarningsDeduped,
   resolveUtilityDeclarations,
   resolveVariant,
   splitSelectorList
-} from "./chunk-6GTG5SZJ.mjs";
+} from "./chunk-PDORZSQX.mjs";
 
 // src/integrations/postcss/index.ts
 import postcss2 from "postcss";
@@ -28,6 +28,7 @@ import { isAbsolute } from "path";
 
 // src/integrations/postcss/apply.ts
 import postcss from "postcss";
+var applyStateByTheme = /* @__PURE__ */ new WeakMap();
 function makeDeclGroup(r) {
   const sortKey = computeSortKey(r.declarations[0]?.property ?? "");
   return {
@@ -100,9 +101,16 @@ function processApply(root, theme, warnings) {
       atRule.name = "apply";
     });
   }
-  const customVariantMap = new Map(theme.customVariants.map((cv) => [cv.name, cv]));
-  const checkedApplyRoots = /* @__PURE__ */ new Set();
-  const resolveCache = /* @__PURE__ */ new Map();
+  let state = applyStateByTheme.get(theme);
+  if (!state) {
+    state = {
+      customVariantMap: new Map(theme.customVariants.map((cv) => [cv.name, cv])),
+      applyRootWarnings: /* @__PURE__ */ new Map(),
+      resolveCache: /* @__PURE__ */ new Map()
+    };
+    applyStateByTheme.set(theme, state);
+  }
+  const { customVariantMap, applyRootWarnings, resolveCache } = state;
   for (let depth = 0; depth < MAX_APPLY_DEPTH; depth++) {
     const applyNodes = [];
     const classListByNode = /* @__PURE__ */ new Map();
@@ -128,7 +136,7 @@ function processApply(root, theme, warnings) {
         warnings,
         customVariantMap,
         groupRoots,
-        checkedApplyRoots,
+        applyRootWarnings,
         resolveCache
       );
     }
@@ -146,7 +154,7 @@ function processApply(root, theme, warnings) {
     }
   }
 }
-function expandApply(atRule, classNames, theme, warnings, customVariantMap, groupRoots, checkedApplyRoots, resolveCache) {
+function expandApply(atRule, classNames, theme, warnings, customVariantMap, groupRoots, applyRootWarnings, resolveCache) {
   const parentRule = atRule.parent;
   if (parentRule?.type !== "rule") {
     warnings.push("[RI-1006] @apply must be used inside a CSS rule, not at the top level.");
@@ -177,7 +185,7 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, grou
           theme,
           entryWarnings,
           customVariantMap,
-          checkedApplyRoots
+          applyRootWarnings
         ),
         warnings: entryWarnings
       };
@@ -252,19 +260,24 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, grou
     parentContainer.insertAfter(insertAfter, rule);
     insertAfter = rule;
   }
-  const groupInfoByKey = /* @__PURE__ */ new Map();
-  let hasGroupVariants = false;
-  for (const [key, bucket] of variantBuckets) {
-    const info = resolveGroupVariantInfo(bucket.wrappers, parentRule, groupRoots);
-    groupInfoByKey.set(key, info);
-    if (info) hasGroupVariants = true;
-  }
   let fullSelectorMemo = null;
   const fullNestingSelector = () => {
     if (fullSelectorMemo === null)
       fullSelectorMemo = resolveFullNestingSelector(parentRule);
     return fullSelectorMemo;
   };
+  const groupInfoByKey = /* @__PURE__ */ new Map();
+  let hasGroupVariants = false;
+  for (const [key, bucket] of variantBuckets) {
+    const info = resolveGroupVariantInfo(
+      bucket.wrappers,
+      parentRule,
+      groupRoots,
+      fullNestingSelector
+    );
+    groupInfoByKey.set(key, info);
+    if (info) hasGroupVariants = true;
+  }
   let docRootMemo = null;
   const docRoot = () => {
     if (docRootMemo === null) docRootMemo = parentContainer.root();
@@ -276,7 +289,7 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, grou
     if (groupVariantInfo) {
       const fullSelector = fullNestingSelector();
       const { groupRootSelector } = groupVariantInfo;
-      const rootBranches = splitSelectorList(groupRootSelector);
+      const rootBranches = groupVariantInfo.isSelf ? [] : splitSelectorList(groupRootSelector);
       const fullBranches = splitSelectorList(fullSelector);
       const baseBranches = [];
       for (const fb of fullBranches) {
@@ -332,7 +345,7 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, grou
   }
   atRule.remove();
 }
-function resolveGroupVariantInfo(wrappers, parentRule, groupRoots) {
+function resolveGroupVariantInfo(wrappers, parentRule, groupRoots, fullNestingSelector) {
   if (groupRoots.size === 0) return null;
   const hasGroupVariant = wrappers.some(
     (w) => w.selectorSuffix && w.replaceAmpersand && GROUP_VARIANT_RE.test(w.selectorSuffix)
@@ -340,23 +353,23 @@ function resolveGroupVariantInfo(wrappers, parentRule, groupRoots) {
   if (!hasGroupVariant) return null;
   const groupInfo = findGroupAncestor(parentRule, groupRoots);
   if (!groupInfo) return null;
+  const isSelf = fullNestingSelector() === groupInfo.groupRootSelector;
   const rewrittenWrappers = wrappers.map((w) => {
     if (!w.selectorSuffix || !w.replaceAmpersand) return w;
     const match = w.selectorSuffix.match(GROUP_VARIANT_RE);
     if (!match) return w;
     const pseudo = match[1];
+    if (isSelf) return { ...w, selectorSuffix: `&${pseudo}` };
     const rootBranches = splitSelectorList(groupInfo.groupRootSelector);
     const newSuffix = rootBranches.map((b) => `${b}${pseudo} &`).join(", ");
     return { ...w, selectorSuffix: newSuffix };
   });
-  return { rewrittenWrappers, groupRootSelector: groupInfo.groupRootSelector };
+  return { rewrittenWrappers, groupRootSelector: groupInfo.groupRootSelector, isSelf };
 }
 var MARKER_CLASSES = /* @__PURE__ */ new Set(["group"]);
 var MAX_CUSTOM_APPLY_DEPTH = 5;
-function findCustomUtility(utility, value, theme) {
-  const target = value === null ? utility : `${utility}-${value}`;
-  const cu = getCustomUtility(theme, target);
-  return cu && !cu.functional ? cu : void 0;
+function findCustomUtility(utility, value, negative, theme) {
+  return matchCustomUtility(utility, value, negative, theme)?.cu;
 }
 function checkCustomApplyWarnings(cu, theme, warnings, visiting = /* @__PURE__ */ new Set()) {
   if (!hasApplyLikeDirective(cu.body)) return;
@@ -378,12 +391,12 @@ function checkCustomApplyWarnings(cu, theme, warnings, visiting = /* @__PURE__ *
   visiting.add(cu.name);
   for (const innerClass of innerClasses) {
     const parsed = parseUtility(innerClass);
-    const innerCu = findCustomUtility(parsed.utility, parsed.value, theme);
+    const innerCu = findCustomUtility(parsed.utility, parsed.value, parsed.negative, theme);
     if (innerCu) checkCustomApplyWarnings(innerCu, theme, warnings, visiting);
   }
   visiting.delete(cu.name);
 }
-function resolveClassName(className, theme, warnings, customVariantMap, checkedApplyRoots) {
+function resolveClassName(className, theme, warnings, customVariantMap, applyRootWarnings) {
   const parsed = parseUtility(className);
   if (parsed.variants.length === 0 && MARKER_CLASSES.has(parsed.utility) && parsed.value === null) {
     return null;
@@ -394,10 +407,15 @@ function resolveClassName(className, theme, warnings, customVariantMap, checkedA
     return null;
   }
   const declarations = [...utilResult.declarations];
-  const cu = findCustomUtility(parsed.utility, parsed.value, theme);
-  if (cu && !checkedApplyRoots.has(cu.name)) {
-    checkedApplyRoots.add(cu.name);
-    checkCustomApplyWarnings(cu, theme, warnings);
+  const cu = findCustomUtility(parsed.utility, parsed.value, parsed.negative, theme);
+  if (cu) {
+    let cuWarnings = applyRootWarnings.get(cu.name);
+    if (!cuWarnings) {
+      cuWarnings = [];
+      checkCustomApplyWarnings(cu, theme, cuWarnings);
+      applyRootWarnings.set(cu.name, cuWarnings);
+    }
+    warnings.push(...cuWarnings);
   }
   const variantWrappers = [];
   for (const variant of parsed.variants) {

package/dist/{chunk-KRZL4IDK.mjs → chunk-4UKFK2GE.mjs}

@@ -437,16 +437,6 @@ var DEFAULT_BREAKPOINTS = {
   lg: "64rem",
   xl: "80rem"
 };
-var DEFAULT_ROUNDED_ROOF = "1.5rem";
-var DEFAULT_ROUNDED = {
-  "2xs": "max(0px, calc(var(--rounded-roof) - var(--spacing) * 5))",
-  xs: "max(0px, calc(var(--rounded-roof) - var(--spacing) * 4))",
-  sm: "max(0px, calc(var(--rounded-roof) - var(--spacing) * 3))",
-  md: "max(0px, calc(var(--rounded-roof) - var(--spacing) * 2))",
-  lg: "max(0px, calc(var(--rounded-roof) - var(--spacing)))",
-  xl: "var(--rounded-roof)",
-  full: "calc(infinity * 1px)"
-};
 var CORNER_SHAPE_KEYWORDS = [
   "round",
   "scoop",
@@ -608,7 +598,6 @@ var defaultTheme = Object.freeze({
   colors: DEFAULT_COLORS,
   text: DEFAULT_TEXT,
   breakpoints: DEFAULT_BREAKPOINTS,
-  rounded: DEFAULT_ROUNDED,
   shadows: DEFAULT_SHADOWS,
   weights: DEFAULT_WEIGHTS,
   easing: DEFAULT_EASING,
@@ -1230,7 +1219,7 @@ addAll(
   ],
   ["border-style"]
 );
-addAll(["rounded", "rounded-none", "rounded-full"], ["border-radius"]);
+addAll(["rounded-none", "rounded-full"], ["border-radius"]);
 addAll(
   [
     "corner-round",
@@ -2182,7 +2171,7 @@ var DIRECTIONAL_BORDER_COLOR_PROPS = new Map(
     "border-y"
   ].map((prefix) => [prefix, Object.freeze([PREFIX_PROPS[prefix][0].replace("width", "color")])])
 );
-function resolvePropsWith(utility, customStaticProps, textSizes, fontFamilies, colorNames) {
+function resolvePropsWith(utility, customStaticProps, customFunctionalProps, textSizes, fontFamilies, colorNames) {
   if (utility.charCodeAt(0) === 91) {
     const colonIdx = utility.indexOf(":");
     if (colonIdx !== -1) {
@@ -2198,6 +2187,10 @@ function resolvePropsWith(utility, customStaticProps, textSizes, fontFamilies, c
   if (Object.hasOwn(customStaticProps, name)) return customStaticProps[name];
   const builtin = BUILTIN_STATIC_PROPS[name];
   if (builtin !== void 0) return builtin;
+  for (const [root, properties] of customFunctionalProps) {
+    if (name.length <= root.length) continue;
+    if (name.startsWith(root) && name.charCodeAt(root.length) === 45) return properties;
+  }
   const firstDash = name.indexOf("-");
   const firstSeg = firstDash === -1 ? name : name.slice(0, firstDash);
   const candidates = PREFIX_FIRST_SEGMENT_MAP.get(firstSeg);
@@ -2223,6 +2216,7 @@ function resolvePropsWith(utility, customStaticProps, textSizes, fontFamilies, c
 
 // src/merge/context.ts
 var _customStaticProps = {};
+var _customFunctionalProps = [];
 var _textSizes = new Set(DEFAULT_TEXT_SIZES);
 var _fontFamilies = new Set(DEFAULT_FONT_FAMILIES);
 var _colorNames = /* @__PURE__ */ new Set();
@@ -2230,13 +2224,54 @@ var _latestSnapshot = null;
 function hasFinalizedSnapshot() {
   return _latestSnapshot !== null;
 }
-var defaultRiCache = /* @__PURE__ */ new Map();
+var RI_CACHE_MAX = 500;
+var RiCache = class {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  maxSize;
+  current = /* @__PURE__ */ new Map();
+  previous = /* @__PURE__ */ new Map();
+  get(key) {
+    const hit = this.current.get(key);
+    if (hit !== void 0) return hit;
+    const promoted = this.previous.get(key);
+    if (promoted !== void 0) this.put(key, promoted);
+    return promoted;
+  }
+  put(key, value) {
+    this.current.set(key, value);
+    if (this.current.size >= this.maxSize) {
+      this.previous = this.current;
+      this.current = /* @__PURE__ */ new Map();
+    }
+  }
+  has(key) {
+    return this.current.has(key) || this.previous.has(key);
+  }
+  get size() {
+    return this.current.size + this.previous.size;
+  }
+  clear() {
+    this.current.clear();
+    this.previous.clear();
+  }
+};
+var defaultRiCache = new RiCache(RI_CACHE_MAX);
 function resolveProps(utility) {
-  return resolvePropsWith(utility, _customStaticProps, _textSizes, _fontFamilies, _colorNames);
+  return resolvePropsWith(
+    utility,
+    _customStaticProps,
+    _customFunctionalProps,
+    _textSizes,
+    _fontFamilies,
+    _colorNames
+  );
 }
 function resolverFor(snapshot) {
   const snap = snapshot ?? _latestSnapshot ?? {
     customStaticProps: _customStaticProps,
+    customFunctionalProps: _customFunctionalProps,
     textSizes: _textSizes,
     fontFamilies: _fontFamilies,
     colorNames: _colorNames
@@ -2244,6 +2279,7 @@ function resolverFor(snapshot) {
   return (utility) => resolvePropsWith(
     utility,
     snap.customStaticProps,
+    snap.customFunctionalProps,
     snap.textSizes,
     snap.fontFamilies,
     snap.colorNames
@@ -2252,12 +2288,13 @@ function resolverFor(snapshot) {
 function createCompilationContext() {
   return {
     customStaticProps: {},
+    customFunctionalProps: {},
     textSizes: new Set(DEFAULT_TEXT_SIZES),
     fontFamilies: new Set(DEFAULT_FONT_FAMILIES),
     colorNames: /* @__PURE__ */ new Set()
   };
 }
-function registerCustomUtility(ctx, name, properties) {
+function registerCustomUtility(ctx, name, properties, functional = false) {
   if (IS_DEV) {
     if (!name) {
       devWarn("[RI-1301] registerCustomUtility() called with empty name \u2014 skipping.");
@@ -2269,7 +2306,8 @@ function registerCustomUtility(ctx, name, properties) {
       );
     }
   }
-  ctx.customStaticProps[name] = properties;
+  if (functional) ctx.customFunctionalProps[name] = properties;
+  else ctx.customStaticProps[name] = properties;
 }
 function registerCustomTextSizes(ctx, sizes) {
   for (const s of sizes) ctx.textSizes.add(s);
@@ -2285,6 +2323,7 @@ function snapshotCompilationContext(ctx) {
     customStaticProps: Object.fromEntries(
       Object.entries(ctx.customStaticProps).map(([k, v]) => [k, [...v]])
     ),
+    customFunctionalProps: Object.entries(ctx.customFunctionalProps).map(([k, v]) => [k, [...v]]).sort((a, b) => b[0].length - a[0].length),
     textSizes: new Set(ctx.textSizes),
     fontFamilies: new Set(ctx.fontFamilies),
     colorNames: new Set(ctx.colorNames)
@@ -2293,6 +2332,7 @@ function snapshotCompilationContext(ctx) {
 function finalizeCompilationContext(ctx) {
   const snapshot = snapshotCompilationContext(ctx);
   _customStaticProps = snapshot.customStaticProps;
+  _customFunctionalProps = snapshot.customFunctionalProps;
   _textSizes = snapshot.textSizes;
   _fontFamilies = snapshot.fontFamilies;
   _colorNames = snapshot.colorNames;
@@ -2302,7 +2342,6 @@ function finalizeCompilationContext(ctx) {
 }
 
 // src/merge/index.ts
-var RI_CACHE_MAX = 500;
 var RI_CACHE_KEY_MAX_LEN = 2048;
 var WS_SPLIT_RE = /\s+/;
 function findVariantSplit(cls) {
@@ -2386,37 +2425,15 @@ function mergeUncached(classes, resolve, trace) {
   result.reverse();
   return result.join(" ");
 }
-function evictLRU(cache, maxSize) {
-  if (cache.size < maxSize) return;
-  const evictCount = maxSize >> 2;
-  let count = 0;
-  for (const key of cache.keys()) {
-    if (count >= evictCount) break;
-    cache.delete(key);
-    count++;
-  }
-}
-function lruGet(cache, key) {
-  const cached = cache.get(key);
-  if (cached !== void 0) {
-    cache.delete(key);
-    cache.set(key, cached);
-  }
-  return cached;
-}
-function lruPut(cache, key, value) {
-  evictLRU(cache, RI_CACHE_MAX);
-  cache.set(key, value);
-}
 function mergeClasses(classes, resolve, cache) {
   const cacheKey = classes.join("\0");
   const useCache = cacheKey.length <= RI_CACHE_KEY_MAX_LEN;
   if (useCache) {
-    const cached = lruGet(cache, cacheKey);
+    const cached = cache.get(cacheKey);
     if (cached !== void 0) return cached;
   }
   const output = mergeUncached(classes, resolve);
-  if (useCache) lruPut(cache, cacheKey, output);
+  if (useCache) cache.put(cacheKey, output);
   return output;
 }
 function mergeFrom(inputs, resolve, cache) {
@@ -2434,11 +2451,11 @@ function mergeFrom(inputs, resolve, cache) {
   if (fastPath) {
     if (rawKey === "") return "";
     if (rawKey.length <= RI_CACHE_KEY_MAX_LEN) {
-      const cached = lruGet(cache, rawKey);
+      const cached = cache.get(rawKey);
       if (cached !== void 0) return cached;
       const classes2 = flattenInputs(inputs);
       const output = classes2.length === 0 ? "" : classes2.length === 1 ? classes2[0] : mergeUncached(classes2, resolve);
-      lruPut(cache, rawKey, output);
+      cache.put(rawKey, output);
       return output;
     }
   }
@@ -2494,7 +2511,7 @@ function ri(...inputs) {
 }
 function createRi(snapshot) {
   const resolve = resolverFor(snapshot);
-  const cache = /* @__PURE__ */ new Map();
+  const cache = new RiCache(RI_CACHE_MAX);
   return function boundRi(...inputs) {
     return mergeFrom(inputs, resolve, cache);
   };
@@ -2592,8 +2609,6 @@ export {
   generateThemeOverrides,
   DEFAULT_TEXT,
   DEFAULT_BREAKPOINTS,
-  DEFAULT_ROUNDED_ROOF,
-  DEFAULT_ROUNDED,
   CORNER_SHAPE_KEYWORDS,
   DEFAULT_CORNER_SCALE,
   DEFAULT_SUPERELLIPSE_SCALE,