@csszyx/compiler 0.9.5 → 0.9.6

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const core = require('@csszyx/core');
-const transformCore = require('./shared/compiler.BfDLUvcf.cjs');
+const transformCore = require('./shared/compiler.BsKlgPl4.cjs');
 const oxcParser = require('oxc-parser');
 const t = require('@babel/types');
 const node_crypto = require('node:crypto');
@@ -605,6 +605,11 @@ function transformSourceCode(source, filename, options) {
                 const szCall = t__namespace.callExpression(t__namespace.identifier("_sz"), [
                   expression
                 ]);
+                collectCandidatesFromBabelExpr(
+                  expression,
+                  path,
+                  collectedClasses
+                );
                 path.node.value = createMergedClassNameValue(szCall);
                 usesRuntime = true;
                 transformed = true;
@@ -1219,6 +1224,145 @@ function collectFromExpr(node, classes) {
     collectFromExpr(node.alternate, classes);
   }
 }
+function collectCandidatesFromBabelExpr(node, path, classes) {
+  if (t__namespace.isTSAsExpression(node) || t__namespace.isTSSatisfiesExpression(node) || t__namespace.isTSNonNullExpression(node) || t__namespace.isTSInstantiationExpression(node)) {
+    collectCandidatesFromBabelExpr(node.expression, path, classes);
+  } else if (t__namespace.isArrayExpression(node)) {
+    for (const element of node.elements) {
+      if (element === null || t__namespace.isSpreadElement(element)) {
+        continue;
+      }
+      const cand = t__namespace.isLogicalExpression(element) && element.operator === "&&" ? element.right : element;
+      collectCandidatesFromBabelExpr(cand, path, classes);
+    }
+  } else if (t__namespace.isObjectExpression(node)) {
+    collectCandidatesFromBabelObj(node, path, classes, "");
+  } else if (t__namespace.isIdentifier(node)) {
+    const binding = path.scope.getBinding(node.name);
+    if (binding?.path.isVariableDeclarator()) {
+      let init = binding.path.node.init;
+      if (init) {
+        while (t__namespace.isTSAsExpression(init) || t__namespace.isTSSatisfiesExpression(init)) {
+          init = init.expression;
+        }
+        collectCandidatesFromBabelExpr(init, path, classes);
+      }
+    }
+  } else if (t__namespace.isConditionalExpression(node)) {
+    collectCandidatesFromBabelExpr(node.consequent, path, classes);
+    collectCandidatesFromBabelExpr(node.alternate, path, classes);
+  } else if (t__namespace.isLogicalExpression(node) && node.operator === "&&") {
+    collectCandidatesFromBabelExpr(node.right, path, classes);
+  }
+}
+function collectCandidatesFromBabelObj(node, path, classes, variantPrefix) {
+  const getBinding = (name) => path.scope.getBinding(name);
+  for (const prop of node.properties) {
+    if (t__namespace.isSpreadElement(prop)) {
+      const spreadArg = prop.argument;
+      if (t__namespace.isIdentifier(spreadArg)) {
+        const binding = getBinding(spreadArg.name);
+        if (binding?.path.isVariableDeclarator()) {
+          let init = binding.path.node.init;
+          if (init) {
+            while (t__namespace.isTSAsExpression(init) || t__namespace.isTSSatisfiesExpression(init)) {
+              init = init.expression;
+            }
+            if (t__namespace.isObjectExpression(init)) {
+              collectCandidatesFromBabelObj(init, path, classes, variantPrefix);
+              continue;
+            }
+          }
+        }
+      }
+      collectCandidatesFromBabelExpr(spreadArg, path, classes);
+    } else if (t__namespace.isObjectProperty(prop)) {
+      let key;
+      if (t__namespace.isIdentifier(prop.key)) {
+        key = prop.key.name;
+      } else if (t__namespace.isStringLiteral(prop.key)) {
+        key = prop.key.value;
+      } else if (t__namespace.isNumericLiteral(prop.key)) {
+        key = String(prop.key.value);
+      } else {
+        continue;
+      }
+      const val = prop.value;
+      if (t__namespace.isObjectExpression(val)) {
+        if (isKnownBabelVariant(key)) {
+          const nestedVariant = variantPrefix ? `${variantPrefix}:${key}` : key;
+          collectCandidatesFromBabelObj(val, path, classes, nestedVariant);
+        } else {
+          const flatVal = resolveObjectSpreads(val, getBinding) ?? val;
+          const staticObj = evaluateStaticObject(flatVal);
+          if (staticObj !== null) {
+            const { className } = transformCore.transform({ [key]: staticObj });
+            const prefixed = variantPrefix ? prefixClasses(className, variantPrefix) : className;
+            for (const c of prefixed.split(/\s+/)) {
+              if (c) classes.add(c);
+            }
+          } else {
+            collectCandidatesFromBabelExpr(val, path, classes);
+          }
+        }
+      } else if (t__namespace.isConditionalExpression(val)) {
+        const consequent = val.consequent;
+        const alternate = val.alternate;
+        const staticCons = t__namespace.isStringLiteral(consequent) || t__namespace.isNumericLiteral(consequent) || t__namespace.isBooleanLiteral(consequent) || t__namespace.isObjectExpression(consequent) ? evaluateStaticObject(
+          t__namespace.objectExpression([t__namespace.objectProperty(t__namespace.identifier(key), consequent)])
+        ) : null;
+        if (staticCons !== null) {
+          const { className } = transformCore.transform(staticCons);
+          const prefixed = variantPrefix ? prefixClasses(className, variantPrefix) : className;
+          for (const c of prefixed.split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } else {
+          collectCandidatesFromBabelExpr(consequent, path, classes);
+        }
+        const staticAlt = t__namespace.isStringLiteral(alternate) || t__namespace.isNumericLiteral(alternate) || t__namespace.isBooleanLiteral(alternate) || t__namespace.isObjectExpression(alternate) ? evaluateStaticObject(
+          t__namespace.objectExpression([t__namespace.objectProperty(t__namespace.identifier(key), alternate)])
+        ) : null;
+        if (staticAlt !== null) {
+          const { className } = transformCore.transform(staticAlt);
+          const prefixed = variantPrefix ? prefixClasses(className, variantPrefix) : className;
+          for (const c of prefixed.split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } else {
+          collectCandidatesFromBabelExpr(alternate, path, classes);
+        }
+      } else {
+        const staticVal = t__namespace.isStringLiteral(val) || t__namespace.isNumericLiteral(val) || t__namespace.isBooleanLiteral(val) ? evaluateStaticObject(
+          t__namespace.objectExpression([t__namespace.objectProperty(t__namespace.identifier(key), val)])
+        ) : null;
+        if (staticVal !== null) {
+          const { className } = transformCore.transform(staticVal);
+          const prefixed = variantPrefix ? (
+            /**
+             *
+             * @param classesStr
+             * @param variantChain
+             */
+            prefixClasses(className, variantPrefix)
+          ) : className;
+          for (const c of prefixed.split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } else {
+          collectCandidatesFromBabelExpr(val, path, classes);
+        }
+      }
+    }
+  }
+}
+function prefixClasses(classesStr, variantChain) {
+  const variantPrefix = transformCore.getVariantPrefix(variantChain);
+  return classesStr.split(/\s+/).map((c) => c ? `${variantPrefix}:${c}` : "").join(" ");
+}
+function isKnownBabelVariant(key) {
+  return transformCore.KNOWN_VARIANTS.has(key) || transformCore.KNOWN_VARIANTS.has(transformCore.getVariantPrefix(key));
+}
 function buildCSSVarClassName$1(info) {
   const { twPrefix, varName, variantChain } = info;
   const variantPrefix = variantChain ? `${transformCore.getVariantPrefix(variantChain)}:` : "";
@@ -2142,6 +2286,12 @@ function transformOxc(source, filename, options) {
         objectBindings,
         classes
       );
+      collectSzvCallClasses(
+        node,
+        effectiveFilename,
+        objectBindings,
+        classes
+      );
       return;
     }
     if (node.type !== "JSXOpeningElement") {
@@ -2336,6 +2486,33 @@ function transformOxc(source, filename, options) {
         }
       }
       if (expression.type === "ArrayExpression") {
+        const arrayMergeExpression = buildArrayMergeExpression(
+          expression,
+          effectiveFilename,
+          objectBindings,
+          globalVarAliases,
+          cssVariableMap,
+          source,
+          classes
+        );
+        if (arrayMergeExpression) {
+          const existingExpression = classNameAttr ? classNameMergeArgument(classNameAttr, source) : null;
+          const mergeExpression = existingExpression ? `_szMerge(${existingExpression}, ${arrayMergeExpression})` : `_szMerge(${arrayMergeExpression})`;
+          if (classNameAttr) {
+            edits.overwrite(
+              classNameAttr.start,
+              classNameAttr.end,
+              `className={${mergeExpression}}`
+            );
+            edits.remove(whitespaceStart(source, szAttr.start), szAttr.end);
+          } else {
+            edits.overwrite(szAttr.start, szAttr.end, `className={${mergeExpression}}`);
+          }
+          usesRuntime = true;
+          usesMerge = true;
+          transformed = true;
+          return;
+        }
         const arrayClasses = astArrayToStaticClasses(
           expression,
           effectiveFilename,
@@ -2348,7 +2525,8 @@ function transformOxc(source, filename, options) {
             expression,
             effectiveFilename,
             objectBindings,
-            classes
+            classes,
+            ""
           );
           runtimeFallbackExpr = expression;
           runtimeFallbackAttr = szAttr;
@@ -2408,7 +2586,7 @@ function transformOxc(source, filename, options) {
             reservedCSSVariableNames,
             globalVarAliases
           );
-          if (partial && szAttrs.length === 1) {
+          if (partial && szAttrs.length === 1 && !(partial.hasConditional && classNameAttr)) {
             const mergedStyleProps = hoistedStyleProps.length > 0 ? [...hoistedStyleProps, ...partial.styleProps] : partial.styleProps;
             if (classNameAttr?.value?.type === "JSXExpressionContainer") {
               const classExpression = classNameAttr.value.expression;
@@ -2499,6 +2677,13 @@ function transformOxc(source, filename, options) {
       if (runtimeFallbackExpr.type !== "ArrayExpression") {
         diagnostics.push(buildRuntimeFallbackDiagnostic(runtimeFallbackExpr, source));
       }
+      collectCandidateClassesFromExpression(
+        runtimeFallbackExpr,
+        effectiveFilename,
+        objectBindings,
+        classes,
+        ""
+      );
       edits.overwrite(
         runtimeFallbackAttr.start,
         runtimeFallbackAttr.end,
@@ -2696,32 +2881,278 @@ function astArrayToStaticClasses(node, filename, bindings, globalVarAliases, css
   }
   return out;
 }
-function collectArrayCandidateClasses(node, filename, bindings, classes) {
+function buildArrayMergeExpression(node, filename, bindings, globalVarAliases, cssVariableMap, source, classes) {
+  const parts = [];
+  let hasConditional = false;
+  for (const element of node.elements) {
+    if (!element || isFalsyLiteral(element)) {
+      continue;
+    }
+    const unwrapped = unwrapExpression(element);
+    let condition = null;
+    let candidate = unwrapped;
+    if (unwrapped.type === "LogicalExpression" && unwrapped.operator === "&&") {
+      const logical = unwrapped;
+      condition = logical.left;
+      candidate = unwrapExpression(logical.right);
+      hasConditional = true;
+    }
+    const objectNode = resolveObjectExpression(candidate, bindings);
+    if (!objectNode) {
+      return null;
+    }
+    let result;
+    try {
+      result = transformCore.transform(
+        applyGlobalVarAliasesToSzObject(
+          astObjectToSzObject(objectNode, filename, bindings),
+          globalVarAliases,
+          cssVariableMap
+        )
+      );
+    } catch (err) {
+      if (err instanceof OxcNotImplementedError) {
+        return null;
+      }
+      throw err;
+    }
+    for (const cls of result.className.split(/\s+/)) {
+      if (cls) {
+        classes.add(cls);
+      }
+    }
+    const classLiteral = JSON.stringify(result.className);
+    parts.push(
+      condition ? `${source.slice(condition.start, condition.end)} && ${classLiteral}` : classLiteral
+    );
+  }
+  return hasConditional ? parts.join(", ") : null;
+}
+function classNameMergeArgument(attribute, source) {
+  const staticValue = stringLiteralValue(attribute.value);
+  if (staticValue !== null) {
+    return JSON.stringify(staticValue);
+  }
+  if (attribute.value?.type === "JSXExpressionContainer") {
+    const expression = attribute.value.expression;
+    return source.slice(expression.start, expression.end);
+  }
+  return '""';
+}
+function collectArrayCandidateClasses(node, filename, bindings, classes, variantPrefix) {
   for (const element of node.elements) {
     if (!element || isFalsyLiteral(element)) {
       continue;
     }
     const candidate = element.type === "LogicalExpression" && element.operator === "&&" ? element.right : element;
-    collectStaticObjectCandidateClasses(candidate, filename, bindings, classes);
+    collectCandidateClassesFromExpression(
+      candidate,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
   }
 }
-function collectStaticObjectCandidateClasses(node, filename, bindings, classes) {
-  const objectNode = resolveObjectExpression(node, bindings);
-  if (!objectNode) {
-    return;
+function collectCandidateClassesFromExpression(node, filename, bindings, classes, variantPrefix) {
+  const unwrapped = unwrapExpression(node);
+  if (unwrapped.type === "ArrayExpression") {
+    collectArrayCandidateClasses(
+      unwrapped,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
+  } else if (unwrapped.type === "ObjectExpression") {
+    collectCandidateClassesFromObjectExpression(
+      unwrapped,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
+  } else if (unwrapped.type === "Identifier") {
+    const bound = bindings.get(String(unwrapped.name));
+    if (bound) {
+      collectCandidateClassesFromExpression(
+        bound,
+        filename,
+        bindings,
+        classes,
+        variantPrefix
+      );
+    }
+  } else if (unwrapped.type === "ConditionalExpression") {
+    const cond = unwrapped;
+    collectCandidateClassesFromExpression(
+      cond.consequent,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
+    collectCandidateClassesFromExpression(
+      cond.alternate,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
+  } else if (unwrapped.type === "LogicalExpression" && unwrapped.operator === "&&") {
+    const logical = unwrapped;
+    collectCandidateClassesFromExpression(
+      logical.right,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
   }
-  let result;
+}
+function collectCandidateClassesFromObjectExpression(node, filename, bindings, classes, variantPrefix) {
   try {
-    result = transformCore.transform(astObjectToSzObject(objectNode, filename, bindings));
+    const compiled = transformCore.transform(astObjectToSzObject(node, filename, bindings));
+    for (const cls of prefixVariantClasses(compiled.className, variantPrefix).split(/\s+/)) {
+      if (cls) {
+        classes.add(cls);
+      }
+    }
+    return;
   } catch (err) {
-    if (err instanceof OxcNotImplementedError) {
-      return;
+    if (!(err instanceof OxcNotImplementedError)) {
+      throw err;
     }
-    throw err;
   }
-  for (const cls of result.className.split(/\s+/)) {
-    if (cls) {
-      classes.add(cls);
+  for (const propRaw of node.properties) {
+    if (propRaw.type === "SpreadElement") {
+      const spread = propRaw;
+      const spreadArg = unwrapExpression(spread.argument);
+      if (spreadArg.type === "Identifier") {
+        const bound = bindings.get(String(spreadArg.name));
+        if (bound) {
+          collectCandidateClassesFromObjectExpression(
+            bound,
+            filename,
+            bindings,
+            classes,
+            variantPrefix
+          );
+        }
+      } else {
+        collectCandidateClassesFromExpression(
+          spread.argument,
+          filename,
+          bindings,
+          classes,
+          variantPrefix
+        );
+      }
+    } else if (propRaw.type === "Property") {
+      const prop = propRaw;
+      if (prop.computed) {
+        continue;
+      }
+      const key = extractKeyName(prop.key);
+      if (key === null) {
+        continue;
+      }
+      const val = unwrapExpression(prop.value);
+      if (val.type === "ObjectExpression") {
+        if (isKnownVariant(key)) {
+          const nestedVariant = variantPrefix ? `${variantPrefix}:${key}` : key;
+          collectCandidateClassesFromObjectExpression(
+            val,
+            filename,
+            bindings,
+            classes,
+            nestedVariant
+          );
+        } else {
+          try {
+            const propertyVal = astObjectToSzObject(
+              val,
+              filename,
+              bindings
+            );
+            const singleObject = { [key]: propertyVal };
+            const compiled = transformCore.transform(singleObject);
+            for (const c of prefixVariantClasses(
+              compiled.className,
+              variantPrefix
+            ).split(/\s+/)) {
+              if (c) classes.add(c);
+            }
+          } catch {
+            collectCandidateClassesFromExpression(
+              val,
+              filename,
+              bindings,
+              classes,
+              variantPrefix
+            );
+          }
+        }
+      } else if (val.type === "ConditionalExpression") {
+        const cond = val;
+        try {
+          const consequentVal = astValueToSzValue(cond.consequent, filename, bindings);
+          const singleConsequent = { [key]: consequentVal };
+          const compiledConsequent = transformCore.transform(singleConsequent);
+          for (const c of prefixVariantClasses(
+            compiledConsequent.className,
+            variantPrefix
+          ).split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } catch {
+          collectCandidateClassesFromExpression(
+            cond.consequent,
+            filename,
+            bindings,
+            classes,
+            variantPrefix
+          );
+        }
+        try {
+          const alternateVal = astValueToSzValue(cond.alternate, filename, bindings);
+          const singleAlternate = { [key]: alternateVal };
+          const compiledAlternate = transformCore.transform(singleAlternate);
+          for (const c of prefixVariantClasses(
+            compiledAlternate.className,
+            variantPrefix
+          ).split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } catch {
+          collectCandidateClassesFromExpression(
+            cond.alternate,
+            filename,
+            bindings,
+            classes,
+            variantPrefix
+          );
+        }
+      } else {
+        try {
+          const propertyVal = astValueToSzValue(val, filename, bindings);
+          const singleObject = { [key]: propertyVal };
+          const compiled = transformCore.transform(singleObject);
+          for (const c of prefixVariantClasses(compiled.className, variantPrefix).split(
+            /\s+/
+          )) {
+            if (c) classes.add(c);
+          }
+        } catch {
+          collectCandidateClassesFromExpression(
+            val,
+            filename,
+            bindings,
+            classes,
+            variantPrefix
+          );
+        }
+      }
     }
   }
 }
@@ -2768,6 +3199,53 @@ function collectDynamicCallClasses(node, filename, bindings, classes) {
     }
   }
 }
+function collectSzvCallClasses(node, filename, bindings, classes) {
+  if (node.callee.type !== "Identifier" || node.callee.name !== "szv") {
+    return;
+  }
+  const [firstArg] = node.arguments;
+  if (!firstArg) {
+    return;
+  }
+  const configNode = resolveObjectExpression(firstArg, bindings);
+  if (!configNode) {
+    return;
+  }
+  let config;
+  try {
+    config = astObjectToSzObject(configNode, filename, bindings);
+  } catch (err) {
+    if (err instanceof OxcNotImplementedError) {
+      return;
+    }
+    throw err;
+  }
+  const base = isSzObject(config.base) ? config.base : {};
+  addCompiledClasses(base, classes);
+  const variants = isSzObject(config.variants) ? config.variants : {};
+  for (const variantValues of Object.values(variants)) {
+    if (!isSzObject(variantValues)) {
+      continue;
+    }
+    for (const variantObject of Object.values(variantValues)) {
+      if (!isSzObject(variantObject)) {
+        continue;
+      }
+      addCompiledClasses({ ...base, ...variantObject }, classes);
+    }
+  }
+}
+function addCompiledClasses(object, classes) {
+  const result = transformCore.transform(object);
+  for (const cls of result.className.split(/\s+/)) {
+    if (cls) {
+      classes.add(cls);
+    }
+  }
+}
+function isSzObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function resolveObjectExpression(node, bindings) {
   const unwrapped = unwrapExpression(node);
   if (unwrapped.type === "ObjectExpression") {
@@ -2863,7 +3341,7 @@ function buildPartialObjectTransform(node, filename, bindings, source, options,
   if (!partial || partial.dynamicProps.size === 0 && partial.conditionalClasses.length === 0) {
     return null;
   }
-  if (partial.conditionalClasses.length > 0 && (partial.conditionalClasses.length !== 1 || partial.dynamicProps.size > 0 || Object.keys(partial.staticProps).length > 0)) {
+  if (partial.conditionalClasses.length > 0 && (partial.conditionalClasses.length !== 1 || partial.dynamicProps.size > 0)) {
     return null;
   }
   const classParts = [];
@@ -2890,7 +3368,13 @@ function buildPartialObjectTransform(node, filename, bindings, source, options,
   const styleProps = [...partial.dynamicProps.entries()].filter(([id]) => !hoistedNames?.has(id)).map(
     ([, info]) => `${JSON.stringify(info.varName)}: ${generateStyleValueSource(info, source)}`
   );
-  return { className, classNameAttr, styleProps, usesColorVar: partial.usesColorVar };
+  return {
+    className,
+    classNameAttr,
+    styleProps,
+    usesColorVar: partial.usesColorVar,
+    hasConditional: partial.conditionalClasses.length > 0
+  };
 }
 function applyHoistedVariableNames(partial, hoistedNames, cssVariableMap) {
   if (!hoistedNames) {
@@ -3452,9 +3936,14 @@ function buildCSSVarClassName(info) {
   return `${variantPrefix}${info.twPrefix}-(${info.varName})`;
 }
 function buildConditionalClassSource(classParts, conditionals, source) {
-  if (conditionals.length === 1 && classParts.length === 2) {
+  if (conditionals.length === 1) {
     const [entry] = conditionals;
-    return `${source.slice(entry.test.start, entry.test.end)} ? ${JSON.stringify(entry.consequent)} : ${JSON.stringify(entry.alternate)}`;
+    const ternary = `${source.slice(entry.test.start, entry.test.end)} ? ${JSON.stringify(entry.consequent)} : ${JSON.stringify(entry.alternate)}`;
+    const staticParts = classParts.slice(0, -2).filter(Boolean);
+    if (staticParts.length === 0) {
+      return ternary;
+    }
+    return `\`${staticParts.join(" ")} \${${ternary}}\``;
   }
   return JSON.stringify(classParts.filter(Boolean).join(" "));
 }

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { init, version, transform_sz, encode } from '@csszyx/core';
-import { t as transform, C as COLOR_PROPERTIES, P as PROPERTY_MAP, g as getCSSVariableName, a as PropertyCategory, K as KNOWN_VARIANTS, b as getVariantPrefix, c as getPropertyCategory, s as stripInvalidColorStrings } from './shared/compiler.wyFFQW-b.mjs';
-export { B as BOOLEAN_SHORTHANDS, d as PROPERTY_CATEGORY_MAP, S as SPECIAL_VARIANTS, e as SUGGESTION_MAP, i as isValidSzProp, n as normalizeClassName } from './shared/compiler.wyFFQW-b.mjs';
+import { t as transform, C as COLOR_PROPERTIES, P as PROPERTY_MAP, g as getCSSVariableName, a as PropertyCategory, K as KNOWN_VARIANTS, b as getVariantPrefix, c as getPropertyCategory, s as stripInvalidColorStrings } from './shared/compiler.fR1gse9A.mjs';
+export { B as BOOLEAN_SHORTHANDS, d as PROPERTY_CATEGORY_MAP, S as SPECIAL_VARIANTS, e as SUGGESTION_MAP, i as isValidSzProp, n as normalizeClassName } from './shared/compiler.fR1gse9A.mjs';
 import { parseSync } from 'oxc-parser';
 import * as t from '@babel/types';
 import { createHash } from 'node:crypto';
@@ -586,6 +586,11 @@ function transformSourceCode(source, filename, options) {
                 const szCall = t.callExpression(t.identifier("_sz"), [
                   expression
                 ]);
+                collectCandidatesFromBabelExpr(
+                  expression,
+                  path,
+                  collectedClasses
+                );
                 path.node.value = createMergedClassNameValue(szCall);
                 usesRuntime = true;
                 transformed = true;
@@ -1200,6 +1205,145 @@ function collectFromExpr(node, classes) {
     collectFromExpr(node.alternate, classes);
   }
 }
+function collectCandidatesFromBabelExpr(node, path, classes) {
+  if (t.isTSAsExpression(node) || t.isTSSatisfiesExpression(node) || t.isTSNonNullExpression(node) || t.isTSInstantiationExpression(node)) {
+    collectCandidatesFromBabelExpr(node.expression, path, classes);
+  } else if (t.isArrayExpression(node)) {
+    for (const element of node.elements) {
+      if (element === null || t.isSpreadElement(element)) {
+        continue;
+      }
+      const cand = t.isLogicalExpression(element) && element.operator === "&&" ? element.right : element;
+      collectCandidatesFromBabelExpr(cand, path, classes);
+    }
+  } else if (t.isObjectExpression(node)) {
+    collectCandidatesFromBabelObj(node, path, classes, "");
+  } else if (t.isIdentifier(node)) {
+    const binding = path.scope.getBinding(node.name);
+    if (binding?.path.isVariableDeclarator()) {
+      let init = binding.path.node.init;
+      if (init) {
+        while (t.isTSAsExpression(init) || t.isTSSatisfiesExpression(init)) {
+          init = init.expression;
+        }
+        collectCandidatesFromBabelExpr(init, path, classes);
+      }
+    }
+  } else if (t.isConditionalExpression(node)) {
+    collectCandidatesFromBabelExpr(node.consequent, path, classes);
+    collectCandidatesFromBabelExpr(node.alternate, path, classes);
+  } else if (t.isLogicalExpression(node) && node.operator === "&&") {
+    collectCandidatesFromBabelExpr(node.right, path, classes);
+  }
+}
+function collectCandidatesFromBabelObj(node, path, classes, variantPrefix) {
+  const getBinding = (name) => path.scope.getBinding(name);
+  for (const prop of node.properties) {
+    if (t.isSpreadElement(prop)) {
+      const spreadArg = prop.argument;
+      if (t.isIdentifier(spreadArg)) {
+        const binding = getBinding(spreadArg.name);
+        if (binding?.path.isVariableDeclarator()) {
+          let init = binding.path.node.init;
+          if (init) {
+            while (t.isTSAsExpression(init) || t.isTSSatisfiesExpression(init)) {
+              init = init.expression;
+            }
+            if (t.isObjectExpression(init)) {
+              collectCandidatesFromBabelObj(init, path, classes, variantPrefix);
+              continue;
+            }
+          }
+        }
+      }
+      collectCandidatesFromBabelExpr(spreadArg, path, classes);
+    } else if (t.isObjectProperty(prop)) {
+      let key;
+      if (t.isIdentifier(prop.key)) {
+        key = prop.key.name;
+      } else if (t.isStringLiteral(prop.key)) {
+        key = prop.key.value;
+      } else if (t.isNumericLiteral(prop.key)) {
+        key = String(prop.key.value);
+      } else {
+        continue;
+      }
+      const val = prop.value;
+      if (t.isObjectExpression(val)) {
+        if (isKnownBabelVariant(key)) {
+          const nestedVariant = variantPrefix ? `${variantPrefix}:${key}` : key;
+          collectCandidatesFromBabelObj(val, path, classes, nestedVariant);
+        } else {
+          const flatVal = resolveObjectSpreads(val, getBinding) ?? val;
+          const staticObj = evaluateStaticObject(flatVal);
+          if (staticObj !== null) {
+            const { className } = transform({ [key]: staticObj });
+            const prefixed = variantPrefix ? prefixClasses(className, variantPrefix) : className;
+            for (const c of prefixed.split(/\s+/)) {
+              if (c) classes.add(c);
+            }
+          } else {
+            collectCandidatesFromBabelExpr(val, path, classes);
+          }
+        }
+      } else if (t.isConditionalExpression(val)) {
+        const consequent = val.consequent;
+        const alternate = val.alternate;
+        const staticCons = t.isStringLiteral(consequent) || t.isNumericLiteral(consequent) || t.isBooleanLiteral(consequent) || t.isObjectExpression(consequent) ? evaluateStaticObject(
+          t.objectExpression([t.objectProperty(t.identifier(key), consequent)])
+        ) : null;
+        if (staticCons !== null) {
+          const { className } = transform(staticCons);
+          const prefixed = variantPrefix ? prefixClasses(className, variantPrefix) : className;
+          for (const c of prefixed.split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } else {
+          collectCandidatesFromBabelExpr(consequent, path, classes);
+        }
+        const staticAlt = t.isStringLiteral(alternate) || t.isNumericLiteral(alternate) || t.isBooleanLiteral(alternate) || t.isObjectExpression(alternate) ? evaluateStaticObject(
+          t.objectExpression([t.objectProperty(t.identifier(key), alternate)])
+        ) : null;
+        if (staticAlt !== null) {
+          const { className } = transform(staticAlt);
+          const prefixed = variantPrefix ? prefixClasses(className, variantPrefix) : className;
+          for (const c of prefixed.split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } else {
+          collectCandidatesFromBabelExpr(alternate, path, classes);
+        }
+      } else {
+        const staticVal = t.isStringLiteral(val) || t.isNumericLiteral(val) || t.isBooleanLiteral(val) ? evaluateStaticObject(
+          t.objectExpression([t.objectProperty(t.identifier(key), val)])
+        ) : null;
+        if (staticVal !== null) {
+          const { className } = transform(staticVal);
+          const prefixed = variantPrefix ? (
+            /**
+             *
+             * @param classesStr
+             * @param variantChain
+             */
+            prefixClasses(className, variantPrefix)
+          ) : className;
+          for (const c of prefixed.split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } else {
+          collectCandidatesFromBabelExpr(val, path, classes);
+        }
+      }
+    }
+  }
+}
+function prefixClasses(classesStr, variantChain) {
+  const variantPrefix = getVariantPrefix(variantChain);
+  return classesStr.split(/\s+/).map((c) => c ? `${variantPrefix}:${c}` : "").join(" ");
+}
+function isKnownBabelVariant(key) {
+  return KNOWN_VARIANTS.has(key) || KNOWN_VARIANTS.has(getVariantPrefix(key));
+}
 function buildCSSVarClassName$1(info) {
   const { twPrefix, varName, variantChain } = info;
   const variantPrefix = variantChain ? `${getVariantPrefix(variantChain)}:` : "";
@@ -2123,6 +2267,12 @@ function transformOxc(source, filename, options) {
         objectBindings,
         classes
       );
+      collectSzvCallClasses(
+        node,
+        effectiveFilename,
+        objectBindings,
+        classes
+      );
       return;
     }
     if (node.type !== "JSXOpeningElement") {
@@ -2317,6 +2467,33 @@ function transformOxc(source, filename, options) {
         }
       }
       if (expression.type === "ArrayExpression") {
+        const arrayMergeExpression = buildArrayMergeExpression(
+          expression,
+          effectiveFilename,
+          objectBindings,
+          globalVarAliases,
+          cssVariableMap,
+          source,
+          classes
+        );
+        if (arrayMergeExpression) {
+          const existingExpression = classNameAttr ? classNameMergeArgument(classNameAttr, source) : null;
+          const mergeExpression = existingExpression ? `_szMerge(${existingExpression}, ${arrayMergeExpression})` : `_szMerge(${arrayMergeExpression})`;
+          if (classNameAttr) {
+            edits.overwrite(
+              classNameAttr.start,
+              classNameAttr.end,
+              `className={${mergeExpression}}`
+            );
+            edits.remove(whitespaceStart(source, szAttr.start), szAttr.end);
+          } else {
+            edits.overwrite(szAttr.start, szAttr.end, `className={${mergeExpression}}`);
+          }
+          usesRuntime = true;
+          usesMerge = true;
+          transformed = true;
+          return;
+        }
         const arrayClasses = astArrayToStaticClasses(
           expression,
           effectiveFilename,
@@ -2329,7 +2506,8 @@ function transformOxc(source, filename, options) {
             expression,
             effectiveFilename,
             objectBindings,
-            classes
+            classes,
+            ""
           );
           runtimeFallbackExpr = expression;
           runtimeFallbackAttr = szAttr;
@@ -2389,7 +2567,7 @@ function transformOxc(source, filename, options) {
             reservedCSSVariableNames,
             globalVarAliases
           );
-          if (partial && szAttrs.length === 1) {
+          if (partial && szAttrs.length === 1 && !(partial.hasConditional && classNameAttr)) {
             const mergedStyleProps = hoistedStyleProps.length > 0 ? [...hoistedStyleProps, ...partial.styleProps] : partial.styleProps;
             if (classNameAttr?.value?.type === "JSXExpressionContainer") {
               const classExpression = classNameAttr.value.expression;
@@ -2480,6 +2658,13 @@ function transformOxc(source, filename, options) {
       if (runtimeFallbackExpr.type !== "ArrayExpression") {
         diagnostics.push(buildRuntimeFallbackDiagnostic(runtimeFallbackExpr, source));
       }
+      collectCandidateClassesFromExpression(
+        runtimeFallbackExpr,
+        effectiveFilename,
+        objectBindings,
+        classes,
+        ""
+      );
       edits.overwrite(
         runtimeFallbackAttr.start,
         runtimeFallbackAttr.end,
@@ -2677,32 +2862,278 @@ function astArrayToStaticClasses(node, filename, bindings, globalVarAliases, css
   }
   return out;
 }
-function collectArrayCandidateClasses(node, filename, bindings, classes) {
+function buildArrayMergeExpression(node, filename, bindings, globalVarAliases, cssVariableMap, source, classes) {
+  const parts = [];
+  let hasConditional = false;
+  for (const element of node.elements) {
+    if (!element || isFalsyLiteral(element)) {
+      continue;
+    }
+    const unwrapped = unwrapExpression(element);
+    let condition = null;
+    let candidate = unwrapped;
+    if (unwrapped.type === "LogicalExpression" && unwrapped.operator === "&&") {
+      const logical = unwrapped;
+      condition = logical.left;
+      candidate = unwrapExpression(logical.right);
+      hasConditional = true;
+    }
+    const objectNode = resolveObjectExpression(candidate, bindings);
+    if (!objectNode) {
+      return null;
+    }
+    let result;
+    try {
+      result = transform(
+        applyGlobalVarAliasesToSzObject(
+          astObjectToSzObject(objectNode, filename, bindings),
+          globalVarAliases,
+          cssVariableMap
+        )
+      );
+    } catch (err) {
+      if (err instanceof OxcNotImplementedError) {
+        return null;
+      }
+      throw err;
+    }
+    for (const cls of result.className.split(/\s+/)) {
+      if (cls) {
+        classes.add(cls);
+      }
+    }
+    const classLiteral = JSON.stringify(result.className);
+    parts.push(
+      condition ? `${source.slice(condition.start, condition.end)} && ${classLiteral}` : classLiteral
+    );
+  }
+  return hasConditional ? parts.join(", ") : null;
+}
+function classNameMergeArgument(attribute, source) {
+  const staticValue = stringLiteralValue(attribute.value);
+  if (staticValue !== null) {
+    return JSON.stringify(staticValue);
+  }
+  if (attribute.value?.type === "JSXExpressionContainer") {
+    const expression = attribute.value.expression;
+    return source.slice(expression.start, expression.end);
+  }
+  return '""';
+}
+function collectArrayCandidateClasses(node, filename, bindings, classes, variantPrefix) {
   for (const element of node.elements) {
     if (!element || isFalsyLiteral(element)) {
       continue;
     }
     const candidate = element.type === "LogicalExpression" && element.operator === "&&" ? element.right : element;
-    collectStaticObjectCandidateClasses(candidate, filename, bindings, classes);
+    collectCandidateClassesFromExpression(
+      candidate,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
   }
 }
-function collectStaticObjectCandidateClasses(node, filename, bindings, classes) {
-  const objectNode = resolveObjectExpression(node, bindings);
-  if (!objectNode) {
-    return;
+function collectCandidateClassesFromExpression(node, filename, bindings, classes, variantPrefix) {
+  const unwrapped = unwrapExpression(node);
+  if (unwrapped.type === "ArrayExpression") {
+    collectArrayCandidateClasses(
+      unwrapped,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
+  } else if (unwrapped.type === "ObjectExpression") {
+    collectCandidateClassesFromObjectExpression(
+      unwrapped,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
+  } else if (unwrapped.type === "Identifier") {
+    const bound = bindings.get(String(unwrapped.name));
+    if (bound) {
+      collectCandidateClassesFromExpression(
+        bound,
+        filename,
+        bindings,
+        classes,
+        variantPrefix
+      );
+    }
+  } else if (unwrapped.type === "ConditionalExpression") {
+    const cond = unwrapped;
+    collectCandidateClassesFromExpression(
+      cond.consequent,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
+    collectCandidateClassesFromExpression(
+      cond.alternate,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
+  } else if (unwrapped.type === "LogicalExpression" && unwrapped.operator === "&&") {
+    const logical = unwrapped;
+    collectCandidateClassesFromExpression(
+      logical.right,
+      filename,
+      bindings,
+      classes,
+      variantPrefix
+    );
   }
-  let result;
+}
+function collectCandidateClassesFromObjectExpression(node, filename, bindings, classes, variantPrefix) {
   try {
-    result = transform(astObjectToSzObject(objectNode, filename, bindings));
+    const compiled = transform(astObjectToSzObject(node, filename, bindings));
+    for (const cls of prefixVariantClasses(compiled.className, variantPrefix).split(/\s+/)) {
+      if (cls) {
+        classes.add(cls);
+      }
+    }
+    return;
   } catch (err) {
-    if (err instanceof OxcNotImplementedError) {
-      return;
+    if (!(err instanceof OxcNotImplementedError)) {
+      throw err;
     }
-    throw err;
   }
-  for (const cls of result.className.split(/\s+/)) {
-    if (cls) {
-      classes.add(cls);
+  for (const propRaw of node.properties) {
+    if (propRaw.type === "SpreadElement") {
+      const spread = propRaw;
+      const spreadArg = unwrapExpression(spread.argument);
+      if (spreadArg.type === "Identifier") {
+        const bound = bindings.get(String(spreadArg.name));
+        if (bound) {
+          collectCandidateClassesFromObjectExpression(
+            bound,
+            filename,
+            bindings,
+            classes,
+            variantPrefix
+          );
+        }
+      } else {
+        collectCandidateClassesFromExpression(
+          spread.argument,
+          filename,
+          bindings,
+          classes,
+          variantPrefix
+        );
+      }
+    } else if (propRaw.type === "Property") {
+      const prop = propRaw;
+      if (prop.computed) {
+        continue;
+      }
+      const key = extractKeyName(prop.key);
+      if (key === null) {
+        continue;
+      }
+      const val = unwrapExpression(prop.value);
+      if (val.type === "ObjectExpression") {
+        if (isKnownVariant(key)) {
+          const nestedVariant = variantPrefix ? `${variantPrefix}:${key}` : key;
+          collectCandidateClassesFromObjectExpression(
+            val,
+            filename,
+            bindings,
+            classes,
+            nestedVariant
+          );
+        } else {
+          try {
+            const propertyVal = astObjectToSzObject(
+              val,
+              filename,
+              bindings
+            );
+            const singleObject = { [key]: propertyVal };
+            const compiled = transform(singleObject);
+            for (const c of prefixVariantClasses(
+              compiled.className,
+              variantPrefix
+            ).split(/\s+/)) {
+              if (c) classes.add(c);
+            }
+          } catch {
+            collectCandidateClassesFromExpression(
+              val,
+              filename,
+              bindings,
+              classes,
+              variantPrefix
+            );
+          }
+        }
+      } else if (val.type === "ConditionalExpression") {
+        const cond = val;
+        try {
+          const consequentVal = astValueToSzValue(cond.consequent, filename, bindings);
+          const singleConsequent = { [key]: consequentVal };
+          const compiledConsequent = transform(singleConsequent);
+          for (const c of prefixVariantClasses(
+            compiledConsequent.className,
+            variantPrefix
+          ).split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } catch {
+          collectCandidateClassesFromExpression(
+            cond.consequent,
+            filename,
+            bindings,
+            classes,
+            variantPrefix
+          );
+        }
+        try {
+          const alternateVal = astValueToSzValue(cond.alternate, filename, bindings);
+          const singleAlternate = { [key]: alternateVal };
+          const compiledAlternate = transform(singleAlternate);
+          for (const c of prefixVariantClasses(
+            compiledAlternate.className,
+            variantPrefix
+          ).split(/\s+/)) {
+            if (c) classes.add(c);
+          }
+        } catch {
+          collectCandidateClassesFromExpression(
+            cond.alternate,
+            filename,
+            bindings,
+            classes,
+            variantPrefix
+          );
+        }
+      } else {
+        try {
+          const propertyVal = astValueToSzValue(val, filename, bindings);
+          const singleObject = { [key]: propertyVal };
+          const compiled = transform(singleObject);
+          for (const c of prefixVariantClasses(compiled.className, variantPrefix).split(
+            /\s+/
+          )) {
+            if (c) classes.add(c);
+          }
+        } catch {
+          collectCandidateClassesFromExpression(
+            val,
+            filename,
+            bindings,
+            classes,
+            variantPrefix
+          );
+        }
+      }
     }
   }
 }
@@ -2749,6 +3180,53 @@ function collectDynamicCallClasses(node, filename, bindings, classes) {
     }
   }
 }
+function collectSzvCallClasses(node, filename, bindings, classes) {
+  if (node.callee.type !== "Identifier" || node.callee.name !== "szv") {
+    return;
+  }
+  const [firstArg] = node.arguments;
+  if (!firstArg) {
+    return;
+  }
+  const configNode = resolveObjectExpression(firstArg, bindings);
+  if (!configNode) {
+    return;
+  }
+  let config;
+  try {
+    config = astObjectToSzObject(configNode, filename, bindings);
+  } catch (err) {
+    if (err instanceof OxcNotImplementedError) {
+      return;
+    }
+    throw err;
+  }
+  const base = isSzObject(config.base) ? config.base : {};
+  addCompiledClasses(base, classes);
+  const variants = isSzObject(config.variants) ? config.variants : {};
+  for (const variantValues of Object.values(variants)) {
+    if (!isSzObject(variantValues)) {
+      continue;
+    }
+    for (const variantObject of Object.values(variantValues)) {
+      if (!isSzObject(variantObject)) {
+        continue;
+      }
+      addCompiledClasses({ ...base, ...variantObject }, classes);
+    }
+  }
+}
+function addCompiledClasses(object, classes) {
+  const result = transform(object);
+  for (const cls of result.className.split(/\s+/)) {
+    if (cls) {
+      classes.add(cls);
+    }
+  }
+}
+function isSzObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function resolveObjectExpression(node, bindings) {
   const unwrapped = unwrapExpression(node);
   if (unwrapped.type === "ObjectExpression") {
@@ -2844,7 +3322,7 @@ function buildPartialObjectTransform(node, filename, bindings, source, options,
   if (!partial || partial.dynamicProps.size === 0 && partial.conditionalClasses.length === 0) {
     return null;
   }
-  if (partial.conditionalClasses.length > 0 && (partial.conditionalClasses.length !== 1 || partial.dynamicProps.size > 0 || Object.keys(partial.staticProps).length > 0)) {
+  if (partial.conditionalClasses.length > 0 && (partial.conditionalClasses.length !== 1 || partial.dynamicProps.size > 0)) {
     return null;
   }
   const classParts = [];
@@ -2871,7 +3349,13 @@ function buildPartialObjectTransform(node, filename, bindings, source, options,
   const styleProps = [...partial.dynamicProps.entries()].filter(([id]) => !hoistedNames?.has(id)).map(
     ([, info]) => `${JSON.stringify(info.varName)}: ${generateStyleValueSource(info, source)}`
   );
-  return { className, classNameAttr, styleProps, usesColorVar: partial.usesColorVar };
+  return {
+    className,
+    classNameAttr,
+    styleProps,
+    usesColorVar: partial.usesColorVar,
+    hasConditional: partial.conditionalClasses.length > 0
+  };
 }
 function applyHoistedVariableNames(partial, hoistedNames, cssVariableMap) {
   if (!hoistedNames) {
@@ -3433,9 +3917,14 @@ function buildCSSVarClassName(info) {
   return `${variantPrefix}${info.twPrefix}-(${info.varName})`;
 }
 function buildConditionalClassSource(classParts, conditionals, source) {
-  if (conditionals.length === 1 && classParts.length === 2) {
+  if (conditionals.length === 1) {
     const [entry] = conditionals;
-    return `${source.slice(entry.test.start, entry.test.end)} ? ${JSON.stringify(entry.consequent)} : ${JSON.stringify(entry.alternate)}`;
+    const ternary = `${source.slice(entry.test.start, entry.test.end)} ? ${JSON.stringify(entry.consequent)} : ${JSON.stringify(entry.alternate)}`;
+    const staticParts = classParts.slice(0, -2).filter(Boolean);
+    if (staticParts.length === 0) {
+      return ternary;
+    }
+    return `\`${staticParts.join(" ")} \${${ternary}}\``;
   }
   return JSON.stringify(classParts.filter(Boolean).join(" "));
 }

package/dist/shared/{compiler.BfDLUvcf.cjs → compiler.BsKlgPl4.cjs}

@@ -301,11 +301,17 @@ const PROPERTY_MAP = {
   borderColor: "border",
   borderStyle: "border",
   borderT: "border-t",
+  borderTColor: "border-t",
   borderR: "border-r",
+  borderRColor: "border-r",
   borderB: "border-b",
+  borderBColor: "border-b",
   borderL: "border-l",
+  borderLColor: "border-l",
   borderX: "border-x",
+  borderXColor: "border-x",
   borderY: "border-y",
+  borderYColor: "border-y",
   borderS: "border-s",
   borderE: "border-e",
   borderBs: "border-bs",

package/dist/shared/{compiler.wyFFQW-b.mjs → compiler.fR1gse9A.mjs}

@@ -299,11 +299,17 @@ const PROPERTY_MAP = {
   borderColor: "border",
   borderStyle: "border",
   borderT: "border-t",
+  borderTColor: "border-t",
   borderR: "border-r",
+  borderRColor: "border-r",
   borderB: "border-b",
+  borderBColor: "border-b",
   borderL: "border-l",
+  borderLColor: "border-l",
   borderX: "border-x",
+  borderXColor: "border-x",
   borderY: "border-y",
+  borderYColor: "border-y",
   borderS: "border-s",
   borderE: "border-e",
   borderBs: "border-bs",

package/dist/transform-core.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const transformCore = require('./shared/compiler.BfDLUvcf.cjs');
+const transformCore = require('./shared/compiler.BsKlgPl4.cjs');
 
 
 

package/dist/transform-core.mjs

@@ -1 +1 @@
-export { B as BOOLEAN_SHORTHANDS, K as KNOWN_VARIANTS, P as PROPERTY_MAP, S as SPECIAL_VARIANTS, e as SUGGESTION_MAP, V as VARIANT_MAP, b as getVariantPrefix, i as isValidSzProp, f as normalizeArbitraryValue, h as normalizeArbitraryVariant, n as normalizeClassName, t as transform } from './shared/compiler.wyFFQW-b.mjs';
+export { B as BOOLEAN_SHORTHANDS, K as KNOWN_VARIANTS, P as PROPERTY_MAP, S as SPECIAL_VARIANTS, e as SUGGESTION_MAP, V as VARIANT_MAP, b as getVariantPrefix, i as isValidSzProp, f as normalizeArbitraryValue, h as normalizeArbitraryVariant, n as normalizeClassName, t as transform } from './shared/compiler.fR1gse9A.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@csszyx/compiler",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "Core compiler and transformation logic for csszyx",
   "keywords": [
     "csszyx",
@@ -65,7 +65,7 @@
     "@babel/types": "^7.23.6",
     "magic-string": "0.30.21",
     "oxc-parser": "0.131.0",
-    "@csszyx/core": "0.9.5"
+    "@csszyx/core": "0.9.6"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",