@csszyx/compiler 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2873 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  COLOR_PROPERTIES: () => COLOR_PROPERTIES,
+  CsszyxCompiler: () => CsszyxCompiler,
+  DEFAULT_COMPILER_OPTIONS: () => DEFAULT_COMPILER_OPTIONS,
+  ManifestBuilder: () => ManifestBuilder,
+  PROPERTY_CATEGORY_MAP: () => PROPERTY_CATEGORY_MAP,
+  PropertyCategory: () => PropertyCategory,
+  VERSION: () => VERSION,
+  buildParentMap: () => buildParentMap,
+  createRecoveryToken: () => createRecoveryToken,
+  generateRecoveryToken: () => generateRecoveryToken,
+  getCSSVariableName: () => getCSSVariableName,
+  getPropertyCategory: () => getPropertyCategory,
+  hoistCSSVariables: () => hoistCSSVariables,
+  injectRecoveryToken: () => injectRecoveryToken,
+  isValidRecoveryMode: () => isValidRecoveryMode,
+  isValidSzProp: () => isValidSzProp,
+  mergeOptions: () => mergeOptions,
+  normalizeClassName: () => normalizeClassName,
+  parseManifest: () => parseManifest,
+  serializeManifest: () => serializeManifest,
+  transform: () => transform,
+  transformSourceCode: () => transformSourceCode,
+  validateManifest: () => validateManifest,
+  validateSzRecover: () => validateSzRecover
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/compiler.ts
+var import_core = require("@csszyx/core");
+
+// src/transform.ts
+var babel = __toESM(require("@babel/core"), 1);
+var t = __toESM(require("@babel/types"), 1);
+
+// src/property-types.ts
+var PropertyCategory = /* @__PURE__ */ ((PropertyCategory2) => {
+  PropertyCategory2[PropertyCategory2["SPACING"] = 0] = "SPACING";
+  PropertyCategory2[PropertyCategory2["COLOR"] = 1] = "COLOR";
+  PropertyCategory2[PropertyCategory2["FRACTION"] = 2] = "FRACTION";
+  PropertyCategory2[PropertyCategory2["UNITLESS"] = 3] = "UNITLESS";
+  PropertyCategory2[PropertyCategory2["ANGLE"] = 4] = "ANGLE";
+  PropertyCategory2[PropertyCategory2["DURATION"] = 5] = "DURATION";
+  PropertyCategory2[PropertyCategory2["ARBITRARY"] = 6] = "ARBITRARY";
+  PropertyCategory2[PropertyCategory2["PASSTHROUGH"] = 7] = "PASSTHROUGH";
+  return PropertyCategory2;
+})(PropertyCategory || {});
+var PROPERTY_CATEGORY_MAP = {
+  // ---- SPACING ----
+  p: 0 /* SPACING */,
+  pt: 0 /* SPACING */,
+  pr: 0 /* SPACING */,
+  pb: 0 /* SPACING */,
+  pl: 0 /* SPACING */,
+  px: 0 /* SPACING */,
+  py: 0 /* SPACING */,
+  ps: 0 /* SPACING */,
+  pe: 0 /* SPACING */,
+  m: 0 /* SPACING */,
+  mt: 0 /* SPACING */,
+  mr: 0 /* SPACING */,
+  mb: 0 /* SPACING */,
+  ml: 0 /* SPACING */,
+  mx: 0 /* SPACING */,
+  my: 0 /* SPACING */,
+  ms: 0 /* SPACING */,
+  me: 0 /* SPACING */,
+  spaceX: 0 /* SPACING */,
+  spaceY: 0 /* SPACING */,
+  gap: 0 /* SPACING */,
+  gapX: 0 /* SPACING */,
+  gapY: 0 /* SPACING */,
+  inset: 0 /* SPACING */,
+  insetX: 0 /* SPACING */,
+  insetY: 0 /* SPACING */,
+  top: 0 /* SPACING */,
+  right: 0 /* SPACING */,
+  bottom: 0 /* SPACING */,
+  left: 0 /* SPACING */,
+  start: 0 /* SPACING */,
+  end: 0 /* SPACING */,
+  w: 0 /* SPACING */,
+  minW: 0 /* SPACING */,
+  maxW: 0 /* SPACING */,
+  h: 0 /* SPACING */,
+  minH: 0 /* SPACING */,
+  maxH: 0 /* SPACING */,
+  size: 0 /* SPACING */,
+  basis: 0 /* SPACING */,
+  indent: 0 /* SPACING */,
+  scrollM: 0 /* SPACING */,
+  scrollMt: 0 /* SPACING */,
+  scrollMr: 0 /* SPACING */,
+  scrollMb: 0 /* SPACING */,
+  scrollMl: 0 /* SPACING */,
+  scrollMs: 0 /* SPACING */,
+  scrollMe: 0 /* SPACING */,
+  scrollMx: 0 /* SPACING */,
+  scrollMy: 0 /* SPACING */,
+  scrollP: 0 /* SPACING */,
+  scrollPt: 0 /* SPACING */,
+  scrollPr: 0 /* SPACING */,
+  scrollPb: 0 /* SPACING */,
+  scrollPl: 0 /* SPACING */,
+  scrollPs: 0 /* SPACING */,
+  scrollPe: 0 /* SPACING */,
+  scrollPx: 0 /* SPACING */,
+  scrollPy: 0 /* SPACING */,
+  translateX: 0 /* SPACING */,
+  translateY: 0 /* SPACING */,
+  borderSpacing: 0 /* SPACING */,
+  borderSpacingX: 0 /* SPACING */,
+  borderSpacingY: 0 /* SPACING */,
+  outlineOffset: 0 /* SPACING */,
+  ringOffset: 0 /* SPACING */,
+  underlineOffset: 0 /* SPACING */,
+  // ---- COLOR ----
+  bg: 1 /* COLOR */,
+  color: 1 /* COLOR */,
+  borderColor: 1 /* COLOR */,
+  divideColor: 1 /* COLOR */,
+  outlineColor: 1 /* COLOR */,
+  ringColor: 1 /* COLOR */,
+  ringOffsetColor: 1 /* COLOR */,
+  shadowColor: 1 /* COLOR */,
+  textShadowColor: 1 /* COLOR */,
+  decorationColor: 1 /* COLOR */,
+  accent: 1 /* COLOR */,
+  caret: 1 /* COLOR */,
+  fill: 1 /* COLOR */,
+  stroke: 1 /* COLOR */,
+  from: 1 /* COLOR */,
+  via: 1 /* COLOR */,
+  to: 1 /* COLOR */,
+  dropShadowColor: 1 /* COLOR */,
+  // ---- UNITLESS ----
+  opacity: 3 /* UNITLESS */,
+  z: 3 /* UNITLESS */,
+  order: 3 /* UNITLESS */,
+  columns: 3 /* UNITLESS */,
+  gridCols: 3 /* UNITLESS */,
+  gridRows: 3 /* UNITLESS */,
+  col: 3 /* UNITLESS */,
+  colSpan: 3 /* UNITLESS */,
+  colStart: 3 /* UNITLESS */,
+  colEnd: 3 /* UNITLESS */,
+  row: 3 /* UNITLESS */,
+  rowSpan: 3 /* UNITLESS */,
+  rowStart: 3 /* UNITLESS */,
+  rowEnd: 3 /* UNITLESS */,
+  lineClamp: 3 /* UNITLESS */,
+  grow: 3 /* UNITLESS */,
+  shrink: 3 /* UNITLESS */,
+  scale: 3 /* UNITLESS */,
+  scaleX: 3 /* UNITLESS */,
+  scaleY: 3 /* UNITLESS */,
+  brightness: 3 /* UNITLESS */,
+  contrast: 3 /* UNITLESS */,
+  saturate: 3 /* UNITLESS */,
+  hueRotate: 3 /* UNITLESS */,
+  backdropBrightness: 3 /* UNITLESS */,
+  backdropContrast: 3 /* UNITLESS */,
+  backdropSaturate: 3 /* UNITLESS */,
+  backdropHueRotate: 3 /* UNITLESS */,
+  backdropOpacity: 3 /* UNITLESS */,
+  strokeWidth: 3 /* UNITLESS */,
+  border: 3 /* UNITLESS */,
+  borderT: 3 /* UNITLESS */,
+  borderR: 3 /* UNITLESS */,
+  borderB: 3 /* UNITLESS */,
+  borderL: 3 /* UNITLESS */,
+  borderX: 3 /* UNITLESS */,
+  borderY: 3 /* UNITLESS */,
+  borderS: 3 /* UNITLESS */,
+  borderE: 3 /* UNITLESS */,
+  ring: 3 /* UNITLESS */,
+  outline: 3 /* UNITLESS */,
+  leading: 3 /* UNITLESS */,
+  decorationThickness: 3 /* UNITLESS */,
+  // ---- ANGLE ----
+  rotate: 4 /* ANGLE */,
+  skewX: 4 /* ANGLE */,
+  skewY: 4 /* ANGLE */,
+  // ---- DURATION ----
+  duration: 5 /* DURATION */,
+  delay: 5 /* DURATION */
+};
+function getPropertyCategory(property) {
+  return PROPERTY_CATEGORY_MAP[property] ?? 7 /* PASSTHROUGH */;
+}
+var COLOR_PROPERTIES = new Set(
+  Object.entries(PROPERTY_CATEGORY_MAP).filter(([, cat]) => cat === 1 /* COLOR */).map(([key]) => key)
+);
+function getCSSVariableName(property, variantPrefix) {
+  const prop = property.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  if (variantPrefix) {
+    return `--_sz-${variantPrefix}-${prop}`;
+  }
+  return `--_sz-${prop}`;
+}
+
+// src/transform-core.ts
+var PROPERTY_MAP = {
+  // Background
+  bg: "bg",
+  bgAttach: "bg",
+  bgClip: "bg-clip",
+  bgImg: "bg",
+  bgOrigin: "bg-origin",
+  bgPos: "bg",
+  bgRepeat: "bg",
+  bgSize: "bg",
+  // Gradient color stops
+  from: "from",
+  via: "via",
+  to: "to",
+  // Border Radius
+  rounded: "rounded",
+  roundedT: "rounded-t",
+  roundedR: "rounded-r",
+  roundedB: "rounded-b",
+  roundedL: "rounded-l",
+  roundedTl: "rounded-tl",
+  roundedTr: "rounded-tr",
+  roundedBl: "rounded-bl",
+  roundedBr: "rounded-br",
+  roundedS: "rounded-s",
+  roundedE: "rounded-e",
+  roundedSs: "rounded-ss",
+  roundedSe: "rounded-se",
+  roundedEs: "rounded-es",
+  roundedEe: "rounded-ee",
+  // Border
+  border: "border",
+  borderColor: "border",
+  borderStyle: "border",
+  borderT: "border-t",
+  borderR: "border-r",
+  borderB: "border-b",
+  borderL: "border-l",
+  borderX: "border-x",
+  borderY: "border-y",
+  borderS: "border-s",
+  borderE: "border-e",
+  // Divide
+  divideX: "divide-x",
+  divideY: "divide-y",
+  divideColor: "divide",
+  divideStyle: "divide",
+  // Outline
+  outline: "outline",
+  outlineColor: "outline",
+  outlineOffset: "outline-offset",
+  outlineStyle: "outline",
+  // Ring (v3 — keep for future v3 support)
+  ring: "ring",
+  ringColor: "ring",
+  ringOffset: "ring-offset",
+  ringOffsetColor: "ring-offset",
+  // Spacing (canonical shorthand only)
+  p: "p",
+  pt: "pt",
+  pr: "pr",
+  pb: "pb",
+  pl: "pl",
+  px: "px",
+  py: "py",
+  ps: "ps",
+  pe: "pe",
+  m: "m",
+  mt: "mt",
+  mr: "mr",
+  mb: "mb",
+  ml: "ml",
+  mx: "mx",
+  my: "my",
+  ms: "ms",
+  me: "me",
+  // Space between
+  spaceX: "space-x",
+  spaceY: "space-y",
+  // Sizing (canonical shorthand only)
+  w: "w",
+  minW: "min-w",
+  maxW: "max-w",
+  h: "h",
+  minH: "min-h",
+  maxH: "max-h",
+  size: "size",
+  // Layout
+  aspect: "aspect",
+  columns: "columns",
+  breakAfter: "break-after",
+  breakBefore: "break-before",
+  breakInside: "break-inside",
+  boxDecoration: "box-decoration",
+  box: "box",
+  float: "float",
+  clear: "clear",
+  isolation: "isolation",
+  objectFit: "object",
+  objectPos: "object",
+  overflowX: "overflow-x",
+  overflowY: "overflow-y",
+  overscroll: "overscroll",
+  overscrollX: "overscroll-x",
+  overscrollY: "overscroll-y",
+  z: "z",
+  position: "position",
+  display: "display",
+  // Inset
+  inset: "inset",
+  insetX: "inset-x",
+  insetY: "inset-y",
+  top: "top",
+  right: "right",
+  bottom: "bottom",
+  left: "left",
+  start: "start",
+  end: "end",
+  // Visibility
+  visibility: "visibility",
+  // Typography
+  color: "text",
+  text: "text",
+  fontWeight: "font",
+  font: "font",
+  fontFamily: "font",
+  fontStretch: "font-stretch",
+  textAlign: "text",
+  decoration: "decoration",
+  decorationColor: "decoration",
+  decorationStyle: "decoration",
+  decorationThickness: "decoration",
+  underlineOffset: "underline-offset",
+  textTransform: "text",
+  textOverflow: "text",
+  textWrap: "text",
+  wrap: "wrap",
+  indent: "indent",
+  align: "align",
+  whitespace: "whitespace",
+  break: "break",
+  hyphens: "hyphens",
+  content: "content",
+  leading: "leading",
+  tracking: "tracking",
+  lineClamp: "line-clamp",
+  list: "list",
+  listPos: "list",
+  listImg: "list-image",
+  // Flex & Grid
+  basis: "basis",
+  flexDir: "flex",
+  flexWrap: "flex",
+  grow: "grow",
+  shrink: "shrink",
+  order: "order",
+  items: "items",
+  self: "self",
+  justify: "justify",
+  justifyItems: "justify-items",
+  justifySelf: "justify-self",
+  placeContent: "place-content",
+  placeItems: "place-items",
+  placeSelf: "place-self",
+  gap: "gap",
+  gapX: "gap-x",
+  gapY: "gap-y",
+  // Grid
+  gridCols: "grid-cols",
+  gridRows: "grid-rows",
+  col: "col",
+  colSpan: "col-span",
+  colStart: "col-start",
+  colEnd: "col-end",
+  row: "row",
+  rowSpan: "row-span",
+  rowStart: "row-start",
+  rowEnd: "row-end",
+  gridFlow: "grid-flow",
+  autoCols: "auto-cols",
+  autoRows: "auto-rows",
+  // Effects
+  shadow: "shadow",
+  shadowColor: "shadow",
+  insetShadow: "inset-shadow",
+  textShadow: "text-shadow",
+  textShadowColor: "text-shadow",
+  opacity: "opacity",
+  mixBlend: "mix-blend",
+  bgBlend: "bg-blend",
+  // Filters
+  blur: "blur",
+  brightness: "brightness",
+  contrast: "contrast",
+  dropShadow: "drop-shadow",
+  dropShadowColor: "drop-shadow",
+  grayscale: "grayscale",
+  hueRotate: "hue-rotate",
+  invert: "invert",
+  saturate: "saturate",
+  sepia: "sepia",
+  backdropBlur: "backdrop-blur",
+  backdropBrightness: "backdrop-brightness",
+  backdropContrast: "backdrop-contrast",
+  backdropGrayscale: "backdrop-grayscale",
+  backdropHueRotate: "backdrop-hue-rotate",
+  backdropInvert: "backdrop-invert",
+  backdropOpacity: "backdrop-opacity",
+  backdropSaturate: "backdrop-saturate",
+  backdropSepia: "backdrop-sepia",
+  // Transforms
+  scale: "scale",
+  scaleX: "scale-x",
+  scaleY: "scale-y",
+  rotate: "rotate",
+  translateX: "translate-x",
+  translateY: "translate-y",
+  skewX: "skew-x",
+  skewY: "skew-y",
+  origin: "origin",
+  backface: "backface",
+  perspective: "perspective",
+  perspectiveOrigin: "perspective-origin",
+  transformStyle: "transform",
+  // Transitions & Animation
+  transition: "transition",
+  transitionBehavior: "transition",
+  duration: "duration",
+  ease: "ease",
+  delay: "delay",
+  animate: "animate",
+  // Masks
+  mask: "mask",
+  maskSize: "mask-size",
+  maskPos: "mask-position",
+  maskRepeat: "mask-repeat",
+  maskShape: "mask",
+  // Interactivity
+  cursor: "cursor",
+  caret: "caret",
+  pointerEvents: "pointer-events",
+  resize: "resize",
+  scroll: "scroll",
+  scrollM: "scroll-m",
+  scrollMt: "scroll-mt",
+  scrollMr: "scroll-mr",
+  scrollMb: "scroll-mb",
+  scrollMl: "scroll-ml",
+  scrollMs: "scroll-ms",
+  scrollMe: "scroll-me",
+  scrollMx: "scroll-mx",
+  scrollMy: "scroll-my",
+  scrollP: "scroll-p",
+  scrollPt: "scroll-pt",
+  scrollPr: "scroll-pr",
+  scrollPb: "scroll-pb",
+  scrollPl: "scroll-pl",
+  scrollPs: "scroll-ps",
+  scrollPe: "scroll-pe",
+  scrollPx: "scroll-px",
+  scrollPy: "scroll-py",
+  snapAlign: "snap",
+  snapStop: "snap",
+  snapType: "snap",
+  touch: "touch",
+  select: "select",
+  willChange: "will-change",
+  appearance: "appearance",
+  accent: "accent",
+  forcedColorAdjust: "forced-color-adjust",
+  // SVG
+  fill: "fill",
+  stroke: "stroke",
+  strokeWidth: "stroke",
+  // Tables
+  borderCollapse: "border",
+  borderSpacing: "border-spacing",
+  borderSpacingX: "border-spacing-x",
+  borderSpacingY: "border-spacing-y",
+  tableLayout: "table",
+  caption: "caption",
+  // Overflow
+  overflow: "overflow"
+};
+var SUGGESTION_MAP = {
+  // Background
+  backgroundColor: "bg",
+  backgroundImage: "bgImg",
+  backgroundSize: "bgSize",
+  backgroundPosition: "bgPos",
+  backgroundRepeat: "bgRepeat",
+  bgAttachment: "bgAttach",
+  bgImage: "bgImg",
+  // Border Radius
+  borderRadius: "rounded",
+  borderTopLeftRadius: "roundedTl",
+  borderTopRightRadius: "roundedTr",
+  borderBottomLeftRadius: "roundedBl",
+  borderBottomRightRadius: "roundedBr",
+  // Border
+  borderWidth: "border",
+  // Spacing
+  padding: "p",
+  paddingTop: "pt",
+  paddingRight: "pr",
+  paddingBottom: "pb",
+  paddingLeft: "pl",
+  paddingX: "px",
+  paddingY: "py",
+  margin: "m",
+  marginTop: "mt",
+  marginRight: "mr",
+  marginBottom: "mb",
+  marginLeft: "ml",
+  marginX: "mx",
+  marginY: "my",
+  // Sizing
+  width: "w",
+  height: "h",
+  minWidth: "minW",
+  maxWidth: "maxW",
+  minHeight: "minH",
+  maxHeight: "maxH",
+  // Layout
+  aspectRatio: "aspect",
+  boxSizing: "box",
+  boxDecorationBreak: "boxDecoration",
+  objectPosition: "objectPos",
+  zIndex: "z",
+  // Typography
+  fontStyle: "italic/notItalic (boolean)",
+  weight: "fontWeight",
+  textDecoration: "decoration or underline/lineThrough/noUnderline (boolean)",
+  textDecorationColor: "decorationColor",
+  textDecorationStyle: "decorationStyle",
+  textDecorationThickness: "decorationThickness",
+  textUnderlineOffset: "underlineOffset",
+  lineHeight: "leading",
+  letterSpacing: "tracking",
+  textIndent: "indent",
+  verticalAlign: "align",
+  wordBreak: "break",
+  overflowWrap: "wrap",
+  textWrap: "textWrap",
+  listStyleType: "list",
+  listStylePosition: "listPos",
+  listStyleImage: "listImg",
+  listStyle: "list",
+  listPosition: "listPos",
+  listImage: "listImg",
+  // Flex & Grid
+  flexBasis: "basis",
+  flexDirection: "flexDir",
+  flexGrow: "grow",
+  flexShrink: "shrink",
+  alignItems: "items",
+  alignContent: "content",
+  alignSelf: "self",
+  justifyContent: "justify",
+  gridTemplateColumns: "gridCols",
+  gridTemplateRows: "gridRows",
+  gridColumn: "col",
+  gridRow: "row",
+  gridAutoFlow: "gridFlow",
+  gridAutoColumns: "autoCols",
+  gridAutoRows: "autoRows",
+  // Effects
+  boxShadow: "shadow",
+  mixBlendMode: "mixBlend",
+  backgroundBlendMode: "bgBlend",
+  // Transitions
+  transitionProperty: "transition",
+  transitionDuration: "duration",
+  transitionTimingFunction: "ease",
+  transitionDelay: "delay",
+  animation: "animate",
+  transformOrigin: "origin",
+  // Interactivity
+  caretColor: "caret",
+  accentColor: "accent",
+  scrollBehavior: "scroll",
+  scrollMargin: "scrollM",
+  scrollPadding: "scrollP",
+  scrollSnapAlign: "snapAlign",
+  scrollSnapStop: "snapStop",
+  scrollSnapType: "snapType",
+  touchAction: "touch",
+  userSelect: "select",
+  captionSide: "caption",
+  // Boolean remaps
+  flexWrapReverse: "flexWrap: 'wrap-reverse'",
+  flexNowrap: "flexWrap: 'nowrap'"
+};
+var VARIANT_MAP = {
+  // Focus variants
+  focusWithin: "focus-within",
+  focusVisible: "focus-visible",
+  // Structural variants
+  firstOfType: "first-of-type",
+  lastOfType: "last-of-type",
+  onlyOfType: "only-of-type",
+  onlyChild: "only",
+  firstChild: "first",
+  lastChild: "last",
+  // Motion variants
+  motionReduce: "motion-reduce",
+  motionSafe: "motion-safe",
+  // Contrast variants
+  contrastMore: "contrast-more",
+  contrastLess: "contrast-less",
+  // Pseudo-element variants
+  firstLine: "first-line",
+  firstLetter: "first-letter",
+  // Form variants
+  placeholderShown: "placeholder-shown",
+  inRange: "in-range",
+  outOfRange: "out-of-range",
+  readOnly: "read-only",
+  // Pointer variants
+  pointerFine: "pointer-fine",
+  pointerCoarse: "pointer-coarse",
+  pointerNone: "pointer-none",
+  // Screen orientation
+  screenPortrait: "portrait",
+  screenLandscape: "landscape",
+  // Container query max variants
+  "@maxSm": "@max-sm",
+  "@maxMd": "@max-md",
+  "@maxLg": "@max-lg",
+  "@maxXl": "@max-xl",
+  "@max2xl": "@max-2xl"
+};
+var KNOWN_VARIANTS = /* @__PURE__ */ new Set([
+  // Responsive
+  "sm",
+  "md",
+  "lg",
+  "xl",
+  "2xl",
+  // Container queries
+  "@sm",
+  "@md",
+  "@lg",
+  "@xl",
+  "@2xl",
+  // Dark mode
+  "dark",
+  "light",
+  // Print/Media
+  "print",
+  "portrait",
+  "landscape",
+  // Motion
+  "motion-reduce",
+  "motion-safe",
+  "motionReduce",
+  "motionSafe",
+  // Contrast
+  "contrast-more",
+  "contrast-less",
+  "contrastMore",
+  "contrastLess",
+  // States
+  "hover",
+  "focus",
+  "focus-within",
+  "focus-visible",
+  "focusWithin",
+  "focusVisible",
+  "active",
+  "visited",
+  "target",
+  "disabled",
+  "enabled",
+  "checked",
+  "indeterminate",
+  "default",
+  "required",
+  "valid",
+  "invalid",
+  "in-range",
+  "out-of-range",
+  "inRange",
+  "outOfRange",
+  "placeholder-shown",
+  "placeholderShown",
+  "autofill",
+  "read-only",
+  "readOnly",
+  // Structure
+  "first",
+  "last",
+  "only",
+  "odd",
+  "even",
+  "empty",
+  "first-of-type",
+  "last-of-type",
+  "only-of-type",
+  "firstOfType",
+  "lastOfType",
+  "onlyOfType",
+  "first-child",
+  "last-child",
+  "only-child",
+  "firstChild",
+  "lastChild",
+  "onlyChild",
+  // Pseudo-elements
+  "before",
+  "after",
+  "placeholder",
+  "file",
+  "marker",
+  "selection",
+  "first-line",
+  "first-letter",
+  "firstLine",
+  "firstLetter",
+  "backdrop",
+  // Pointer
+  "pointer-fine",
+  "pointer-coarse",
+  "pointer-none",
+  "pointerFine",
+  "pointerCoarse",
+  "pointerNone",
+  // Open
+  "open",
+  // RTL/LTR
+  "ltr",
+  "rtl"
+]);
+var ARIA_STATES = /* @__PURE__ */ new Set([
+  "checked",
+  "disabled",
+  "expanded",
+  "hidden",
+  "pressed",
+  "readonly",
+  "required",
+  "selected",
+  "busy",
+  "current",
+  "invalid",
+  "live",
+  "atomic",
+  "modal"
+]);
+var BOOLEAN_SHORTHANDS = /* @__PURE__ */ new Set([
+  // Display
+  "block",
+  "inline",
+  "inlineBlock",
+  "flex",
+  "inlineFlex",
+  "grid",
+  "inlineGrid",
+  "hidden",
+  "contents",
+  "table",
+  "tableRow",
+  "tableCell",
+  "flowRoot",
+  "listItem",
+  // Position
+  "static",
+  "fixed",
+  "absolute",
+  "relative",
+  "sticky",
+  // Visibility
+  "visible",
+  "invisible",
+  "collapse",
+  // Typography
+  "truncate",
+  "uppercase",
+  "lowercase",
+  "capitalize",
+  "normalCase",
+  "underline",
+  "overline",
+  "lineThrough",
+  "noUnderline",
+  "italic",
+  "notItalic",
+  "antialiased",
+  "subpixelAntialiased",
+  // Flexbox (grow/shrink only — flexWrap uses string values)
+  "grow",
+  "shrink",
+  // Filters (default values)
+  "blur",
+  "grayscale",
+  "invert",
+  "sepia",
+  "backdropBlur",
+  "backdropGrayscale",
+  "backdropInvert",
+  "backdropSepia",
+  // Misc
+  "container",
+  "prose",
+  "srOnly",
+  "notSrOnly",
+  "isolate",
+  "ordinal",
+  "slashedZero",
+  // Font variant numeric
+  "liningNums",
+  "oldstyleNums",
+  "proportionalNums",
+  "tabularNums",
+  "diagonalFractions",
+  "stackedFractions",
+  // Divide/Space reverse
+  "divideXReverse",
+  "divideYReverse",
+  "spaceXReverse",
+  "spaceYReverse",
+  // Ring (v3 future)
+  "ring",
+  // Outline
+  "outline",
+  // Transforms
+  "scale3d",
+  "rotate3d",
+  "translate3d",
+  "transformGpu",
+  "transformCpu",
+  "transformNone"
+]);
+var BOOLEAN_TO_CLASS = {
+  inlineBlock: "inline-block",
+  inlineFlex: "inline-flex",
+  inlineGrid: "inline-grid",
+  tableRow: "table-row",
+  tableCell: "table-cell",
+  flowRoot: "flow-root",
+  listItem: "list-item",
+  normalCase: "normal-case",
+  lineThrough: "line-through",
+  noUnderline: "no-underline",
+  notItalic: "not-italic",
+  subpixelAntialiased: "subpixel-antialiased",
+  backdropBlur: "backdrop-blur",
+  backdropGrayscale: "backdrop-grayscale",
+  backdropInvert: "backdrop-invert",
+  backdropSepia: "backdrop-sepia",
+  srOnly: "sr-only",
+  notSrOnly: "not-sr-only",
+  divideXReverse: "divide-x-reverse",
+  divideYReverse: "divide-y-reverse",
+  spaceXReverse: "space-x-reverse",
+  spaceYReverse: "space-y-reverse",
+  // Font variant numeric
+  liningNums: "lining-nums",
+  oldstyleNums: "oldstyle-nums",
+  proportionalNums: "proportional-nums",
+  tabularNums: "tabular-nums",
+  diagonalFractions: "diagonal-fractions",
+  stackedFractions: "stacked-fractions",
+  // Transforms
+  scale3d: "scale-3d",
+  rotate3d: "rotate-3d",
+  translate3d: "translate-3d",
+  transformGpu: "transform-gpu",
+  transformCpu: "transform-cpu",
+  transformNone: "transform-none"
+};
+var SNAP_DIRECT_MAP = {
+  snapAlign: {
+    start: "snap-start",
+    end: "snap-end",
+    center: "snap-center",
+    none: "snap-align-none"
+  },
+  snapStop: {
+    normal: "snap-normal",
+    always: "snap-always"
+  },
+  snapType: {
+    none: "snap-none",
+    x: "snap-x",
+    y: "snap-y",
+    both: "snap-both"
+  },
+  snapStrictness: {
+    mandatory: "snap-mandatory",
+    proximity: "snap-proximity"
+  }
+};
+var NEGATIVE_ALLOWED = /* @__PURE__ */ new Set([
+  "m",
+  "mt",
+  "mr",
+  "mb",
+  "ml",
+  "mx",
+  "my",
+  "ms",
+  "me",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "inset",
+  "inset-x",
+  "inset-y",
+  "start",
+  "end",
+  "z",
+  "order",
+  "col",
+  "col-start",
+  "col-end",
+  "row",
+  "row-start",
+  "row-end",
+  "rotate",
+  "skew-x",
+  "skew-y",
+  "translate-x",
+  "translate-y",
+  "space-x",
+  "space-y",
+  "tracking",
+  "indent",
+  "scroll-m",
+  "scroll-mx",
+  "scroll-my",
+  "scroll-mt",
+  "scroll-mr",
+  "scroll-mb",
+  "scroll-ml",
+  "hue-rotate",
+  "backdrop-hue-rotate"
+]);
+function handleImportant(value) {
+  if (typeof value === "string" && value.endsWith("!")) {
+    return { value: value.slice(0, -1), important: true };
+  }
+  return { value, important: false };
+}
+function formatOpacity(op) {
+  if (typeof op === "number") {
+    return String(op);
+  }
+  if (typeof op === "string") {
+    if (op.startsWith("--")) {
+      return `(${op})`;
+    }
+    return `[${op}]`;
+  }
+  return String(op);
+}
+function isArbitraryVariant(key) {
+  return key.startsWith("[") && key.endsWith("]");
+}
+function normalizeArbitraryVariant(key) {
+  return key.replace(/\s+/g, "");
+}
+function normalizeArbitraryValue(value) {
+  return value.trim().replace(/\s*([+*/(),:])\s*/g, "$1").replace(/\s+/g, "_");
+}
+var FRACTION_SUPPORTED_PROPS = /* @__PURE__ */ new Set([
+  // Sizing (both rawKey and resolved key forms)
+  "w",
+  "width",
+  "min-w",
+  "minW",
+  "minWidth",
+  "max-w",
+  "maxW",
+  "maxWidth",
+  "h",
+  "height",
+  "min-h",
+  "minH",
+  "minHeight",
+  "max-h",
+  "maxH",
+  "maxHeight",
+  "size",
+  // Flex
+  "basis",
+  "flexBasis",
+  "flex",
+  // Inset
+  "inset",
+  "inset-x",
+  "insetX",
+  "inset-y",
+  "insetY",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "start",
+  "end",
+  // Translate
+  "translate-x",
+  "translateX",
+  "translate-y",
+  "translateY"
+]);
+function needsArbitraryBrackets(value) {
+  return /^\d+(\.\d+)?(px|rem|em|%|vh|vw|ch|dvh|dvw|svh|svw|lvh|lvw|cqw|cqh|deg|rad|turn|grad|ms|s|fr)$/.test(value) || // Units
+  /^\.\d+(px|rem|em|%|vh|vw|ch)?$/.test(value) || // Values starting with . like .25em
+  value.startsWith("#") || // Hex colors
+  value.startsWith("rgb") || // RGB colors
+  value.startsWith("hsl") || // HSL colors
+  value.includes("calc(") || // Calculations
+  value.includes("var(") || // CSS variables (old syntax)
+  value.includes("attr(") || // attr() function
+  value.includes("url(") || // URLs
+  value.includes("clamp(") || // Clamp
+  value.includes("min(") || // Min
+  value.includes("max(") || // Max
+  value.includes(" ");
+}
+var LIST_STYLE_STANDARD = /* @__PURE__ */ new Set(["none", "disc", "decimal"]);
+var FONT_STRETCH_KEYWORDS = /* @__PURE__ */ new Set([
+  "ultra-condensed",
+  "extra-condensed",
+  "condensed",
+  "semi-condensed",
+  "normal",
+  "semi-expanded",
+  "expanded",
+  "extra-expanded",
+  "ultra-expanded"
+]);
+var NEEDS_ARBITRARY_PROPERTY = /* @__PURE__ */ new Set([
+  "mask-type",
+  "mask-composite",
+  "mask-mode"
+]);
+function getVariantPrefix(key) {
+  if (VARIANT_MAP[key]) {
+    return VARIANT_MAP[key];
+  }
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function handleGroupPeer(type, nestedObj, prefix) {
+  const classes = [];
+  for (const [nestedKey, nestedValue] of Object.entries(nestedObj)) {
+    if (nestedValue === null || nestedValue === void 0 || nestedValue === false) {
+      continue;
+    }
+    if (nestedKey === "has" && typeof nestedValue === "object") {
+      for (const [selector, selectorValue] of Object.entries(nestedValue)) {
+        if (selectorValue === null || selectorValue === void 0 || selectorValue === false) {
+          continue;
+        }
+        const variantPrefix = `${prefix}${type}-has-[${selector}]:`;
+        const result = transform(selectorValue, variantPrefix);
+        if (result.className) {
+          classes.push(result.className);
+        }
+      }
+      continue;
+    }
+    const isVariant = KNOWN_VARIANTS.has(nestedKey) || KNOWN_VARIANTS.has(getVariantPrefix(nestedKey));
+    const isArbitrary = nestedKey.startsWith(".") || nestedKey.startsWith("#") || nestedKey.startsWith("[") || nestedKey.startsWith(":");
+    if (isArbitrary) {
+      const variantPrefix = `${prefix}${type}-[${nestedKey}]:`;
+      const result = transform(nestedValue, variantPrefix);
+      if (result.className) {
+        classes.push(result.className);
+      }
+    } else if (isVariant) {
+      const mappedVariant = getVariantPrefix(nestedKey);
+      const variantPrefix = `${prefix}${type}-${mappedVariant}:`;
+      const result = transform(nestedValue, variantPrefix);
+      if (result.className) {
+        classes.push(result.className);
+      }
+    } else if (typeof nestedValue === "object" && nestedValue !== null) {
+      for (const [state, stateValue] of Object.entries(nestedValue)) {
+        if (stateValue === null || stateValue === void 0 || stateValue === false) {
+          continue;
+        }
+        const mappedState = getVariantPrefix(state);
+        const variantPrefix = `${prefix}${type}-${mappedState}/${nestedKey}:`;
+        const result = transform(stateValue, variantPrefix);
+        if (result.className) {
+          classes.push(result.className);
+        }
+      }
+    }
+  }
+  return classes;
+}
+function handleHas(hasObj, prefix) {
+  const classes = [];
+  for (const [selector, value] of Object.entries(hasObj)) {
+    if (value === null || value === void 0 || value === false) {
+      continue;
+    }
+    let selectorStr;
+    if (KNOWN_VARIANTS.has(selector) || selector.startsWith(":")) {
+      selectorStr = selector.startsWith(":") ? selector : `:${selector}`;
+    } else {
+      selectorStr = selector;
+    }
+    const variantPrefix = `${prefix}has-[${selectorStr}]:`;
+    const result = transform(value, variantPrefix);
+    if (result.className) {
+      classes.push(result.className);
+    }
+  }
+  return classes;
+}
+function handleNot(notObj, prefix) {
+  const classes = [];
+  for (const [key, value] of Object.entries(notObj)) {
+    if (value === null || value === void 0 || value === false) {
+      continue;
+    }
+    if (key === "supports" && typeof value === "object") {
+      for (const [condition, condValue] of Object.entries(value)) {
+        const variantPrefix = `${prefix}not-supports-[${condition}]:`;
+        const result = transform(condValue, variantPrefix);
+        if (result.className) {
+          classes.push(result.className);
+        }
+      }
+    } else {
+      const mappedVariant = getVariantPrefix(key);
+      const variantPrefix = `${prefix}not-${mappedVariant}:`;
+      const result = transform(value, variantPrefix);
+      if (result.className) {
+        classes.push(result.className);
+      }
+    }
+  }
+  return classes;
+}
+function handleData(dataObj, prefix) {
+  const classes = [];
+  for (const [key, value] of Object.entries(dataObj)) {
+    if (value === null || value === void 0 || value === false) {
+      continue;
+    }
+    const variantPrefix = `${prefix}data-[${key}]:`;
+    const result = transform(value, variantPrefix);
+    if (result.className) {
+      classes.push(result.className);
+    }
+  }
+  return classes;
+}
+function handleAria(ariaObj, prefix) {
+  const classes = [];
+  for (const [key, value] of Object.entries(ariaObj)) {
+    if (value === null || value === void 0 || value === false) {
+      continue;
+    }
+    let variantPrefix;
+    if (ARIA_STATES.has(key)) {
+      variantPrefix = `${prefix}aria-${key}:`;
+    } else {
+      variantPrefix = `${prefix}aria-[${key}]:`;
+    }
+    const result = transform(value, variantPrefix);
+    if (result.className) {
+      classes.push(result.className);
+    }
+  }
+  return classes;
+}
+function handleSupports(supportsObj, prefix) {
+  const classes = [];
+  for (const [condition, value] of Object.entries(supportsObj)) {
+    if (value === null || value === void 0 || value === false) {
+      continue;
+    }
+    const variantPrefix = `${prefix}supports-[${condition}]:`;
+    const result = transform(value, variantPrefix);
+    if (result.className) {
+      classes.push(result.className);
+    }
+  }
+  return classes;
+}
+function transform(szProp, prefix = "", mangleMap) {
+  if (!szProp || typeof szProp !== "object") {
+    return { className: "", attributes: {} };
+  }
+  const classes = [];
+  const attributes = {};
+  for (const [rawKey, value] of Object.entries(szProp)) {
+    if (value === false) {
+      if (rawKey === "italic") {
+        classes.push(`${prefix}not-italic`);
+      } else if (rawKey === "antialiased") {
+        classes.push(`${prefix}subpixel-antialiased`);
+      }
+      continue;
+    }
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (rawKey.startsWith("@") && typeof value === "string") {
+      const mappedKey = VARIANT_MAP[rawKey] || rawKey;
+      classes.push(`${prefix}${mappedKey}/${value}`);
+      continue;
+    }
+    if (rawKey === "bgImg" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const grad = value;
+      const gradType = grad.gradient;
+      if (!gradType) {
+        continue;
+      }
+      let cls = "";
+      if (gradType === "linear") {
+        const dir = grad.dir ?? "to-r";
+        if (typeof dir === "number") {
+          if (dir < 0) {
+            cls = `-bg-linear-${Math.abs(dir)}`;
+          } else {
+            cls = `bg-linear-${dir}`;
+          }
+        } else if (typeof dir === "string") {
+          if (dir.startsWith("--")) {
+            cls = `bg-linear-(${dir})`;
+          } else if (dir.startsWith("to-")) {
+            cls = `bg-linear-${dir}`;
+          } else {
+            cls = `bg-linear-[${normalizeArbitraryValue(dir)}]`;
+          }
+        }
+      } else if (gradType === "radial") {
+        const dir = grad.dir;
+        if (dir === void 0 || dir === null) {
+          cls = "bg-radial";
+        } else if (typeof dir === "string") {
+          if (dir.startsWith("--")) {
+            cls = `bg-radial-(${dir})`;
+          } else {
+            cls = `bg-radial-[${normalizeArbitraryValue(dir)}]`;
+          }
+        }
+      } else if (gradType === "conic") {
+        const dir = grad.dir;
+        if (dir === void 0 || dir === null) {
+          cls = "bg-conic";
+        } else if (typeof dir === "number") {
+          if (dir < 0) {
+            cls = `-bg-conic-${Math.abs(dir)}`;
+          } else {
+            cls = `bg-conic-${dir}`;
+          }
+        } else if (typeof dir === "string") {
+          if (dir.startsWith("--")) {
+            cls = `bg-conic-(${dir})`;
+          } else {
+            cls = `bg-conic-[${normalizeArbitraryValue(dir)}]`;
+          }
+        }
+      }
+      if (grad.in) {
+        cls += `/${grad.in}`;
+      }
+      if (cls) {
+        classes.push(`${prefix}${cls}`);
+      }
+      continue;
+    }
+    if ((rawKey === "group" || rawKey === "peer") && typeof value === "string") {
+      classes.push(`${prefix}${rawKey}/${value}`);
+      continue;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && "color" in value) {
+      const colorObj = value;
+      const twPrefix = PROPERTY_MAP[rawKey] || rawKey.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      const colorBase = String(colorObj.color);
+      if (colorObj.op !== void 0) {
+        const opStr = formatOpacity(colorObj.op);
+        classes.push(`${prefix}${twPrefix}-${colorBase}/${opStr}`);
+      } else {
+        classes.push(`${prefix}${twPrefix}-${colorBase}`);
+      }
+      continue;
+    }
+    if (typeof value === "object" && !Array.isArray(value)) {
+      if (rawKey === "group") {
+        const groupClasses = handleGroupPeer("group", value, prefix);
+        classes.push(...groupClasses);
+        continue;
+      }
+      if (rawKey === "peer") {
+        const peerClasses = handleGroupPeer("peer", value, prefix);
+        classes.push(...peerClasses);
+        continue;
+      }
+      if (rawKey === "has") {
+        const hasClasses = handleHas(value, prefix);
+        classes.push(...hasClasses);
+        continue;
+      }
+      if (rawKey === "not") {
+        const notClasses = handleNot(value, prefix);
+        classes.push(...notClasses);
+        continue;
+      }
+      if (rawKey === "data") {
+        const dataClasses = handleData(value, prefix);
+        classes.push(...dataClasses);
+        continue;
+      }
+      if (rawKey === "aria") {
+        const ariaClasses = handleAria(value, prefix);
+        classes.push(...ariaClasses);
+        continue;
+      }
+      if (rawKey === "supports") {
+        const supportsClasses = handleSupports(value, prefix);
+        classes.push(...supportsClasses);
+        continue;
+      }
+      if (rawKey === "min" || rawKey === "max") {
+        const KNOWN_BP = /* @__PURE__ */ new Set(["sm", "md", "lg", "xl", "2xl"]);
+        for (const [breakpoint, breakpointValue] of Object.entries(value)) {
+          if (breakpointValue === null || breakpointValue === void 0 || breakpointValue === false) {
+            continue;
+          }
+          let bpStr;
+          if (isArbitraryVariant(breakpoint)) {
+            bpStr = `${rawKey}-${breakpoint}`;
+          } else if (KNOWN_BP.has(breakpoint)) {
+            bpStr = `${rawKey}-${breakpoint}`;
+          } else {
+            bpStr = `${rawKey}-[${breakpoint}]`;
+          }
+          const nestedPrefix2 = `${prefix}${bpStr}:`;
+          const result = transform(breakpointValue, nestedPrefix2);
+          if (result.className) {
+            classes.push(result.className);
+          }
+        }
+        continue;
+      }
+      if (rawKey.startsWith("@")) {
+        const mappedKey = VARIANT_MAP[rawKey] || rawKey;
+        if (typeof value === "string") {
+          classes.push(`${prefix}${mappedKey}/${value}`);
+          continue;
+        }
+        const KNOWN_BP = /* @__PURE__ */ new Set(["sm", "md", "lg", "xl", "2xl"]);
+        for (const [nestedKey, nestedValue] of Object.entries(value)) {
+          if (nestedValue === null || nestedValue === void 0 || nestedValue === false) {
+            continue;
+          }
+          if (isArbitraryVariant(nestedKey)) {
+            const nestedPrefix2 = `${prefix}${mappedKey}-${nestedKey}:`;
+            const result = transform(nestedValue, nestedPrefix2);
+            if (result.className) {
+              classes.push(result.className);
+            }
+          } else if ((mappedKey === "@min" || mappedKey === "@max") && typeof nestedValue === "object" && nestedValue !== null && !KNOWN_BP.has(nestedKey) && !PROPERTY_MAP[nestedKey] && !BOOLEAN_SHORTHANDS.has(nestedKey)) {
+            const nestedPrefix2 = `${prefix}${mappedKey}-[${nestedKey}]:`;
+            const result = transform(nestedValue, nestedPrefix2);
+            if (result.className) {
+              classes.push(result.className);
+            }
+          } else if (PROPERTY_MAP[nestedKey] || BOOLEAN_SHORTHANDS.has(nestedKey) || nestedKey.startsWith("@")) {
+            const nestedPrefix2 = `${prefix}${mappedKey}:`;
+            const result = transform({ [nestedKey]: nestedValue }, nestedPrefix2);
+            if (result.className) {
+              classes.push(result.className);
+            }
+          } else if (typeof nestedValue === "object" && nestedValue !== null) {
+            const nestedPrefix2 = `${prefix}${mappedKey}/${nestedKey}:`;
+            const result = transform(nestedValue, nestedPrefix2);
+            if (result.className) {
+              classes.push(result.className);
+            }
+          } else {
+            const nestedPrefix2 = `${prefix}${mappedKey}:`;
+            const result = transform({ [nestedKey]: nestedValue }, nestedPrefix2);
+            if (result.className) {
+              classes.push(result.className);
+            }
+          }
+        }
+        continue;
+      }
+      if (isArbitraryVariant(rawKey)) {
+        const normalizedKey = normalizeArbitraryVariant(rawKey);
+        const nestedPrefix2 = `${prefix}${normalizedKey}:`;
+        const nestedResult2 = transform(value, nestedPrefix2);
+        if (nestedResult2.className) {
+          classes.push(nestedResult2.className);
+        }
+        continue;
+      }
+      const variantName = getVariantPrefix(rawKey);
+      const nestedPrefix = `${prefix}${variantName}:`;
+      const nestedResult = transform(value, nestedPrefix);
+      if (nestedResult.className) {
+        classes.push(nestedResult.className);
+      }
+      continue;
+    }
+    if (SNAP_DIRECT_MAP[rawKey] && typeof value === "string") {
+      const mapped = SNAP_DIRECT_MAP[rawKey][value];
+      if (mapped) {
+        classes.push(`${prefix}${mapped}`);
+        continue;
+      }
+    }
+    if (typeof value === "string" && KNOWN_VARIANTS.has(rawKey)) {
+      const variantName = getVariantPrefix(rawKey);
+      classes.push(`${prefix}${variantName}:${value}`);
+      continue;
+    }
+    if (rawKey.startsWith("--")) {
+      classes.push(`${prefix}[${rawKey}:${value}]`);
+      continue;
+    }
+    if (rawKey === "container") {
+      if (value === true) {
+        classes.push(`${prefix}container`);
+      } else if (typeof value === "string") {
+        classes.push(`${prefix}@container/${value}`);
+      }
+      continue;
+    }
+    let key = rawKey;
+    if (PROPERTY_MAP[key]) {
+      key = PROPERTY_MAP[key];
+    } else {
+      key = key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+    }
+    let className = prefix;
+    if (rawKey === "willChange" && typeof value === "string") {
+      if (value === "scroll") {
+        classes.push(`${prefix}will-change-scroll-position`);
+      } else if (value.startsWith("--")) {
+        classes.push(`${prefix}will-change-(${value})`);
+      } else {
+        classes.push(`${prefix}will-change-${value}`);
+      }
+      continue;
+    }
+    if (key === "display") {
+      if (typeof value === "string") {
+        if (value === "none") {
+          className += "hidden";
+        } else {
+          className += value;
+        }
+        classes.push(className);
+        continue;
+      }
+    }
+    if (key === "position") {
+      if (typeof value === "string") {
+        className += value;
+        classes.push(className);
+        continue;
+      }
+    }
+    if (key === "visibility") {
+      if (typeof value === "string") {
+        if (value === "hidden") {
+          className += "invisible";
+        } else {
+          className += value;
+        }
+        classes.push(className);
+        continue;
+      }
+    }
+    if (key === "isolation") {
+      if (typeof value === "string") {
+        if (value === "isolate") {
+          className += "isolate";
+        } else {
+          className += `isolation-${value}`;
+        }
+        classes.push(className);
+        continue;
+      }
+    }
+    if ((rawKey === "fromPos" || rawKey === "viaPos" || rawKey === "toPos") && typeof value === "number") {
+      const gradPrefix = rawKey.replace("Pos", "");
+      classes.push(`${prefix}${gradPrefix}-${value}%`);
+      continue;
+    }
+    if (typeof value === "string") {
+      if (rawKey === "decoration") {
+        if (["underline", "overline", "line-through", "no-underline", "none"].includes(value)) {
+          className += value === "none" ? "no-underline" : value;
+          classes.push(className);
+          continue;
+        }
+      }
+      if (rawKey === "textTransform") {
+        if (["uppercase", "lowercase", "capitalize", "normal-case"].includes(value)) {
+          className += value;
+          classes.push(className);
+          continue;
+        }
+      }
+      if (rawKey === "fontVariant") {
+        const FONT_VARIANT_CLASSES = /* @__PURE__ */ new Set([
+          "normal-nums",
+          "ordinal",
+          "slashed-zero",
+          "lining-nums",
+          "oldstyle-nums",
+          "proportional-nums",
+          "tabular-nums",
+          "diagonal-fractions",
+          "stacked-fractions"
+        ]);
+        if (FONT_VARIANT_CLASSES.has(value)) {
+          className += value;
+          classes.push(className);
+          continue;
+        }
+      }
+      if (rawKey === "textWrap") {
+        className += `text-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "break") {
+        const wbMap = {
+          "normal": "break-normal",
+          "all": "break-all",
+          "keep": "break-keep",
+          "break-normal": "break-normal",
+          "break-all": "break-all",
+          "break-keep": "break-keep"
+        };
+        className += wbMap[value] || `break-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "wrap") {
+        const owMap = {
+          "normal": "wrap-normal",
+          "break-word": "wrap-break-word",
+          "anywhere": "wrap-anywhere",
+          "wrap-normal": "wrap-normal",
+          "wrap-break-word": "wrap-break-word",
+          "wrap-anywhere": "wrap-anywhere"
+        };
+        className += owMap[value] || `wrap-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "textOverflow") {
+        if (value === "ellipsis") {
+          classes.push(`${prefix}truncate`);
+        } else {
+          classes.push(`${prefix}text-${value}`);
+        }
+        continue;
+      }
+      if (rawKey === "lineClamp") {
+        const sValue = String(value);
+        if (sValue.startsWith("--")) {
+          className += `line-clamp-(${sValue})`;
+        } else {
+          const numVal = Number(sValue);
+          if (!isNaN(numVal) && Number.isInteger(numVal)) {
+            className += `line-clamp-${sValue}`;
+          } else {
+            className += `line-clamp-[${sValue}]`;
+          }
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "list" || rawKey === "listStyle") {
+        const sValue = String(value);
+        if (sValue.startsWith("--")) {
+          className += `list-(${sValue})`;
+        } else if (LIST_STYLE_STANDARD.has(sValue)) {
+          className += `list-${sValue}`;
+        } else {
+          className += `list-[${sValue}]`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "listPos") {
+        className += `list-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "divideStyle") {
+        className += `divide-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "decorationStyle" || rawKey === "textDecorationStyle") {
+        className += `decoration-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "decorationColor" || rawKey === "textDecorationColor") {
+        className += `decoration-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "decorationThickness" || rawKey === "textDecorationThickness") {
+        if (needsArbitraryBrackets(value)) {
+          className += `decoration-[${value}]`;
+        } else if (value.startsWith("--")) {
+          className += `decoration-(${value})`;
+        } else {
+          className += `decoration-${value}`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "fontStretch") {
+        const sValue = String(value);
+        if (FONT_STRETCH_KEYWORDS.has(sValue)) {
+          className += `font-${sValue}`;
+        } else if (sValue.startsWith("--")) {
+          className += `font-stretch-(${sValue})`;
+        } else if (/^\d+%$/.test(sValue)) {
+          className += `font-stretch-${sValue}`;
+        } else {
+          className += `font-stretch-[${sValue}]`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "maxW" && value === "container") {
+        classes.push("container");
+        continue;
+      }
+      if (rawKey === "shadowColor") {
+        if (String(value).startsWith("--")) {
+          classes.push(`shadow-(color:${value})`);
+        } else {
+          classes.push(`shadow-${value}`);
+        }
+        continue;
+      }
+      if (rawKey === "brightness" || rawKey === "contrast" || rawKey === "saturate" || rawKey === "scale" || rawKey === "backdropBrightness" || rawKey === "backdropContrast" || rawKey === "backdropSaturate") {
+        const prop = rawKey.startsWith("backdrop") ? `backdrop-${rawKey.slice(8).toLowerCase()}` : rawKey;
+        const sValue = String(value);
+        if (sValue.startsWith("--")) {
+          classes.push(`${prop}-(${sValue})`);
+        } else {
+          classes.push(`${prop}-[${sValue}]`);
+        }
+        continue;
+      }
+      if (rawKey === "textShadow") {
+        if (value === "none") {
+          className += "text-shadow-none";
+        } else if (value === "") {
+          className += "text-shadow";
+        } else if (needsArbitraryBrackets(value)) {
+          className += `text-shadow-[${normalizeArbitraryValue(value)}]`;
+        } else {
+          className += `text-shadow-${value}`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "textShadowColor") {
+        className += `text-shadow-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "fromPos" || rawKey === "viaPos" || rawKey === "toPos") {
+        const gradPrefix = rawKey.replace("Pos", "");
+        const sValue = String(value);
+        if (value.startsWith("--")) {
+          classes.push(`${gradPrefix}-(${value})`);
+        } else if (/^\d+%$/.test(sValue)) {
+          classes.push(`${gradPrefix}-${sValue}`);
+        } else {
+          classes.push(`${gradPrefix}-[${sValue}]`);
+        }
+        continue;
+      }
+      if (rawKey === "bgImg") {
+        const v = String(value).trim();
+        if (v === "none") {
+          classes.push("bg-none");
+          continue;
+        }
+        const vNorm = v.startsWith("-") ? v.slice(1) : v;
+        if (vNorm.startsWith("linear-") || vNorm.startsWith("radial") || vNorm.startsWith("conic") || vNorm.startsWith("gradient-to-")) {
+          const vMapped = vNorm.startsWith("gradient-to-") ? vNorm.replace("gradient-to-", "linear-to-") : vNorm;
+          if (v.startsWith("-")) {
+            classes.push(`-bg-${vMapped}`);
+          } else {
+            classes.push(`bg-${vMapped}`);
+          }
+          continue;
+        }
+        if (v.startsWith("--")) {
+          classes.push(`bg-(image:${v})`);
+          continue;
+        }
+        if (v.startsWith("url(")) {
+          classes.push(`bg-[${v}]`);
+          continue;
+        }
+        classes.push(`bg-[url(${v})]`);
+        continue;
+      }
+      if (rawKey === "bgPos") {
+        const sVal = String(value);
+        if (sVal.startsWith("--")) {
+          classes.push(`bg-(${sVal})`);
+        } else if (sVal.includes("_") || needsArbitraryBrackets(sVal)) {
+          classes.push(`bg-[${normalizeArbitraryValue(sVal)}]`);
+        } else {
+          classes.push(`bg-${sVal}`);
+        }
+        continue;
+      }
+      if (rawKey === "maskPos") {
+        className += `mask-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "maskRepeat") {
+        if (value === "repeat") {
+          className += "mask-repeat";
+        } else if (value === "no-repeat") {
+          className += "mask-no-repeat";
+        } else {
+          className += `mask-${value}`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "maskSize") {
+        className += `mask-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "maskShape") {
+        className += `mask-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "maskComposite") {
+        className += `mask-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "maskMode") {
+        className += `mask-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "maskType") {
+        className += `mask-type-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "content") {
+        if (value.startsWith("--")) {
+          className += `content-(${value})`;
+        } else if (!["none", "empty"].includes(value)) {
+          className += `content-[${value}]`;
+        } else {
+          className += `content-${value}`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "borderTColor") {
+        className += `border-t-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "borderRColor") {
+        className += `border-r-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "borderBColor") {
+        className += `border-b-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "borderLColor") {
+        className += `border-l-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "borderXColor") {
+        className += `border-x-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "borderYColor") {
+        className += `border-y-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "transitionBehavior") {
+        className += `transition-${value}`;
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "dropShadowColor") {
+        if (value.startsWith("--")) {
+          className += `drop-shadow-(color:${value})`;
+        } else {
+          className += `drop-shadow-${value}`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "origin" || rawKey === "ease" || rawKey === "animate" || rawKey === "filter" || rawKey === "backdropFilter" || rawKey === "dropShadow") {
+        const sVal = String(value);
+        const prop = PROPERTY_MAP[rawKey] || rawKey;
+        if (needsArbitraryBrackets(sVal) || sVal.includes("(") || sVal.includes("_") || sVal.includes("%")) {
+          classes.push(`${prop}-[${normalizeArbitraryValue(sVal)}]`);
+          continue;
+        }
+      }
+      if (rawKey === "transformStyle") {
+        if (value === "preserve-3d" || value === "3d") {
+          className += "transform-3d";
+        } else {
+          className += `transform-${value}`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "perspective") {
+        const STANDARD_PERSPECTIVE = /* @__PURE__ */ new Set(["none", "normal", "dramatic", "midrange"]);
+        if (STANDARD_PERSPECTIVE.has(value)) {
+          className += `perspective-${value}`;
+        } else if (value.startsWith("--")) {
+          className += `perspective-(${value})`;
+        } else if (needsArbitraryBrackets(value)) {
+          className += `perspective-[${value}]`;
+        } else {
+          className += `perspective-${value}`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "perspectiveOrigin") {
+        const STANDARD_ORIGINS = /* @__PURE__ */ new Set(["center", "top", "right", "bottom", "left", "top-left", "top-right", "bottom-left", "bottom-right"]);
+        if (STANDARD_ORIGINS.has(value)) {
+          className += `perspective-origin-${value}`;
+        } else {
+          className += `perspective-origin-[${value}]`;
+        }
+        classes.push(className);
+        continue;
+      }
+      if (rawKey === "backface") {
+        className += `backface-${value}`;
+        classes.push(className);
+        continue;
+      }
+    }
+    if (process.env.NODE_ENV !== "production" && typeof window === "undefined") {
+      const isKnown = PROPERTY_MAP[rawKey] || BOOLEAN_SHORTHANDS.has(rawKey) || SNAP_DIRECT_MAP[rawKey] || NEEDS_ARBITRARY_PROPERTY.has(key) || rawKey === "fromPos" || rawKey === "viaPos" || rawKey === "toPos" || rawKey.startsWith("--") || rawKey.startsWith("[") || rawKey.startsWith("@") || // Variants that fell through (e.g. empty object)
+      KNOWN_VARIANTS.has(rawKey) || // Groups/Peers
+      rawKey === "group" || rawKey === "peer" || // Special variant objects
+      rawKey === "has" || rawKey === "not" || rawKey === "data" || rawKey === "aria" || rawKey === "supports" || rawKey === "min" || rawKey === "max";
+      if (!isKnown) {
+        const suggestion = SUGGESTION_MAP[rawKey];
+        if (suggestion) {
+          console.warn(
+            `[csszyx] Use the canonical key "${suggestion}" instead of "${rawKey}".`
+          );
+        } else {
+          console.warn(
+            `[csszyx] Unknown property "${rawKey}" in sz prop. This will be ignored. Check for typos.`
+          );
+        }
+      }
+    }
+    if (value === true) {
+      if (BOOLEAN_SHORTHANDS.has(rawKey)) {
+        const mappedClass = BOOLEAN_TO_CLASS[rawKey] || key;
+        className += mappedClass;
+      } else {
+        className += key;
+      }
+      classes.push(className);
+      continue;
+    }
+    if (typeof value === "number") {
+      if (value < 0 && NEGATIVE_ALLOWED.has(key)) {
+        className += `-${key}-${Math.abs(value)}`;
+      } else {
+        className += `${key}-${value}`;
+      }
+      classes.push(className);
+      continue;
+    }
+    if (typeof value === "string") {
+      const { value: cleanValue, important } = handleImportant(value);
+      let finalValue = cleanValue;
+      if (NEEDS_ARBITRARY_PROPERTY.has(key)) {
+        const arbitraryProp = `[${key}:${finalValue}]`;
+        className += arbitraryProp;
+        if (important) {
+          className += "!";
+        }
+        classes.push(className);
+        continue;
+      }
+      const isAspectRatio = key === "aspect" && /^\d+\/\d+$/.test(finalValue);
+      if (finalValue.startsWith("--")) {
+        finalValue = `(${finalValue})`;
+      } else if (finalValue.startsWith("var(")) {
+        finalValue = `[${normalizeArbitraryValue(finalValue)}]`;
+      } else if (/^\d+\/\d+$/.test(finalValue)) {
+        if (!FRACTION_SUPPORTED_PROPS.has(rawKey)) {
+          finalValue = `[${finalValue}]`;
+        }
+      } else if (needsArbitraryBrackets(finalValue) || isAspectRatio || /^\d+\.\d+%$/.test(finalValue)) {
+        finalValue = `[${normalizeArbitraryValue(finalValue)}]`;
+      }
+      className += `${key}-${finalValue}`;
+      if (important) {
+        className += "!";
+      }
+      classes.push(className);
+    }
+  }
+  const finalClasses = classes.filter(Boolean);
+  if (mangleMap) {
+    const mangledClasses = finalClasses.map((cls) => mangleMap[cls] || cls);
+    return {
+      className: mangledClasses.join(" "),
+      attributes
+    };
+  }
+  return {
+    className: finalClasses.join(" "),
+    attributes
+  };
+}
+function isValidSzProp(szProp) {
+  return szProp !== null && szProp !== void 0 && typeof szProp === "object" && !Array.isArray(szProp);
+}
+function normalizeClassName(className) {
+  return className.split(/\s+/).filter(Boolean).join(" ");
+}
+
+// src/transform.ts
+function transformSourceCode(source) {
+  let usesRuntime = false;
+  let usesColorVar = false;
+  let transformed = false;
+  if (!source.includes("sz")) {
+    return { code: source, transformed: false, usesRuntime: false, usesColorVar: false };
+  }
+  try {
+    const result = babel.transformSync(source, {
+      filename: "file.tsx",
+      // Enable TS/JSX parsing
+      ast: true,
+      code: true,
+      configFile: false,
+      babelrc: false,
+      parserOpts: {
+        plugins: ["typescript", "jsx"]
+      },
+      plugins: [
+        function() {
+          return {
+            visitor: {
+              JSXAttribute(path) {
+                if (path.node.name.name !== "sz") {
+                  return;
+                }
+                const value = path.node.value;
+                if (t.isStringLiteral(value)) {
+                  path.node.name.name = "className";
+                  transformed = true;
+                  return;
+                }
+                if (t.isJSXExpressionContainer(value)) {
+                  const expression = value.expression;
+                  if (t.isObjectExpression(expression)) {
+                    const staticObject = evaluateStaticObject(expression);
+                    if (staticObject !== null) {
+                      const { className, attributes } = transform(staticObject);
+                      path.node.name.name = "className";
+                      path.node.value = t.stringLiteral(className);
+                      Object.entries(attributes).forEach(([key, val]) => {
+                        if (path.parentPath?.isJSXOpeningElement()) {
+                          path.parentPath.node.attributes.push(
+                            t.jsxAttribute(
+                              t.jsxIdentifier(key),
+                              t.stringLiteral(val)
+                            )
+                          );
+                        }
+                      });
+                      transformed = true;
+                      return;
+                    }
+                    const partial = evaluatePartialObject(expression);
+                    if (partial !== null && !partial.hasSpread && partial.dynamicProps.size > 0) {
+                      const staticClasses = [];
+                      if (Object.keys(partial.staticProps).length > 0) {
+                        const { className: sc } = transform(partial.staticProps);
+                        if (sc) {
+                          staticClasses.push(sc);
+                        }
+                      }
+                      const cssVarClasses = [];
+                      const styleProps = [];
+                      for (const [, info] of partial.dynamicProps) {
+                        if (!info.skipClass) {
+                          cssVarClasses.push(buildCSSVarClassName(info));
+                        }
+                        styleProps.push(
+                          t.objectProperty(
+                            t.stringLiteral(info.varName),
+                            generateStyleValueExpression(info)
+                          )
+                        );
+                      }
+                      const allClasses = [...staticClasses, ...partial.rawClasses, ...cssVarClasses].join(" ");
+                      path.node.name.name = "className";
+                      path.node.value = t.stringLiteral(allClasses);
+                      if (styleProps.length > 0 && path.parentPath?.isJSXOpeningElement()) {
+                        const styleAttr = t.jsxAttribute(
+                          t.jsxIdentifier("style"),
+                          t.jsxExpressionContainer(
+                            t.objectExpression(styleProps)
+                          )
+                        );
+                        path.parentPath.node.attributes.push(styleAttr);
+                      }
+                      if (partial.usesColorVar) {
+                        usesColorVar = true;
+                      }
+                      transformed = true;
+                      return;
+                    }
+                  }
+                  if (t.isIdentifier(expression) && !t.isJSXEmptyExpression(expression)) {
+                    const binding = path.scope.getBinding(expression.name);
+                    if (binding && binding.path.isVariableDeclarator()) {
+                      const init2 = binding.path.node.init;
+                      if (init2) {
+                        const resolved = tryStaticTransformNode(init2);
+                        if (resolved !== null) {
+                          path.node.name.name = "className";
+                          if (t.isStringLiteral(resolved)) {
+                            path.node.value = resolved;
+                          } else {
+                            value.expression = resolved;
+                          }
+                          transformed = true;
+                          return;
+                        }
+                      }
+                    }
+                  }
+                  if (t.isConditionalExpression(expression)) {
+                    const resolved = tryStaticTransformNode(expression);
+                    if (resolved !== null) {
+                      path.node.name.name = "className";
+                      if (t.isStringLiteral(resolved)) {
+                        path.node.value = resolved;
+                      } else {
+                        value.expression = resolved;
+                      }
+                      transformed = true;
+                      return;
+                    }
+                  }
+                  path.node.name.name = "className";
+                  const szCall = t.callExpression(
+                    t.identifier("_sz"),
+                    [expression]
+                  );
+                  value.expression = szCall;
+                  usesRuntime = true;
+                  transformed = true;
+                }
+              }
+            }
+          };
+        }
+      ]
+    });
+    return {
+      code: result?.code || source,
+      transformed,
+      usesRuntime,
+      usesColorVar
+    };
+  } catch (e) {
+    console.warn("[csszyx] AST transform failed, falling back to original code:", e);
+    return { code: source, transformed: false, usesRuntime: false, usesColorVar: false };
+  }
+}
+function tryStaticTransformNode(node) {
+  if (t.isObjectExpression(node)) {
+    const staticObj = evaluateStaticObject(node);
+    if (staticObj !== null) {
+      const { className } = transform(staticObj);
+      return t.stringLiteral(className);
+    }
+    return null;
+  }
+  if (t.isStringLiteral(node)) {
+    return node;
+  }
+  if (t.isConditionalExpression(node)) {
+    const consequent = tryStaticTransformNode(node.consequent);
+    const alternate = tryStaticTransformNode(node.alternate);
+    if (consequent !== null && alternate !== null) {
+      return t.conditionalExpression(node.test, consequent, alternate);
+    }
+    return null;
+  }
+  return null;
+}
+function evaluateStaticObject(node) {
+  const result = {};
+  for (const prop of node.properties) {
+    if (!t.isObjectProperty(prop)) {
+      return null;
+    }
+    if (prop.computed) {
+      return null;
+    }
+    let key;
+    if (t.isIdentifier(prop.key)) {
+      key = prop.key.name;
+    } else if (t.isStringLiteral(prop.key)) {
+      key = prop.key.value;
+    } else {
+      return null;
+    }
+    const value = prop.value;
+    if (t.isStringLiteral(value)) {
+      result[key] = value.value;
+    } else if (t.isNumericLiteral(value)) {
+      result[key] = value.value;
+    } else if (t.isBooleanLiteral(value)) {
+      result[key] = value.value;
+    } else if (t.isUnaryExpression(value) && value.operator === "-" && t.isNumericLiteral(value.argument)) {
+      result[key] = -value.argument.value;
+    } else if (t.isObjectExpression(value)) {
+      const nested = evaluateStaticObject(value);
+      if (nested === null) {
+        return null;
+      }
+      result[key] = nested;
+    } else {
+      return null;
+    }
+  }
+  return result;
+}
+function evaluatePartialObject(node, variantChain = "") {
+  const staticProps = {};
+  const dynamicProps = /* @__PURE__ */ new Map();
+  const rawClasses = [];
+  let usesColorVar = false;
+  for (const prop of node.properties) {
+    if (t.isSpreadElement(prop)) {
+      return null;
+    }
+    if (!t.isObjectProperty(prop)) {
+      return null;
+    }
+    if (prop.computed) {
+      return null;
+    }
+    let key;
+    if (t.isIdentifier(prop.key)) {
+      key = prop.key.name;
+    } else if (t.isStringLiteral(prop.key)) {
+      key = prop.key.value;
+    } else {
+      return null;
+    }
+    const value = prop.value;
+    if (t.isStringLiteral(value)) {
+      staticProps[key] = value.value;
+    } else if (t.isNumericLiteral(value)) {
+      staticProps[key] = value.value;
+    } else if (t.isBooleanLiteral(value)) {
+      staticProps[key] = value.value;
+    } else if (t.isUnaryExpression(value) && value.operator === "-" && t.isNumericLiteral(value.argument)) {
+      staticProps[key] = -value.argument.value;
+    } else if (t.isObjectExpression(value)) {
+      const nested = evaluateStaticObject(value);
+      if (nested !== null) {
+        staticProps[key] = nested;
+      } else {
+        const colorObjProps = /* @__PURE__ */ new Map();
+        for (const p of value.properties) {
+          if (t.isObjectProperty(p) && !p.computed && t.isIdentifier(p.key)) {
+            colorObjProps.set(p.key.name, p);
+          }
+        }
+        if (colorObjProps.has("color") && COLOR_PROPERTIES.has(key)) {
+          const colorProp = colorObjProps.get("color");
+          if (!colorProp) {
+            continue;
+          }
+          const opProp = colorObjProps.get("op");
+          const twPrefix = PROPERTY_MAP[key] || key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+          let colorStr = null;
+          if (t.isStringLiteral(colorProp.value)) {
+            colorStr = colorProp.value.value;
+          }
+          if (colorStr && opProp) {
+            const opVarName = getCSSVariableName(`${key}-op`, variantChain || void 0);
+            const uniqueKey = variantChain ? `${variantChain}-${key}-op` : `${key}-op`;
+            if (t.isStringLiteral(opProp.value) || t.isNumericLiteral(opProp.value)) {
+              const opVal = t.isStringLiteral(opProp.value) ? opProp.value.value : opProp.value.value;
+              staticProps[key] = { color: colorStr, op: opVal };
+            } else if (t.isExpression(opProp.value)) {
+              const variantPfx = variantChain ? `${variantChain}:` : "";
+              rawClasses.push(`${variantPfx}${twPrefix}-${colorStr}/[var(${opVarName})]`);
+              dynamicProps.set(uniqueKey, {
+                expression: opProp.value,
+                category: 3 /* UNITLESS */,
+                varName: opVarName,
+                twPrefix: `${twPrefix}-op`,
+                variantChain: variantChain || "",
+                skipClass: true
+              });
+            }
+          } else if (!colorStr && opProp) {
+            const varName = getCSSVariableName(key, variantChain || void 0);
+            const uniqueKey = variantChain ? `${variantChain}-${key}` : key;
+            usesColorVar = true;
+            dynamicProps.set(uniqueKey, {
+              expression: t.isExpression(colorProp.value) ? colorProp.value : t.stringLiteral(""),
+              category: 1 /* COLOR */,
+              varName,
+              twPrefix,
+              variantChain: variantChain || ""
+            });
+          } else if (colorStr && !opProp) {
+            staticProps[key] = colorStr;
+          }
+        } else {
+          const isVariant = KNOWN_VARIANTS.has(key) || KNOWN_VARIANTS.has(getVariantPrefix(key));
+          if (isVariant) {
+            const variantKey = variantChain ? `${variantChain}-${key}` : key;
+            const nestedResult = evaluatePartialObject(value, variantKey);
+            if (nestedResult === null) {
+              return null;
+            }
+            if (Object.keys(nestedResult.staticProps).length > 0) {
+              staticProps[key] = nestedResult.staticProps;
+            }
+            for (const [k, v] of nestedResult.dynamicProps) {
+              dynamicProps.set(k, v);
+            }
+            rawClasses.push(...nestedResult.rawClasses);
+            if (nestedResult.usesColorVar) {
+              usesColorVar = true;
+            }
+          } else {
+            return null;
+          }
+        }
+      }
+    } else if (t.isExpression(value)) {
+      const twPrefix = PROPERTY_MAP[key] || key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      const category = getPropertyCategory(key);
+      const varName = getCSSVariableName(key, variantChain || void 0);
+      const uniqueKey = variantChain ? `${variantChain}-${key}` : key;
+      if (COLOR_PROPERTIES.has(key)) {
+        usesColorVar = true;
+      }
+      dynamicProps.set(uniqueKey, {
+        expression: value,
+        category,
+        varName,
+        twPrefix,
+        variantChain: variantChain || ""
+      });
+    } else {
+      return null;
+    }
+  }
+  return { staticProps, dynamicProps, rawClasses, hasSpread: false, usesColorVar };
+}
+function generateStyleValueExpression(info) {
+  const { expression, category } = info;
+  switch (category) {
+    case 0 /* SPACING */:
+      return t.templateLiteral(
+        [
+          t.templateElement({ raw: "calc(", cooked: "calc(" }, false),
+          t.templateElement({ raw: " * var(--spacing))", cooked: " * var(--spacing))" }, true)
+        ],
+        [expression]
+      );
+    case 1 /* COLOR */:
+      return t.callExpression(
+        t.identifier("__szColorVar"),
+        [expression]
+      );
+    case 4 /* ANGLE */:
+      return t.templateLiteral(
+        [
+          t.templateElement({ raw: "", cooked: "" }, false),
+          t.templateElement({ raw: "deg", cooked: "deg" }, true)
+        ],
+        [expression]
+      );
+    case 5 /* DURATION */:
+      return t.templateLiteral(
+        [
+          t.templateElement({ raw: "", cooked: "" }, false),
+          t.templateElement({ raw: "ms", cooked: "ms" }, true)
+        ],
+        [expression]
+      );
+    case 3 /* UNITLESS */:
+    case 7 /* PASSTHROUGH */:
+    case 2 /* FRACTION */:
+    case 6 /* ARBITRARY */:
+    default:
+      return t.templateLiteral(
+        [
+          t.templateElement({ raw: "", cooked: "" }, false),
+          t.templateElement({ raw: "", cooked: "" }, true)
+        ],
+        [expression]
+      );
+  }
+}
+function buildCSSVarClassName(info) {
+  const { twPrefix, varName, variantChain } = info;
+  const variantPrefix = variantChain ? `${getVariantPrefix(variantChain)}:` : "";
+  return `${variantPrefix}${twPrefix}-[var(${varName})]`;
+}
+
+// src/compiler.ts
+var CsszyxCompiler = class _CsszyxCompiler {
+  /**
+   * Private constructor to enforce singleton pattern.
+   */
+  constructor() {
+    this.wasmLoaded = false;
+  }
+  /**
+   * Gets the singleton instance of the compiler.
+   *
+   * @returns {CsszyxCompiler} The compiler instance.
+   */
+  static getInstance() {
+    if (!_CsszyxCompiler.instance) {
+      _CsszyxCompiler.instance = new _CsszyxCompiler();
+    }
+    return _CsszyxCompiler.instance;
+  }
+  /**
+   * Initializes the WASM core.
+   *
+   * @returns {Promise<void>} Resolves when WASM is ready.
+   */
+  async init() {
+    if (this.wasmLoaded) {
+      return;
+    }
+    try {
+      (0, import_core.init)();
+      this.wasmLoaded = true;
+      console.info(`[csszyx] WASM Core initialized (v${(0, import_core.version)()})`);
+    } catch (error) {
+      console.warn(
+        "[csszyx] Failed to initialize WASM core, falling back to JavaScript transformer",
+        error
+      );
+      this.wasmLoaded = false;
+    }
+  }
+  /**
+   * Transforms an sz object into Tailwind classes.
+   *
+   * @param {SzObject} sz - The object to transform.
+   * @returns {string} The transformed class string.
+   */
+  transform(sz) {
+    if (this.wasmLoaded) {
+      try {
+        return (0, import_core.transform_sz)(sz);
+      } catch (error) {
+        console.warn(
+          "[csszyx] WASM transformation failed, using JS fallback",
+          error
+        );
+        return transform(sz).className;
+      }
+    }
+    return transform(sz).className;
+  }
+  /**
+   * Checks if the WASM core is currently active.
+   *
+   * @returns {boolean} True if WASM is loaded.
+   */
+  isWasmActive() {
+    return this.wasmLoaded;
+  }
+  /**
+   * Generates a recovery token using WASM or JS fallback.
+   *
+   * @param {object} metadata - Token metadata
+   * @param metadata.component - Component name
+   * @param metadata.filePath - File path source
+   * @param metadata.line - Line number
+   * @param metadata.column - Column number
+   * @param metadata.mode - Build mode (dev/prod)
+   * @param metadata.buildId - Unique build identifier
+   * @returns {string} The generated token
+   */
+  generateRecoveryToken(metadata) {
+    if (this.wasmLoaded) {
+      try {
+        const { generate_token } = require("@csszyx/core");
+        return generate_token(
+          metadata.component,
+          metadata.filePath,
+          metadata.line,
+          metadata.column,
+          metadata.mode,
+          metadata.buildId
+        );
+      } catch (error) {
+        console.warn("[csszyx] WASM token generation failed", error);
+      }
+    }
+    const str = `${metadata.component}:${metadata.filePath}:${metadata.line}:${metadata.column}:${metadata.mode}:${metadata.buildId}`;
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      hash = (hash << 5) - hash + str.charCodeAt(i) | 0;
+    }
+    return Math.abs(hash).toString(16).padStart(12, "0").slice(0, 12);
+  }
+};
+
+// src/recovery.ts
+function isValidRecoveryMode(value) {
+  return value === "csr" || value === "dev-only";
+}
+function generateRecoveryToken(metadata) {
+  return CsszyxCompiler.getInstance().generateRecoveryToken(metadata);
+}
+function createRecoveryToken(metadata, buildId) {
+  const fullMetadata = {
+    ...metadata,
+    buildId
+  };
+  const token = generateRecoveryToken(fullMetadata);
+  return {
+    token,
+    metadata: fullMetadata
+  };
+}
+function validateSzRecover(value, componentName) {
+  if (!isValidRecoveryMode(value)) {
+    return {
+      valid: false,
+      error: `szRecover in ${componentName} must be static literal "csr" or "dev-only", got: ${JSON.stringify(value)}`
+    };
+  }
+  return { valid: true };
+}
+function injectRecoveryToken(attributes, token) {
+  return {
+    ...attributes,
+    "data-sz-recovery-token": token
+  };
+}
+
+// src/manifest.ts
+var import_crypto = require("crypto");
+var ManifestBuilder = class {
+  /**
+   * Creates a new manifest builder.
+   *
+   * @param {string} buildId - Build ID (git hash or timestamp)
+   *
+   * @example
+   * ```typescript
+   * const builder = new ManifestBuilder('abc123');
+   * ```
+   */
+  constructor(buildId) {
+    this.tokens = /* @__PURE__ */ new Map();
+    this.buildId = buildId;
+  }
+  /**
+   * Adds a token to the manifest.
+   *
+   * @param {string} token - The recovery token
+   * @param {TokenMetadata} metadata - Token metadata
+   *
+   * @example
+   * ```typescript
+   * builder.addToken('a94f1c2e8b3d', {
+   *     mode: 'csr',
+   *     component: 'Button',
+   *     filePath: '/app/Button.tsx',
+   *     line: 10,
+   *     column: 5,
+   *     buildId: 'abc123'
+   * });
+   * ```
+   */
+  addToken(token, metadata) {
+    const relativePath = this.toRelativePath(metadata.filePath);
+    this.tokens.set(token, {
+      mode: metadata.mode,
+      component: metadata.component,
+      path: relativePath
+    });
+  }
+  /**
+   * Converts absolute path to relative path.
+   *
+   * @param {string} absolutePath - Absolute file path
+   * @returns {string} Relative path
+   */
+  toRelativePath(absolutePath) {
+    if (absolutePath.startsWith("/")) {
+      const parts = absolutePath.split("/");
+      const rootIndex = parts.findIndex(
+        (p) => p === "src" || p === "app" || p === "components"
+      );
+      if (rootIndex > 0) {
+        return parts.slice(rootIndex).join("/");
+      }
+    }
+    return absolutePath;
+  }
+  /**
+   * Computes checksum of the tokens object.
+   *
+   * @param {Record<string, TokenData>} tokens - Tokens object
+   * @returns {string} SHA-256 checksum
+   */
+  computeChecksum(tokens) {
+    const sortedKeys = Object.keys(tokens).sort();
+    const sortedTokens = {};
+    for (const key of sortedKeys) {
+      sortedTokens[key] = tokens[key];
+    }
+    const content = JSON.stringify(sortedTokens);
+    return (0, import_crypto.createHash)("sha256").update(content).digest("hex");
+  }
+  /**
+   * Builds the final recovery manifest.
+   *
+   * @returns {RecoveryManifest} The complete recovery manifest
+   *
+   * @example
+   * ```typescript
+   * const manifest = builder.build();
+   * // Returns: { buildId: 'abc123', checksum: '...', tokens: {...} }
+   * ```
+   */
+  build() {
+    const tokensObject = {};
+    for (const [token, data] of this.tokens.entries()) {
+      tokensObject[token] = data;
+    }
+    const checksum = this.computeChecksum(tokensObject);
+    return {
+      buildId: this.buildId,
+      checksum,
+      tokens: tokensObject
+    };
+  }
+  /**
+   * Gets the number of tokens in the manifest.
+   *
+   * @returns {number} Token count
+   */
+  size() {
+    return this.tokens.size;
+  }
+  /**
+   * Checks if a token exists in the manifest.
+   *
+   * @param {string} token - Token to check
+   * @returns {boolean} True if token exists
+   */
+  hasToken(token) {
+    return this.tokens.has(token);
+  }
+  /**
+   * Clears all tokens from the manifest.
+   */
+  clear() {
+    this.tokens.clear();
+  }
+};
+function serializeManifest(manifest, pretty = false) {
+  return JSON.stringify(manifest, null, pretty ? 2 : 0);
+}
+function parseManifest(json) {
+  const parsed = JSON.parse(json);
+  if (!parsed.buildId || !parsed.checksum || !parsed.tokens) {
+    throw new Error("Invalid recovery manifest format");
+  }
+  return parsed;
+}
+function validateManifest(manifest) {
+  if (!manifest || typeof manifest !== "object") {
+    return { valid: false, error: "Manifest must be an object" };
+  }
+  const m = manifest;
+  if (typeof m.buildId !== "string") {
+    return { valid: false, error: "buildId must be a string" };
+  }
+  if (typeof m.checksum !== "string") {
+    return { valid: false, error: "checksum must be a string" };
+  }
+  if (!m.tokens || typeof m.tokens !== "object") {
+    return { valid: false, error: "tokens must be an object" };
+  }
+  return { valid: true };
+}
+
+// src/hoisting.ts
+var t2 = __toESM(require("@babel/types"), 1);
+function findLCA(nodeA, nodeB, parentMap) {
+  const ancestorsA = /* @__PURE__ */ new Set();
+  let current = nodeA;
+  while (current) {
+    ancestorsA.add(current);
+    current = parentMap.get(current);
+  }
+  current = nodeB;
+  while (current) {
+    if (ancestorsA.has(current) && t2.isJSXOpeningElement(current) && current !== nodeA && current !== nodeB) {
+      return current;
+    }
+    current = parentMap.get(current);
+  }
+  return null;
+}
+function isFragment(node) {
+  if (t2.isJSXIdentifier(node.name)) {
+    return node.name.name === "Fragment";
+  }
+  if (t2.isJSXMemberExpression(node.name)) {
+    return t2.isJSXIdentifier(node.name.property) && node.name.property.name === "Fragment";
+  }
+  return false;
+}
+function removeStyleVar(element, varName) {
+  for (const attr of element.attributes) {
+    if (!t2.isJSXAttribute(attr)) {
+      continue;
+    }
+    if (!t2.isJSXIdentifier(attr.name) || attr.name.name !== "style") {
+      continue;
+    }
+    if (!t2.isJSXExpressionContainer(attr.value)) {
+      continue;
+    }
+    const styleObj = attr.value.expression;
+    if (!t2.isObjectExpression(styleObj)) {
+      continue;
+    }
+    styleObj.properties = styleObj.properties.filter((prop) => {
+      if (!t2.isObjectProperty(prop)) {
+        return true;
+      }
+      if (t2.isStringLiteral(prop.key)) {
+        return prop.key.value !== varName;
+      }
+      return true;
+    });
+    if (styleObj.properties.length === 0) {
+      const idx = element.attributes.indexOf(attr);
+      if (idx !== -1) {
+        element.attributes.splice(idx, 1);
+      }
+    }
+    break;
+  }
+}
+function addStyleVar(element, varName, valueExpr) {
+  for (const attr of element.attributes) {
+    if (!t2.isJSXAttribute(attr)) {
+      continue;
+    }
+    if (!t2.isJSXIdentifier(attr.name) || attr.name.name !== "style") {
+      continue;
+    }
+    if (!t2.isJSXExpressionContainer(attr.value)) {
+      continue;
+    }
+    const styleObj = attr.value.expression;
+    if (!t2.isObjectExpression(styleObj)) {
+      continue;
+    }
+    const existing = styleObj.properties.find(
+      (prop) => t2.isObjectProperty(prop) && t2.isStringLiteral(prop.key) && prop.key.value === varName
+    );
+    if (!existing) {
+      styleObj.properties.push(
+        t2.objectProperty(t2.stringLiteral(varName), valueExpr)
+      );
+    }
+    return;
+  }
+  element.attributes.push(
+    t2.jsxAttribute(
+      t2.jsxIdentifier("style"),
+      t2.jsxExpressionContainer(
+        t2.objectExpression([
+          t2.objectProperty(t2.stringLiteral(varName), valueExpr)
+        ])
+      )
+    )
+  );
+}
+function hoistCSSVariables(usages, parentMap) {
+  if (usages.length < 2) {
+    return;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    if (usage.serializedValue === null) {
+      continue;
+    }
+    const groupKey = `${usage.varName}::${usage.serializedValue}`;
+    const group = groups.get(groupKey) || [];
+    group.push(usage);
+    groups.set(groupKey, group);
+  }
+  for (const [, group] of groups) {
+    if (group.length < 2) {
+      continue;
+    }
+    let lca = group[0].element;
+    for (let i = 1; i < group.length; i++) {
+      const newLca = findLCA(lca, group[i].element, parentMap);
+      if (newLca === null || isFragment(newLca)) {
+        lca = null;
+        break;
+      }
+      lca = newLca;
+    }
+    if (!lca) {
+      continue;
+    }
+    addStyleVar(lca, group[0].varName, group[0].valueExpr);
+    for (const usage of group) {
+      removeStyleVar(usage.element, usage.varName);
+    }
+  }
+}
+function buildParentMap(ast) {
+  const map = /* @__PURE__ */ new Map();
+  function traverse(node, parent) {
+    if (parent) {
+      map.set(node, parent);
+    }
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (value && typeof value === "object") {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            if (item && typeof item === "object" && "type" in item) {
+              traverse(item, node);
+            }
+          }
+        } else if ("type" in value) {
+          traverse(value, node);
+        }
+      }
+    }
+  }
+  traverse(ast);
+  return map;
+}
+
+// src/index.ts
+var VERSION = "0.0.0";
+var DEFAULT_COMPILER_OPTIONS = {
+  buildId: Date.now().toString(),
+  development: process.env.NODE_ENV !== "production",
+  autoInjectRecovery: false,
+  strictMode: false
+};
+function mergeOptions(options = {}) {
+  return {
+    ...DEFAULT_COMPILER_OPTIONS,
+    ...options
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COLOR_PROPERTIES,
+  CsszyxCompiler,
+  DEFAULT_COMPILER_OPTIONS,
+  ManifestBuilder,
+  PROPERTY_CATEGORY_MAP,
+  PropertyCategory,
+  VERSION,
+  buildParentMap,
+  createRecoveryToken,
+  generateRecoveryToken,
+  getCSSVariableName,
+  getPropertyCategory,
+  hoistCSSVariables,
+  injectRecoveryToken,
+  isValidRecoveryMode,
+  isValidSzProp,
+  mergeOptions,
+  normalizeClassName,
+  parseManifest,
+  serializeManifest,
+  transform,
+  transformSourceCode,
+  validateManifest,
+  validateSzRecover
+});