typewritingclass 0.3.2 → 0.3.4

package/dist/index.js

@@ -47,33 +47,55 @@ import {
   zinc
 } from "./chunk-XEHQXLQR.js";
 import {
+  _2xl,
+  _3xl,
+  _4xl,
+  _5xl,
+  _6xl,
+  _7xl,
+  _8xl,
+  _9xl,
+  base,
+  black_,
+  bold,
+  extrabold,
+  extralight,
   fontFamilies,
   letterSpacings,
-  lineHeights
+  lg,
+  light,
+  lineHeights,
+  medium,
+  normal,
+  semibold,
+  sm,
+  thin,
+  xl,
+  xs
 } from "./chunk-LARVCDO3.js";
 import {
   maxWidths
 } from "./chunk-U2LSMKZS.js";
 import {
   DEFAULT as DEFAULT2,
-  _2xl as _2xl2,
+  _2xl as _2xl3,
   inner,
-  lg as lg2,
+  lg as lg3,
   md as md2,
   none as none2,
-  sm as sm2,
-  xl as xl2
+  sm as sm3,
+  xl as xl3
 } from "./chunk-IL3LVS32.js";
 import {
   DEFAULT,
-  _2xl,
-  _3xl,
+  _2xl as _2xl2,
+  _3xl as _3xl2,
   full,
-  lg,
+  lg as lg2,
   md,
   none,
-  sm,
-  xl
+  sm as sm2,
+  xl as xl2
 } from "./chunk-YHDPOIUZ.js";
 import {
   createTheme
@@ -129,7 +151,7 @@ function cx(...args) {
 function _cxCore(args) {
   return args.map((arg) => {
     if (typeof arg === "string") return arg;
-    if (typeof arg === "function") return String(arg);
+    if (typeof arg === "function" && arg._tag !== "StyleRule") return String(arg);
     const layerNum = arg._layer ?? nextLayer();
     const className = generateHash(arg, layerNum);
     register(className, arg, layerNum);
@@ -230,6 +252,340 @@ function isDynamic(v) {
   return typeof v === "object" && v !== null && "_tag" in v && v._tag === "DynamicValue";
 }
 
+// src/tokens.ts
+var colorScaleNames = [
+  "slate",
+  "gray",
+  "zinc",
+  "neutral",
+  "stone",
+  "red",
+  "orange",
+  "amber",
+  "yellow",
+  "lime",
+  "green",
+  "emerald",
+  "teal",
+  "cyan",
+  "sky",
+  "blue",
+  "indigo",
+  "violet",
+  "purple",
+  "fuchsia",
+  "pink",
+  "rose"
+];
+var shades = ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"];
+var colorTokens = {};
+for (const name of colorScaleNames) {
+  for (const shade of shades) {
+    colorTokens[`${name}${shade}`] = `${name}-${shade}`;
+  }
+}
+colorTokens["white"] = "white";
+colorTokens["black"] = "black";
+colorTokens["transparent"] = "transparent";
+colorTokens["current"] = "current";
+var radiusTokens = {
+  sm: "sm",
+  md: "md",
+  lg: "lg",
+  xl: "xl",
+  _2xl: "2xl",
+  _3xl: "3xl",
+  full: "full",
+  none: "none"
+};
+var shadowTokens = {
+  sm: "sm",
+  md: "md",
+  lg: "lg",
+  xl: "xl",
+  _2xl: "2xl",
+  inner: "inner",
+  none: "none"
+};
+var textSizeTokens = {
+  xs,
+  sm,
+  base,
+  lg,
+  xl,
+  _2xl,
+  _3xl,
+  _4xl,
+  _5xl,
+  _6xl,
+  _7xl,
+  _8xl,
+  _9xl
+};
+var fontWeightTokens = {
+  thin,
+  extralight,
+  light,
+  normal,
+  medium,
+  semibold,
+  bold,
+  extrabold,
+  black: black_
+};
+var trackingTokens = {
+  tighter: "tighter",
+  tight: "tight",
+  normal: "normal",
+  wide: "wide",
+  wider: "wider",
+  widest: "widest"
+};
+var leadingTokens = {
+  none: "none",
+  tight: "tight",
+  snug: "snug",
+  normal: "normal",
+  relaxed: "relaxed",
+  loose: "loose",
+  _3: "3",
+  _4: "4",
+  _5: "5",
+  _6: "6",
+  _7: "7",
+  _8: "8",
+  _9: "9",
+  _10: "10"
+};
+var fontFamilyTokens = {
+  sans: "sans",
+  serif: "serif",
+  mono: "mono"
+};
+var alignItemsTokens = {
+  center: "center",
+  start: "flex-start",
+  end: "flex-end",
+  baseline: "baseline",
+  stretch: "stretch"
+};
+var justifyTokens = {
+  center: "center",
+  start: "flex-start",
+  end: "flex-end",
+  between: "space-between",
+  around: "space-around",
+  evenly: "space-evenly",
+  stretch: "stretch"
+};
+var displayTokens = {
+  block: "block",
+  inline: "inline",
+  inlineBlock: "inline-block",
+  flex: "flex",
+  inlineFlex: "inline-flex",
+  grid: "grid",
+  inlineGrid: "inline-grid",
+  none: "none",
+  contents: "contents",
+  table: "table",
+  flowRoot: "flow-root"
+};
+var overflowTokens = {
+  auto: "auto",
+  hidden: "hidden",
+  visible: "visible",
+  scroll: "scroll",
+  clip: "clip"
+};
+var cursorTokens = {
+  auto: "auto",
+  default: "default",
+  pointer: "pointer",
+  wait: "wait",
+  text: "text",
+  move: "move",
+  help: "help",
+  notAllowed: "not-allowed",
+  none: "none",
+  progress: "progress",
+  cell: "cell",
+  crosshair: "crosshair",
+  grab: "grab",
+  grabbing: "grabbing",
+  colResize: "col-resize",
+  rowResize: "row-resize",
+  noDrop: "no-drop",
+  zoomIn: "zoom-in",
+  zoomOut: "zoom-out"
+};
+var textAlignTokens = {
+  left: "left",
+  center: "center",
+  right: "right",
+  justify: "justify",
+  start: "start",
+  end: "end"
+};
+var objectFitTokens = {
+  contain: "contain",
+  cover: "cover",
+  fill: "fill",
+  none: "none",
+  scaleDown: "scale-down"
+};
+var selfTokens = {
+  auto: "auto",
+  start: "flex-start",
+  end: "flex-end",
+  center: "center",
+  stretch: "stretch",
+  baseline: "baseline"
+};
+var textWrapTokens = {
+  wrap: "wrap",
+  nowrap: "nowrap",
+  balance: "balance",
+  pretty: "pretty"
+};
+var textOverflowTokens = {
+  ellipsis: "ellipsis",
+  clip: "clip"
+};
+var textTransformTokens = {
+  uppercase: "uppercase",
+  lowercase: "lowercase",
+  capitalize: "capitalize",
+  none: "none"
+};
+var UTIL_TOKENS = {
+  // Color utilities
+  bg: { tokens: colorTokens, supportsOpacity: true },
+  textColor: { tokens: colorTokens, supportsOpacity: true },
+  borderColor: { tokens: colorTokens, supportsOpacity: true },
+  shadowColor: { tokens: colorTokens, supportsOpacity: true },
+  ringColor: { tokens: colorTokens, supportsOpacity: true },
+  outlineColor: { tokens: colorTokens, supportsOpacity: true },
+  accentColor: { tokens: colorTokens, supportsOpacity: true },
+  caretColor: { tokens: colorTokens, supportsOpacity: true },
+  divideColor: { tokens: colorTokens, supportsOpacity: true },
+  textDecorationColor: { tokens: colorTokens, supportsOpacity: true },
+  gradientFrom: { tokens: colorTokens },
+  gradientVia: { tokens: colorTokens },
+  gradientTo: { tokens: colorTokens },
+  // Radius utilities
+  rounded: { tokens: radiusTokens },
+  roundedT: { tokens: radiusTokens },
+  roundedB: { tokens: radiusTokens },
+  roundedL: { tokens: radiusTokens },
+  roundedR: { tokens: radiusTokens },
+  roundedTL: { tokens: radiusTokens },
+  roundedTR: { tokens: radiusTokens },
+  roundedBR: { tokens: radiusTokens },
+  roundedBL: { tokens: radiusTokens },
+  roundedSS: { tokens: radiusTokens },
+  roundedSE: { tokens: radiusTokens },
+  roundedEE: { tokens: radiusTokens },
+  roundedES: { tokens: radiusTokens },
+  // Shadow
+  shadow: { tokens: shadowTokens },
+  // Typography
+  text: { tokens: textSizeTokens },
+  font: { tokens: fontWeightTokens },
+  tracking: { tokens: trackingTokens },
+  leading: { tokens: leadingTokens },
+  fontFamily: { tokens: fontFamilyTokens },
+  // Layout enums
+  items: { tokens: alignItemsTokens },
+  justify: { tokens: justifyTokens },
+  display: { tokens: displayTokens },
+  overflow: { tokens: overflowTokens },
+  overflowX: { tokens: overflowTokens },
+  overflowY: { tokens: overflowTokens },
+  cursor: { tokens: cursorTokens },
+  textAlign: { tokens: textAlignTokens },
+  objectFit: { tokens: objectFitTokens },
+  self: { tokens: selfTokens },
+  textWrap: { tokens: textWrapTokens },
+  textOverflow: { tokens: textOverflowTokens },
+  textTransform: { tokens: textTransformTokens }
+};
+
+// src/utilities/colors.ts
+var colorMap = {};
+var colorScales = {
+  slate,
+  gray,
+  zinc,
+  neutral,
+  stone,
+  red,
+  orange,
+  amber,
+  yellow,
+  lime,
+  green,
+  emerald,
+  teal,
+  cyan,
+  sky,
+  blue,
+  indigo,
+  violet,
+  purple,
+  fuchsia,
+  pink,
+  rose
+};
+for (const [name, scale2] of Object.entries(colorScales)) {
+  for (const [shade, hex] of Object.entries(scale2)) {
+    colorMap[`${name}-${shade}`] = hex;
+  }
+}
+colorMap["white"] = white;
+colorMap["black"] = black;
+colorMap["transparent"] = "transparent";
+colorMap["current"] = "currentColor";
+function resolveColor(value) {
+  return colorMap[value] ?? value;
+}
+function resolveColorWithOpacity(colorKey, opacity2) {
+  const hex = resolveColor(colorKey);
+  if (!/^#[0-9a-fA-F]{6}$/.test(hex)) return hex;
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  const alpha = opacity2 > 1 ? opacity2 / 100 : opacity2;
+  return `rgb(${r} ${g} ${b} / ${alpha})`;
+}
+function bg(color) {
+  if (isDynamic(color)) {
+    return createDynamicRule(
+      { "background-color": `var(${color.__id})` },
+      { [color.__id]: String(color.__value) }
+    );
+  }
+  return createRule({ "background-color": resolveColor(color) });
+}
+function textColor(color) {
+  if (isDynamic(color)) {
+    return createDynamicRule(
+      { color: `var(${color.__id})` },
+      { [color.__id]: String(color.__value) }
+    );
+  }
+  return createRule({ color: resolveColor(color) });
+}
+function borderColor(color) {
+  if (isDynamic(color)) {
+    return createDynamicRule(
+      { "border-color": `var(${color.__id})` },
+      { [color.__id]: String(color.__value) }
+    );
+  }
+  return createRule({ "border-color": resolveColor(color) });
+}
+
 // src/utilities/spacing.ts
 function sp(value) {
   if (isDynamic(value)) return value;
@@ -336,72 +692,6 @@ function spaceYReverse() {
   return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
 }
 
-// src/utilities/colors.ts
-var colorMap = {};
-var colorScales = {
-  slate,
-  gray,
-  zinc,
-  neutral,
-  stone,
-  red,
-  orange,
-  amber,
-  yellow,
-  lime,
-  green,
-  emerald,
-  teal,
-  cyan,
-  sky,
-  blue,
-  indigo,
-  violet,
-  purple,
-  fuchsia,
-  pink,
-  rose
-};
-for (const [name, scale2] of Object.entries(colorScales)) {
-  for (const [shade, hex] of Object.entries(scale2)) {
-    colorMap[`${name}-${shade}`] = hex;
-  }
-}
-colorMap["white"] = white;
-colorMap["black"] = black;
-colorMap["transparent"] = "transparent";
-colorMap["current"] = "currentColor";
-function resolveColor(value) {
-  return colorMap[value] ?? value;
-}
-function bg(color) {
-  if (isDynamic(color)) {
-    return createDynamicRule(
-      { "background-color": `var(${color.__id})` },
-      { [color.__id]: String(color.__value) }
-    );
-  }
-  return createRule({ "background-color": resolveColor(color) });
-}
-function textColor(color) {
-  if (isDynamic(color)) {
-    return createDynamicRule(
-      { color: `var(${color.__id})` },
-      { [color.__id]: String(color.__value) }
-    );
-  }
-  return createRule({ color: resolveColor(color) });
-}
-function borderColor(color) {
-  if (isDynamic(color)) {
-    return createDynamicRule(
-      { "border-color": `var(${color.__id})` },
-      { [color.__id]: String(color.__value) }
-    );
-  }
-  return createRule({ "border-color": resolveColor(color) });
-}
-
 // src/utilities/typography.ts
 var trackingMap = { ...letterSpacings };
 var leadingMap = { ...lineHeights };
@@ -939,13 +1229,13 @@ function px2(value) {
 }
 var radiusMap = {
   none,
-  sm,
+  sm: sm2,
   DEFAULT,
   md,
-  lg,
-  xl,
-  "2xl": _2xl,
-  "3xl": _3xl,
+  lg: lg2,
+  xl: xl2,
+  "2xl": _2xl2,
+  "3xl": _3xl2,
   full
 };
 function resolveRadius(value) {
@@ -1202,12 +1492,12 @@ function divideYReverse() {
 
 // src/utilities/effects.ts
 var shadowMap = {
-  sm: sm2,
+  sm: sm3,
   DEFAULT: DEFAULT2,
   md: md2,
-  lg: lg2,
-  xl: xl2,
-  "2xl": _2xl2,
+  lg: lg3,
+  xl: xl3,
+  "2xl": _2xl3,
   inner,
   none: none2
 };
@@ -1866,11 +2156,11 @@ function has_(selector) {
 }
 
 // src/modifiers/responsive.ts
-var sm3 = (rule) => wrapWithMediaQuery(rule, "(min-width: 640px)");
+var sm4 = (rule) => wrapWithMediaQuery(rule, "(min-width: 640px)");
 var md3 = (rule) => wrapWithMediaQuery(rule, "(min-width: 768px)");
-var lg3 = (rule) => wrapWithMediaQuery(rule, "(min-width: 1024px)");
-var xl3 = (rule) => wrapWithMediaQuery(rule, "(min-width: 1280px)");
-var _2xl3 = (rule) => wrapWithMediaQuery(rule, "(min-width: 1536px)");
+var lg4 = (rule) => wrapWithMediaQuery(rule, "(min-width: 1024px)");
+var xl4 = (rule) => wrapWithMediaQuery(rule, "(min-width: 1280px)");
+var _2xl4 = (rule) => wrapWithMediaQuery(rule, "(min-width: 1536px)");
 var maxSm = (rule) => wrapWithMediaQuery(rule, "(max-width: 639px)");
 var maxMd = (rule) => wrapWithMediaQuery(rule, "(max-width: 767px)");
 var maxLg = (rule) => wrapWithMediaQuery(rule, "(max-width: 1023px)");
@@ -2328,11 +2618,11 @@ var MODS = {
   target,
   open: open_,
   // Responsive
-  sm: sm3,
+  sm: sm4,
   md: md3,
-  lg: lg3,
-  xl: xl3,
-  _2xl: _2xl3,
+  lg: lg4,
+  xl: xl4,
+  _2xl: _2xl4,
   maxSm,
   maxMd,
   maxLg,
@@ -2490,9 +2780,38 @@ function createChain(rules, pendingMods) {
       }
       if (name in UTILS) {
         const utilFn = UTILS[name];
+        const tokenConfig = UTIL_TOKENS[name];
         return new Proxy(function() {
         }, {
           get(_t, innerProp) {
+            if (typeof innerProp === "symbol") {
+              const rule2 = utilFn();
+              const modified2 = applyMods(rule2, pendingMods);
+              return createChain([...rules, modified2], [])[innerProp];
+            }
+            if (tokenConfig && innerProp in tokenConfig.tokens) {
+              const tokenArg = tokenConfig.tokens[innerProp];
+              if (tokenConfig.supportsOpacity) {
+                const rule3 = utilFn(tokenArg);
+                const modified3 = applyMods(rule3, pendingMods);
+                const chainWithRule = createChain([...rules, modified3], []);
+                return new Proxy(function() {
+                }, {
+                  get(_t2, chainProp) {
+                    return chainWithRule[chainProp];
+                  },
+                  apply(_t2, _this2, args) {
+                    const colorWithOpacity = resolveColorWithOpacity(tokenArg, args[0]);
+                    const opacityRule = utilFn(colorWithOpacity);
+                    const modifiedOpacity = applyMods(opacityRule, pendingMods);
+                    return createChain([...rules, modifiedOpacity], []);
+                  }
+                });
+              }
+              const rule2 = utilFn(tokenArg);
+              const modified2 = applyMods(rule2, pendingMods);
+              return createChain([...rules, modified2], []);
+            }
             const rule = utilFn();
             const modified = applyMods(rule, pendingMods);
             return createChain([...rules, modified], [])[innerProp];
@@ -2541,10 +2860,86 @@ function googleFonts(family, options) {
   }
   return family;
 }
+
+// src/standalone.ts
+function createStandaloneProxy(utilFn, config) {
+  return new Proxy(utilFn, {
+    get(_target, prop) {
+      if (typeof prop === "symbol") return utilFn[prop];
+      if (prop in config.tokens) {
+        const tokenArg = config.tokens[prop];
+        const rule = utilFn(tokenArg);
+        if (config.supportsOpacity) {
+          return new Proxy(function() {
+          }, {
+            get(_t, ruleProp) {
+              return rule[ruleProp];
+            },
+            apply(_t, _this, args) {
+              return utilFn(resolveColorWithOpacity(tokenArg, args[0]));
+            }
+          });
+        }
+        return rule;
+      }
+      return utilFn[prop];
+    },
+    apply(_target, _this, args) {
+      return utilFn(...args);
+    }
+  });
+}
+
+// src/index.ts
+var bg2 = createStandaloneProxy(bg, UTIL_TOKENS.bg);
+var textColor2 = createStandaloneProxy(textColor, UTIL_TOKENS.textColor);
+var borderColor2 = createStandaloneProxy(borderColor, UTIL_TOKENS.borderColor);
+var shadowColor2 = createStandaloneProxy(shadowColor, UTIL_TOKENS.shadowColor);
+var ringColor2 = createStandaloneProxy(ringColor, UTIL_TOKENS.ringColor);
+var outlineColor2 = createStandaloneProxy(outlineColor, UTIL_TOKENS.outlineColor);
+var accentColor2 = createStandaloneProxy(accentColor, UTIL_TOKENS.accentColor);
+var caretColor2 = createStandaloneProxy(caretColor, UTIL_TOKENS.caretColor);
+var divideColor2 = createStandaloneProxy(divideColor, UTIL_TOKENS.divideColor);
+var textDecorationColor2 = createStandaloneProxy(textDecorationColor, UTIL_TOKENS.textDecorationColor);
+var gradientFrom2 = createStandaloneProxy(gradientFrom, UTIL_TOKENS.gradientFrom);
+var gradientVia2 = createStandaloneProxy(gradientVia, UTIL_TOKENS.gradientVia);
+var gradientTo2 = createStandaloneProxy(gradientTo, UTIL_TOKENS.gradientTo);
+var rounded2 = createStandaloneProxy(rounded, UTIL_TOKENS.rounded);
+var roundedT2 = createStandaloneProxy(roundedT, UTIL_TOKENS.roundedT);
+var roundedB2 = createStandaloneProxy(roundedB, UTIL_TOKENS.roundedB);
+var roundedL2 = createStandaloneProxy(roundedL, UTIL_TOKENS.roundedL);
+var roundedR2 = createStandaloneProxy(roundedR, UTIL_TOKENS.roundedR);
+var roundedTL2 = createStandaloneProxy(roundedTL, UTIL_TOKENS.roundedTL);
+var roundedTR2 = createStandaloneProxy(roundedTR, UTIL_TOKENS.roundedTR);
+var roundedBR2 = createStandaloneProxy(roundedBR, UTIL_TOKENS.roundedBR);
+var roundedBL2 = createStandaloneProxy(roundedBL, UTIL_TOKENS.roundedBL);
+var roundedSS2 = createStandaloneProxy(roundedSS, UTIL_TOKENS.roundedSS);
+var roundedSE2 = createStandaloneProxy(roundedSE, UTIL_TOKENS.roundedSE);
+var roundedEE2 = createStandaloneProxy(roundedEE, UTIL_TOKENS.roundedEE);
+var roundedES2 = createStandaloneProxy(roundedES, UTIL_TOKENS.roundedES);
+var shadow2 = createStandaloneProxy(shadow, UTIL_TOKENS.shadow);
+var text2 = createStandaloneProxy(text, UTIL_TOKENS.text);
+var font2 = createStandaloneProxy(font, UTIL_TOKENS.font);
+var tracking2 = createStandaloneProxy(tracking, UTIL_TOKENS.tracking);
+var leading2 = createStandaloneProxy(leading, UTIL_TOKENS.leading);
+var fontFamily2 = createStandaloneProxy(fontFamily, UTIL_TOKENS.fontFamily);
+var textAlign2 = createStandaloneProxy(textAlign, UTIL_TOKENS.textAlign);
+var textTransform2 = createStandaloneProxy(textTransform, UTIL_TOKENS.textTransform);
+var textOverflow2 = createStandaloneProxy(textOverflow, UTIL_TOKENS.textOverflow);
+var textWrap2 = createStandaloneProxy(textWrap, UTIL_TOKENS.textWrap);
+var display2 = createStandaloneProxy(display, UTIL_TOKENS.display);
+var items2 = createStandaloneProxy(items, UTIL_TOKENS.items);
+var justify2 = createStandaloneProxy(justify, UTIL_TOKENS.justify);
+var self2 = createStandaloneProxy(self, UTIL_TOKENS.self);
+var overflow2 = createStandaloneProxy(overflow, UTIL_TOKENS.overflow);
+var overflowX2 = createStandaloneProxy(overflowX, UTIL_TOKENS.overflowX);
+var overflowY2 = createStandaloneProxy(overflowY, UTIL_TOKENS.overflowY);
+var cursor2 = createStandaloneProxy(cursor, UTIL_TOKENS.cursor);
+var objectFit2 = createStandaloneProxy(objectFit, UTIL_TOKENS.objectFit);
 export {
-  _2xl3 as _2xl,
+  _2xl4 as _2xl,
   absolute,
-  accentColor,
+  accentColor2 as accentColor,
   active,
   after,
   alignContent,
@@ -2576,7 +2971,7 @@ export {
   backdropSepia,
   backdrop_,
   before,
-  bg,
+  bg2 as bg,
   bgAttachment,
   bgBlendMode,
   bgClip,
@@ -2590,7 +2985,7 @@ export {
   border,
   borderB,
   borderCollapse,
-  borderColor,
+  borderColor2 as borderColor,
   borderE,
   borderL,
   borderR,
@@ -2611,7 +3006,7 @@ export {
   breakInside,
   brightness,
   captionSide,
-  caretColor,
+  caretColor2 as caretColor,
   checked,
   clear_,
   colEnd,
@@ -2625,7 +3020,7 @@ export {
   contrastLess,
   contrastMore,
   createTheme,
-  cursor,
+  cursor2 as cursor,
   cx,
   dark,
   data,
@@ -2634,8 +3029,8 @@ export {
   delay,
   diagonalFractions,
   disabled,
-  display,
-  divideColor,
+  display2 as display,
+  divideColor2 as divideColor,
   divideStyle,
   divideX,
   divideXReverse,
@@ -2672,8 +3067,8 @@ export {
   focus,
   focusVisible,
   focusWithin,
-  font,
-  fontFamily,
+  font2 as font,
+  fontFamily2 as fontFamily,
   forcedColorAdjust,
   forcedColors,
   gap,
@@ -2681,9 +3076,9 @@ export {
   gapY,
   generateCSS,
   googleFonts,
-  gradientFrom,
-  gradientTo,
-  gradientVia,
+  gradientFrom2 as gradientFrom,
+  gradientTo2 as gradientTo,
+  gradientVia2 as gradientVia,
   grayscale,
   grid,
   gridCols,
@@ -2724,17 +3119,17 @@ export {
   isolate,
   isolationAuto,
   italic,
-  items,
-  justify,
+  items2 as items,
+  justify2 as justify,
   justifyItems,
   justifySelf,
   landscape,
   lastChild,
   lastOfType,
   layer,
-  leading,
+  leading2 as leading,
   left,
-  lg3 as lg,
+  lg4 as lg,
   lineClamp,
   liningNums,
   listStyleImage,
@@ -2767,7 +3162,7 @@ export {
   normalNums,
   notItalic,
   notSrOnly,
-  objectFit,
+  objectFit2 as objectFit,
   objectPosition,
   odd,
   oldstyleNums,
@@ -2779,14 +3174,14 @@ export {
   ordinal,
   outOfRange,
   outline,
-  outlineColor,
+  outlineColor2 as outlineColor,
   outlineNone,
   outlineOffset,
   outlineStyle,
   outlineWidth,
-  overflow,
-  overflowX,
-  overflowY,
+  overflow2 as overflow,
+  overflowX2 as overflowX,
+  overflowY2 as overflowY,
   overscrollBehavior,
   overscrollX,
   overscrollY,
@@ -2832,24 +3227,24 @@ export {
   resize,
   right,
   ring,
-  ringColor,
+  ringColor2 as ringColor,
   ringInset,
   ringOffsetColor,
   ringOffsetWidth,
   rotate,
-  rounded,
-  roundedB,
-  roundedBL,
-  roundedBR,
-  roundedEE,
-  roundedES,
-  roundedL,
-  roundedR,
-  roundedSE,
-  roundedSS,
-  roundedT,
-  roundedTL,
-  roundedTR,
+  rounded2 as rounded,
+  roundedB2 as roundedB,
+  roundedBL2 as roundedBL,
+  roundedBR2 as roundedBR,
+  roundedEE2 as roundedEE,
+  roundedES2 as roundedES,
+  roundedL2 as roundedL,
+  roundedR2 as roundedR,
+  roundedSE2 as roundedSE,
+  roundedSS2 as roundedSS,
+  roundedT2 as roundedT,
+  roundedTL2 as roundedTL,
+  roundedTR2 as roundedTR,
   rowEnd,
   rowSpan,
   rowStart,
@@ -2875,17 +3270,17 @@ export {
   scrollPaddingY,
   select,
   selection_,
-  self,
+  self2 as self,
   sepia,
   setTheme,
-  shadow,
-  shadowColor,
+  shadow2 as shadow,
+  shadowColor2 as shadowColor,
   shrink,
   size,
   skewX,
   skewY,
   slashedZero,
-  sm3 as sm,
+  sm4 as sm,
   snapAlign,
   snapStop,
   snapType,
@@ -2905,21 +3300,21 @@ export {
   tableLayout,
   tabularNums,
   target,
-  text,
-  textAlign,
-  textColor,
+  text2 as text,
+  textAlign2 as textAlign,
+  textColor2 as textColor,
   textDecoration,
-  textDecorationColor,
+  textDecorationColor2 as textDecorationColor,
   textDecorationStyle,
   textDecorationThickness,
   textIndent,
-  textOverflow,
-  textTransform,
+  textOverflow2 as textOverflow,
+  textTransform2 as textTransform,
   textUnderlineOffset,
-  textWrap,
+  textWrap2 as textWrap,
   top,
   touchAction,
-  tracking,
+  tracking2 as tracking,
   transformGpu,
   transformNone,
   transformOrigin,
@@ -2943,6 +3338,6 @@ export {
   whitespace,
   willChange,
   wordBreak,
-  xl3 as xl,
+  xl4 as xl,
   z
 };