@unocss/preset-mini 0.44.7 → 0.45.1

package/dist/chunks/default2.cjs

@@ -1,774 +1,297 @@
 'use strict';
 
 const colors = require('./colors2.cjs');
-const core = require('@unocss/core');
-const transform = require('./transform.cjs');
+const decoration = require('./decoration.cjs');
+require('./colors.cjs');
+require('@unocss/core');
 
-const verticalAlignAlias = {
-  "mid": "middle",
-  "base": "baseline",
-  "btm": "bottom",
-  "baseline": "baseline",
-  "top": "top",
-  "middle": "middle",
-  "bottom": "bottom",
-  "text-top": "text-top",
-  "text-bottom": "text-bottom",
-  "sub": "sub",
-  "super": "super",
-  ...Object.fromEntries(colors.globalKeywords.map((x) => [x, x]))
+const fontFamily = {
+  sans: [
+    "ui-sans-serif",
+    "system-ui",
+    "-apple-system",
+    "BlinkMacSystemFont",
+    '"Segoe UI"',
+    "Roboto",
+    '"Helvetica Neue"',
+    "Arial",
+    '"Noto Sans"',
+    "sans-serif",
+    '"Apple Color Emoji"',
+    '"Segoe UI Emoji"',
+    '"Segoe UI Symbol"',
+    '"Noto Color Emoji"'
+  ].join(","),
+  serif: [
+    "ui-serif",
+    "Georgia",
+    "Cambria",
+    '"Times New Roman"',
+    "Times",
+    "serif"
+  ].join(","),
+  mono: [
+    "ui-monospace",
+    "SFMono-Regular",
+    "Menlo",
+    "Monaco",
+    "Consolas",
+    '"Liberation Mono"',
+    '"Courier New"',
+    "monospace"
+  ].join(",")
 };
-const verticalAligns = [
-  [/^(?:vertical|align|v)-([-\w]+)$/, ([, v]) => ({ "vertical-align": verticalAlignAlias[v] }), { autocomplete: `(vertical|align|v)-(${Object.keys(verticalAlignAlias).join("|")})` }]
-];
-const textAligns = ["center", "left", "right", "justify", "start", "end", ...colors.globalKeywords].map((v) => [`text-${v}`, { "text-align": v }]);
-
-const outline = [
-  [/^outline-(?:width-|size-)?(.+)$/, ([, d], { theme }) => ({ "outline-width": theme.lineWidth?.[d] ?? colors.handler.bracket.cssvar.global.px(d) }), { autocomplete: "outline-(width|size)-<num>" }],
-  [/^outline-(?:color-)?(.+)$/, colors.colorResolver("outline-color", "outline-color"), { autocomplete: "outline-$colors" }],
-  [/^outline-offset-(.+)$/, ([, d], { theme }) => ({ "outline-offset": theme.lineWidth?.[d] ?? colors.handler.bracket.cssvar.global.px(d) }), { autocomplete: "outline-(offset)-<num>" }],
-  ["outline", { "outline-style": "solid" }],
-  ...["auto", "dashed", "dotted", "double", "hidden", "solid", "groove", "ridge", "inset", "outset", ...colors.globalKeywords].map((v) => [`outline-${v}`, { "outline-style": v }]),
-  ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }]
-];
-const appearance = [
-  ["appearance-none", {
-    "appearance": "none",
-    "-webkit-appearance": "none"
-  }]
-];
-const willChangeProperty = (prop) => {
-  return colors.handler.properties.auto.global(prop) ?? {
-    contents: "contents",
-    scroll: "scroll-position"
-  }[prop];
+const fontSize = {
+  "xs": ["0.75rem", "1rem"],
+  "sm": ["0.875rem", "1.25rem"],
+  "base": ["1rem", "1.5rem"],
+  "lg": ["1.125rem", "1.75rem"],
+  "xl": ["1.25rem", "1.75rem"],
+  "2xl": ["1.5rem", "2rem"],
+  "3xl": ["1.875rem", "2.25rem"],
+  "4xl": ["2.25rem", "2.5rem"],
+  "5xl": ["3rem", "1"],
+  "6xl": ["3.75rem", "1"],
+  "7xl": ["4.5rem", "1"],
+  "8xl": ["6rem", "1"],
+  "9xl": ["8rem", "1"]
 };
-const willChange = [
-  [/^will-change-(.+)/, ([, p]) => ({ "will-change": willChangeProperty(p) })]
-];
-
-const borderStyles = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", ...colors.globalKeywords];
-const borders = [
-  [/^(?:border|b)()(?:-(.+))?$/, handlerBorder, { autocomplete: "(border|b)-<directions>" }],
-  [/^(?:border|b)-([xy])(?:-(.+))?$/, handlerBorder],
-  [/^(?:border|b)-([rltbse])(?:-(.+))?$/, handlerBorder],
-  [/^(?:border|b)-(block|inline)(?:-(.+))?$/, handlerBorder],
-  [/^(?:border|b)-([bi][se])(?:-(.+))?$/, handlerBorder],
-  [/^(?:border|b)-()(?:width|size)-(.+)$/, handlerBorderSize, { autocomplete: ["(border|b)-<num>", "(border|b)-<directions>-<num>"] }],
-  [/^(?:border|b)-([xy])-(?:width|size)-(.+)$/, handlerBorderSize],
-  [/^(?:border|b)-([rltbse])-(?:width|size)-(.+)$/, handlerBorderSize],
-  [/^(?:border|b)-(block|inline)-(?:width|size)-(.+)$/, handlerBorderSize],
-  [/^(?:border|b)-([bi][se])-(?:width|size)-(.+)$/, handlerBorderSize],
-  [/^(?:border|b)-()(?:color-)?(.+)$/, handlerBorderColor, { autocomplete: ["(border|b)-$colors", "(border|b)-<directions>-$colors"] }],
-  [/^(?:border|b)-([xy])-(?:color-)?(.+)$/, handlerBorderColor],
-  [/^(?:border|b)-([rltbse])-(?:color-)?(.+)$/, handlerBorderColor],
-  [/^(?:border|b)-(block|inline)-(?:color-)?(.+)$/, handlerBorderColor],
-  [/^(?:border|b)-([bi][se])-(?:color-)?(.+)$/, handlerBorderColor],
-  [/^(?:border|b)-()op(?:acity)?-?(.+)$/, handlerBorderOpacity, { autocomplete: "(border|b)-(op|opacity)-<percent>" }],
-  [/^(?:border|b)-([xy])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
-  [/^(?:border|b)-([rltbse])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
-  [/^(?:border|b)-(block|inline)-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
-  [/^(?:border|b)-([bi][se])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
-  [/^(?:border-|b-)?(?:rounded|rd)()(?:-(.+))?$/, handlerRounded, { autocomplete: ["(border|b)-(rounded|rd)", "(border|b)-(rounded|rd)-<num>", "(rounded|rd)", "(rounded|rd)-<num>"] }],
-  [/^(?:border-|b-)?(?:rounded|rd)-([rltb])(?:-(.+))?$/, handlerRounded],
-  [/^(?:border-|b-)?(?:rounded|rd)-([rltb]{2})(?:-(.+))?$/, handlerRounded],
-  [/^(?:border-|b-)?(?:rounded|rd)-([bi][se])(?:-(.+))?$/, handlerRounded],
-  [/^(?:border-|b-)?(?:rounded|rd)-([bi][se]-[bi][se])(?:-(.+))?$/, handlerRounded],
-  [/^(?:border|b)-(?:style-)?()(.+)$/, handlerBorderStyle, { autocomplete: ["(border|b)-style", `(border|b)-(${borderStyles.join("|")})`, "(border|b)-<directions>-style", `(border|b)-<directions>-(${borderStyles.join("|")})`, `(border|b)-<directions>-style-(${borderStyles.join("|")})`, `(border|b)-style-(${borderStyles.join("|")})`] }],
-  [/^(?:border|b)-([xy])-(?:style-)?(.+)$/, handlerBorderStyle],
-  [/^(?:border|b)-([rltbse])-(?:style-)?(.+)$/, handlerBorderStyle],
-  [/^(?:border|b)-(block|inline)-(?:style-)?(.+)$/, handlerBorderStyle],
-  [/^(?:border|b)-([bi][se])-(?:style-)?(.+)$/, handlerBorderStyle]
-];
-const borderColorResolver = (direction) => ([, body], theme) => {
-  const data = colors.parseColor(body, theme);
-  if (!data)
-    return;
-  const { alpha, color, cssColor } = data;
-  if (cssColor) {
-    if (alpha != null) {
-      return {
-        [`border${direction}-color`]: colors.colorToString(cssColor, alpha)
-      };
-    }
-    if (direction === "") {
-      return {
-        "--un-border-opacity": colors.colorOpacityToString(cssColor),
-        "border-color": colors.colorToString(cssColor, "var(--un-border-opacity)")
-      };
-    } else {
-      return {
-        "--un-border-opacity": colors.colorOpacityToString(cssColor),
-        [`--un-border${direction}-opacity`]: "var(--un-border-opacity)",
-        [`border${direction}-color`]: colors.colorToString(cssColor, `var(--un-border${direction}-opacity)`)
-      };
-    }
-  } else if (color) {
-    return {
-      [`border${direction}-color`]: colors.colorToString(color, alpha)
-    };
-  }
+const textIndent = {
+  "DEFAULT": "1.5rem",
+  "xs": "0.5rem",
+  "sm": "1rem",
+  "md": "1.5rem",
+  "lg": "2rem",
+  "xl": "2.5rem",
+  "2xl": "3rem",
+  "3xl": "4rem"
 };
-function handlerBorder(m, ctx) {
-  const borderSizes = handlerBorderSize(m, ctx);
-  const borderStyle = handlerBorderStyle(["", m[1], "solid"]);
-  if (borderSizes && borderStyle) {
-    return [
-      ...borderSizes,
-      ...borderStyle
-    ];
-  }
-}
-function handlerBorderSize([, a = "", b], { theme }) {
-  const v = theme.lineWidth?.[b || "DEFAULT"] ?? colors.handler.bracket.cssvar.global.px(b || "1");
-  if (a in colors.directionMap && v != null)
-    return colors.directionMap[a].map((i) => [`border${i}-width`, v]);
-}
-function handlerBorderColor([, a = "", c], { theme }) {
-  if (a in colors.directionMap && colors.hasParseableColor(c, theme)) {
-    return Object.assign({}, ...colors.directionMap[a].map((i) => borderColorResolver(i)(["", c], theme)));
-  }
-}
-function handlerBorderOpacity([, a = "", opacity]) {
-  const v = colors.handler.bracket.percent(opacity);
-  if (a in colors.directionMap && v != null)
-    return colors.directionMap[a].map((i) => [`--un-border${i}-opacity`, v]);
-}
-function handlerRounded([, a = "", s], { theme }) {
-  const v = theme.borderRadius?.[s || "DEFAULT"] || colors.handler.bracket.cssvar.global.fraction.rem(s || "1");
-  if (a in colors.cornerMap && v != null)
-    return colors.cornerMap[a].map((i) => [`border${i}-radius`, v]);
-}
-function handlerBorderStyle([, a = "", s]) {
-  if (borderStyles.includes(s) && a in colors.directionMap)
-    return colors.directionMap[a].map((i) => [`border${i}-style`, s]);
-}
-
-const opacity = [
-  [/^op(?:acity)?-?(.+)$/, ([, d]) => ({ opacity: colors.handler.bracket.percent.cssvar(d) })]
-];
-const textColors = [
-  [/^(?:color|c)-(.+)$/, colors.colorResolver("color", "text"), { autocomplete: "(text|color|c)-$colors" }],
-  [/^text-(.+)$/, colors.colorResolver("color", "text", (css) => !css.color?.toString().match(colors.numberWithUnitRE)), { autocomplete: "(text|color|c)-$colors" }],
-  [/^(?:text|color|c)-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-text-opacity": colors.handler.bracket.percent(opacity2) }), { autocomplete: "(text|color|c)-(op|opacity)-<percent>" }]
-];
-const bgColors = [
-  [/^bg-(.+)$/, colors.colorResolver("background-color", "bg"), { autocomplete: "bg-$colors" }],
-  [/^bg-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-bg-opacity": colors.handler.bracket.percent(opacity2) }), { autocomplete: "bg-(op|opacity)-<percent>" }]
-];
-
-const transitionPropertyGroup = {
-  all: "all",
-  colors: ["color", "background-color", "border-color", "text-decoration-color", "fill", "stroke"].join(","),
-  none: "none",
-  opacity: "opacity",
-  shadow: "box-shadow",
-  transform: "transform"
+const textStrokeWidth = {
+  DEFAULT: "1.5rem",
+  none: "0",
+  sm: "thin",
+  md: "medium",
+  lg: "thick"
 };
-const transitionProperty = (prop) => {
-  return colors.handler.properties(prop) ?? transitionPropertyGroup[prop];
+const textShadow = {
+  DEFAULT: ["0 0 1px rgba(0,0,0,0.2)", "0 0 1px rgba(1,0,5,0.1)"],
+  none: "0 0 rgba(0,0,0,0)",
+  sm: "1px 1px 3px rgba(36,37,47,0.25)",
+  md: ["0 1px 2px rgba(30,29,39,0.19)", "1px 2px 4px rgba(54,64,147,0.18)"],
+  lg: ["3px 3px 6px rgba(0,0,0,0.26)", "0 0 5px rgba(15,3,86,0.22)"],
+  xl: ["1px 1px 3px rgba(0,0,0,0.29)", "2px 4px 7px rgba(73,64,125,0.35)"]
 };
-const transitions = [
-  [/^transition(?:-([a-z-]+(?:,[a-z-]+)*))?(?:-(\d+))?$/, ([, prop, d], { theme }) => {
-    const p = prop != null ? transitionProperty(prop) : [transitionPropertyGroup.colors, "opacity", "box-shadow", "transform", "filter", "backdrop-filter"].join(",");
-    if (p) {
-      const duration = theme.duration?.[d || "DEFAULT"] ?? colors.handler.time(d || "150");
-      return {
-        "transition-property": p,
-        "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
-        "transition-duration": duration
-      };
-    }
-  }, { autocomplete: `transition-(${Object.keys(transitionPropertyGroup).join("|")})` }],
-  [
-    /^(?:transition-)?duration-(.+)$/,
-    ([, d], { theme }) => ({ "transition-duration": theme.duration?.[d || "DEFAULT"] ?? colors.handler.bracket.cssvar.time(d) }),
-    { autocomplete: ["transition-duration-$duration", "duration-$duration"] }
-  ],
-  [
-    /^(?:transition-)?delay-(.+)$/,
-    ([, d], { theme }) => ({ "transition-delay": theme.duration?.[d || "DEFAULT"] ?? colors.handler.bracket.cssvar.time(d) }),
-    { autocomplete: ["transition-delay-$duration", "delay-$duration"] }
-  ],
-  [
-    /^(?:transition-)?ease(?:-(.+))?$/,
-    ([, d], { theme }) => ({ "transition-timing-function": theme.easing?.[d || "DEFAULT"] ?? colors.handler.bracket.cssvar(d) }),
-    { autocomplete: ["transition-ease-(linear|in|out|in-out|DEFAULT)", "ease-(linear|in|out|in-out|DEFAULT)"] }
-  ],
-  [
-    /^(?:transition-)?property-(.+)$/,
-    ([, v]) => ({ "transition-property": colors.handler.bracket.global(v) || transitionProperty(v) }),
-    { autocomplete: [`transition-property-(${[...colors.globalKeywords, ...Object.keys(transitionPropertyGroup)].join("|")})`] }
-  ],
-  ["transition-none", { transition: "none" }],
-  ...colors.makeGlobalStaticRules("transition")
-];
-
-const flex = [
-  ["flex", { display: "flex" }],
-  ["inline-flex", { display: "inline-flex" }],
-  ["flex-inline", { display: "inline-flex" }],
-  [/^flex-(.*)$/, ([, d]) => ({ flex: colors.handler.bracket(d) != null ? colors.handler.bracket(d).split(" ").map((e) => colors.handler.cssvar.fraction(e) ?? e).join(" ") : colors.handler.cssvar.fraction(d) })],
-  ["flex-1", { flex: "1 1 0%" }],
-  ["flex-auto", { flex: "1 1 auto" }],
-  ["flex-initial", { flex: "0 1 auto" }],
-  ["flex-none", { flex: "none" }],
-  [/^(?:flex-)?shrink(?:-(.*))?$/, ([, d = ""]) => ({ "flex-shrink": colors.handler.bracket.cssvar.number(d) ?? 1 }), { autocomplete: ["flex-shrink-<num>", "shrink-<num>"] }],
-  [/^(?:flex-)?grow(?:-(.*))?$/, ([, d = ""]) => ({ "flex-grow": colors.handler.bracket.cssvar.number(d) ?? 1 }), { autocomplete: ["flex-grow-<num>", "grow-<num>"] }],
-  [/^(?:flex-)?basis-(.+)$/, ([, d], { theme }) => ({ "flex-basis": theme.spacing?.[d] ?? colors.handler.bracket.cssvar.auto.fraction.rem(d) }), { autocomplete: ["flex-basis-$spacing", "basis-$spacing"] }],
-  ["flex-row", { "flex-direction": "row" }],
-  ["flex-row-reverse", { "flex-direction": "row-reverse" }],
-  ["flex-col", { "flex-direction": "column" }],
-  ["flex-col-reverse", { "flex-direction": "column-reverse" }],
-  ["flex-wrap", { "flex-wrap": "wrap" }],
-  ["flex-wrap-reverse", { "flex-wrap": "wrap-reverse" }],
-  ["flex-nowrap", { "flex-wrap": "nowrap" }]
-];
-
-const weightMap = {
-  thin: "100",
-  extralight: "200",
-  light: "300",
-  normal: "400",
-  medium: "500",
-  semibold: "600",
-  bold: "700",
-  extrabold: "800",
-  black: "900"
+const lineHeight = {
+  none: "1",
+  tight: "1.25",
+  snug: "1.375",
+  normal: "1.5",
+  relaxed: "1.625",
+  loose: "2"
 };
-const fonts = [
-  [
-    /^font-(.+)$/,
-    ([, d], { theme }) => ({ "font-family": theme.fontFamily?.[d] || colors.handler.bracket.cssvar.global(d) }),
-    { autocomplete: "font-$fontFamily" }
-  ],
-  [
-    /^text-(.+)$/,
-    ([, s = "base"], { theme }) => {
-      const themed = core.toArray(theme.fontSize?.[s]);
-      if (themed?.[0]) {
-        const [size, height = "1"] = themed;
-        return {
-          "font-size": size,
-          "line-height": height
-        };
-      }
-      return { "font-size": colors.handler.bracketOfLength.rem(s) };
-    },
-    { autocomplete: "text-$fontSize" }
-  ],
-  [/^text-size-(.+)$/, ([, s], { theme }) => {
-    const themed = core.toArray(theme.fontSize?.[s]);
-    const size = themed?.[0] ?? colors.handler.bracket.cssvar.global.rem(s);
-    if (size != null)
-      return { "font-size": size };
-  }, { autocomplete: "text-size-$fontSize" }],
-  [
-    /^(?:font|fw)-?([^-]+)$/,
-    ([, s]) => ({ "font-weight": weightMap[s] || colors.handler.global.number(s) }),
-    { autocomplete: `(font|fw)-(100|200|300|400|500|600|700|800|900|${Object.keys(weightMap).join("|")})` }
-  ],
-  [
-    /^(?:font-)?(?:leading|lh)-(.+)$/,
-    ([, s], { theme }) => ({ "line-height": theme.lineHeight?.[s] || colors.handler.bracket.cssvar.global.rem(s) }),
-    { autocomplete: "(leading|lh)-$lineHeight" }
-  ],
-  ["font-synthesis-weight", { "font-synthesis": "weight" }],
-  ["font-synthesis-style", { "font-synthesis": "style" }],
-  ["font-synthesis-small-caps", { "font-synthesis": "small-caps" }],
-  ["font-synthesis-none", { "font-synthesis": "none" }],
-  [/^font-synthesis-(.+)$/, ([, s]) => ({ "font-synthesis": colors.handler.bracket.cssvar.global(s) })],
-  [
-    /^(?:font-)?tracking-(.+)$/,
-    ([, s], { theme }) => ({ "letter-spacing": theme.letterSpacing?.[s] || colors.handler.bracket.cssvar.global.rem(s) }),
-    { autocomplete: "tracking-$letterSpacing" }
-  ],
-  [
-    /^(?:font-)?word-spacing-(.+)$/,
-    ([, s], { theme }) => ({ "word-spacing": theme.wordSpacing?.[s] || colors.handler.bracket.cssvar.global.rem(s) }),
-    { autocomplete: "word-spacing-$wordSpacing" }
-  ]
-];
-const tabSizes = [
-  [/^tab(?:-(.+))?$/, ([, s]) => {
-    const v = colors.handler.bracket.cssvar.global.number(s || "4");
-    if (v != null) {
-      return {
-        "-moz-tab-size": v,
-        "-o-tab-size": v,
-        "tab-size": v
-      };
-    }
-  }]
-];
-const textIndents = [
-  [/^indent(?:-(.+))?$/, ([, s], { theme }) => ({ "text-indent": theme.textIndent?.[s || "DEFAULT"] || colors.handler.bracket.cssvar.global.fraction.rem(s) }), { autocomplete: "indent-$textIndent" }]
-];
-const textStrokes = [
-  [/^text-stroke(?:-(.+))?$/, ([, s], { theme }) => ({ "-webkit-text-stroke-width": theme.textStrokeWidth?.[s || "DEFAULT"] || colors.handler.bracket.cssvar.px(s) }), { autocomplete: "text-stroke-$textStrokeWidth" }],
-  [/^text-stroke-(.+)$/, colors.colorResolver("-webkit-text-stroke-color", "text-stroke"), { autocomplete: "text-stroke-$colors" }],
-  [/^text-stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-stroke-opacity": colors.handler.bracket.percent(opacity) }), { autocomplete: "text-stroke-(op|opacity)-<percent>" }]
-];
-const textShadows = [
-  [/^text-shadow(?:-(.+))?$/, ([, s], { theme }) => {
-    const v = theme.textShadow?.[s || "DEFAULT"];
-    if (v != null) {
-      return {
-        "--un-text-shadow": colors.colorableShadows(v, "--un-text-shadow-color").join(","),
-        "text-shadow": "var(--un-text-shadow)"
-      };
-    }
-    return { "text-shadow": colors.handler.bracket.cssvar.global(s) };
-  }, { autocomplete: "text-shadow-$textShadow" }],
-  [/^text-shadow-color-(.+)$/, colors.colorResolver("--un-text-shadow-color", "text-shadow"), { autocomplete: "text-shadow-color-$colors" }],
-  [/^text-shadow-color-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-shadow-opacity": colors.handler.bracket.percent(opacity) }), { autocomplete: "text-shadow-color-(op|opacity)-<percent>" }]
-];
+const letterSpacing = {
+  tighter: "-0.05em",
+  tight: "-0.025em",
+  normal: "0em",
+  wide: "0.025em",
+  wider: "0.05em",
+  widest: "0.1em"
+};
+const wordSpacing = letterSpacing;
 
-const directions = {
-  "": "",
-  "x": "column-",
-  "y": "row-"
+const breakpoints = {
+  "sm": "640px",
+  "md": "768px",
+  "lg": "1024px",
+  "xl": "1280px",
+  "2xl": "1536px"
 };
-const handleGap = ([, d = "", s], { theme }) => {
-  const v = theme.spacing?.[s] ?? colors.handler.bracket.cssvar.global.rem(s);
-  if (v != null) {
-    return {
-      [`grid-${directions[d]}gap`]: v,
-      [`${directions[d]}gap`]: v
-    };
-  }
+const verticalBreakpoints = { ...breakpoints };
+const lineWidth = {
+  DEFAULT: "1px",
+  none: "0px"
 };
-const gaps = [
-  [/^(?:flex-|grid-)?gap-?()(.+)$/, handleGap, { autocomplete: ["gap-$spacing", "gap-<num>"] }],
-  [/^(?:flex-|grid-)?gap-([xy])-?(.+)$/, handleGap, { autocomplete: ["gap-(x|y)-$spacing", "gap-(x|y)-<num>"] }]
-];
-
-const rowCol = (s) => s.replace("col", "column");
-const rowColTheme = (s) => s[0] === "r" ? "Row" : "Column";
-const autoDirection = (c, theme, prop) => {
-  const v = theme[`gridAuto${rowColTheme(c)}`]?.[prop];
-  if (v != null)
-    return v;
-  switch (prop) {
-    case "min":
-      return "min-content";
-    case "max":
-      return "max-content";
-    case "fr":
-      return "minmax(0,1fr)";
-  }
-  return colors.handler.bracket.cssvar.auto.rem(prop);
+const spacing = {
+  "DEFAULT": "1rem",
+  "none": "0rem",
+  "xs": "0.75rem",
+  "sm": "0.875rem",
+  "lg": "1.125rem",
+  "xl": "1.25rem",
+  "2xl": "1.5rem",
+  "3xl": "1.875rem",
+  "4xl": "2.25rem",
+  "5xl": "3rem",
+  "6xl": "3.75rem",
+  "7xl": "4.5rem",
+  "8xl": "6rem",
+  "9xl": "8rem"
 };
-const grids = [
-  ["grid", { display: "grid" }],
-  ["inline-grid", { display: "inline-grid" }],
-  [/^(?:grid-)?(row|col)-(.+)$/, ([, c, v], { theme }) => ({
-    [`grid-${rowCol(c)}`]: theme[`grid${rowColTheme(c)}`]?.[v] ?? colors.handler.bracket.cssvar.auto(v)
-  })],
-  [/^(?:grid-)?(row|col)-span-(.+)$/, ([, c, s]) => {
-    if (s === "full")
-      return { [`grid-${rowCol(c)}`]: "1/-1" };
-    const v = colors.handler.bracket.number(s);
-    if (v != null)
-      return { [`grid-${rowCol(c)}`]: `span ${v}/span ${v}` };
-  }, { autocomplete: ["grid-(row|col)-span-<num>", "(row|col)-span-<num>"] }],
-  [/^(?:grid-)?(row|col)-start-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-start`]: colors.handler.bracket.cssvar(v) ?? v })],
-  [/^(?:grid-)?(row|col)-end-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-end`]: colors.handler.bracket.cssvar(v) ?? v }), { autocomplete: ["grid-(row|col)-(start|end)-<num>"] }],
-  [/^(?:grid-)?auto-(rows|cols)-(.+)$/, ([, c, v], { theme }) => ({ [`grid-auto-${rowCol(c)}`]: autoDirection(c, theme, v) }), { autocomplete: ["grid-auto-(rows|cols)-<num>"] }],
-  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(.+)$/, ([, v]) => ({ "grid-auto-flow": colors.handler.bracket.cssvar(v) })],
-  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(row|col|dense|row-dense|col-dense)$/, ([, v]) => ({ "grid-auto-flow": rowCol(v).replace("-", " ") }), { autocomplete: ["(grid-auto-flow|auto-flow|grid-flow)-(row|col|dense|row-dense|col-dense)"] }],
-  [/^grid-(rows|cols)-(.+)$/, ([, c, v], { theme }) => ({
-    [`grid-template-${rowCol(c)}`]: theme[`gridTemplate${rowColTheme(c)}`]?.[v] ?? colors.handler.bracket.cssvar(v)
-  })],
-  [/^grid-(rows|cols)-minmax-([\w.-]+)$/, ([, c, d]) => ({ [`grid-template-${rowCol(c)}`]: `repeat(auto-fill,minmax(${d},1fr))` })],
-  [/^grid-(rows|cols)-(\d+)$/, ([, c, d]) => ({ [`grid-template-${rowCol(c)}`]: `repeat(${d},minmax(0,1fr))` }), { autocomplete: ["grid-(rows|cols)-<num>", "grid-(rows|cols)-none"] }],
-  ["grid-rows-none", { "grid-template-rows": "none" }],
-  ["grid-cols-none", { "grid-template-columns": "none" }]
-];
-
-const overflowValues = [
-  "auto",
-  "hidden",
-  "clip",
-  "visible",
-  "scroll",
-  ...colors.globalKeywords
-];
-const overflows = [
-  [/^(?:overflow|of)-(.+)$/, ([, v]) => overflowValues.includes(v) ? { overflow: v } : void 0, { autocomplete: [`(overflow|of)-(${overflowValues.join("|")})`, `(overflow|of)-(x|y)-(${overflowValues.join("|")})`] }],
-  [/^(?:overflow|of)-([xy])-(.+)$/, ([, d, v]) => overflowValues.includes(v) ? { [`overflow-${d}`]: v } : void 0]
-];
-
-const positions = [
-  [/^(?:position-|pos-)?(relative|absolute|fixed|sticky)$/, ([, v]) => ({ position: v })],
-  [/^(?:position-|pos-)([-\w]+)$/, ([, v]) => colors.globalKeywords.includes(v) ? { position: v } : void 0],
-  [/^(?:position-|pos-)?(static)$/, ([, v]) => ({ position: v })]
-];
-const justifies = [
-  ["justify-start", { "justify-content": "flex-start" }],
-  ["justify-end", { "justify-content": "flex-end" }],
-  ["justify-center", { "justify-content": "center" }],
-  ["justify-between", { "justify-content": "space-between" }],
-  ["justify-around", { "justify-content": "space-around" }],
-  ["justify-evenly", { "justify-content": "space-evenly" }],
-  ...colors.makeGlobalStaticRules("justify", "justify-content"),
-  ["justify-items-start", { "justify-items": "start" }],
-  ["justify-items-end", { "justify-items": "end" }],
-  ["justify-items-center", { "justify-items": "center" }],
-  ["justify-items-stretch", { "justify-items": "stretch" }],
-  ...colors.makeGlobalStaticRules("justify-items"),
-  ["justify-self-auto", { "justify-self": "auto" }],
-  ["justify-self-start", { "justify-self": "start" }],
-  ["justify-self-end", { "justify-self": "end" }],
-  ["justify-self-center", { "justify-self": "center" }],
-  ["justify-self-stretch", { "justify-self": "stretch" }],
-  ...colors.makeGlobalStaticRules("justify-self")
-];
-const orders = [
-  [/^order-(.+)$/, ([, v]) => ({ order: colors.handler.bracket.cssvar.number(v) })],
-  ["order-first", { order: "-9999" }],
-  ["order-last", { order: "9999" }],
-  ["order-none", { order: "0" }]
-];
-const alignments = [
-  ["content-center", { "align-content": "center" }],
-  ["content-start", { "align-content": "flex-start" }],
-  ["content-end", { "align-content": "flex-end" }],
-  ["content-between", { "align-content": "space-between" }],
-  ["content-around", { "align-content": "space-around" }],
-  ["content-evenly", { "align-content": "space-evenly" }],
-  ...colors.makeGlobalStaticRules("content", "align-content"),
-  ["items-start", { "align-items": "flex-start" }],
-  ["items-end", { "align-items": "flex-end" }],
-  ["items-center", { "align-items": "center" }],
-  ["items-baseline", { "align-items": "baseline" }],
-  ["items-stretch", { "align-items": "stretch" }],
-  ...colors.makeGlobalStaticRules("items", "align-items"),
-  ["self-auto", { "align-self": "auto" }],
-  ["self-start", { "align-self": "flex-start" }],
-  ["self-end", { "align-self": "flex-end" }],
-  ["self-center", { "align-self": "center" }],
-  ["self-stretch", { "align-self": "stretch" }],
-  ["self-baseline", { "align-self": "baseline" }],
-  ...colors.makeGlobalStaticRules("self", "align-self")
-];
-const placements = [
-  ["place-content-center", { "place-content": "center" }],
-  ["place-content-start", { "place-content": "start" }],
-  ["place-content-end", { "place-content": "end" }],
-  ["place-content-between", { "place-content": "space-between" }],
-  ["place-content-around", { "place-content": "space-around" }],
-  ["place-content-evenly", { "place-content": "space-evenly" }],
-  ["place-content-stretch", { "place-content": "stretch" }],
-  ...colors.makeGlobalStaticRules("place-content"),
-  ["place-items-start", { "place-items": "start" }],
-  ["place-items-end", { "place-items": "end" }],
-  ["place-items-center", { "place-items": "center" }],
-  ["place-items-stretch", { "place-items": "stretch" }],
-  ...colors.makeGlobalStaticRules("place-items"),
-  ["place-self-auto", { "place-self": "auto" }],
-  ["place-self-start", { "place-self": "start" }],
-  ["place-self-end", { "place-self": "end" }],
-  ["place-self-center", { "place-self": "center" }],
-  ["place-self-stretch", { "place-self": "stretch" }],
-  ...colors.makeGlobalStaticRules("place-self")
-];
-function handleInsetValue(v, { theme }) {
-  return theme.spacing?.[v] ?? colors.handler.bracket.cssvar.global.auto.fraction.rem(v);
-}
-function handleInsetValues([, d, v], ctx) {
-  const r = handleInsetValue(v, ctx);
-  if (r != null && d in colors.insetMap)
-    return colors.insetMap[d].map((i) => [i.slice(1), r]);
-}
-const insets = [
-  [
-    /^(?:position-|pos-)?inset-(.+)$/,
-    ([, v], ctx) => ({ inset: handleInsetValue(v, ctx) }),
-    {
-      autocomplete: [
-        "(position|pos)-inset-<directions>-$spacing",
-        "(position|pos)-inset-(block|inline)-$spacing",
-        "(position|pos)-inset-(bs|be|is|ie)-$spacing",
-        "(position|pos)-(top|left|right|bottom)-$spacing"
-      ]
-    }
-  ],
-  [/^(?:position-|pos-)?inset-([xy])-(.+)$/, handleInsetValues],
-  [/^(?:position-|pos-)?inset-([rltbse])-(.+)$/, handleInsetValues],
-  [/^(?:position-|pos-)?inset-(block|inline)-(.+)$/, handleInsetValues],
-  [/^(?:position-|pos-)?inset-([bi][se])-(.+)$/, handleInsetValues],
-  [/^(?:position-|pos-)?(top|left|right|bottom)-(.+)$/, ([, d, v], ctx) => ({ [d]: handleInsetValue(v, ctx) })]
-];
-const floats = [
-  ["float-left", { float: "left" }],
-  ["float-right", { float: "right" }],
-  ["float-none", { float: "none" }],
-  ...colors.makeGlobalStaticRules("float"),
-  ["clear-left", { clear: "left" }],
-  ["clear-right", { clear: "right" }],
-  ["clear-both", { clear: "both" }],
-  ["clear-none", { clear: "none" }],
-  ...colors.makeGlobalStaticRules("clear")
-];
-const zIndexes = [
-  [/^z([\d.]+)$/, ([, v]) => ({ "z-index": colors.handler.number(v) })],
-  [/^z-(.+)$/, ([, v]) => ({ "z-index": colors.handler.bracket.cssvar.global.auto.number(v) }), { autocomplete: "z-<num>" }]
-];
-const boxSizing = [
-  ["box-border", { "box-sizing": "border-box" }],
-  ["box-content", { "box-sizing": "content-box" }],
-  ...colors.makeGlobalStaticRules("box", "box-sizing")
-];
-
-const sizeMapping = {
-  h: "height",
-  w: "width",
-  inline: "inline-size",
-  block: "block-size"
+const duration = {
+  DEFAULT: "150ms",
+  none: "0ms",
+  75: "75ms",
+  100: "100ms",
+  150: "150ms",
+  200: "200ms",
+  300: "300ms",
+  500: "500ms",
+  700: "700ms",
+  1e3: "1000ms"
 };
-function getPropName(minmax, hw) {
-  return `${minmax || ""}${sizeMapping[hw]}`;
-}
-function getSizeValue(minmax, hw, theme, prop) {
-  const str = getPropName(minmax, hw).replace(/-(\w)/g, (_, p) => p.toUpperCase());
-  const v = theme[str]?.[prop];
-  if (v != null)
-    return v;
-  switch (prop) {
-    case "fit":
-    case "max":
-    case "min":
-      return `${prop}-content`;
-  }
-  return colors.handler.bracket.cssvar.global.auto.fraction.rem(prop);
-}
-const sizes = [
-  [/^(min-|max-)?([wh])-?(.+)$/, ([, m, w, s], { theme }) => ({ [getPropName(m, w)]: getSizeValue(m, w, theme, s) })],
-  [/^(min-|max-)?(block|inline)-(.+)$/, ([, m, w, s], { theme }) => ({ [getPropName(m, w)]: getSizeValue(m, w, theme, s) }), {
-    autocomplete: [
-      "(w|h)-$width|height|maxWidth|maxHeight|minWidth|minHeight|inlineSize|blockSize|maxInlineSize|maxBlockSize|minInlineSize|minBlockSize",
-      "(block|inline)-$width|height|maxWidth|maxHeight|minWidth|minHeight|inlineSize|blockSize|maxInlineSize|maxBlockSize|minInlineSize|minBlockSize",
-      "(max|min)-(w|h|block|inline)",
-      "(max|min)-(w|h|block|inline)-$width|height|maxWidth|maxHeight|minWidth|minHeight|inlineSize|blockSize|maxInlineSize|maxBlockSize|minInlineSize|minBlockSize"
-    ]
-  }],
-  [/^(min-|max-)?(h)-screen-(.+)$/, ([, m, w, s], context) => ({ [getPropName(m, w)]: colors.resolveVerticalBreakpoints(context)?.[s] })],
-  [/^(min-|max-)?(w)-screen-(.+)$/, ([, m, w, s], context) => ({ [getPropName(m, w)]: colors.resolveBreakpoints(context)?.[s] }), {
-    autocomplete: [
-      "(w|h)-screen",
-      "(min|max)-(w|h)-screen",
-      "h-screen-$verticalBreakpoints",
-      "(min|max)-h-screen-$verticalBreakpoints",
-      "w-screen-$breakpoints",
-      "(min|max)-w-screen-$breakpoints"
-    ]
-  }]
-];
-function getAspectRatio(prop) {
-  if (/^\d+\/\d+$/.test(prop))
-    return prop;
-  switch (prop) {
-    case "square":
-      return "1/1";
-    case "video":
-      return "16/9";
-  }
-  return colors.handler.bracket.cssvar.global.auto.number(prop);
-}
-const aspectRatio = [
-  [/^aspect-(?:ratio-)?(.+)$/, ([, d]) => ({ "aspect-ratio": getAspectRatio(d) }), { autocomplete: ["aspect-(square|video|ratio)", "aspect-ratio-(square|video)"] }]
-];
-
-const paddings = [
-  [/^pa?()-?(-?.+)$/, colors.directionSize("padding"), { autocomplete: ["(m|p)<num>", "(m|p)-<num>"] }],
-  [/^p-?xy()()$/, colors.directionSize("padding"), { autocomplete: "(m|p)-(xy)" }],
-  [/^p-?([xy])(?:-?(-?.+))?$/, colors.directionSize("padding")],
-  [/^p-?([rltbse])(?:-?(-?.+))?$/, colors.directionSize("padding"), { autocomplete: "(m|p)<directions>-<num>" }],
-  [/^p-(block|inline)(?:-(-?.+))?$/, colors.directionSize("padding"), { autocomplete: "(m|p)-(block|inline)-<num>" }],
-  [/^p-?([bi][se])(?:-?(-?.+))?$/, colors.directionSize("padding"), { autocomplete: "(m|p)-(bs|be|is|ie)-<num>" }]
-];
-const margins = [
-  [/^ma?()-?(-?.+)$/, colors.directionSize("margin")],
-  [/^m-?xy()()$/, colors.directionSize("margin")],
-  [/^m-?([xy])(?:-?(-?.+))?$/, colors.directionSize("margin")],
-  [/^m-?([rltbse])(?:-?(-?.+))?$/, colors.directionSize("margin")],
-  [/^m-(block|inline)(?:-(-?.+))?$/, colors.directionSize("margin")],
-  [/^m-?([bi][se])(?:-?(-?.+))?$/, colors.directionSize("margin")]
-];
-
-const variablesAbbrMap = {
-  backface: "backface-visibility",
-  break: "word-break",
-  case: "text-transform",
-  content: "align-content",
-  fw: "font-weight",
-  items: "align-items",
-  justify: "justify-content",
-  select: "user-select",
-  self: "align-self",
-  vertical: "vertical-align",
-  visible: "visibility",
-  whitespace: "white-space",
-  ws: "white-space"
+const borderRadius = {
+  "DEFAULT": "0.25rem",
+  "none": "0rem",
+  "sm": "0.125rem",
+  "md": "0.375rem",
+  "lg": "0.5rem",
+  "xl": "0.75rem",
+  "2xl": "1rem",
+  "3xl": "1.5rem",
+  "full": "9999px"
+};
+const boxShadow = {
+  "DEFAULT": ["var(--un-shadow-inset) 0 1px 3px 0 rgba(0,0,0,0.1)", "var(--un-shadow-inset) 0 1px 2px -1px rgba(0,0,0,0.1)"],
+  "none": "0 0 rgba(0,0,0,0)",
+  "sm": "var(--un-shadow-inset) 0 1px 2px 0 rgba(0,0,0,0.05)",
+  "md": ["var(--un-shadow-inset) 0 4px 6px -1px rgba(0,0,0,0.1)", "var(--un-shadow-inset) 0 2px 4px -2px rgba(0,0,0,0.1)"],
+  "lg": ["var(--un-shadow-inset) 0 10px 15px -3px rgba(0,0,0,0.1)", "var(--un-shadow-inset) 0 4px 6px -4px rgba(0,0,0,0.1)"],
+  "xl": ["var(--un-shadow-inset) 0 20px 25px -5px rgba(0,0,0,0.1)", "var(--un-shadow-inset) 0 8px 10px -6px rgba(0,0,0,0.1)"],
+  "2xl": "var(--un-shadow-inset) 0 25px 50px -12px rgba(0,0,0,0.25)",
+  "inner": "inset 0 2px 4px 0 rgba(0,0,0,0.05)"
+};
+const easing = {
+  "DEFAULT": "cubic-bezier(0.4, 0, 0.2, 1)",
+  "linear": "linear",
+  "in": "cubic-bezier(0.4, 0, 1, 1)",
+  "out": "cubic-bezier(0, 0, 0.2, 1)",
+  "in-out": "cubic-bezier(0.4, 0, 0.2, 1)"
+};
+const ringWidth = {
+  DEFAULT: "1px",
+  none: "0px"
 };
-const cssVariables = [
-  [/^(.+?)-(\$.+)$/, ([, name, varname]) => {
-    const prop = variablesAbbrMap[name];
-    if (prop)
-      return { [prop]: colors.handler.cssvar(varname) };
-  }]
-];
-const cssProperty = [
-  [/^\[([\w_-]+):([^'"]+)\]$/, ([, prop, value]) => ({ [prop]: colors.handler.bracket(`[${value}]`) })]
-];
 
-const questionMark = [
-  [
-    /^(where|\?)$/,
-    (_, { constructCSS, generator }) => {
-      if (generator.userConfig.envMode === "dev")
-        return `@keyframes __un_qm{0%{box-shadow:inset 4px 4px #ff1e90, inset -4px -4px #ff1e90}100%{box-shadow:inset 8px 8px #3399ff, inset -8px -8px #3399ff}}
-${constructCSS({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
-    }
-  ]
-];
+const blur = {
+  "DEFAULT": "8px",
+  "0": "0",
+  "sm": "4px",
+  "md": "12px",
+  "lg": "16px",
+  "xl": "24px",
+  "2xl": "40px",
+  "3xl": "64px"
+};
+const dropShadow = {
+  "DEFAULT": ["0 1px 2px rgba(0,0,0,0.1)", "0 1px 1px rgba(0,0,0,0.06)"],
+  "sm": "0 1px 1px rgba(0,0,0,0.05)",
+  "md": ["0 4px 3px rgba(0,0,0,0.07)", "0 2px 2px rgba(0,0,0,0.06)"],
+  "lg": ["0 10px 8px rgba(0,0,0,0.04)", "0 4px 3px rgba(0,0,0,0.1)"],
+  "xl": ["0 20px 13px rgba(0,0,0,0.03)", "0 8px 5px rgba(0,0,0,0.08)"],
+  "2xl": "0 25px 25px rgba(0,0,0,0.15)",
+  "none": "0 0 rgba(0,0,0,0)"
+};
 
-const decorationStyles = ["solid", "double", "dotted", "dashed", "wavy", ...colors.globalKeywords];
-const textDecorations = [
-  [/^(?:decoration-)?(underline|overline|line-through)$/, ([, s]) => ({ "text-decoration-line": s }), { autocomplete: "decoration-(underline|overline|line-through)" }],
-  [/^(?:underline|decoration)-(?:size-)?(.+)$/, ([, s], { theme }) => ({ "text-decoration-thickness": theme.lineWidth?.[s] ?? colors.handler.bracket.cssvar.global.px(s) }), { autocomplete: "(underline|decoration)-<num>" }],
-  [/^(?:underline|decoration)-(auto|from-font)$/, ([, s]) => ({ "text-decoration-thickness": s }), { autocomplete: "(underline|decoration)-(auto|from-font)" }],
-  [/^(?:underline|decoration)-(.+)$/, (match, ctx) => {
-    const result = colors.colorResolver("text-decoration-color", "line")(match, ctx);
-    if (result) {
-      return {
-        "-webkit-text-decoration-color": result["text-decoration-color"],
-        ...result
-      };
-    }
-  }, { autocomplete: "(underline|decoration)-$colors" }],
-  [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": colors.handler.bracket.percent(opacity) }), { autocomplete: "(underline|decoration)-(op|opacity)-<percent>" }],
-  [/^(?:underline|decoration)-offset-(.+)$/, ([, s], { theme }) => ({ "text-underline-offset": theme.lineWidth?.[s] ?? colors.handler.auto.bracket.cssvar.global.px(s) }), { autocomplete: "(underline|decoration)-(offset)-<num>" }],
-  ...decorationStyles.map((v) => [`underline-${v}`, { "text-decoration-style": v }]),
-  ...decorationStyles.map((v) => [`decoration-${v}`, { "text-decoration-style": v }]),
-  ["no-underline", { "text-decoration": "none" }],
-  ["decoration-none", { "text-decoration": "none" }]
-];
+const baseSize = {
+  "xs": "20rem",
+  "sm": "24rem",
+  "md": "28rem",
+  "lg": "32rem",
+  "xl": "36rem",
+  "2xl": "42rem",
+  "3xl": "48rem",
+  "4xl": "56rem",
+  "5xl": "64rem",
+  "6xl": "72rem",
+  "7xl": "80rem",
+  "prose": "65ch"
+};
+const width = {
+  auto: "auto",
+  ...baseSize,
+  screen: "100vw"
+};
+const maxWidth = {
+  none: "none",
+  ...baseSize,
+  screen: "100vw"
+};
+const height = {
+  auto: "auto",
+  ...baseSize,
+  screen: "100vh"
+};
+const maxHeight = {
+  none: "none",
+  ...baseSize,
+  screen: "100vh"
+};
 
-const svgUtilities = [
-  [/^fill-(.+)$/, colors.colorResolver("fill", "fill"), { autocomplete: "fill-$colors" }],
-  [/^fill-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-fill-opacity": colors.handler.bracket.percent(opacity) }), { autocomplete: "fill-(op|opacity)-<percent>" }],
-  ["fill-none", { fill: "none" }],
-  [/^stroke-(?:width-|size-)?(.+)$/, ([, s], { theme }) => ({ "stroke-width": theme.lineWidth?.[s] ?? colors.handler.bracket.cssvar.fraction.px.number(s) }), { autocomplete: ["stroke-width-$lineWidth", "stroke-size-$lineWidth"] }],
-  [/^stroke-dash-(.+)$/, ([, s]) => ({ "stroke-dasharray": colors.handler.bracket.cssvar.number(s) }), { autocomplete: "stroke-dash-<num>" }],
-  [/^stroke-offset-(.+)$/, ([, s], { theme }) => ({ "stroke-dashoffset": theme.lineWidth?.[s] ?? colors.handler.bracket.cssvar.px.numberWithUnit(s) }), { autocomplete: "stroke-offset-$lineWidth" }],
-  [/^stroke-(.+)$/, colors.colorResolver("stroke", "stroke"), { autocomplete: "stroke-$colors" }],
-  [/^stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-stroke-opacity": colors.handler.bracket.percent(opacity) }), { autocomplete: "stroke-(op|opacity)-<percent>" }],
-  ["stroke-cap-square", { "stroke-linecap": "square" }],
-  ["stroke-cap-round", { "stroke-linecap": "round" }],
-  ["stroke-cap-auto", { "stroke-linecap": "butt" }],
-  ["stroke-join-arcs", { "stroke-linejoin": "arcs" }],
-  ["stroke-join-bevel", { "stroke-linejoin": "bevel" }],
-  ["stroke-join-clip", { "stroke-linejoin": "miter-clip" }],
-  ["stroke-join-round", { "stroke-linejoin": "round" }],
-  ["stroke-join-auto", { "stroke-linejoin": "miter" }],
-  ["stroke-none", { stroke: "none" }]
-];
+const preflightBase = {
+  ...decoration.transformBase,
+  ...decoration.boxShadowsBase,
+  ...decoration.ringBase
+};
 
-const rules = [
-  cssVariables,
-  cssProperty,
-  paddings,
-  margins,
-  transform.displays,
-  opacity,
-  bgColors,
-  svgUtilities,
-  borders,
-  transform.contents,
-  fonts,
-  tabSizes,
-  textIndents,
-  transform.textOverflows,
-  textDecorations,
-  textStrokes,
-  textShadows,
-  transform.textTransforms,
-  textAligns,
-  textColors,
-  transform.fontStyles,
-  transform.fontSmoothings,
-  transform.boxShadows,
-  transform.rings,
-  flex,
-  grids,
-  gaps,
-  positions,
-  sizes,
-  aspectRatio,
-  transform.cursors,
-  transform.appearances,
-  transform.pointerEvents,
-  transform.resizes,
-  verticalAligns,
-  transform.userSelects,
-  transform.whitespaces,
-  transform.breaks,
-  overflows,
-  outline,
-  appearance,
-  orders,
-  justifies,
-  alignments,
-  placements,
-  insets,
-  floats,
-  zIndexes,
-  boxSizing,
-  transitions,
-  transform.transforms,
-  willChange,
-  questionMark
-].flat(1);
+const theme = {
+  width,
+  height,
+  maxWidth,
+  maxHeight,
+  minWidth: maxWidth,
+  minHeight: maxHeight,
+  inlineSize: width,
+  blockSize: height,
+  maxInlineSize: maxWidth,
+  maxBlockSize: maxHeight,
+  minInlineSize: maxWidth,
+  minBlockSize: maxHeight,
+  colors: colors.colors,
+  fontFamily,
+  fontSize,
+  breakpoints,
+  verticalBreakpoints,
+  borderRadius,
+  lineHeight,
+  letterSpacing,
+  wordSpacing,
+  boxShadow,
+  textIndent,
+  textShadow,
+  textStrokeWidth,
+  blur,
+  dropShadow,
+  easing,
+  lineWidth,
+  spacing,
+  duration,
+  ringWidth,
+  preflightBase
+};
 
-exports.alignments = alignments;
-exports.appearance = appearance;
-exports.aspectRatio = aspectRatio;
-exports.bgColors = bgColors;
-exports.borderStyles = borderStyles;
-exports.borders = borders;
-exports.boxSizing = boxSizing;
-exports.cssProperty = cssProperty;
-exports.cssVariables = cssVariables;
-exports.flex = flex;
-exports.floats = floats;
-exports.fonts = fonts;
-exports.gaps = gaps;
-exports.grids = grids;
-exports.handlerBorderStyle = handlerBorderStyle;
-exports.insets = insets;
-exports.justifies = justifies;
-exports.margins = margins;
-exports.opacity = opacity;
-exports.orders = orders;
-exports.outline = outline;
-exports.overflows = overflows;
-exports.paddings = paddings;
-exports.placements = placements;
-exports.positions = positions;
-exports.questionMark = questionMark;
-exports.rules = rules;
-exports.sizes = sizes;
-exports.svgUtilities = svgUtilities;
-exports.tabSizes = tabSizes;
-exports.textAligns = textAligns;
-exports.textColors = textColors;
-exports.textDecorations = textDecorations;
-exports.textIndents = textIndents;
-exports.textShadows = textShadows;
-exports.textStrokes = textStrokes;
-exports.transitions = transitions;
-exports.verticalAligns = verticalAligns;
-exports.willChange = willChange;
-exports.zIndexes = zIndexes;
+exports.baseSize = baseSize;
+exports.blur = blur;
+exports.borderRadius = borderRadius;
+exports.boxShadow = boxShadow;
+exports.breakpoints = breakpoints;
+exports.dropShadow = dropShadow;
+exports.duration = duration;
+exports.easing = easing;
+exports.fontFamily = fontFamily;
+exports.fontSize = fontSize;
+exports.height = height;
+exports.letterSpacing = letterSpacing;
+exports.lineHeight = lineHeight;
+exports.lineWidth = lineWidth;
+exports.maxHeight = maxHeight;
+exports.maxWidth = maxWidth;
+exports.preflightBase = preflightBase;
+exports.ringWidth = ringWidth;
+exports.spacing = spacing;
+exports.textIndent = textIndent;
+exports.textShadow = textShadow;
+exports.textStrokeWidth = textStrokeWidth;
+exports.theme = theme;
+exports.verticalBreakpoints = verticalBreakpoints;
+exports.width = width;
+exports.wordSpacing = wordSpacing;