typewritingclass 0.2.2 → 0.2.6

package/dist/index.js

@@ -0,0 +1,2944 @@
+import {
+  blur,
+  dropShadow
+} from "./chunk-JKT74FUK.js";
+import {
+  injectTheme,
+  resolveSpacing,
+  setTheme
+} from "./chunk-TAAEIXRF.js";
+import {
+  generateCSS,
+  register
+} from "./chunk-T776FXQK.js";
+import {
+  combineRules,
+  createDynamicRule,
+  createRule,
+  wrapWithMediaQuery,
+  wrapWithSelector,
+  wrapWithSelectorTemplate,
+  wrapWithSupportsQuery
+} from "./chunk-PBQX6PVK.js";
+import {
+  amber,
+  black,
+  blue,
+  cyan,
+  emerald,
+  fuchsia,
+  gray,
+  green,
+  indigo,
+  lime,
+  neutral,
+  orange,
+  pink,
+  purple,
+  red,
+  rose,
+  sky,
+  slate,
+  stone,
+  teal,
+  violet,
+  white,
+  yellow,
+  zinc
+} from "./chunk-XEHQXLQR.js";
+import {
+  fontFamilies,
+  letterSpacings,
+  lineHeights
+} from "./chunk-LARVCDO3.js";
+import {
+  maxWidths
+} from "./chunk-U2LSMKZS.js";
+import {
+  DEFAULT as DEFAULT2,
+  _2xl as _2xl2,
+  inner,
+  lg as lg2,
+  md as md2,
+  none as none2,
+  sm as sm2,
+  xl as xl2
+} from "./chunk-IL3LVS32.js";
+import {
+  DEFAULT,
+  _2xl,
+  _3xl,
+  full,
+  lg,
+  md,
+  none,
+  sm,
+  xl
+} from "./chunk-YHDPOIUZ.js";
+import {
+  createTheme
+} from "./chunk-ATLK64TQ.js";
+import {
+  bounce,
+  ping,
+  pulse,
+  spin
+} from "./chunk-L7AJQJBR.js";
+import "./chunk-MLKGABMK.js";
+
+// src/hash.ts
+function djb2(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+  }
+  return hash >>> 0;
+}
+function generateHash(rule, layer2) {
+  const input = JSON.stringify(rule.declarations) + JSON.stringify(rule.selectors) + JSON.stringify(rule.mediaQueries) + JSON.stringify(rule.supportsQueries) + String(layer2) + (rule.selectorTemplate ?? "");
+  return "_" + djb2(input).toString(36);
+}
+
+// src/layer.ts
+var globalLayer = 0;
+function nextLayer() {
+  return globalLayer++;
+}
+function layer(priority) {
+  return (...rules) => {
+    const combined = rules.length === 1 ? rules[0] : {
+      _tag: "StyleRule",
+      declarations: Object.assign({}, ...rules.map((r) => r.declarations)),
+      selectors: [...new Set(rules.flatMap((r) => r.selectors))],
+      mediaQueries: [...new Set(rules.flatMap((r) => r.mediaQueries))],
+      ...rules.some((r) => r.dynamicBindings) ? {
+        dynamicBindings: Object.assign({}, ...rules.filter((r) => r.dynamicBindings).map((r) => r.dynamicBindings))
+      } : {}
+    };
+    return { ...combined, _layer: priority };
+  };
+}
+
+// src/cx.ts
+function cx(...args) {
+  if (process.env.NODE_ENV !== "production") {
+    warnConflicts(args);
+  }
+  return args.map((arg) => {
+    if (typeof arg === "string") return arg;
+    const layerNum = arg._layer ?? nextLayer();
+    const className = generateHash(arg, layerNum);
+    register(className, arg, layerNum);
+    return className;
+  }).join(" ");
+}
+function warnConflicts(args) {
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (typeof arg === "string") continue;
+    for (const prop of Object.keys(arg.declarations)) {
+      if (seen.has(prop)) {
+        console.warn(
+          `[typewritingclass] cx() conflict: "${prop}" is set by arguments at index ${seen.get(prop)} and ${i}. The later value will override. If intentional, this warning can be ignored.`
+        );
+      }
+      seen.set(prop, i);
+    }
+  }
+}
+
+// src/dcx.ts
+function dcx(...args) {
+  const classNames = [];
+  const style = {};
+  for (const arg of args) {
+    if (typeof arg === "string") {
+      classNames.push(arg);
+      continue;
+    }
+    const layerNum = arg._layer ?? nextLayer();
+    const className = generateHash(arg, layerNum);
+    register(className, arg, layerNum);
+    classNames.push(className);
+    if (arg.dynamicBindings) {
+      Object.assign(style, arg.dynamicBindings);
+    }
+  }
+  return { className: classNames.join(" "), style };
+}
+
+// src/when.ts
+function when(...modifiers) {
+  return (...rules) => {
+    const combined = combineRules(rules);
+    return modifiers.reduceRight((acc, mod) => mod(acc), combined);
+  };
+}
+
+// src/dynamic.ts
+var counter = 0;
+function dynamic(value) {
+  return { _tag: "DynamicValue", __value: value, __id: `--twc-d${counter++}` };
+}
+function isDynamic(v) {
+  return typeof v === "object" && v !== null && "_tag" in v && v._tag === "DynamicValue";
+}
+
+// src/css.ts
+function css(first, ...values) {
+  if (!Array.isArray(first) && !("raw" in first)) {
+    return createRule(first);
+  }
+  const strings = first;
+  const declarations = {};
+  let dynamicBindings;
+  let raw = "";
+  for (let i = 0; i < strings.length; i++) {
+    raw += strings[i];
+    if (i < values.length) {
+      const val = values[i];
+      if (isDynamic(val)) {
+        if (!dynamicBindings) dynamicBindings = {};
+        dynamicBindings[val.__id] = String(val.__value);
+        raw += `var(${val.__id})`;
+      } else {
+        raw += String(val);
+      }
+    }
+  }
+  const lines = raw.split(";");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const prop = trimmed.slice(0, colonIdx).trim();
+    const value = trimmed.slice(colonIdx + 1).trim();
+    if (prop && value) {
+      declarations[prop] = value;
+    }
+  }
+  if (dynamicBindings) {
+    return createDynamicRule(declarations, dynamicBindings);
+  }
+  return createRule(declarations);
+}
+
+// src/utilities/spacing.ts
+function sp(value) {
+  if (isDynamic(value)) return value;
+  return resolveSpacing(value);
+}
+function spacingRule(prop, value) {
+  const v = sp(value);
+  if (isDynamic(v)) {
+    return createDynamicRule(
+      { [prop]: `var(${v.__id})` },
+      { [v.__id]: String(v.__value) }
+    );
+  }
+  return createRule({ [prop]: v });
+}
+function spacingRuleMulti(props, value) {
+  const v = sp(value);
+  if (isDynamic(v)) {
+    const decls2 = {};
+    for (const prop of props) decls2[prop] = `var(${v.__id})`;
+    return createDynamicRule(decls2, { [v.__id]: String(v.__value) });
+  }
+  const decls = {};
+  for (const prop of props) decls[prop] = v;
+  return createRule(decls);
+}
+function p(value) {
+  return spacingRule("padding", value);
+}
+function px(value) {
+  return spacingRuleMulti(["padding-left", "padding-right"], value);
+}
+function py(value) {
+  return spacingRuleMulti(["padding-top", "padding-bottom"], value);
+}
+function pt(value) {
+  return spacingRule("padding-top", value);
+}
+function pr(value) {
+  return spacingRule("padding-right", value);
+}
+function pb(value) {
+  return spacingRule("padding-bottom", value);
+}
+function pl(value) {
+  return spacingRule("padding-left", value);
+}
+function m(value) {
+  return spacingRule("margin", value);
+}
+function mx(value) {
+  return spacingRuleMulti(["margin-left", "margin-right"], value);
+}
+function my(value) {
+  return spacingRuleMulti(["margin-top", "margin-bottom"], value);
+}
+function mt(value) {
+  return spacingRule("margin-top", value);
+}
+function mr(value) {
+  return spacingRule("margin-right", value);
+}
+function mb(value) {
+  return spacingRule("margin-bottom", value);
+}
+function ml(value) {
+  return spacingRule("margin-left", value);
+}
+function gap(value) {
+  return spacingRule("gap", value);
+}
+function gapX(value) {
+  return spacingRule("column-gap", value);
+}
+function gapY(value) {
+  return spacingRule("row-gap", value);
+}
+function ps(value) {
+  return spacingRule("padding-inline-start", value);
+}
+function pe(value) {
+  return spacingRule("padding-inline-end", value);
+}
+function ms(value) {
+  return spacingRule("margin-inline-start", value);
+}
+function me(value) {
+  return spacingRule("margin-inline-end", value);
+}
+function spaceX(value) {
+  const rule = spacingRule("margin-left", value);
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+function spaceY(value) {
+  const rule = spacingRule("margin-top", value);
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+function spaceXReverse() {
+  const rule = createRule({ "--twc-space-x-reverse": "1" });
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+function spaceYReverse() {
+  const rule = createRule({ "--twc-space-y-reverse": "1" });
+  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 };
+var fontFamilyMap = { ...fontFamilies };
+function text(size2) {
+  if (isDynamic(size2)) {
+    return createDynamicRule(
+      { "font-size": `var(${size2.__id})` },
+      { [size2.__id]: String(size2.__value) }
+    );
+  }
+  if (typeof size2 === "string") {
+    return createRule({ "font-size": size2 });
+  }
+  return createRule({ "font-size": size2.fontSize, "line-height": size2.lineHeight });
+}
+function font(weight) {
+  if (isDynamic(weight)) {
+    return createDynamicRule(
+      { "font-weight": `var(${weight.__id})` },
+      { [weight.__id]: String(weight.__value) }
+    );
+  }
+  return createRule({ "font-weight": weight });
+}
+function tracking(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "letter-spacing": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "letter-spacing": trackingMap[value] ?? value });
+}
+function leading(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "line-height": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "string" ? leadingMap[value] ?? value : String(value);
+  return createRule({ "line-height": v });
+}
+function textAlign(value) {
+  return createRule({ "text-align": value });
+}
+function fontFamily(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "font-family": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "font-family": fontFamilyMap[value] ?? value });
+}
+function antialiased() {
+  return createRule({
+    "-webkit-font-smoothing": "antialiased",
+    "-moz-osx-font-smoothing": "grayscale"
+  });
+}
+function subpixelAntialiased() {
+  return createRule({
+    "-webkit-font-smoothing": "auto",
+    "-moz-osx-font-smoothing": "auto"
+  });
+}
+function italic() {
+  return createRule({ "font-style": "italic" });
+}
+function notItalic() {
+  return createRule({ "font-style": "normal" });
+}
+function normalNums() {
+  return createRule({ "font-variant-numeric": "normal" });
+}
+function ordinal() {
+  return createRule({ "font-variant-numeric": "ordinal" });
+}
+function slashedZero() {
+  return createRule({ "font-variant-numeric": "slashed-zero" });
+}
+function liningNums() {
+  return createRule({ "font-variant-numeric": "lining-nums" });
+}
+function oldstyleNums() {
+  return createRule({ "font-variant-numeric": "oldstyle-nums" });
+}
+function proportionalNums() {
+  return createRule({ "font-variant-numeric": "proportional-nums" });
+}
+function tabularNums() {
+  return createRule({ "font-variant-numeric": "tabular-nums" });
+}
+function diagonalFractions() {
+  return createRule({ "font-variant-numeric": "diagonal-fractions" });
+}
+function stackedFractions() {
+  return createRule({ "font-variant-numeric": "stacked-fractions" });
+}
+function lineClamp(value) {
+  return createRule({
+    overflow: "hidden",
+    display: "-webkit-box",
+    "-webkit-box-orient": "vertical",
+    "-webkit-line-clamp": String(value)
+  });
+}
+function listStyleImage(value) {
+  return createRule({ "list-style-image": value });
+}
+function listStylePosition(value) {
+  return createRule({ "list-style-position": value });
+}
+function listStyleType(value) {
+  return createRule({ "list-style-type": value });
+}
+function textDecoration(value) {
+  return createRule({ "text-decoration-line": value });
+}
+function textDecorationColor(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "text-decoration-color": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "text-decoration-color": resolveColor(value) });
+}
+function textDecorationStyle(value) {
+  return createRule({ "text-decoration-style": value });
+}
+function textDecorationThickness(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "text-decoration-thickness": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "text-decoration-thickness": value });
+}
+function textUnderlineOffset(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "text-underline-offset": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "text-underline-offset": value });
+}
+function textTransform(value) {
+  return createRule({ "text-transform": value });
+}
+function textOverflow(value) {
+  return createRule({ "text-overflow": value });
+}
+function textWrap(value) {
+  return createRule({ "text-wrap": value });
+}
+function textIndent(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "text-indent": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "text-indent": value });
+}
+function verticalAlign(value) {
+  return createRule({ "vertical-align": value });
+}
+function whitespace(value) {
+  return createRule({ "white-space": value });
+}
+function wordBreak(value) {
+  return createRule({ "word-break": value });
+}
+function hyphens(value) {
+  return createRule({ hyphens: value });
+}
+function content_(value) {
+  return createRule({ content: value });
+}
+function truncate() {
+  return createRule({
+    overflow: "hidden",
+    "text-overflow": "ellipsis",
+    "white-space": "nowrap"
+  });
+}
+
+// src/utilities/layout.ts
+var sizeMap = {
+  full: "100%",
+  auto: "auto",
+  min: "min-content",
+  max: "max-content",
+  fit: "fit-content",
+  "1/2": "50%",
+  "1/3": "33.333333%",
+  "2/3": "66.666667%",
+  "1/4": "25%",
+  "2/4": "50%",
+  "3/4": "75%",
+  "1/5": "20%",
+  "2/5": "40%",
+  "3/5": "60%",
+  "4/5": "80%",
+  "1/6": "16.666667%",
+  "2/6": "33.333333%",
+  "3/6": "50%",
+  "4/6": "66.666667%",
+  "5/6": "83.333333%",
+  "1/12": "8.333333%",
+  "2/12": "16.666667%",
+  "3/12": "25%",
+  "4/12": "33.333333%",
+  "5/12": "41.666667%",
+  "6/12": "50%",
+  "7/12": "58.333333%",
+  "8/12": "66.666667%",
+  "9/12": "75%",
+  "10/12": "83.333333%",
+  "11/12": "91.666667%"
+};
+var widthSizeMap = { ...sizeMap, screen: "100vw" };
+var heightSizeMap = { ...sizeMap, screen: "100vh" };
+var maxWidthMap = { ...sizeMap, ...maxWidths };
+function resolveSize(value, nameMap) {
+  if (isDynamic(value)) return value;
+  if (typeof value === "string") return (nameMap && nameMap[value]) ?? sizeMap[value] ?? value;
+  return resolveSpacing(value);
+}
+function sizeRule(prop, value, nameMap) {
+  const v = resolveSize(value, nameMap);
+  if (isDynamic(v)) {
+    return createDynamicRule(
+      { [prop]: `var(${v.__id})` },
+      { [v.__id]: String(v.__value) }
+    );
+  }
+  return createRule({ [prop]: v });
+}
+function sizeRuleMulti(props, value, nameMap) {
+  const v = resolveSize(value, nameMap);
+  if (isDynamic(v)) {
+    const decls2 = {};
+    for (const prop of props) decls2[prop] = `var(${v.__id})`;
+    return createDynamicRule(decls2, { [v.__id]: String(v.__value) });
+  }
+  const decls = {};
+  for (const prop of props) decls[prop] = v;
+  return createRule(decls);
+}
+function flex() {
+  return createRule({ display: "flex" });
+}
+function flexCol() {
+  return createRule({ "flex-direction": "column" });
+}
+function flexRow() {
+  return createRule({ "flex-direction": "row" });
+}
+function flexWrap() {
+  return createRule({ "flex-wrap": "wrap" });
+}
+function inlineFlex() {
+  return createRule({ display: "inline-flex" });
+}
+function grid(cols) {
+  const decls = { display: "grid" };
+  if (cols !== void 0) {
+    decls["grid-template-columns"] = `repeat(${cols}, minmax(0, 1fr))`;
+  }
+  return createRule(decls);
+}
+function gridCols(n) {
+  return createRule({ "grid-template-columns": `repeat(${n}, minmax(0, 1fr))` });
+}
+function gridRows(n) {
+  return createRule({ "grid-template-rows": `repeat(${n}, minmax(0, 1fr))` });
+}
+function w(value) {
+  return sizeRule("width", value, widthSizeMap);
+}
+function h(value) {
+  return sizeRule("height", value, heightSizeMap);
+}
+function size(value) {
+  return sizeRuleMulti(["width", "height"], value);
+}
+function minW(value) {
+  return sizeRule("min-width", value);
+}
+function minH(value) {
+  return sizeRule("min-height", value, heightSizeMap);
+}
+function maxW(value) {
+  return sizeRule("max-width", value, maxWidthMap);
+}
+function maxH(value) {
+  return sizeRule("max-height", value, heightSizeMap);
+}
+function display(value) {
+  return createRule({ display: value });
+}
+function items(value) {
+  return createRule({ "align-items": value });
+}
+function justify(value) {
+  return createRule({ "justify-content": value });
+}
+function self(value) {
+  return createRule({ "align-self": value });
+}
+function overflow(value) {
+  return createRule({ overflow: value });
+}
+function overflowX(value) {
+  return createRule({ "overflow-x": value });
+}
+function overflowY(value) {
+  return createRule({ "overflow-y": value });
+}
+function relative() {
+  return createRule({ position: "relative" });
+}
+function absolute() {
+  return createRule({ position: "absolute" });
+}
+function fixed() {
+  return createRule({ position: "fixed" });
+}
+function sticky() {
+  return createRule({ position: "sticky" });
+}
+function top(value) {
+  return sizeRule("top", value);
+}
+function right(value) {
+  return sizeRule("right", value);
+}
+function bottom(value) {
+  return sizeRule("bottom", value);
+}
+function left(value) {
+  return sizeRule("left", value);
+}
+function inset(value) {
+  return sizeRule("inset", value);
+}
+function z(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "z-index": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "z-index": String(value) });
+}
+var aspectRatioMap = {
+  auto: "auto",
+  square: "1 / 1",
+  video: "16 / 9"
+};
+function aspectRatio(value) {
+  return createRule({ "aspect-ratio": aspectRatioMap[value] ?? value });
+}
+function columns(value) {
+  return createRule({ columns: String(value) });
+}
+function breakAfter(value) {
+  return createRule({ "break-after": value });
+}
+function breakBefore(value) {
+  return createRule({ "break-before": value });
+}
+function breakInside(value) {
+  return createRule({ "break-inside": value });
+}
+function boxDecorationBreak(value) {
+  return createRule({ "box-decoration-break": value });
+}
+function boxSizing(value) {
+  return createRule({ "box-sizing": value });
+}
+function float_(value) {
+  return createRule({ float: value });
+}
+function clear_(value) {
+  return createRule({ clear: value });
+}
+function isolate() {
+  return createRule({ isolation: "isolate" });
+}
+function isolationAuto() {
+  return createRule({ isolation: "auto" });
+}
+function objectFit(value) {
+  return createRule({ "object-fit": value });
+}
+function objectPosition(value) {
+  return createRule({ "object-position": value });
+}
+function overscrollBehavior(value) {
+  return createRule({ "overscroll-behavior": value });
+}
+function overscrollX(value) {
+  return createRule({ "overscroll-behavior-x": value });
+}
+function overscrollY(value) {
+  return createRule({ "overscroll-behavior-y": value });
+}
+function static_() {
+  return createRule({ position: "static" });
+}
+function insetX(value) {
+  return sizeRuleMulti(["left", "right"], value);
+}
+function insetY(value) {
+  return sizeRuleMulti(["top", "bottom"], value);
+}
+function start(value) {
+  return sizeRule("inset-inline-start", value);
+}
+function end(value) {
+  return sizeRule("inset-inline-end", value);
+}
+function visible() {
+  return createRule({ visibility: "visible" });
+}
+function invisible() {
+  return createRule({ visibility: "hidden" });
+}
+function collapse_() {
+  return createRule({ visibility: "collapse" });
+}
+function flexBasis(value) {
+  return sizeRule("flex-basis", value);
+}
+function flexRowReverse() {
+  return createRule({ "flex-direction": "row-reverse" });
+}
+function flexColReverse() {
+  return createRule({ "flex-direction": "column-reverse" });
+}
+function flexWrapReverse() {
+  return createRule({ "flex-wrap": "wrap-reverse" });
+}
+function flexNowrap() {
+  return createRule({ "flex-wrap": "nowrap" });
+}
+function flex1() {
+  return createRule({ flex: "1 1 0%" });
+}
+function flexAuto() {
+  return createRule({ flex: "1 1 auto" });
+}
+function flexInitial() {
+  return createRule({ flex: "0 1 auto" });
+}
+function flexNone() {
+  return createRule({ flex: "none" });
+}
+function grow(value = 1) {
+  return createRule({ "flex-grow": String(value) });
+}
+function shrink(value = 1) {
+  return createRule({ "flex-shrink": String(value) });
+}
+function order(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { order: `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ order: String(value) });
+}
+function colSpan(value) {
+  if (value === "full") return createRule({ "grid-column": "1 / -1" });
+  return createRule({ "grid-column": `span ${value} / span ${value}` });
+}
+function colStart(value) {
+  return createRule({ "grid-column-start": String(value) });
+}
+function colEnd(value) {
+  return createRule({ "grid-column-end": String(value) });
+}
+function rowSpan(value) {
+  if (value === "full") return createRule({ "grid-row": "1 / -1" });
+  return createRule({ "grid-row": `span ${value} / span ${value}` });
+}
+function rowStart(value) {
+  return createRule({ "grid-row-start": String(value) });
+}
+function rowEnd(value) {
+  return createRule({ "grid-row-end": String(value) });
+}
+function gridFlow(value) {
+  return createRule({ "grid-auto-flow": value });
+}
+function autoCols(value) {
+  return createRule({ "grid-auto-columns": value });
+}
+function autoRows(value) {
+  return createRule({ "grid-auto-rows": value });
+}
+function justifyItems(value) {
+  return createRule({ "justify-items": value });
+}
+function justifySelf(value) {
+  return createRule({ "justify-self": value });
+}
+function alignContent(value) {
+  return createRule({ "align-content": value });
+}
+function placeContent(value) {
+  return createRule({ "place-content": value });
+}
+function placeItems(value) {
+  return createRule({ "place-items": value });
+}
+function placeSelf(value) {
+  return createRule({ "place-self": value });
+}
+function container() {
+  return createRule({ width: "100%" });
+}
+
+// src/utilities/borders.ts
+function px2(value) {
+  return typeof value === "number" ? `${value}px` : value;
+}
+var radiusMap = {
+  none,
+  sm,
+  DEFAULT,
+  md,
+  lg,
+  xl,
+  "2xl": _2xl,
+  "3xl": _3xl,
+  full
+};
+function resolveRadius(value) {
+  if (value == null) return DEFAULT;
+  if (typeof value === "string") return radiusMap[value] ?? value;
+  return value;
+}
+function rounded(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "border-radius": resolveRadius(value) });
+}
+function roundedT(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-top-left-radius": `var(${value.__id})`, "border-top-right-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = resolveRadius(value);
+  return createRule({ "border-top-left-radius": v, "border-top-right-radius": v });
+}
+function roundedB(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-bottom-left-radius": `var(${value.__id})`, "border-bottom-right-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = resolveRadius(value);
+  return createRule({ "border-bottom-left-radius": v, "border-bottom-right-radius": v });
+}
+function roundedL(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-top-left-radius": `var(${value.__id})`, "border-bottom-left-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = resolveRadius(value);
+  return createRule({ "border-top-left-radius": v, "border-bottom-left-radius": v });
+}
+function roundedR(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-top-right-radius": `var(${value.__id})`, "border-bottom-right-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = resolveRadius(value);
+  return createRule({ "border-top-right-radius": v, "border-bottom-right-radius": v });
+}
+function border(width) {
+  return createRule({ "border-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+}
+function borderT(width) {
+  return createRule({ "border-top-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+}
+function borderR(width) {
+  return createRule({ "border-right-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+}
+function borderB(width) {
+  return createRule({ "border-bottom-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+}
+function borderL(width) {
+  return createRule({ "border-left-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+}
+function ring(width, color) {
+  const w2 = width != null ? px2(width) : "3px";
+  const c = color ?? "#3b82f6";
+  return createRule({ "box-shadow": `0 0 0 ${w2} ${c}` });
+}
+function roundedTL(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-top-left-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "border-top-left-radius": resolveRadius(value) });
+}
+function roundedTR(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-top-right-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "border-top-right-radius": resolveRadius(value) });
+}
+function roundedBR(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-bottom-right-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "border-bottom-right-radius": resolveRadius(value) });
+}
+function roundedBL(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-bottom-left-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "border-bottom-left-radius": resolveRadius(value) });
+}
+function roundedSS(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-start-start-radius": `var(${value.__id})`, "border-end-start-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = resolveRadius(value);
+  return createRule({ "border-start-start-radius": v, "border-end-start-radius": v });
+}
+function roundedSE(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-start-end-radius": `var(${value.__id})`, "border-end-end-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = resolveRadius(value);
+  return createRule({ "border-start-end-radius": v, "border-end-end-radius": v });
+}
+function roundedEE(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-start-end-radius": `var(${value.__id})`, "border-end-end-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = resolveRadius(value);
+  return createRule({ "border-start-end-radius": v, "border-end-end-radius": v });
+}
+function roundedES(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-end-start-radius": `var(${value.__id})`, "border-start-start-radius": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = resolveRadius(value);
+  return createRule({ "border-end-start-radius": v, "border-start-start-radius": v });
+}
+function borderX(width) {
+  const w2 = width != null ? px2(width) : "1px";
+  return createRule({ "border-left-width": w2, "border-right-width": w2, "border-style": "solid" });
+}
+function borderY(width) {
+  const w2 = width != null ? px2(width) : "1px";
+  return createRule({ "border-top-width": w2, "border-bottom-width": w2, "border-style": "solid" });
+}
+function borderS(width) {
+  return createRule({ "border-inline-start-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+}
+function borderE(width) {
+  return createRule({ "border-inline-end-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+}
+function borderStyle(value) {
+  return createRule({ "border-style": value });
+}
+function outlineWidth(value) {
+  return createRule({ "outline-width": px2(value) });
+}
+function outlineColor(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "outline-color": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "outline-color": resolveColor(value) });
+}
+function outlineStyle(value) {
+  return createRule({ "outline-style": value });
+}
+function outlineOffset(value) {
+  return createRule({ "outline-offset": px2(value) });
+}
+function outline(width, style, color) {
+  const decls = {};
+  decls["outline-width"] = width != null ? px2(width) : "2px";
+  decls["outline-style"] = style ?? "solid";
+  if (color) decls["outline-color"] = color;
+  return createRule(decls);
+}
+function outlineNone() {
+  return createRule({ outline: "2px solid transparent", "outline-offset": "2px" });
+}
+function ringInset() {
+  return createRule({ "--twc-ring-inset": "inset" });
+}
+function ringColor(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "--twc-ring-color": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "--twc-ring-color": resolveColor(value) });
+}
+function ringOffsetWidth(value) {
+  return createRule({ "--twc-ring-offset-width": px2(value) });
+}
+function ringOffsetColor(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "--twc-ring-offset-color": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "--twc-ring-offset-color": resolveColor(value) });
+}
+function divideX(width) {
+  const rule = createRule({ "border-left-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+function divideY(width) {
+  const rule = createRule({ "border-top-width": width != null ? px2(width) : "1px", "border-style": "solid" });
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+function divideColor(value) {
+  let rule;
+  if (isDynamic(value)) {
+    rule = createDynamicRule(
+      { "border-color": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  } else {
+    rule = createRule({ "border-color": resolveColor(value) });
+  }
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+function divideStyle(value) {
+  const rule = createRule({ "border-style": value });
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+function divideXReverse() {
+  const rule = createRule({ "--twc-divide-x-reverse": "1" });
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+function divideYReverse() {
+  const rule = createRule({ "--twc-divide-y-reverse": "1" });
+  return wrapWithSelectorTemplate(rule, "& > :not([hidden]) ~ :not([hidden])");
+}
+
+// src/utilities/effects.ts
+var shadowMap = {
+  sm: sm2,
+  DEFAULT: DEFAULT2,
+  md: md2,
+  lg: lg2,
+  xl: xl2,
+  "2xl": _2xl2,
+  inner,
+  none: none2
+};
+function resolveShadow(value) {
+  if (value == null) return DEFAULT2;
+  return shadowMap[value] ?? value;
+}
+function shadow(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "box-shadow": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "box-shadow": resolveShadow(value) });
+}
+function opacity(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { opacity: `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ opacity: String(value) });
+}
+function backdrop(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "backdrop-filter": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "backdrop-filter": value });
+}
+function shadowColor(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "--twc-shadow-color": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "--twc-shadow-color": resolveColor(value) });
+}
+function mixBlendMode(value) {
+  return createRule({ "mix-blend-mode": value });
+}
+function bgBlendMode(value) {
+  return createRule({ "background-blend-mode": value });
+}
+
+// src/utilities/interactivity.ts
+function cursor(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { cursor: `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ cursor: value });
+}
+function select(value) {
+  return createRule({ "user-select": value });
+}
+function pointerEvents(value) {
+  return createRule({ "pointer-events": value });
+}
+function accentColor(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "accent-color": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "accent-color": resolveColor(value) });
+}
+function appearance(value) {
+  return createRule({ appearance: value });
+}
+function caretColor(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "caret-color": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "caret-color": resolveColor(value) });
+}
+function resize(value) {
+  return createRule({ resize: value });
+}
+function scrollBehavior(value) {
+  return createRule({ "scroll-behavior": value });
+}
+function scrollSpacingRule(prop, value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { [prop]: `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? resolveSpacing(value) : value;
+  return createRule({ [prop]: v });
+}
+function scrollMargin(value) {
+  return scrollSpacingRule("scroll-margin", value);
+}
+function scrollMarginX(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "scroll-margin-left": `var(${value.__id})`, "scroll-margin-right": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? resolveSpacing(value) : String(value);
+  return createRule({ "scroll-margin-left": v, "scroll-margin-right": v });
+}
+function scrollMarginY(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "scroll-margin-top": `var(${value.__id})`, "scroll-margin-bottom": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? resolveSpacing(value) : String(value);
+  return createRule({ "scroll-margin-top": v, "scroll-margin-bottom": v });
+}
+function scrollMarginT(value) {
+  return scrollSpacingRule("scroll-margin-top", value);
+}
+function scrollMarginR(value) {
+  return scrollSpacingRule("scroll-margin-right", value);
+}
+function scrollMarginB(value) {
+  return scrollSpacingRule("scroll-margin-bottom", value);
+}
+function scrollMarginL(value) {
+  return scrollSpacingRule("scroll-margin-left", value);
+}
+function scrollPadding(value) {
+  return scrollSpacingRule("scroll-padding", value);
+}
+function scrollPaddingX(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "scroll-padding-left": `var(${value.__id})`, "scroll-padding-right": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? resolveSpacing(value) : String(value);
+  return createRule({ "scroll-padding-left": v, "scroll-padding-right": v });
+}
+function scrollPaddingY(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "scroll-padding-top": `var(${value.__id})`, "scroll-padding-bottom": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? resolveSpacing(value) : String(value);
+  return createRule({ "scroll-padding-top": v, "scroll-padding-bottom": v });
+}
+function scrollPaddingT(value) {
+  return scrollSpacingRule("scroll-padding-top", value);
+}
+function scrollPaddingR(value) {
+  return scrollSpacingRule("scroll-padding-right", value);
+}
+function scrollPaddingB(value) {
+  return scrollSpacingRule("scroll-padding-bottom", value);
+}
+function scrollPaddingL(value) {
+  return scrollSpacingRule("scroll-padding-left", value);
+}
+function snapAlign(value) {
+  return createRule({ "scroll-snap-align": value });
+}
+function snapStop(value) {
+  return createRule({ "scroll-snap-stop": value });
+}
+function snapType(value) {
+  return createRule({ "scroll-snap-type": value });
+}
+function touchAction(value) {
+  return createRule({ "touch-action": value });
+}
+function willChange(value) {
+  return createRule({ "will-change": value });
+}
+
+// src/utilities/filters.ts
+var blurMap = {
+  none: blur.none,
+  sm: blur.sm,
+  DEFAULT: blur.DEFAULT,
+  md: blur.md,
+  lg: blur.lg,
+  xl: blur.xl,
+  "2xl": blur._2xl,
+  "3xl": blur._3xl
+};
+var dropShadowMap = {
+  sm: dropShadow.sm,
+  DEFAULT: dropShadow.DEFAULT,
+  md: dropShadow.md,
+  lg: dropShadow.lg,
+  xl: dropShadow.xl,
+  "2xl": dropShadow._2xl,
+  none: dropShadow.none
+};
+function filterRule(fn, value, prop = "filter") {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { [prop]: `${fn}(var(${value.__id}))` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ [prop]: `${fn}(${value})` });
+}
+function blur2(value = "8px") {
+  if (!isDynamic(value)) return filterRule("blur", blurMap[value] ?? value);
+  return filterRule("blur", value);
+}
+function brightness(value) {
+  return filterRule("brightness", value);
+}
+function contrast(value) {
+  return filterRule("contrast", value);
+}
+function dropShadow2(value = "DEFAULT") {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { filter: `drop-shadow(var(${value.__id}))` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const resolved = dropShadowMap[value] ?? value;
+  return createRule({ filter: `drop-shadow(${resolved})` });
+}
+function grayscale(value = "100%") {
+  return filterRule("grayscale", value);
+}
+function hueRotate(value) {
+  return filterRule("hue-rotate", value);
+}
+function invert(value = "100%") {
+  return filterRule("invert", value);
+}
+function saturate(value) {
+  return filterRule("saturate", value);
+}
+function sepia(value = "100%") {
+  return filterRule("sepia", value);
+}
+function backdropBlur(value = "8px") {
+  if (!isDynamic(value)) return filterRule("blur", blurMap[value] ?? value, "backdrop-filter");
+  return filterRule("blur", value, "backdrop-filter");
+}
+function backdropBrightness(value) {
+  return filterRule("brightness", value, "backdrop-filter");
+}
+function backdropContrast(value) {
+  return filterRule("contrast", value, "backdrop-filter");
+}
+function backdropGrayscale(value = "100%") {
+  return filterRule("grayscale", value, "backdrop-filter");
+}
+function backdropHueRotate(value) {
+  return filterRule("hue-rotate", value, "backdrop-filter");
+}
+function backdropInvert(value = "100%") {
+  return filterRule("invert", value, "backdrop-filter");
+}
+function backdropOpacity(value) {
+  return filterRule("opacity", value, "backdrop-filter");
+}
+function backdropSaturate(value) {
+  return filterRule("saturate", value, "backdrop-filter");
+}
+function backdropSepia(value = "100%") {
+  return filterRule("sepia", value, "backdrop-filter");
+}
+
+// src/utilities/transforms.ts
+function transformRule(fn, value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { transform: `${fn}(var(${value.__id}))` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ transform: `${fn}(${value})` });
+}
+function scale(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { transform: `scale(var(${value.__id}))` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? String(value / 100) : value;
+  return createRule({ transform: `scale(${v})` });
+}
+function scaleX(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { transform: `scaleX(var(${value.__id}))` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? String(value / 100) : value;
+  return createRule({ transform: `scaleX(${v})` });
+}
+function scaleY(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { transform: `scaleY(var(${value.__id}))` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? String(value / 100) : value;
+  return createRule({ transform: `scaleY(${v})` });
+}
+function rotate(value) {
+  return transformRule("rotate", value);
+}
+function translateX(value) {
+  if (typeof value === "number") return transformRule("translateX", resolveSpacing(value));
+  return transformRule("translateX", value);
+}
+function translateY(value) {
+  if (typeof value === "number") return transformRule("translateY", resolveSpacing(value));
+  return transformRule("translateY", value);
+}
+function skewX(value) {
+  return transformRule("skewX", value);
+}
+function skewY(value) {
+  return transformRule("skewY", value);
+}
+function transformOrigin(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "transform-origin": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "transform-origin": value });
+}
+function transformGpu() {
+  return createRule({ transform: "translate3d(0, 0, 0)" });
+}
+function transformNone() {
+  return createRule({ transform: "none" });
+}
+
+// src/utilities/transitions.ts
+var animateMap = {
+  spin,
+  ping,
+  pulse,
+  bounce,
+  none: "none"
+};
+function transition() {
+  return createRule({
+    "transition-property": "color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter",
+    "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
+    "transition-duration": "150ms"
+  });
+}
+function transitionAll() {
+  return createRule({
+    "transition-property": "all",
+    "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
+    "transition-duration": "150ms"
+  });
+}
+function transitionColors() {
+  return createRule({
+    "transition-property": "color, background-color, border-color, text-decoration-color, fill, stroke",
+    "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
+    "transition-duration": "150ms"
+  });
+}
+function transitionOpacity() {
+  return createRule({
+    "transition-property": "opacity",
+    "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
+    "transition-duration": "150ms"
+  });
+}
+function transitionShadow() {
+  return createRule({
+    "transition-property": "box-shadow",
+    "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
+    "transition-duration": "150ms"
+  });
+}
+function transitionTransform() {
+  return createRule({
+    "transition-property": "transform",
+    "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
+    "transition-duration": "150ms"
+  });
+}
+function transitionNone() {
+  return createRule({ "transition-property": "none" });
+}
+function duration(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "transition-duration": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? `${value}ms` : value;
+  return createRule({ "transition-duration": v });
+}
+function ease(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "transition-timing-function": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "transition-timing-function": value });
+}
+function delay(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "transition-delay": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? `${value}ms` : value;
+  return createRule({ "transition-delay": v });
+}
+function animate(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { animation: `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ animation: animateMap[value] ?? value });
+}
+
+// src/utilities/tables.ts
+function borderCollapse() {
+  return createRule({ "border-collapse": "collapse" });
+}
+function borderSeparate() {
+  return createRule({ "border-collapse": "separate" });
+}
+function borderSpacing(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-spacing": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? resolveSpacing(value) : value;
+  return createRule({ "border-spacing": v });
+}
+function borderSpacingX(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-spacing": `var(${value.__id}) 0` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? resolveSpacing(value) : value;
+  return createRule({ "border-spacing": `${v} 0` });
+}
+function borderSpacingY(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "border-spacing": `0 var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  const v = typeof value === "number" ? resolveSpacing(value) : value;
+  return createRule({ "border-spacing": `0 ${v}` });
+}
+function tableLayout(value) {
+  return createRule({ "table-layout": value });
+}
+function captionSide(value) {
+  return createRule({ "caption-side": value });
+}
+
+// src/utilities/svg.ts
+function fill(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { fill: `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ fill: resolveColor(value) });
+}
+function stroke(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { stroke: `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ stroke: resolveColor(value) });
+}
+function strokeWidth(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "stroke-width": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "stroke-width": String(value) });
+}
+
+// src/utilities/accessibility.ts
+function srOnly() {
+  return createRule({
+    position: "absolute",
+    width: "1px",
+    height: "1px",
+    padding: "0",
+    margin: "-1px",
+    overflow: "hidden",
+    clip: "rect(0, 0, 0, 0)",
+    "white-space": "nowrap",
+    "border-width": "0"
+  });
+}
+function notSrOnly() {
+  return createRule({
+    position: "static",
+    width: "auto",
+    height: "auto",
+    padding: "0",
+    margin: "0",
+    overflow: "visible",
+    clip: "auto",
+    "white-space": "normal"
+  });
+}
+function forcedColorAdjust(value) {
+  return createRule({ "forced-color-adjust": value });
+}
+
+// src/utilities/backgrounds.ts
+function bgAttachment(value) {
+  return createRule({ "background-attachment": value });
+}
+function bgClip(value) {
+  return createRule({ "background-clip": value });
+}
+function bgOrigin(value) {
+  return createRule({ "background-origin": value });
+}
+function bgPosition(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "background-position": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "background-position": value });
+}
+function bgRepeat(value) {
+  return createRule({ "background-repeat": value });
+}
+function bgSize(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "background-size": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "background-size": value });
+}
+function bgImage(value) {
+  if (isDynamic(value)) {
+    return createDynamicRule(
+      { "background-image": `var(${value.__id})` },
+      { [value.__id]: String(value.__value) }
+    );
+  }
+  return createRule({ "background-image": value });
+}
+function bgGradient(direction = "to right") {
+  return createRule({
+    "background-image": `linear-gradient(${direction}, var(--twc-gradient-stops, var(--twc-gradient-from, transparent), var(--twc-gradient-to, transparent)))`
+  });
+}
+function gradientFrom(color) {
+  if (isDynamic(color)) {
+    return createDynamicRule(
+      { "--twc-gradient-from": `var(${color.__id})` },
+      { [color.__id]: String(color.__value) }
+    );
+  }
+  return createRule({ "--twc-gradient-from": resolveColor(color) });
+}
+function gradientVia(color) {
+  if (isDynamic(color)) {
+    return createDynamicRule(
+      { "--twc-gradient-via": `var(${color.__id})`, "--twc-gradient-stops": "var(--twc-gradient-from, transparent), var(--twc-gradient-via), var(--twc-gradient-to, transparent)" },
+      { [color.__id]: String(color.__value) }
+    );
+  }
+  return createRule({ "--twc-gradient-via": resolveColor(color), "--twc-gradient-stops": "var(--twc-gradient-from, transparent), var(--twc-gradient-via), var(--twc-gradient-to, transparent)" });
+}
+function gradientTo(color) {
+  if (isDynamic(color)) {
+    return createDynamicRule(
+      { "--twc-gradient-to": `var(${color.__id})` },
+      { [color.__id]: String(color.__value) }
+    );
+  }
+  return createRule({ "--twc-gradient-to": resolveColor(color) });
+}
+
+// src/modifiers/pseudo.ts
+var hover = (rule) => wrapWithSelector(rule, ":hover");
+var focus = (rule) => wrapWithSelector(rule, ":focus");
+var active = (rule) => wrapWithSelector(rule, ":active");
+var disabled = (rule) => wrapWithSelector(rule, ":disabled");
+var focusVisible = (rule) => wrapWithSelector(rule, ":focus-visible");
+var focusWithin = (rule) => wrapWithSelector(rule, ":focus-within");
+var firstChild = (rule) => wrapWithSelector(rule, ":first-child");
+var lastChild = (rule) => wrapWithSelector(rule, ":last-child");
+var visited = (rule) => wrapWithSelector(rule, ":visited");
+var checked = (rule) => wrapWithSelector(rule, ":checked");
+var indeterminate = (rule) => wrapWithSelector(rule, ":indeterminate");
+var default_ = (rule) => wrapWithSelector(rule, ":default");
+var required_ = (rule) => wrapWithSelector(rule, ":required");
+var valid = (rule) => wrapWithSelector(rule, ":valid");
+var invalid = (rule) => wrapWithSelector(rule, ":invalid");
+var inRange = (rule) => wrapWithSelector(rule, ":in-range");
+var outOfRange = (rule) => wrapWithSelector(rule, ":out-of-range");
+var placeholderShown = (rule) => wrapWithSelector(rule, ":placeholder-shown");
+var autofill = (rule) => wrapWithSelector(rule, ":autofill");
+var readOnly = (rule) => wrapWithSelector(rule, ":read-only");
+var empty = (rule) => wrapWithSelector(rule, ":empty");
+var even = (rule) => wrapWithSelector(rule, ":nth-child(even)");
+var odd = (rule) => wrapWithSelector(rule, ":nth-child(odd)");
+var firstOfType = (rule) => wrapWithSelector(rule, ":first-of-type");
+var lastOfType = (rule) => wrapWithSelector(rule, ":last-of-type");
+var onlyChild = (rule) => wrapWithSelector(rule, ":only-child");
+var onlyOfType = (rule) => wrapWithSelector(rule, ":only-of-type");
+var target = (rule) => wrapWithSelector(rule, ":target");
+var open_ = (rule) => wrapWithSelector(rule, "[open]");
+function has_(selector) {
+  return (rule) => wrapWithSelector(rule, `:has(${selector})`);
+}
+
+// src/modifiers/responsive.ts
+var sm3 = (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 maxSm = (rule) => wrapWithMediaQuery(rule, "(max-width: 639px)");
+var maxMd = (rule) => wrapWithMediaQuery(rule, "(max-width: 767px)");
+var maxLg = (rule) => wrapWithMediaQuery(rule, "(max-width: 1023px)");
+var maxXl = (rule) => wrapWithMediaQuery(rule, "(max-width: 1279px)");
+var max2xl = (rule) => wrapWithMediaQuery(rule, "(max-width: 1535px)");
+
+// src/modifiers/colorScheme.ts
+var dark = (rule) => wrapWithMediaQuery(rule, "(prefers-color-scheme: dark)");
+
+// src/modifiers/media.ts
+var motionReduce = (rule) => wrapWithMediaQuery(rule, "(prefers-reduced-motion: reduce)");
+var motionSafe = (rule) => wrapWithMediaQuery(rule, "(prefers-reduced-motion: no-preference)");
+var print_ = (rule) => wrapWithMediaQuery(rule, "print");
+var portrait = (rule) => wrapWithMediaQuery(rule, "(orientation: portrait)");
+var landscape = (rule) => wrapWithMediaQuery(rule, "(orientation: landscape)");
+var contrastMore = (rule) => wrapWithMediaQuery(rule, "(prefers-contrast: more)");
+var contrastLess = (rule) => wrapWithMediaQuery(rule, "(prefers-contrast: less)");
+var forcedColors = (rule) => wrapWithMediaQuery(rule, "(forced-colors: active)");
+
+// src/modifiers/pseudoElements.ts
+var before = (rule) => {
+  const result = wrapWithSelector(rule, "::before");
+  if (!result.declarations.content) {
+    result.declarations = { content: '""', ...result.declarations };
+  }
+  return result;
+};
+var after = (rule) => {
+  const result = wrapWithSelector(rule, "::after");
+  if (!result.declarations.content) {
+    result.declarations = { content: '""', ...result.declarations };
+  }
+  return result;
+};
+var placeholder_ = (rule) => wrapWithSelector(rule, "::placeholder");
+var file_ = (rule) => wrapWithSelector(rule, "::file-selector-button");
+var marker = (rule) => wrapWithSelector(rule, "::marker");
+var selection_ = (rule) => wrapWithSelector(rule, "::selection");
+var firstLine = (rule) => wrapWithSelector(rule, "::first-line");
+var firstLetter = (rule) => wrapWithSelector(rule, "::first-letter");
+var backdrop_ = (rule) => wrapWithSelector(rule, "::backdrop");
+
+// src/modifiers/aria.ts
+var ariaChecked = (rule) => wrapWithSelector(rule, '[aria-checked="true"]');
+var ariaDisabled = (rule) => wrapWithSelector(rule, '[aria-disabled="true"]');
+var ariaExpanded = (rule) => wrapWithSelector(rule, '[aria-expanded="true"]');
+var ariaHidden = (rule) => wrapWithSelector(rule, '[aria-hidden="true"]');
+var ariaPressed = (rule) => wrapWithSelector(rule, '[aria-pressed="true"]');
+var ariaReadonly = (rule) => wrapWithSelector(rule, '[aria-readonly="true"]');
+var ariaRequired = (rule) => wrapWithSelector(rule, '[aria-required="true"]');
+var ariaSelected = (rule) => wrapWithSelector(rule, '[aria-selected="true"]');
+function aria(attr) {
+  return (rule) => wrapWithSelector(rule, `[aria-${attr}]`);
+}
+
+// src/modifiers/data.ts
+function data(attr) {
+  return (rule) => wrapWithSelector(rule, `[data-${attr}]`);
+}
+
+// src/modifiers/supports.ts
+function supports(query) {
+  return (rule) => wrapWithSupportsQuery(rule, query);
+}
+
+// src/modifiers/group.ts
+var groupHover = (rule) => wrapWithSelectorTemplate(rule, ".group:hover &");
+var groupFocus = (rule) => wrapWithSelectorTemplate(rule, ".group:focus &");
+var groupActive = (rule) => wrapWithSelectorTemplate(rule, ".group:active &");
+var groupFocusVisible = (rule) => wrapWithSelectorTemplate(rule, ".group:focus-visible &");
+var groupFocusWithin = (rule) => wrapWithSelectorTemplate(rule, ".group:focus-within &");
+var groupDisabled = (rule) => wrapWithSelectorTemplate(rule, ".group:disabled &");
+var groupChecked = (rule) => wrapWithSelectorTemplate(rule, ".group:checked &");
+var groupEmpty = (rule) => wrapWithSelectorTemplate(rule, ".group:empty &");
+var groupFirst = (rule) => wrapWithSelectorTemplate(rule, ".group:first-child &");
+var groupLast = (rule) => wrapWithSelectorTemplate(rule, ".group:last-child &");
+var groupOdd = (rule) => wrapWithSelectorTemplate(rule, ".group:nth-child(odd) &");
+var groupEven = (rule) => wrapWithSelectorTemplate(rule, ".group:nth-child(even) &");
+var groupOpen = (rule) => wrapWithSelectorTemplate(rule, ".group[open] &");
+var groupVisited = (rule) => wrapWithSelectorTemplate(rule, ".group:visited &");
+function groupHas(selector) {
+  return (rule) => wrapWithSelectorTemplate(rule, `.group:has(${selector}) &`);
+}
+
+// src/modifiers/peer.ts
+var peerHover = (rule) => wrapWithSelectorTemplate(rule, ".peer:hover ~ &");
+var peerFocus = (rule) => wrapWithSelectorTemplate(rule, ".peer:focus ~ &");
+var peerActive = (rule) => wrapWithSelectorTemplate(rule, ".peer:active ~ &");
+var peerFocusVisible = (rule) => wrapWithSelectorTemplate(rule, ".peer:focus-visible ~ &");
+var peerDisabled = (rule) => wrapWithSelectorTemplate(rule, ".peer:disabled ~ &");
+var peerChecked = (rule) => wrapWithSelectorTemplate(rule, ".peer:checked ~ &");
+var peerInvalid = (rule) => wrapWithSelectorTemplate(rule, ".peer:invalid ~ &");
+var peerRequired = (rule) => wrapWithSelectorTemplate(rule, ".peer:required ~ &");
+var peerPlaceholderShown = (rule) => wrapWithSelectorTemplate(rule, ".peer:placeholder-shown ~ &");
+var peerFocusWithin = (rule) => wrapWithSelectorTemplate(rule, ".peer:focus-within ~ &");
+var peerEmpty = (rule) => wrapWithSelectorTemplate(rule, ".peer:empty ~ &");
+var peerFirst = (rule) => wrapWithSelectorTemplate(rule, ".peer:first-child ~ &");
+var peerLast = (rule) => wrapWithSelectorTemplate(rule, ".peer:last-child ~ &");
+var peerOdd = (rule) => wrapWithSelectorTemplate(rule, ".peer:nth-child(odd) ~ &");
+var peerEven = (rule) => wrapWithSelectorTemplate(rule, ".peer:nth-child(even) ~ &");
+var peerOpen = (rule) => wrapWithSelectorTemplate(rule, ".peer[open] ~ &");
+var peerVisited = (rule) => wrapWithSelectorTemplate(rule, ".peer:visited ~ &");
+function peerHas(selector) {
+  return (rule) => wrapWithSelectorTemplate(rule, `.peer:has(${selector}) ~ &`);
+}
+
+// src/modifiers/direction.ts
+var rtl = (rule) => wrapWithSelectorTemplate(rule, '[dir="rtl"] &');
+var ltr = (rule) => wrapWithSelectorTemplate(rule, '[dir="ltr"] &');
+
+// src/tw.ts
+var UTILS = {
+  // Spacing
+  p,
+  px,
+  py,
+  pt,
+  pr,
+  pb,
+  pl,
+  m,
+  mx,
+  my,
+  mt,
+  mr,
+  mb,
+  ml,
+  gap,
+  gapX,
+  gapY,
+  ps,
+  pe,
+  ms,
+  me,
+  spaceX,
+  spaceY,
+  // Colors
+  bg,
+  textColor,
+  borderColor,
+  // Typography
+  text,
+  font,
+  tracking,
+  leading,
+  textAlign,
+  fontFamily,
+  lineClamp,
+  listStyleImage,
+  listStylePosition,
+  listStyleType,
+  textDecoration,
+  textDecorationColor,
+  textDecorationStyle,
+  textDecorationThickness,
+  textUnderlineOffset,
+  textTransform,
+  textOverflow,
+  textWrap,
+  textIndent,
+  verticalAlign,
+  whitespace,
+  wordBreak,
+  hyphens,
+  content: content_,
+  // Layout
+  grid,
+  gridCols,
+  gridRows,
+  w,
+  h,
+  size,
+  minW,
+  minH,
+  maxW,
+  maxH,
+  display,
+  items,
+  justify,
+  self,
+  overflow,
+  overflowX,
+  overflowY,
+  top,
+  right,
+  bottom,
+  left,
+  inset,
+  z,
+  aspectRatio,
+  columns,
+  breakAfter,
+  breakBefore,
+  breakInside,
+  boxDecorationBreak,
+  boxSizing,
+  float: float_,
+  clear: clear_,
+  objectFit,
+  objectPosition,
+  overscrollBehavior,
+  overscrollX,
+  overscrollY,
+  insetX,
+  insetY,
+  start,
+  end,
+  flexBasis,
+  grow,
+  shrink,
+  order,
+  colSpan,
+  colStart,
+  colEnd,
+  rowSpan,
+  rowStart,
+  rowEnd,
+  gridFlow,
+  autoCols,
+  autoRows,
+  justifyItems,
+  justifySelf,
+  alignContent,
+  placeContent,
+  placeItems,
+  placeSelf,
+  // Borders
+  rounded,
+  roundedT,
+  roundedB,
+  roundedL,
+  roundedR,
+  roundedTL,
+  roundedTR,
+  roundedBR,
+  roundedBL,
+  roundedSS,
+  roundedSE,
+  roundedEE,
+  roundedES,
+  border,
+  borderT,
+  borderR,
+  borderB,
+  borderL,
+  borderX,
+  borderY,
+  borderS,
+  borderE,
+  borderStyle,
+  ring,
+  ringColor,
+  ringOffsetWidth,
+  ringOffsetColor,
+  outlineWidth,
+  outlineColor,
+  outlineStyle,
+  outlineOffset,
+  outline,
+  divideX,
+  divideY,
+  divideColor,
+  divideStyle,
+  // Effects
+  shadow,
+  opacity,
+  backdrop,
+  shadowColor,
+  mixBlendMode,
+  bgBlendMode,
+  // Interactivity
+  cursor,
+  select,
+  pointerEvents,
+  accentColor,
+  appearance,
+  caretColor,
+  resize,
+  scrollBehavior,
+  scrollMargin,
+  scrollMarginX,
+  scrollMarginY,
+  scrollMarginT,
+  scrollMarginR,
+  scrollMarginB,
+  scrollMarginL,
+  scrollPadding,
+  scrollPaddingX,
+  scrollPaddingY,
+  scrollPaddingT,
+  scrollPaddingR,
+  scrollPaddingB,
+  scrollPaddingL,
+  snapAlign,
+  snapStop,
+  snapType,
+  touchAction,
+  willChange,
+  // Filters
+  blur: blur2,
+  brightness,
+  contrast,
+  dropShadow: dropShadow2,
+  grayscale,
+  hueRotate,
+  invert,
+  saturate,
+  sepia,
+  backdropBlur,
+  backdropBrightness,
+  backdropContrast,
+  backdropGrayscale,
+  backdropHueRotate,
+  backdropInvert,
+  backdropOpacity,
+  backdropSaturate,
+  backdropSepia,
+  // Transforms
+  scale,
+  scaleX,
+  scaleY,
+  rotate,
+  translateX,
+  translateY,
+  skewX,
+  skewY,
+  transformOrigin,
+  // Transitions
+  transition,
+  duration,
+  ease,
+  delay,
+  animate,
+  // Tables
+  borderSpacing,
+  borderSpacingX,
+  borderSpacingY,
+  tableLayout,
+  captionSide,
+  // SVG
+  fill,
+  stroke,
+  strokeWidth,
+  // Accessibility
+  forcedColorAdjust,
+  // Backgrounds
+  bgAttachment,
+  bgClip,
+  bgOrigin,
+  bgPosition,
+  bgRepeat,
+  bgSize,
+  bgImage,
+  bgGradient,
+  gradientFrom,
+  gradientVia,
+  gradientTo
+};
+var VALUELESS = {
+  // Layout
+  flex,
+  flexCol,
+  flexRow,
+  flexWrap,
+  inlineFlex,
+  relative,
+  absolute,
+  fixed,
+  sticky,
+  static: static_,
+  visible,
+  invisible,
+  collapse: collapse_,
+  isolate,
+  isolationAuto,
+  container,
+  flexRowReverse,
+  flexColReverse,
+  flexWrapReverse,
+  flexNowrap,
+  flex1,
+  flexAuto,
+  flexInitial,
+  flexNone,
+  // Typography
+  antialiased,
+  subpixelAntialiased,
+  italic,
+  notItalic,
+  truncate,
+  normalNums,
+  ordinal,
+  slashedZero,
+  liningNums,
+  oldstyleNums,
+  proportionalNums,
+  tabularNums,
+  diagonalFractions,
+  stackedFractions,
+  // Borders
+  ringInset,
+  outlineNone,
+  borderCollapse,
+  borderSeparate,
+  spaceXReverse,
+  spaceYReverse,
+  divideXReverse,
+  divideYReverse,
+  // Transforms
+  transformGpu,
+  transformNone,
+  // Transitions
+  transitionAll,
+  transitionColors,
+  transitionOpacity,
+  transitionShadow,
+  transitionTransform,
+  transitionNone,
+  // Accessibility
+  srOnly,
+  notSrOnly,
+  // Raw class names
+  group: "group",
+  peer: "peer"
+};
+var MODS = {
+  // Pseudo-classes
+  hover,
+  focus,
+  active,
+  disabled,
+  focusVisible,
+  focusWithin,
+  firstChild,
+  lastChild,
+  visited,
+  checked,
+  indeterminate,
+  default: default_,
+  required: required_,
+  valid,
+  invalid,
+  inRange,
+  outOfRange,
+  placeholderShown,
+  autofill,
+  readOnly,
+  empty,
+  even,
+  odd,
+  firstOfType,
+  lastOfType,
+  onlyChild,
+  onlyOfType,
+  target,
+  open: open_,
+  // Responsive
+  sm: sm3,
+  md: md3,
+  lg: lg3,
+  xl: xl3,
+  _2xl: _2xl3,
+  maxSm,
+  maxMd,
+  maxLg,
+  maxXl,
+  max2xl,
+  // Color scheme
+  dark,
+  // Media
+  motionReduce,
+  motionSafe,
+  print: print_,
+  portrait,
+  landscape,
+  contrastMore,
+  contrastLess,
+  forcedColors,
+  // Pseudo-elements
+  before,
+  after,
+  placeholder: placeholder_,
+  file: file_,
+  marker,
+  selection: selection_,
+  firstLine,
+  firstLetter,
+  backdropEl: backdrop_,
+  // ARIA
+  ariaChecked,
+  ariaDisabled,
+  ariaExpanded,
+  ariaHidden,
+  ariaPressed,
+  ariaReadonly,
+  ariaRequired,
+  ariaSelected,
+  // Group
+  groupHover,
+  groupFocus,
+  groupActive,
+  groupFocusVisible,
+  groupFocusWithin,
+  groupDisabled,
+  groupChecked,
+  groupEmpty,
+  groupFirst,
+  groupLast,
+  groupOdd,
+  groupEven,
+  groupOpen,
+  groupVisited,
+  // Peer
+  peerHover,
+  peerFocus,
+  peerActive,
+  peerFocusVisible,
+  peerDisabled,
+  peerChecked,
+  peerInvalid,
+  peerRequired,
+  peerPlaceholderShown,
+  peerFocusWithin,
+  peerEmpty,
+  peerFirst,
+  peerLast,
+  peerOdd,
+  peerEven,
+  peerOpen,
+  peerVisited,
+  // Direction
+  rtl,
+  ltr
+};
+var PARAM_MODS = {
+  has: has_,
+  aria,
+  data,
+  supports,
+  groupHas,
+  peerHas
+};
+var TW_BRAND = /* @__PURE__ */ Symbol.for("twc.chain");
+function isTwChain(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && value[TW_BRAND] === true;
+}
+function applyMods(rule, mods) {
+  if (mods.length === 0) return rule;
+  return when(...mods)(rule);
+}
+function applyModsToRules(rules, mods) {
+  if (mods.length === 0) return rules;
+  return rules.map((r) => typeof r === "string" ? r : applyMods(r, mods));
+}
+function createChain(rules, pendingMods) {
+  const target2 = function() {
+  };
+  return new Proxy(target2, {
+    get(_target, prop) {
+      if (prop === TW_BRAND) return true;
+      if (prop === "_rules") return rules;
+      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
+        return () => cx(...rules);
+      }
+      if (prop === Symbol.toStringTag) return "TwChain";
+      if (prop === "value" || prop === "className") {
+        return cx(...rules);
+      }
+      if (prop === Symbol.iterator) return void 0;
+      if (prop === "inspect" || prop === /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")) {
+        return () => `TwChain(${cx(...rules)})`;
+      }
+      const name = prop;
+      if (name in PARAM_MODS) {
+        const paramModFn = PARAM_MODS[name];
+        return (...args) => {
+          const mod = paramModFn(...args);
+          return createChain(rules, [...pendingMods, mod]);
+        };
+      }
+      if (name in MODS) {
+        const mod = MODS[name];
+        const innerChain = createChain(rules, [...pendingMods, mod]);
+        return new Proxy(function() {
+        }, {
+          get(_t, innerProp) {
+            return innerChain[innerProp];
+          },
+          apply(_t, _this, args) {
+            if (args.length > 0 && isTwChain(args[0])) {
+              const childRules = args[0]._rules;
+              const modified = applyModsToRules(childRules, [...pendingMods, mod]);
+              return createChain([...rules, ...modified], []);
+            }
+            const allChildRules = [];
+            for (const arg of args) {
+              if (isTwChain(arg)) {
+                allChildRules.push(...arg._rules);
+              }
+            }
+            if (allChildRules.length > 0) {
+              const modified = applyModsToRules(allChildRules, [...pendingMods, mod]);
+              return createChain([...rules, ...modified], []);
+            }
+            return innerChain;
+          }
+        });
+      }
+      if (name in VALUELESS) {
+        const entry = VALUELESS[name];
+        if (typeof entry === "string") {
+          return createChain([...rules, entry], []);
+        }
+        const rule = entry();
+        const modified = applyMods(rule, pendingMods);
+        return createChain([...rules, modified], []);
+      }
+      if (name in UTILS) {
+        const utilFn = UTILS[name];
+        return new Proxy(function() {
+        }, {
+          get(_t, innerProp) {
+            const rule = utilFn();
+            const modified = applyMods(rule, pendingMods);
+            return createChain([...rules, modified], [])[innerProp];
+          },
+          apply(_t, _this, args) {
+            const rule = utilFn(...args);
+            const modified = applyMods(rule, pendingMods);
+            return createChain([...rules, modified], []);
+          }
+        });
+      }
+      return createChain([...rules, name], []);
+    },
+    apply(_target, _this, args) {
+      const extra = [];
+      for (const arg of args) {
+        if (isTwChain(arg)) {
+          extra.push(...arg._rules);
+        } else {
+          extra.push(arg);
+        }
+      }
+      return createChain([...rules, ...extra], pendingMods);
+    }
+  });
+}
+var tw = createChain([], []);
+
+// src/plugins/googleFonts.ts
+var injected = /* @__PURE__ */ new Set();
+function googleFonts(family, options) {
+  if (typeof document !== "undefined" && !injected.has(family)) {
+    injected.add(family);
+    const params = new URLSearchParams();
+    const weights = options?.weights;
+    if (weights && weights.length > 0) {
+      params.set("family", `${family}:wght@${weights.join(";")}`);
+    } else {
+      params.set("family", family);
+    }
+    params.set("display", options?.display ?? "swap");
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = `https://fonts.googleapis.com/css2?${params.toString()}`;
+    document.head.appendChild(link);
+  }
+  return family;
+}
+export {
+  _2xl3 as _2xl,
+  absolute,
+  accentColor,
+  active,
+  after,
+  alignContent,
+  animate,
+  antialiased,
+  appearance,
+  aria,
+  ariaChecked,
+  ariaDisabled,
+  ariaExpanded,
+  ariaHidden,
+  ariaPressed,
+  ariaReadonly,
+  ariaRequired,
+  ariaSelected,
+  aspectRatio,
+  autoCols,
+  autoRows,
+  autofill,
+  backdrop,
+  backdropBlur,
+  backdropBrightness,
+  backdropContrast,
+  backdropGrayscale,
+  backdropHueRotate,
+  backdropInvert,
+  backdropOpacity,
+  backdropSaturate,
+  backdropSepia,
+  backdrop_,
+  before,
+  bg,
+  bgAttachment,
+  bgBlendMode,
+  bgClip,
+  bgGradient,
+  bgImage,
+  bgOrigin,
+  bgPosition,
+  bgRepeat,
+  bgSize,
+  blur2 as blur,
+  border,
+  borderB,
+  borderCollapse,
+  borderColor,
+  borderE,
+  borderL,
+  borderR,
+  borderS,
+  borderSeparate,
+  borderSpacing,
+  borderSpacingX,
+  borderSpacingY,
+  borderStyle,
+  borderT,
+  borderX,
+  borderY,
+  bottom,
+  boxDecorationBreak,
+  boxSizing,
+  breakAfter,
+  breakBefore,
+  breakInside,
+  brightness,
+  captionSide,
+  caretColor,
+  checked,
+  clear_,
+  colEnd,
+  colSpan,
+  colStart,
+  collapse_,
+  columns,
+  container,
+  content_,
+  contrast,
+  contrastLess,
+  contrastMore,
+  createTheme,
+  css,
+  cursor,
+  cx,
+  dark,
+  data,
+  dcx,
+  default_,
+  delay,
+  diagonalFractions,
+  disabled,
+  display,
+  divideColor,
+  divideStyle,
+  divideX,
+  divideXReverse,
+  divideY,
+  divideYReverse,
+  dropShadow2 as dropShadow,
+  duration,
+  dynamic,
+  ease,
+  empty,
+  end,
+  even,
+  file_,
+  fill,
+  firstChild,
+  firstLetter,
+  firstLine,
+  firstOfType,
+  fixed,
+  flex,
+  flex1,
+  flexAuto,
+  flexBasis,
+  flexCol,
+  flexColReverse,
+  flexInitial,
+  flexNone,
+  flexNowrap,
+  flexRow,
+  flexRowReverse,
+  flexWrap,
+  flexWrapReverse,
+  float_,
+  focus,
+  focusVisible,
+  focusWithin,
+  font,
+  fontFamily,
+  forcedColorAdjust,
+  forcedColors,
+  gap,
+  gapX,
+  gapY,
+  generateCSS,
+  googleFonts,
+  gradientFrom,
+  gradientTo,
+  gradientVia,
+  grayscale,
+  grid,
+  gridCols,
+  gridFlow,
+  gridRows,
+  groupActive,
+  groupChecked,
+  groupDisabled,
+  groupEmpty,
+  groupEven,
+  groupFirst,
+  groupFocus,
+  groupFocusVisible,
+  groupFocusWithin,
+  groupHas,
+  groupHover,
+  groupLast,
+  groupOdd,
+  groupOpen,
+  groupVisited,
+  grow,
+  h,
+  has_,
+  hover,
+  hueRotate,
+  hyphens,
+  inRange,
+  indeterminate,
+  injectTheme,
+  inlineFlex,
+  inset,
+  insetX,
+  insetY,
+  invalid,
+  invert,
+  invisible,
+  isDynamic,
+  isolate,
+  isolationAuto,
+  italic,
+  items,
+  justify,
+  justifyItems,
+  justifySelf,
+  landscape,
+  lastChild,
+  lastOfType,
+  layer,
+  leading,
+  left,
+  lg3 as lg,
+  lineClamp,
+  liningNums,
+  listStyleImage,
+  listStylePosition,
+  listStyleType,
+  ltr,
+  m,
+  marker,
+  max2xl,
+  maxH,
+  maxLg,
+  maxMd,
+  maxSm,
+  maxW,
+  maxXl,
+  mb,
+  md3 as md,
+  me,
+  minH,
+  minW,
+  mixBlendMode,
+  ml,
+  motionReduce,
+  motionSafe,
+  mr,
+  ms,
+  mt,
+  mx,
+  my,
+  normalNums,
+  notItalic,
+  notSrOnly,
+  objectFit,
+  objectPosition,
+  odd,
+  oldstyleNums,
+  onlyChild,
+  onlyOfType,
+  opacity,
+  open_,
+  order,
+  ordinal,
+  outOfRange,
+  outline,
+  outlineColor,
+  outlineNone,
+  outlineOffset,
+  outlineStyle,
+  outlineWidth,
+  overflow,
+  overflowX,
+  overflowY,
+  overscrollBehavior,
+  overscrollX,
+  overscrollY,
+  p,
+  pb,
+  pe,
+  peerActive,
+  peerChecked,
+  peerDisabled,
+  peerEmpty,
+  peerEven,
+  peerFirst,
+  peerFocus,
+  peerFocusVisible,
+  peerFocusWithin,
+  peerHas,
+  peerHover,
+  peerInvalid,
+  peerLast,
+  peerOdd,
+  peerOpen,
+  peerPlaceholderShown,
+  peerRequired,
+  peerVisited,
+  pl,
+  placeContent,
+  placeItems,
+  placeSelf,
+  placeholderShown,
+  placeholder_,
+  pointerEvents,
+  portrait,
+  pr,
+  print_,
+  proportionalNums,
+  ps,
+  pt,
+  px,
+  py,
+  readOnly,
+  relative,
+  required_,
+  resize,
+  right,
+  ring,
+  ringColor,
+  ringInset,
+  ringOffsetColor,
+  ringOffsetWidth,
+  rotate,
+  rounded,
+  roundedB,
+  roundedBL,
+  roundedBR,
+  roundedEE,
+  roundedES,
+  roundedL,
+  roundedR,
+  roundedSE,
+  roundedSS,
+  roundedT,
+  roundedTL,
+  roundedTR,
+  rowEnd,
+  rowSpan,
+  rowStart,
+  rtl,
+  saturate,
+  scale,
+  scaleX,
+  scaleY,
+  scrollBehavior,
+  scrollMargin,
+  scrollMarginB,
+  scrollMarginL,
+  scrollMarginR,
+  scrollMarginT,
+  scrollMarginX,
+  scrollMarginY,
+  scrollPadding,
+  scrollPaddingB,
+  scrollPaddingL,
+  scrollPaddingR,
+  scrollPaddingT,
+  scrollPaddingX,
+  scrollPaddingY,
+  select,
+  selection_,
+  self,
+  sepia,
+  setTheme,
+  shadow,
+  shadowColor,
+  shrink,
+  size,
+  skewX,
+  skewY,
+  slashedZero,
+  sm3 as sm,
+  snapAlign,
+  snapStop,
+  snapType,
+  spaceX,
+  spaceXReverse,
+  spaceY,
+  spaceYReverse,
+  srOnly,
+  stackedFractions,
+  start,
+  static_,
+  sticky,
+  stroke,
+  strokeWidth,
+  subpixelAntialiased,
+  supports,
+  tableLayout,
+  tabularNums,
+  target,
+  text,
+  textAlign,
+  textColor,
+  textDecoration,
+  textDecorationColor,
+  textDecorationStyle,
+  textDecorationThickness,
+  textIndent,
+  textOverflow,
+  textTransform,
+  textUnderlineOffset,
+  textWrap,
+  top,
+  touchAction,
+  tracking,
+  transformGpu,
+  transformNone,
+  transformOrigin,
+  transition,
+  transitionAll,
+  transitionColors,
+  transitionNone,
+  transitionOpacity,
+  transitionShadow,
+  transitionTransform,
+  translateX,
+  translateY,
+  truncate,
+  tw,
+  valid,
+  verticalAlign,
+  visible,
+  visited,
+  w,
+  when,
+  whitespace,
+  willChange,
+  wordBreak,
+  xl3 as xl,
+  z
+};