@pandacss/transformer 2.0.0-beta.19 → 2.0.0-beta.20

package/dist/runtime/internal.js

@@ -42,76 +42,293 @@ function getMergeKey(className, separator) {
   const propStart = lastColon + 1;
   const sepIdx = className.indexOf(separator, propStart);
   if (sepIdx < propStart + 1 || sepIdx >= end) return null;
-  const property = className.slice(propStart, sepIdx);
-  if (lastColon === -1) return property;
-  return `${className.slice(0, lastColon)}:${property}`;
+  return className.slice(0, sepIdx);
 }
-function flattenParts(parts, out) {
-  for (const part of parts) {
-    if (!part) continue;
-    if (Array.isArray(part)) {
-      flattenParts(part, out);
+var CACHE_LIMIT = 2048;
+var CHAR_SPACE = 32;
+var CHAR_BANG = 33;
+var FIELDS = 4;
+function createCache(limit = CACHE_LIMIT) {
+  let size = 0;
+  let current = /* @__PURE__ */ new Map();
+  let previous = /* @__PURE__ */ new Map();
+  const set = (key, value) => {
+    current.set(key, value);
+    if (++size > limit) {
+      size = 0;
+      previous = current;
+      current = /* @__PURE__ */ new Map();
+    }
+  };
+  return {
+    get(key) {
+      let value = current.get(key);
+      if (value === void 0 && (value = previous.get(key)) !== void 0) set(key, value);
+      return value;
+    },
+    set
+  };
+}
+function scanPart(part, separator, out, offset) {
+  let count = 0;
+  let clean = part.length > 0;
+  let start = 0;
+  for (let i = 0; i <= part.length; i++) {
+    const code = i === part.length ? CHAR_SPACE : part.charCodeAt(i);
+    if (code !== CHAR_SPACE && (code < 9 || code > 13)) continue;
+    if (code !== CHAR_SPACE || i === start) clean = false;
+    if (i === start) {
+      start = i + 1;
       continue;
     }
-    if (part === "") continue;
-    out.push(part);
+    const at = offset + count * FIELDS;
+    count++;
+    out[at] = start;
+    out[at + 1] = i;
+    out[at + 2] = -1;
+    let end = i;
+    if (part.charCodeAt(end - 1) === CHAR_BANG) end--;
+    let depth = 0;
+    let propStart = start;
+    for (let c = start; c < end; c++) {
+      const code2 = part.charCodeAt(c);
+      if (code2 === CHAR_OPEN_BRACKET) depth++;
+      else if (code2 === CHAR_CLOSE_BRACKET) depth--;
+      else if (code2 === CHAR_COLON && depth === 0) propStart = c + 1;
+    }
+    const sep = part.indexOf(separator, propStart);
+    if (sep > propStart && sep < end) {
+      let hash = 2166136261;
+      for (let c = start; c < sep; c++) hash = Math.imul(hash ^ part.charCodeAt(c), 16777619);
+      out[at + 2] = sep;
+      out[at + 3] = hash;
+    }
+    start = i + 1;
   }
+  return clean ? count : -count;
 }
-function mergeClassStrings(separator, classes) {
-  const seen = /* @__PURE__ */ new Map();
-  const order = [];
-  let id = 0;
-  for (const cls of classes) {
-    let tokenStart = 0;
-    for (let i = 0; i <= cls.length; i++) {
-      if (i !== cls.length && cls.charCodeAt(i) !== 32) continue;
-      if (i === tokenStart) {
-        tokenStart = i + 1;
-        continue;
+function createCx(options = {}) {
+  const separator = options.separator ?? bakedSeparator;
+  const scanned = createCache();
+  const seenOnce = createCache(512);
+  const parts = [];
+  let tokens = new Int32Array(64 * FIELDS);
+  let tokenPart = new Int32Array(64);
+  let winner = new Int32Array(64);
+  let tableSize = 128;
+  let table = new Int32Array(tableSize);
+  let stamps = new Int32Array(tableSize);
+  let stamp = 0;
+  function collect(value) {
+    if (!value) return;
+    if (typeof value === "string") parts.push(value);
+    else for (let i = 0; i < value.length; i++) collect(value[i]);
+  }
+  function reserve(tokenCount) {
+    if (tokenCount <= tokenPart.length) return;
+    let size = tokenPart.length;
+    while (size < tokenCount) size *= 2;
+    const grow = (from, length) => {
+      const next = new Int32Array(length);
+      next.set(from);
+      return next;
+    };
+    tokens = grow(tokens, size * FIELDS);
+    tokenPart = grow(tokenPart, size);
+    winner = grow(winner, size);
+  }
+  function sameKey(a, b) {
+    const aStart = tokens[a * FIELDS];
+    const bStart = tokens[b * FIELDS];
+    const length = tokens[a * FIELDS + 2] - aStart;
+    if (tokens[b * FIELDS + 2] - bStart !== length) return false;
+    const left = parts[tokenPart[a]];
+    const right = parts[tokenPart[b]];
+    for (let i = 0; i < length; i++) {
+      if (left.charCodeAt(aStart + i) !== right.charCodeAt(bStart + i)) return false;
+    }
+    return true;
+  }
+  function merge() {
+    let count = 0;
+    let clean = true;
+    for (let p = 0; p < parts.length; p++) {
+      const part = parts[p];
+      const cached = scanned.get(part);
+      let partCount;
+      if (cached !== void 0) {
+        partCount = cached[0];
+        reserve(count + Math.abs(partCount));
+        const base = count * FIELDS;
+        for (let i = 1; i < cached.length; i++) tokens[base + i - 1] = cached[i];
+      } else {
+        reserve(count + part.length);
+        partCount = scanPart(part, separator, tokens, count * FIELDS);
+        if (seenOnce.get(part) === void 0) seenOnce.set(part, true);
+        else {
+          const record = new Int32Array(1 + Math.abs(partCount) * FIELDS);
+          record[0] = partCount;
+          record.set(tokens.subarray(count * FIELDS, (count + Math.abs(partCount)) * FIELDS), 1);
+          scanned.set(part, record);
+        }
+      }
+      if (partCount <= 0) clean = false;
+      const end = count + Math.abs(partCount);
+      for (; count < end; count++) tokenPart[count] = p;
+    }
+    if (count * 2 > tableSize) {
+      while (count * 2 > tableSize) tableSize *= 2;
+      table = new Int32Array(tableSize);
+      stamps = new Int32Array(tableSize);
+      stamp = 0;
+    }
+    if (++stamp === 2147483647) {
+      stamp = 1;
+      stamps.fill(0);
+    }
+    const mask = tableSize - 1;
+    let replaced = false;
+    for (let t = 0; t < count; t++) {
+      winner[t] = t;
+      if (tokens[t * FIELDS + 2] < 0) continue;
+      const hash = tokens[t * FIELDS + 3];
+      let slot = hash & mask;
+      let owner = -1;
+      while (stamps[slot] === stamp) {
+        const candidate = table[slot];
+        if (tokens[candidate * FIELDS + 3] === hash && sameKey(candidate, t)) {
+          owner = candidate;
+          break;
+        }
+        slot = slot + 1 & mask;
       }
-      const token = cls.slice(tokenStart, i);
-      tokenStart = i + 1;
-      const key = getMergeKey(token, separator);
-      if (key !== null) {
-        if (!seen.has(key)) order.push(key);
-        seen.set(key, token);
+      if (owner === -1) {
+        stamps[slot] = stamp;
+        table[slot] = t;
       } else {
-        const uniqueKey = `__${id++}`;
-        order.push(uniqueKey);
-        seen.set(uniqueKey, token);
+        winner[owner] = t;
+        winner[t] = -1;
+        replaced = true;
       }
     }
-  }
-  if (order.length === 0) return "";
-  if (order.length === 1) return seen.get(order[0]);
-  let str = seen.get(order[0]);
-  for (let i = 1; i < order.length; i++) {
-    str += ` ${seen.get(order[i])}`;
-  }
-  return str;
-}
-function createCx(options = {}) {
-  const separator = options.separator ?? bakedSeparator;
-  return function cx2(...parts) {
-    if (parts.length === 1) {
-      const only = parts[0];
-      if (typeof only === "string") return only;
-      if (!only) return "";
+    if (!replaced && clean) {
+      let joined = parts[0];
+      for (let p = 1; p < parts.length; p++) joined += " " + parts[p];
+      return joined;
+    }
+    let result = "";
+    for (let t = 0; t < count; t++) {
+      const w = winner[t];
+      if (w === -1) continue;
+      const piece = parts[tokenPart[w]].slice(tokens[w * FIELDS], tokens[w * FIELDS + 1]);
+      result = result ? result + " " + piece : piece;
     }
-    const flat = [];
-    flattenParts(parts, flat);
-    if (flat.length === 0) return "";
-    if (flat.length === 1) return flat[0];
-    return mergeClassStrings(separator, flat);
+    return result;
+  }
+  return function cx2(...args) {
+    parts.length = 0;
+    for (let i = 0; i < args.length; i++) collect(args[i]);
+    const count = parts.length;
+    if (count === 0) return "";
+    if (count === 1) return parts[0];
+    return merge();
   };
 }
-var cx = createCx();
+var cx = /* @__PURE__ */ createCx();
 
 // src/runtime/internal/css.ts
 function css(...styles) {
   return cx(...styles);
 }
 
+// src/runtime/internal/memo.ts
+var TABLE_MAX_SLOTS = 256;
+var RING_ROWS = 16;
+var isMutable = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var KNOWN_MISSES = ["true", "false", "null"];
+function tableMemo(resolve, keys, variantMap, strict) {
+  let slots = 1;
+  const radixes = [];
+  const trueStates = [];
+  const falseStates = [];
+  const nullStates = [];
+  const states = keys.map((key) => {
+    const state = /* @__PURE__ */ Object.create(null);
+    let count = 1;
+    for (const option of variantMap[key]) state[option] = count++;
+    if (strict) {
+      trueStates.push(count++);
+      falseStates.push(count++);
+      nullStates.push(count++);
+    } else {
+      for (const value of KNOWN_MISSES) state[value] ??= count++;
+      trueStates.push(state.true);
+      falseStates.push(state.false);
+      nullStates.push(state.null);
+    }
+    radixes.push(count);
+    slots *= count;
+    return state;
+  });
+  if (slots > TABLE_MAX_SLOTS) return null;
+  const table = new Array(slots);
+  let noProps;
+  return (props) => {
+    if (props == null) return noProps === void 0 ? noProps = resolve() : noProps;
+    let slot = 0;
+    for (let i = 0; i < keys.length; i++) {
+      const value = props[keys[i]];
+      let state = 0;
+      if (value === true) state = trueStates[i];
+      else if (value === false) state = falseStates[i];
+      else if (value === null) state = nullStates[i];
+      else if (typeof value === "string") state = states[i][value];
+      else if (value !== void 0) {
+        if (strict || isMutable(value)) return resolve(props);
+        state = states[i][String(value)];
+      }
+      if (state === void 0) return resolve(props);
+      slot = slot * radixes[i] + state;
+    }
+    let result = table[slot];
+    if (result === void 0) table[slot] = result = resolve(props);
+    return result;
+  };
+}
+function ringMemo(resolve, keys) {
+  const width = keys.length;
+  const values = new Array(RING_ROWS * width);
+  const results = new Array(RING_ROWS);
+  let written = 0;
+  let next = 0;
+  let noProps;
+  return (props) => {
+    if (props == null) return noProps === void 0 ? noProps = resolve() : noProps;
+    scan: for (let row = 0; row < written; row++) {
+      const start2 = row * width;
+      for (let i = 0; i < width; i++) {
+        if (props[keys[i]] !== values[start2 + i]) continue scan;
+      }
+      return results[row];
+    }
+    for (let i = 0; i < width; i++) {
+      if (isMutable(props[keys[i]])) return resolve(props);
+    }
+    const result = resolve(props);
+    const start = next * width;
+    for (let i = 0; i < width; i++) values[start + i] = props[keys[i]];
+    results[next] = result;
+    if (next === written) written++;
+    next = (next + 1) % RING_ROWS;
+    return result;
+  };
+}
+function memoRecipe(resolve, variantMap, hasCompounds) {
+  const keys = Object.keys(variantMap);
+  if (keys.length === 0) return resolve;
+  return tableMemo(resolve, keys, variantMap, !!hasCompounds) ?? ringMemo(resolve, keys);
+}
+
 // src/runtime/internal/shared.ts
 function withDefaults(defaults, props) {
   const out = { ...defaults };
@@ -120,20 +337,6 @@ function withDefaults(defaults, props) {
   }
   return out;
 }
-function splitVariantProps(props, variantKeySet) {
-  const rest = {};
-  const variantProps = {};
-  for (const key in props) {
-    if (variantKeySet.has(key)) variantProps[key] = props[key];
-    else rest[key] = props[key];
-  }
-  return [rest, variantProps];
-}
-function toVariantMap(variants) {
-  const map = {};
-  for (const key in variants) map[key] = Object.keys(variants[key] ?? {});
-  return map;
-}
 function compoundMatches(compound, variants) {
   for (const key in compound) {
     if (key === "css" || key === "className" || key === "classNames") continue;
@@ -147,298 +350,88 @@ function compoundMatches(compound, variants) {
   }
   return true;
 }
-function variantClass(variants, key, value) {
-  if (value == null) return void 0;
-  const cls = variants[key]?.[value];
-  return typeof cls === "string" && cls ? cls : void 0;
-}
-function memoProps(resolve) {
-  const cache = /* @__PURE__ */ new Map();
-  let lastKey = "";
-  let lastValue;
-  let hasLast = false;
-  return (props = {}) => {
-    let key = "";
-    for (const k in props) {
-      const value = props[k];
-      if (value !== void 0) key += `${k}:${String(value)}|`;
-    }
-    if (hasLast && key === lastKey) return lastValue;
-    const hit = cache.get(key);
-    if (hit !== void 0) {
-      lastKey = key;
-      lastValue = hit;
-      hasLast = true;
-      return hit;
+
+// src/runtime/internal/recipe.ts
+var isStyleObject = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+function mergeStyles(...styles) {
+  const out = {};
+  for (const style of styles) {
+    if (!isStyleObject(style)) continue;
+    for (const key in style) {
+      const value = style[key];
+      out[key] = isStyleObject(value) ? mergeStyles(out[key], value) : value;
     }
-    const out = resolve(props);
-    cache.set(key, out);
-    if (cache.size > 500) cache.delete(cache.keys().next().value);
-    lastKey = key;
-    lastValue = out;
-    hasLast = true;
-    return out;
-  };
-}
-function joinClasses(parts) {
-  if (parts.length === 0) return "";
-  if (parts.length === 1) return parts[0];
-  return cx(...parts);
-}
-function isBooleanBranch(branch) {
-  if (!branch) return false;
-  const keys = Object.keys(branch);
-  return keys.length === 1 && keys[0] === "true" && typeof branch.true === "string";
-}
-function booleanKeys(variants, keys, defaults, hasCompounds) {
-  if (hasCompounds || keys.length === 0 || keys.length > 12) return void 0;
-  for (const key of keys) {
-    if (!isBooleanBranch(variants[key])) return void 0;
-  }
-  for (const key in defaults) {
-    if (!keys.includes(key)) return void 0;
-    const value = defaults[key];
-    if (value !== true && value !== false && value !== "true" && value !== "false") return void 0;
   }
-  return keys;
-}
-function selectsTrue(value) {
-  return value === true || value === "true";
+  return out;
 }
-function booleanBitset(base, variants, keys, defaults, hasCompounds) {
-  const boolKeys = booleanKeys(variants, keys, defaults, hasCompounds);
-  if (!boolKeys) return void 0;
-  const n = boolKeys.length;
-  let defaultMask = 0;
-  for (let i = 0; i < n; i++) {
-    if (selectsTrue(defaults[boolKeys[i]])) defaultMask |= 1 << i;
+function resolveRaw(config, props, pick = (style) => style) {
+  const selected = withDefaults(config.defaultVariants ?? {}, props);
+  const variants = config.variants ?? {};
+  const styles = [pick(config.base)];
+  for (const key in selected) styles.push(pick(variants[key]?.[selected[key]]));
+  for (const compound of config.compoundVariants ?? []) {
+    if (compoundMatches(compound, selected)) styles.push(pick(compound.css));
   }
-  const table = new Array(1 << n);
-  const build = (mask) => {
-    const parts = [];
-    if (base) parts.push(base);
-    for (let i = 0; i < n; i++) {
-      if (mask & 1 << i) parts.push(variants[boolKeys[i]].true);
-    }
-    return joinClasses(parts);
-  };
-  return (props = {}) => {
-    let mask = defaultMask;
-    for (let i = 0; i < n; i++) {
-      const value = props[boolKeys[i]];
-      if (value === void 0) continue;
-      if (selectsTrue(value)) mask |= 1 << i;
-      else mask &= ~(1 << i);
-    }
-    return table[mask] ??= build(mask);
-  };
+  return mergeStyles(...styles);
 }
-var MAX_VARIANT_STATES = 4096;
-function optionIndex(options) {
-  const index = /* @__PURE__ */ new Map();
-  for (let i = 0; i < options.length; i++) {
-    const option = options[i];
-    const slot = i + 1;
-    index.set(option, slot);
-    if (option === "true") index.set(true, slot);
-    else if (option === "false") index.set(false, slot);
-    else {
-      const numeric = Number(option);
-      if (option !== "" && !Number.isNaN(numeric)) index.set(numeric, slot);
-    }
+function resolveSlotRaw(config, props) {
+  const result = {};
+  for (const slot of config.slots ?? Object.keys(config.base ?? {})) {
+    result[slot] = resolveRaw(config, props, (style) => style?.[slot]);
   }
-  return index;
+  return result;
 }
-function variantTable(base, variants, keys, defaults, hasCompounds) {
-  if (hasCompounds || keys.length === 0) return void 0;
-  const slots = [];
-  let states = 1;
-  for (const key of keys) {
-    const options = Object.keys(variants[key] ?? {});
-    if (options.length === 0) return void 0;
-    slots.push({ key, options, index: optionIndex(options), radix: options.length + 1, stride: states });
-    states *= options.length + 1;
-    if (states > MAX_VARIANT_STATES) return void 0;
-  }
-  let defaultState = 0;
-  for (const key in defaults) {
-    const slot = slots.find((candidate) => candidate.key === key);
-    if (!slot) return void 0;
-    const chosen = slot.index.get(defaults[key]);
-    if (chosen === void 0) return void 0;
-    defaultState += chosen * slot.stride;
-  }
-  const table = new Array(states);
-  const build = (state) => {
-    const parts = [];
-    if (base) parts.push(base);
-    for (const slot of slots) {
-      const chosen = Math.floor(state / slot.stride) % slot.radix;
-      if (chosen === 0) continue;
-      const cls = variants[slot.key][slot.options[chosen - 1]];
-      if (cls) parts.push(cls);
-    }
-    return joinClasses(parts);
-  };
-  return (props = {}) => {
-    let state = defaultState;
-    for (let i = 0; i < slots.length; i++) {
-      const slot = slots[i];
-      const value = props[slot.key];
-      if (value === void 0) continue;
-      const chosen = slot.index.get(value) ?? 0;
-      const current = Math.floor(state / slot.stride) % slot.radix;
-      state += (chosen - current) * slot.stride;
-    }
-    return table[state] ??= build(state);
+function mergeRecipes(parent, child) {
+  const defaultVariants = { ...parent.config?.defaultVariants, ...child.config?.defaultVariants };
+  const variantKeys = [.../* @__PURE__ */ new Set([...parent.variantKeys ?? [], ...child.variantKeys ?? []])];
+  const resolve = (props = {}) => withDefaults(defaultVariants, props);
+  const merged = attachRecipe(
+    (props) => {
+      const selected = resolve(props);
+      return cx(parent(selected), child(selected));
+    },
+    // Compounds from either side rule out the coercing table memo.
+    {
+      defaultVariants,
+      compoundVariants: [...parent.config?.compoundVariants ?? [], ...child.config?.compoundVariants ?? []]
+    },
+    variantKeys,
+    { ...parent.variantMap, ...child.variantMap }
+  );
+  merged.raw = (props) => {
+    const selected = resolve(props);
+    return mergeStyles(parent.raw(selected), child.raw(selected));
   };
+  return merged;
 }
-
-// src/runtime/internal/cva.ts
-function unionKeys(other, own) {
-  const keys = [...other];
-  for (const key of own) {
-    if (!keys.includes(key)) keys.push(key);
-  }
-  return keys;
-}
-function cva(config) {
-  const base = config.base ?? "";
-  const variants = config.variants ?? {};
-  const defaultVariants = config.defaultVariants ?? {};
-  const compoundVariants = config.compoundVariants ?? [];
-  const variantKeys = Object.keys(variants);
-  const variantKeySet = new Set(variantKeys);
-  const hasDefaults = Object.keys(defaultVariants).length > 0;
-  const hasCompounds = compoundVariants.length > 0;
-  const resolve = (props = {}) => {
-    const computed = hasDefaults ? withDefaults(defaultVariants, props) : props;
-    const parts = [];
-    if (base) parts.push(base);
-    for (const key of variantKeys) {
-      const cls = variantClass(variants, key, computed[key]);
-      if (cls) parts.push(cls);
-    }
-    if (hasCompounds) {
-      for (const compound of compoundVariants) {
-        if (!compoundMatches(compound, computed)) continue;
-        const cls = compound.className ?? compound.css;
-        if (typeof cls === "string" && cls) parts.push(cls);
-      }
-    }
-    return joinClasses(parts);
-  };
-  const cvaFn = booleanBitset(base, variants, variantKeys, defaultVariants, hasCompounds) ?? variantTable(base, variants, variantKeys, defaultVariants, hasCompounds) ?? memoProps(resolve);
-  const merge = (other) => {
-    const override = other.config;
-    const overrideVariants = override.variants ?? {};
-    const mergedVariants = {};
-    for (const key of unionKeys(other.variantKeys, variantKeys)) {
-      const group = { ...variants[key] };
-      const theirs = overrideVariants[key] ?? {};
-      for (const option in theirs) {
-        const mine = group[option];
-        group[option] = mine ? cx(mine, theirs[option]) : theirs[option];
-      }
-      mergedVariants[key] = group;
-    }
-    return cva({
-      base: cx(base, override.base),
-      variants: mergedVariants,
-      defaultVariants: { ...defaultVariants, ...override.defaultVariants },
-      compoundVariants: [...compoundVariants, ...override.compoundVariants ?? []]
-    });
-  };
-  return Object.assign(cvaFn, {
-    __cva__: true,
+function attachRecipe(fn, config, variantKeys, variantMap, classNameMap) {
+  const recipeConfig = config;
+  const defaults = recipeConfig.defaultVariants ?? {};
+  const recipe = memoRecipe(fn, variantMap, recipeConfig.compoundVariants?.length);
+  return Object.assign(recipe, {
+    __cva__: !classNameMap,
     variantKeys,
-    variantMap: toVariantMap(variants),
-    raw: resolve,
-    merge,
+    variantMap,
+    ...classNameMap && { classNameMap },
     config,
-    getVariantProps: (props) => withDefaults(defaultVariants, props),
-    splitVariantProps: (props) => splitVariantProps(props, variantKeySet)
-  });
-}
-
-// src/runtime/internal/sva.ts
-function variantsForSlot(variants, slot) {
-  if (!variants) return void 0;
-  const out = {};
-  for (const key in variants) {
-    const options = {};
-    for (const option in variants[key]) {
-      const value = variants[key][option];
-      const cls = typeof value === "string" ? value : value?.[slot];
-      if (cls) options[option] = cls;
-    }
-    out[key] = options;
-  }
-  return out;
-}
-function compoundsForSlot(compounds, slot) {
-  if (!compounds?.length) return void 0;
-  const out = [];
-  for (const compound of compounds) {
-    const next = {};
-    for (const key in compound) {
-      if (key === "css" || key === "className" || key === "classNames") continue;
-      next[key] = compound[key];
+    raw: (props = {}) => classNameMap ? resolveSlotRaw(recipeConfig, props) : resolveRaw(recipeConfig, props),
+    // The styled factory passes its own `cva`, so chains merge exactly like styled-system.
+    merge: (other, cva) => cva ? cva(config).merge(other) : mergeRecipes(recipe, other),
+    getVariantProps: (props = {}) => withDefaults(defaults, props),
+    splitVariantProps: (props) => {
+      const variantProps = {};
+      const restProps = {};
+      for (const key in props) (variantKeys.includes(key) ? variantProps : restProps)[key] = props[key];
+      return [variantProps, restProps];
     }
-    const css2 = compound.css;
-    if (typeof css2 === "string") next.css = css2;
-    else if (css2 && typeof css2 === "object" && slot in css2) next.css = css2[slot];
-    const className = compound.classNames?.[slot] ?? compound.className;
-    if (className) next.className = className;
-    if (next.css || next.className) out.push(next);
-  }
-  return out.length ? out : void 0;
-}
-function sva(config) {
-  const slots = config.slots ?? Object.keys(config.base ?? {});
-  const defaultVariants = config.defaultVariants ?? {};
-  const variantKeys = Object.keys(config.variants ?? {});
-  const variantKeySet = new Set(variantKeys);
-  const slotFns = slots.map((slot) => {
-    let base = config.base?.[slot];
-    if (config.className?.[slot]) base = cx(base, config.className[slot]);
-    return [
-      slot,
-      cva({
-        base,
-        variants: variantsForSlot(config.variants, slot),
-        defaultVariants: config.defaultVariants,
-        compoundVariants: compoundsForSlot(config.compoundVariants, slot)
-      })
-    ];
-  });
-  const resolve = (props = {}) => {
-    const result = {};
-    for (const [slot, fn] of slotFns) result[slot] = fn(props);
-    return result;
-  };
-  const raw = (props = {}) => {
-    const result = {};
-    for (const [slot, fn] of slotFns) result[slot] = fn.raw(props);
-    return result;
-  };
-  return Object.assign(memoProps(resolve), {
-    __cva__: false,
-    raw,
-    config,
-    variantMap: Object.fromEntries(variantKeys.map((key) => [key, Object.keys(config.variants?.[key] ?? {})])),
-    variantKeys,
-    classNameMap: config.className ?? {},
-    getVariantProps: (props) => withDefaults(defaultVariants, props),
-    splitVariantProps: (props) => splitVariantProps(props, variantKeySet)
   });
 }
 export {
+  attachRecipe,
   createCx,
   css,
-  cva,
   cx,
   getMergeKey,
-  splitClassName,
-  sva
+  memoRecipe,
+  splitClassName
 };