@unocss/preset-mini 0.55.7 → 0.56.0

package/dist/rules.cjs

@@ -1,8 +1,9 @@
 'use strict';
 
-const colors = require('./shared/preset-mini.b4ad509c.cjs');
+const utils = require('./shared/preset-mini.3a376028.cjs');
+const ruleUtils = require('@unocss/rule-utils');
 const core = require('@unocss/core');
-const transform = require('./shared/preset-mini.5bfee53b.cjs');
+const transform = require('./shared/preset-mini.f22c1fe0.cjs');
 
 const verticalAlignAlias = {
   "mid": "middle",
@@ -18,12 +19,12 @@ const verticalAlignAlias = {
   "text-bottom": "text-bottom",
   "sub": "sub",
   "super": "super",
-  ...Object.fromEntries(colors.globalKeywords.map((x) => [x, x]))
+  ...Object.fromEntries(utils.globalKeywords.map((x) => [x, x]))
 };
 const verticalAligns = [
   [
     /^(?:vertical|align|v)-([-\w]+%?)$/,
-    ([, v]) => ({ "vertical-align": verticalAlignAlias[v] ?? colors.h.numberWithUnit(v) }),
+    ([, v]) => ({ "vertical-align": verticalAlignAlias[v] ?? utils.h.numberWithUnit(v) }),
     {
       autocomplete: [
         `(vertical|align|v)-(${Object.keys(verticalAlignAlias).join("|")})`,
@@ -36,14 +37,14 @@ const textAligns = ["center", "left", "right", "justify", "start", "end"].map((v
 
 const outline = [
   // size
-  [/^outline-(?:width-|size-)?(.+)$/, ([, d], { theme }) => ({ "outline-width": theme.lineWidth?.[d] ?? colors.h.bracket.cssvar.global.px(d) }), { autocomplete: "outline-(width|size)-<num>" }],
+  [/^outline-(?:width-|size-)?(.+)$/, ([, d], { theme }) => ({ "outline-width": theme.lineWidth?.[d] ?? utils.h.bracket.cssvar.global.px(d) }), { autocomplete: "outline-(width|size)-<num>" }],
   // color
-  [/^outline-(?:color-)?(.+)$/, colors.colorResolver("outline-color", "outline-color"), { autocomplete: "outline-$colors" }],
+  [/^outline-(?:color-)?(.+)$/, utils.colorResolver("outline-color", "outline-color"), { autocomplete: "outline-$colors" }],
   // offset
-  [/^outline-offset-(.+)$/, ([, d], { theme }) => ({ "outline-offset": theme.lineWidth?.[d] ?? colors.h.bracket.cssvar.global.px(d) }), { autocomplete: "outline-(offset)-<num>" }],
+  [/^outline-offset-(.+)$/, ([, d], { theme }) => ({ "outline-offset": theme.lineWidth?.[d] ?? utils.h.bracket.cssvar.global.px(d) }), { autocomplete: "outline-(offset)-<num>" }],
   // style
   ["outline", { "outline-style": "solid" }],
-  ...["auto", "dashed", "dotted", "double", "hidden", "solid", "groove", "ridge", "inset", "outset", ...colors.globalKeywords].map((v) => [`outline-${v}`, { "outline-style": v }]),
+  ...["auto", "dashed", "dotted", "double", "hidden", "solid", "groove", "ridge", "inset", "outset", ...utils.globalKeywords].map((v) => [`outline-${v}`, { "outline-style": v }]),
   ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }]
 ];
 const appearance = [
@@ -53,7 +54,7 @@ const appearance = [
   }]
 ];
 function willChangeProperty(prop) {
-  return colors.h.properties.auto.global(prop) ?? {
+  return utils.h.properties.auto.global(prop) ?? {
     contents: "contents",
     scroll: "scroll-position"
   }[prop];
@@ -62,7 +63,7 @@ const willChange = [
   [/^will-change-(.+)/, ([, p]) => ({ "will-change": willChangeProperty(p) })]
 ];
 
-const borderStyles = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", ...colors.globalKeywords];
+const borderStyles = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", ...utils.globalKeywords];
 const borders = [
   // compound
   [/^(?:border|b)()(?:-(.+))?$/, handlerBorder, { autocomplete: "(border|b)-<directions>" }],
@@ -103,32 +104,32 @@ const borders = [
 ];
 function borderColorResolver(direction) {
   return ([, body], theme) => {
-    const data = colors.parseColor(body, theme);
+    const data = utils.parseColor(body, theme);
     if (!data)
       return;
     const { alpha, color, cssColor } = data;
     if (cssColor) {
       if (alpha != null) {
         return {
-          [`border${direction}-color`]: colors.colorToString(cssColor, alpha)
+          [`border${direction}-color`]: ruleUtils.colorToString(cssColor, alpha)
         };
       }
       if (direction === "") {
         return {
-          "--un-border-opacity": colors.colorOpacityToString(cssColor),
-          "border-color": colors.colorToString(cssColor, "var(--un-border-opacity)")
+          "--un-border-opacity": ruleUtils.colorOpacityToString(cssColor),
+          "border-color": ruleUtils.colorToString(cssColor, "var(--un-border-opacity)")
         };
       } else {
         return {
           // Separate this return since if `direction` is an empty string, the first key will be overwritten by the second.
-          "--un-border-opacity": colors.colorOpacityToString(cssColor),
+          "--un-border-opacity": ruleUtils.colorOpacityToString(cssColor),
           [`--un-border${direction}-opacity`]: "var(--un-border-opacity)",
-          [`border${direction}-color`]: colors.colorToString(cssColor, `var(--un-border${direction}-opacity)`)
+          [`border${direction}-color`]: ruleUtils.colorToString(cssColor, `var(--un-border${direction}-opacity)`)
         };
       }
     } else if (color) {
       return {
-        [`border${direction}-color`]: colors.colorToString(color, alpha)
+        [`border${direction}-color`]: ruleUtils.colorToString(color, alpha)
       };
     }
   };
@@ -137,46 +138,46 @@ function handlerBorder(m, ctx) {
   return handlerBorderSize(m, ctx);
 }
 function handlerBorderSize([, a = "", b], { theme }) {
-  const v = theme.lineWidth?.[b || "DEFAULT"] ?? colors.h.bracket.cssvar.global.px(b || "1");
-  if (a in colors.directionMap && v != null)
-    return colors.directionMap[a].map((i) => [`border${i}-width`, v]);
+  const v = theme.lineWidth?.[b || "DEFAULT"] ?? utils.h.bracket.cssvar.global.px(b || "1");
+  if (a in utils.directionMap && v != null)
+    return utils.directionMap[a].map((i) => [`border${i}-width`, v]);
 }
 function handlerBorderColor([, a = "", c], { theme }) {
-  if (a in colors.directionMap && colors.hasParseableColor(c, theme)) {
+  if (a in utils.directionMap && utils.hasParseableColor(c, theme)) {
     return Object.assign(
       {},
-      ...colors.directionMap[a].map((i) => borderColorResolver(i)(["", c], theme))
+      ...utils.directionMap[a].map((i) => borderColorResolver(i)(["", c], theme))
     );
   }
 }
 function handlerBorderOpacity([, a = "", opacity]) {
-  const v = colors.h.bracket.percent.cssvar(opacity);
-  if (a in colors.directionMap && v != null)
-    return colors.directionMap[a].map((i) => [`--un-border${i}-opacity`, v]);
+  const v = utils.h.bracket.percent.cssvar(opacity);
+  if (a in utils.directionMap && v != null)
+    return utils.directionMap[a].map((i) => [`--un-border${i}-opacity`, v]);
 }
 function handlerRounded([, a = "", s], { theme }) {
-  const v = theme.borderRadius?.[s || "DEFAULT"] || colors.h.bracket.cssvar.global.fraction.rem(s || "1");
-  if (a in colors.cornerMap && v != null)
-    return colors.cornerMap[a].map((i) => [`border${i}-radius`, v]);
+  const v = theme.borderRadius?.[s || "DEFAULT"] || utils.h.bracket.cssvar.global.fraction.rem(s || "1");
+  if (a in utils.cornerMap && v != null)
+    return utils.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]);
+  if (borderStyles.includes(s) && a in utils.directionMap)
+    return utils.directionMap[a].map((i) => [`border${i}-style`, s]);
 }
 
 const opacity = [
-  [/^op(?:acity)?-?(.+)$/, ([, d]) => ({ opacity: colors.h.bracket.percent.cssvar(d) })]
+  [/^op(?:acity)?-?(.+)$/, ([, d]) => ({ opacity: utils.h.bracket.percent.cssvar(d) })]
 ];
 const textColors = [
-  [/^(?:color|c)-(.+)$/, colors.colorResolver("color", "text"), { autocomplete: "(color|c)-$colors" }],
+  [/^(?:color|c)-(.+)$/, utils.colorResolver("color", "text"), { autocomplete: "(color|c)-$colors" }],
   // auto detection and fallback to font-size if the content looks like a size
-  [/^text-(.+)$/, colors.colorResolver("color", "text", (css) => !css.color?.toString().match(colors.numberWithUnitRE)), { autocomplete: "text-$colors" }],
-  [/^(?:text|color|c)-(.+)$/, ([, v]) => colors.globalKeywords.includes(v) ? { color: v } : void 0, { autocomplete: `(text|color|c)-(${colors.globalKeywords.join("|")})` }],
-  [/^(?:text|color|c)-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-text-opacity": colors.h.bracket.percent.cssvar(opacity2) }), { autocomplete: "(text|color|c)-(op|opacity)-<percent>" }]
+  [/^text-(.+)$/, utils.colorResolver("color", "text", (css) => !css.color?.toString().match(utils.numberWithUnitRE)), { autocomplete: "text-$colors" }],
+  [/^(?:text|color|c)-(.+)$/, ([, v]) => utils.globalKeywords.includes(v) ? { color: v } : void 0, { autocomplete: `(text|color|c)-(${utils.globalKeywords.join("|")})` }],
+  [/^(?:text|color|c)-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-text-opacity": utils.h.bracket.percent.cssvar(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.h.bracket.percent.cssvar(opacity2) }), { autocomplete: "bg-(op|opacity)-<percent>" }]
+  [/^bg-(.+)$/, utils.colorResolver("background-color", "bg"), { autocomplete: "bg-$colors" }],
+  [/^bg-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-bg-opacity": utils.h.bracket.percent.cssvar(opacity2) }), { autocomplete: "bg-(op|opacity)-<percent>" }]
 ];
 const colorScheme = [
   [/^color-scheme-(\w+)$/, ([, v]) => ({ "color-scheme": v })]
@@ -192,15 +193,15 @@ const containerParent = [
   }]
 ];
 
-const decorationStyles = ["solid", "double", "dotted", "dashed", "wavy", ...colors.globalKeywords];
+const decorationStyles = ["solid", "double", "dotted", "dashed", "wavy", ...utils.globalKeywords];
 const textDecorations = [
   [/^(?:decoration-)?(underline|overline|line-through)$/, ([, s]) => ({ "text-decoration-line": s }), { autocomplete: "decoration-(underline|overline|line-through)" }],
   // size
-  [/^(?:underline|decoration)-(?:size-)?(.+)$/, ([, s], { theme }) => ({ "text-decoration-thickness": theme.lineWidth?.[s] ?? colors.h.bracket.cssvar.global.px(s) }), { autocomplete: "(underline|decoration)-<num>" }],
+  [/^(?:underline|decoration)-(?:size-)?(.+)$/, ([, s], { theme }) => ({ "text-decoration-thickness": theme.lineWidth?.[s] ?? utils.h.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)" }],
   // colors
   [/^(?:underline|decoration)-(.+)$/, (match, ctx) => {
-    const result = colors.colorResolver("text-decoration-color", "line")(match, ctx);
+    const result = utils.colorResolver("text-decoration-color", "line")(match, ctx);
     if (result) {
       return {
         "-webkit-text-decoration-color": result["text-decoration-color"],
@@ -208,9 +209,9 @@ const textDecorations = [
       };
     }
   }, { autocomplete: "(underline|decoration)-$colors" }],
-  [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": colors.h.bracket.percent.cssvar(opacity) }), { autocomplete: "(underline|decoration)-(op|opacity)-<percent>" }],
+  [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": utils.h.bracket.percent.cssvar(opacity) }), { autocomplete: "(underline|decoration)-(op|opacity)-<percent>" }],
   // offset
-  [/^(?:underline|decoration)-offset-(.+)$/, ([, s], { theme }) => ({ "text-underline-offset": theme.lineWidth?.[s] ?? colors.h.auto.bracket.cssvar.global.px(s) }), { autocomplete: "(underline|decoration)-(offset)-<num>" }],
+  [/^(?:underline|decoration)-offset-(.+)$/, ([, s], { theme }) => ({ "text-underline-offset": theme.lineWidth?.[s] ?? utils.h.auto.bracket.cssvar.global.px(s) }), { autocomplete: "(underline|decoration)-(offset)-<num>" }],
   // style
   ...decorationStyles.map((v) => [`underline-${v}`, { "text-decoration-style": v }]),
   ...decorationStyles.map((v) => [`decoration-${v}`, { "text-decoration-style": v }]),
@@ -227,14 +228,14 @@ const transitionPropertyGroup = {
   transform: "transform"
 };
 function transitionProperty(prop) {
-  return colors.h.properties(prop) ?? transitionPropertyGroup[prop];
+  return utils.h.properties(prop) ?? transitionPropertyGroup[prop];
 }
 const transitions = [
   // transition
   [/^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.h.time(d || "150");
+      const duration = theme.duration?.[d || "DEFAULT"] ?? utils.h.time(d || "150");
       return {
         "transition-property": p,
         "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
@@ -245,28 +246,28 @@ const transitions = [
   // timings
   [
     /^(?:transition-)?duration-(.+)$/,
-    ([, d], { theme }) => ({ "transition-duration": theme.duration?.[d || "DEFAULT"] ?? colors.h.bracket.cssvar.time(d) }),
+    ([, d], { theme }) => ({ "transition-duration": theme.duration?.[d || "DEFAULT"] ?? utils.h.bracket.cssvar.time(d) }),
     { autocomplete: ["transition-duration-$duration", "duration-$duration"] }
   ],
   [
     /^(?:transition-)?delay-(.+)$/,
-    ([, d], { theme }) => ({ "transition-delay": theme.duration?.[d || "DEFAULT"] ?? colors.h.bracket.cssvar.time(d) }),
+    ([, d], { theme }) => ({ "transition-delay": theme.duration?.[d || "DEFAULT"] ?? utils.h.bracket.cssvar.time(d) }),
     { autocomplete: ["transition-delay-$duration", "delay-$duration"] }
   ],
   [
     /^(?:transition-)?ease(?:-(.+))?$/,
-    ([, d], { theme }) => ({ "transition-timing-function": theme.easing?.[d || "DEFAULT"] ?? colors.h.bracket.cssvar(d) }),
+    ([, d], { theme }) => ({ "transition-timing-function": theme.easing?.[d || "DEFAULT"] ?? utils.h.bracket.cssvar(d) }),
     { autocomplete: ["transition-ease-(linear|in|out|in-out|DEFAULT)", "ease-(linear|in|out|in-out|DEFAULT)"] }
   ],
   // props
   [
     /^(?:transition-)?property-(.+)$/,
-    ([, v]) => ({ "transition-property": colors.h.bracket.global(v) || transitionProperty(v) }),
-    { autocomplete: [`transition-property-(${[...colors.globalKeywords, ...Object.keys(transitionPropertyGroup)].join("|")})`] }
+    ([, v]) => ({ "transition-property": utils.h.bracket.global(v) || transitionProperty(v) }),
+    { autocomplete: [`transition-property-(${[...utils.globalKeywords, ...Object.keys(transitionPropertyGroup)].join("|")})`] }
   ],
   // none
   ["transition-none", { transition: "none" }],
-  ...colors.makeGlobalStaticRules("transition")
+  ...utils.makeGlobalStaticRules("transition")
 ];
 
 const flex = [
@@ -275,15 +276,15 @@ const flex = [
   ["inline-flex", { display: "inline-flex" }],
   ["flex-inline", { display: "inline-flex" }],
   // flex
-  [/^flex-(.*)$/, ([, d]) => ({ flex: colors.h.bracket(d) != null ? colors.h.bracket(d).split(" ").map((e) => colors.h.cssvar.fraction(e) ?? e).join(" ") : colors.h.cssvar.fraction(d) })],
+  [/^flex-(.*)$/, ([, d]) => ({ flex: utils.h.bracket(d) != null ? utils.h.bracket(d).split(" ").map((e) => utils.h.cssvar.fraction(e) ?? e).join(" ") : utils.h.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" }],
   // shrink/grow/basis
-  [/^(?:flex-)?shrink(?:-(.*))?$/, ([, d = ""]) => ({ "flex-shrink": colors.h.bracket.cssvar.number(d) ?? 1 }), { autocomplete: ["flex-shrink-<num>", "shrink-<num>"] }],
-  [/^(?:flex-)?grow(?:-(.*))?$/, ([, d = ""]) => ({ "flex-grow": colors.h.bracket.cssvar.number(d) ?? 1 }), { autocomplete: ["flex-grow-<num>", "grow-<num>"] }],
-  [/^(?:flex-)?basis-(.+)$/, ([, d], { theme }) => ({ "flex-basis": theme.spacing?.[d] ?? colors.h.bracket.cssvar.auto.fraction.rem(d) }), { autocomplete: ["flex-basis-$spacing", "basis-$spacing"] }],
+  [/^(?:flex-)?shrink(?:-(.*))?$/, ([, d = ""]) => ({ "flex-shrink": utils.h.bracket.cssvar.number(d) ?? 1 }), { autocomplete: ["flex-shrink-<num>", "shrink-<num>"] }],
+  [/^(?:flex-)?grow(?:-(.*))?$/, ([, d = ""]) => ({ "flex-grow": utils.h.bracket.cssvar.number(d) ?? 1 }), { autocomplete: ["flex-grow-<num>", "grow-<num>"] }],
+  [/^(?:flex-)?basis-(.+)$/, ([, d], { theme }) => ({ "flex-basis": theme.spacing?.[d] ?? utils.h.bracket.cssvar.auto.fraction.rem(d) }), { autocomplete: ["flex-basis-$spacing", "basis-$spacing"] }],
   // directions
   ["flex-row", { "flex-direction": "row" }],
   ["flex-row-reverse", { "flex-direction": "row-reverse" }],
@@ -296,14 +297,14 @@ const flex = [
 ];
 
 function handleLineHeight(s, theme) {
-  return theme.lineHeight?.[s] || colors.h.bracket.cssvar.global.rem(s);
+  return theme.lineHeight?.[s] || utils.h.bracket.cssvar.global.rem(s);
 }
 const fonts = [
   // size
   [
     /^text-(.+)$/,
     ([, s = "base"], { theme }) => {
-      const [size, leading] = colors.splitShorthand(s, "length");
+      const [size, leading] = utils.splitShorthand(s, "length");
       const sizePairs = core.toArray(theme.fontSize?.[size]);
       const lineHeight = leading ? handleLineHeight(leading, theme) : void 0;
       if (sizePairs?.[0]) {
@@ -313,27 +314,27 @@ const fonts = [
           "line-height": lineHeight ?? height ?? "1"
         };
       }
-      const fontSize = colors.h.bracketOfLength.rem(size);
+      const fontSize = utils.h.bracketOfLength.rem(size);
       if (lineHeight && fontSize) {
         return {
           "font-size": fontSize,
           "line-height": lineHeight
         };
       }
-      return { "font-size": colors.h.bracketOfLength.rem(s) };
+      return { "font-size": utils.h.bracketOfLength.rem(s) };
     },
     { autocomplete: "text-$fontSize" }
   ],
   [/^(?:text|font)-size-(.+)$/, ([, s], { theme }) => {
     const themed = core.toArray(theme.fontSize?.[s]);
-    const size = themed?.[0] ?? colors.h.bracket.cssvar.global.rem(s);
+    const size = themed?.[0] ?? utils.h.bracket.cssvar.global.rem(s);
     if (size != null)
       return { "font-size": size };
   }, { autocomplete: "text-size-$fontSize" }],
   // weights
   [
     /^(?:font|fw)-?([^-]+)$/,
-    ([, s], { theme }) => ({ "font-weight": theme.fontWeight?.[s] || colors.h.bracket.global.number(s) }),
+    ([, s], { theme }) => ({ "font-weight": theme.fontWeight?.[s] || utils.h.bracket.global.number(s) }),
     {
       autocomplete: [
         "(font|fw)-(100|200|300|400|500|600|700|800|900)",
@@ -352,29 +353,29 @@ const fonts = [
   ["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.h.bracket.cssvar.global(s) })],
+  [/^font-synthesis-(.+)$/, ([, s]) => ({ "font-synthesis": utils.h.bracket.cssvar.global(s) })],
   // tracking
   [
     /^(?:font-)?tracking-(.+)$/,
-    ([, s], { theme }) => ({ "letter-spacing": theme.letterSpacing?.[s] || colors.h.bracket.cssvar.global.rem(s) }),
+    ([, s], { theme }) => ({ "letter-spacing": theme.letterSpacing?.[s] || utils.h.bracket.cssvar.global.rem(s) }),
     { autocomplete: "tracking-$letterSpacing" }
   ],
   // word-spacing
   [
     /^(?:font-)?word-spacing-(.+)$/,
-    ([, s], { theme }) => ({ "word-spacing": theme.wordSpacing?.[s] || colors.h.bracket.cssvar.global.rem(s) }),
+    ([, s], { theme }) => ({ "word-spacing": theme.wordSpacing?.[s] || utils.h.bracket.cssvar.global.rem(s) }),
     { autocomplete: "word-spacing-$wordSpacing" }
   ],
   // family
   [
     /^font-(.+)$/,
-    ([, d], { theme }) => ({ "font-family": theme.fontFamily?.[d] || colors.h.bracket.cssvar.global(d) }),
+    ([, d], { theme }) => ({ "font-family": theme.fontFamily?.[d] || utils.h.bracket.cssvar.global(d) }),
     { autocomplete: "font-$fontFamily" }
   ]
 ];
 const tabSizes = [
   [/^tab(?:-(.+))?$/, ([, s]) => {
-    const v = colors.h.bracket.cssvar.global.number(s || "4");
+    const v = utils.h.bracket.cssvar.global.number(s || "4");
     if (v != null) {
       return {
         "-moz-tab-size": v,
@@ -385,29 +386,29 @@ const tabSizes = [
   }]
 ];
 const textIndents = [
-  [/^indent(?:-(.+))?$/, ([, s], { theme }) => ({ "text-indent": theme.textIndent?.[s || "DEFAULT"] || colors.h.bracket.cssvar.global.fraction.rem(s) }), { autocomplete: "indent-$textIndent" }]
+  [/^indent(?:-(.+))?$/, ([, s], { theme }) => ({ "text-indent": theme.textIndent?.[s || "DEFAULT"] || utils.h.bracket.cssvar.global.fraction.rem(s) }), { autocomplete: "indent-$textIndent" }]
 ];
 const textStrokes = [
   // widths
-  [/^text-stroke(?:-(.+))?$/, ([, s], { theme }) => ({ "-webkit-text-stroke-width": theme.textStrokeWidth?.[s || "DEFAULT"] || colors.h.bracket.cssvar.px(s) }), { autocomplete: "text-stroke-$textStrokeWidth" }],
+  [/^text-stroke(?:-(.+))?$/, ([, s], { theme }) => ({ "-webkit-text-stroke-width": theme.textStrokeWidth?.[s || "DEFAULT"] || utils.h.bracket.cssvar.px(s) }), { autocomplete: "text-stroke-$textStrokeWidth" }],
   // colors
-  [/^text-stroke-(.+)$/, colors.colorResolver("-webkit-text-stroke-color", "text-stroke"), { autocomplete: "text-stroke-$colors" }],
-  [/^text-stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-stroke-opacity": colors.h.bracket.percent.cssvar(opacity) }), { autocomplete: "text-stroke-(op|opacity)-<percent>" }]
+  [/^text-stroke-(.+)$/, utils.colorResolver("-webkit-text-stroke-color", "text-stroke"), { autocomplete: "text-stroke-$colors" }],
+  [/^text-stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-stroke-opacity": utils.h.bracket.percent.cssvar(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(","),
+        "--un-text-shadow": utils.colorableShadows(v, "--un-text-shadow-color").join(","),
         "text-shadow": "var(--un-text-shadow)"
       };
     }
-    return { "text-shadow": colors.h.bracket.cssvar.global(s) };
+    return { "text-shadow": utils.h.bracket.cssvar.global(s) };
   }, { autocomplete: "text-shadow-$textShadow" }],
   // colors
-  [/^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.h.bracket.percent.cssvar(opacity) }), { autocomplete: "text-shadow-color-(op|opacity)-<percent>" }]
+  [/^text-shadow-color-(.+)$/, utils.colorResolver("--un-text-shadow-color", "text-shadow"), { autocomplete: "text-shadow-color-$colors" }],
+  [/^text-shadow-color-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-shadow-opacity": utils.h.bracket.percent.cssvar(opacity) }), { autocomplete: "text-shadow-color-(op|opacity)-<percent>" }]
 ];
 
 const directions = {
@@ -416,7 +417,7 @@ const directions = {
   "y": "row-"
 };
 function handleGap([, d = "", s], { theme }) {
-  const v = theme.spacing?.[s] ?? colors.h.bracket.cssvar.global.rem(s);
+  const v = theme.spacing?.[s] ?? utils.h.bracket.cssvar.global.rem(s);
   if (v != null) {
     return {
       [`${directions[d]}gap`]: v
@@ -446,7 +447,7 @@ function autoDirection(c, theme, prop) {
     case "fr":
       return "minmax(0,1fr)";
   }
-  return colors.h.bracket.cssvar.auto.rem(prop);
+  return utils.h.bracket.cssvar.auto.rem(prop);
 }
 const grids = [
   // displays
@@ -454,36 +455,36 @@ const grids = [
   ["inline-grid", { display: "inline-grid" }],
   // global
   [/^(?:grid-)?(row|col)-(.+)$/, ([, c, v], { theme }) => ({
-    [`grid-${rowCol(c)}`]: theme[`grid${rowColTheme(c)}`]?.[v] ?? colors.h.bracket.cssvar.auto(v)
+    [`grid-${rowCol(c)}`]: theme[`grid${rowColTheme(c)}`]?.[v] ?? utils.h.bracket.cssvar.auto(v)
   })],
   // span
   [/^(?:grid-)?(row|col)-span-(.+)$/, ([, c, s]) => {
     if (s === "full")
       return { [`grid-${rowCol(c)}`]: "1/-1" };
-    const v = colors.h.bracket.number(s);
+    const v = utils.h.bracket.number(s);
     if (v != null)
       return { [`grid-${rowCol(c)}`]: `span ${v}/span ${v}` };
   }, { autocomplete: ["grid-(row|col)-span-<num>", "(row|col)-span-<num>"] }],
   // starts & ends
-  [/^(?:grid-)?(row|col)-start-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-start`]: colors.h.bracket.cssvar(v) ?? v })],
-  [/^(?:grid-)?(row|col)-end-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-end`]: colors.h.bracket.cssvar(v) ?? v }), { autocomplete: ["grid-(row|col)-(start|end)-<num>"] }],
+  [/^(?:grid-)?(row|col)-start-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-start`]: utils.h.bracket.cssvar(v) ?? v })],
+  [/^(?:grid-)?(row|col)-end-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-end`]: utils.h.bracket.cssvar(v) ?? v }), { autocomplete: ["grid-(row|col)-(start|end)-<num>"] }],
   // auto flows
   [/^(?: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: uno
   // grid-flow: wind
-  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(.+)$/, ([, v]) => ({ "grid-auto-flow": colors.h.bracket.cssvar(v) })],
+  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(.+)$/, ([, v]) => ({ "grid-auto-flow": utils.h.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)"] }],
   // templates
   [/^grid-(rows|cols)-(.+)$/, ([, c, v], { theme }) => ({
-    [`grid-template-${rowCol(c)}`]: theme[`gridTemplate${rowColTheme(c)}`]?.[v] ?? colors.h.bracket.cssvar(v)
+    [`grid-template-${rowCol(c)}`]: theme[`gridTemplate${rowColTheme(c)}`]?.[v] ?? utils.h.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"] }],
   // areas
   [/^grid-area(s)?-(.+)$/, ([, s, v]) => {
     if (s != null)
-      return { "grid-template-areas": colors.h.cssvar(v) ?? v.split("-").map((s2) => `"${colors.h.bracket(s2)}"`).join(" ") };
-    return { "grid-area": colors.h.bracket.cssvar(v) };
+      return { "grid-template-areas": utils.h.cssvar(v) ?? v.split("-").map((s2) => `"${utils.h.bracket(s2)}"`).join(" ") };
+    return { "grid-area": utils.h.bracket.cssvar(v) };
   }],
   // template none
   ["grid-rows-none", { "grid-template-rows": "none" }],
@@ -497,7 +498,7 @@ const overflowValues = [
   "visible",
   "scroll",
   "overlay",
-  ...colors.globalKeywords
+  ...utils.globalKeywords
 ];
 const overflows = [
   [/^(?:overflow|of)-(.+)$/, ([, v]) => overflowValues.includes(v) ? { overflow: v } : void 0, { autocomplete: [`(overflow|of)-(${overflowValues.join("|")})`, `(overflow|of)-(x|y)-(${overflowValues.join("|")})`] }],
@@ -512,7 +513,7 @@ const positions = [
       "<position>"
     ]
   }],
-  [/^(?:position-|pos-)([-\w]+)$/, ([, v]) => colors.globalKeywords.includes(v) ? { position: v } : void 0],
+  [/^(?:position-|pos-)([-\w]+)$/, ([, v]) => utils.globalKeywords.includes(v) ? { position: v } : void 0],
   [/^(?:position-|pos-)?(static)$/, ([, v]) => ({ position: v })]
 ];
 const justifies = [
@@ -524,23 +525,23 @@ const justifies = [
   ["justify-around", { "justify-content": "space-around" }],
   ["justify-evenly", { "justify-content": "space-evenly" }],
   ["justify-stretch", { "justify-content": "stretch" }],
-  ...colors.makeGlobalStaticRules("justify", "justify-content"),
+  ...utils.makeGlobalStaticRules("justify", "justify-content"),
   // items
   ["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"),
+  ...utils.makeGlobalStaticRules("justify-items"),
   // selfs
   ["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")
+  ...utils.makeGlobalStaticRules("justify-self")
 ];
 const orders = [
-  [/^order-(.+)$/, ([, v]) => ({ order: colors.h.bracket.cssvar.number(v) })],
+  [/^order-(.+)$/, ([, v]) => ({ order: utils.h.bracket.cssvar.number(v) })],
   ["order-first", { order: "-9999" }],
   ["order-last", { order: "9999" }],
   ["order-none", { order: "0" }]
@@ -553,14 +554,14 @@ const alignments = [
   ["content-between", { "align-content": "space-between" }],
   ["content-around", { "align-content": "space-around" }],
   ["content-evenly", { "align-content": "space-evenly" }],
-  ...colors.makeGlobalStaticRules("content", "align-content"),
+  ...utils.makeGlobalStaticRules("content", "align-content"),
   // items
   ["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"),
+  ...utils.makeGlobalStaticRules("items", "align-items"),
   // selfs
   ["self-auto", { "align-self": "auto" }],
   ["self-start", { "align-self": "flex-start" }],
@@ -568,7 +569,7 @@ const alignments = [
   ["self-center", { "align-self": "center" }],
   ["self-stretch", { "align-self": "stretch" }],
   ["self-baseline", { "align-self": "baseline" }],
-  ...colors.makeGlobalStaticRules("self", "align-self")
+  ...utils.makeGlobalStaticRules("self", "align-self")
 ];
 const placements = [
   // contents
@@ -579,32 +580,32 @@ const placements = [
   ["place-content-around", { "place-content": "space-around" }],
   ["place-content-evenly", { "place-content": "space-evenly" }],
   ["place-content-stretch", { "place-content": "stretch" }],
-  ...colors.makeGlobalStaticRules("place-content"),
+  ...utils.makeGlobalStaticRules("place-content"),
   // items
   ["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"),
+  ...utils.makeGlobalStaticRules("place-items"),
   // selfs
   ["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")
+  ...utils.makeGlobalStaticRules("place-self")
 ];
 const flexGridJustifiesAlignments = [...justifies, ...alignments].flatMap(([k, v]) => [
   [`flex-${k}`, v],
   [`grid-${k}`, v]
 ]);
 function handleInsetValue(v, { theme }) {
-  return theme.spacing?.[v] ?? colors.h.bracket.cssvar.global.auto.fraction.rem(v);
+  return theme.spacing?.[v] ?? utils.h.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]);
+  if (r != null && d in utils.insetMap)
+    return utils.insetMap[d].map((i) => [i.slice(1), r]);
 }
 const insets = [
   [
@@ -631,22 +632,22 @@ const floats = [
   ["float-left", { float: "left" }],
   ["float-right", { float: "right" }],
   ["float-none", { float: "none" }],
-  ...colors.makeGlobalStaticRules("float"),
+  ...utils.makeGlobalStaticRules("float"),
   // clears
   ["clear-left", { clear: "left" }],
   ["clear-right", { clear: "right" }],
   ["clear-both", { clear: "both" }],
   ["clear-none", { clear: "none" }],
-  ...colors.makeGlobalStaticRules("clear")
+  ...utils.makeGlobalStaticRules("clear")
 ];
 const zIndexes = [
-  [/^(?:position-|pos-)?z([\d.]+)$/, ([, v]) => ({ "z-index": colors.h.number(v) })],
-  [/^(?:position-|pos-)?z-(.+)$/, ([, v], { theme }) => ({ "z-index": theme.zIndex?.[v] ?? colors.h.bracket.cssvar.global.auto.number(v) }), { autocomplete: "z-<num>" }]
+  [/^(?:position-|pos-)?z([\d.]+)$/, ([, v]) => ({ "z-index": utils.h.number(v) })],
+  [/^(?:position-|pos-)?z-(.+)$/, ([, v], { theme }) => ({ "z-index": theme.zIndex?.[v] ?? utils.h.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")
+  ...utils.makeGlobalStaticRules("box", "box-sizing")
 ];
 
 const sizeMapping = {
@@ -669,7 +670,7 @@ function getSizeValue(minmax, hw, theme, prop) {
     case "min":
       return `${prop}-content`;
   }
-  return colors.h.bracket.cssvar.global.auto.fraction.rem(prop);
+  return utils.h.bracket.cssvar.global.auto.fraction.rem(prop);
 }
 const sizes = [
   [/^(?:size-)?(min-|max-)?([wh])-?(.+)$/, ([, m, w, s], { theme }) => ({ [getPropName(m, w)]: getSizeValue(m, w, theme, s) })],
@@ -683,8 +684,8 @@ const sizes = [
       "(max|min)-(w|h)-full"
     ]
   }],
-  [/^(?:size-)?(min-|max-)?(h)-screen-(.+)$/, ([, m, w, s], context) => ({ [getPropName(m, w)]: colors.resolveVerticalBreakpoints(context)?.[s] })],
-  [/^(?:size-)?(min-|max-)?(w)-screen-(.+)$/, ([, m, w, s], context) => ({ [getPropName(m, w)]: colors.resolveBreakpoints(context)?.[s] }), {
+  [/^(?:size-)?(min-|max-)?(h)-screen-(.+)$/, ([, m, w, s], context) => ({ [getPropName(m, w)]: utils.resolveVerticalBreakpoints(context)?.[s] })],
+  [/^(?:size-)?(min-|max-)?(w)-screen-(.+)$/, ([, m, w, s], context) => ({ [getPropName(m, w)]: utils.resolveBreakpoints(context)?.[s] }), {
     autocomplete: [
       "(w|h)-screen",
       "(min|max)-(w|h)-screen",
@@ -704,27 +705,27 @@ function getAspectRatio(prop) {
     case "video":
       return "16/9";
   }
-  return colors.h.bracket.cssvar.global.auto.number(prop);
+  return utils.h.bracket.cssvar.global.auto.number(prop);
 }
 const aspectRatio = [
   [/^(?:size-)?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>" }]
+  [/^pa?()-?(-?.+)$/, utils.directionSize("padding"), { autocomplete: ["(m|p)<num>", "(m|p)-<num>"] }],
+  [/^p-?xy()()$/, utils.directionSize("padding"), { autocomplete: "(m|p)-(xy)" }],
+  [/^p-?([xy])(?:-?(-?.+))?$/, utils.directionSize("padding")],
+  [/^p-?([rltbse])(?:-?(-?.+))?$/, utils.directionSize("padding"), { autocomplete: "(m|p)<directions>-<num>" }],
+  [/^p-(block|inline)(?:-(-?.+))?$/, utils.directionSize("padding"), { autocomplete: "(m|p)-(block|inline)-<num>" }],
+  [/^p-?([bi][se])(?:-?(-?.+))?$/, utils.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")]
+  [/^ma?()-?(-?.+)$/, utils.directionSize("margin")],
+  [/^m-?xy()()$/, utils.directionSize("margin")],
+  [/^m-?([xy])(?:-?(-?.+))?$/, utils.directionSize("margin")],
+  [/^m-?([rltbse])(?:-?(-?.+))?$/, utils.directionSize("margin")],
+  [/^m-(block|inline)(?:-(-?.+))?$/, utils.directionSize("margin")],
+  [/^m-?([bi][se])(?:-?(-?.+))?$/, utils.directionSize("margin")]
 ];
 
 const variablesAbbrMap = {
@@ -746,7 +747,7 @@ const cssVariables = [
   [/^(.+?)-(\$.+)$/, ([, name, varname]) => {
     const prop = variablesAbbrMap[name];
     if (prop)
-      return { [prop]: colors.h.cssvar(varname) };
+      return { [prop]: utils.h.cssvar(varname) };
   }]
 ];
 const cssProperty = [
@@ -756,7 +757,7 @@ const cssProperty = [
     const [prop, ...rest] = body.split(":");
     const value = rest.join(":");
     if (!isURI(body) && prop.match(/^[a-z-]+$/) && isValidCSSBody(value)) {
-      const parsed = colors.h.bracket(`[${value}]`);
+      const parsed = utils.h.bracket(`[${value}]`);
       if (parsed)
         return { [prop]: parsed };
     }
@@ -810,17 +811,17 @@ ${constructCSS({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
 
 const svgUtilities = [
   // fills
-  [/^fill-(.+)$/, colors.colorResolver("fill", "fill"), { autocomplete: "fill-$colors" }],
-  [/^fill-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-fill-opacity": colors.h.bracket.percent.cssvar(opacity) }), { autocomplete: "fill-(op|opacity)-<percent>" }],
+  [/^fill-(.+)$/, utils.colorResolver("fill", "fill"), { autocomplete: "fill-$colors" }],
+  [/^fill-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-fill-opacity": utils.h.bracket.percent.cssvar(opacity) }), { autocomplete: "fill-(op|opacity)-<percent>" }],
   ["fill-none", { fill: "none" }],
   // stroke size
-  [/^stroke-(?:width-|size-)?(.+)$/, ([, s], { theme }) => ({ "stroke-width": theme.lineWidth?.[s] ?? colors.h.bracket.cssvar.fraction.px.number(s) }), { autocomplete: ["stroke-width-$lineWidth", "stroke-size-$lineWidth"] }],
+  [/^stroke-(?:width-|size-)?(.+)$/, ([, s], { theme }) => ({ "stroke-width": theme.lineWidth?.[s] ?? utils.h.bracket.cssvar.fraction.px.number(s) }), { autocomplete: ["stroke-width-$lineWidth", "stroke-size-$lineWidth"] }],
   // stroke dash
-  [/^stroke-dash-(.+)$/, ([, s]) => ({ "stroke-dasharray": colors.h.bracket.cssvar.number(s) }), { autocomplete: "stroke-dash-<num>" }],
-  [/^stroke-offset-(.+)$/, ([, s], { theme }) => ({ "stroke-dashoffset": theme.lineWidth?.[s] ?? colors.h.bracket.cssvar.px.numberWithUnit(s) }), { autocomplete: "stroke-offset-$lineWidth" }],
+  [/^stroke-dash-(.+)$/, ([, s]) => ({ "stroke-dasharray": utils.h.bracket.cssvar.number(s) }), { autocomplete: "stroke-dash-<num>" }],
+  [/^stroke-offset-(.+)$/, ([, s], { theme }) => ({ "stroke-dashoffset": theme.lineWidth?.[s] ?? utils.h.bracket.cssvar.px.numberWithUnit(s) }), { autocomplete: "stroke-offset-$lineWidth" }],
   // stroke colors
-  [/^stroke-(.+)$/, colors.colorResolver("stroke", "stroke"), { autocomplete: "stroke-$colors" }],
-  [/^stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-stroke-opacity": colors.h.bracket.percent.cssvar(opacity) }), { autocomplete: "stroke-(op|opacity)-<percent>" }],
+  [/^stroke-(.+)$/, utils.colorResolver("stroke", "stroke"), { autocomplete: "stroke-$colors" }],
+  [/^stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-stroke-opacity": utils.h.bracket.percent.cssvar(opacity) }), { autocomplete: "stroke-(op|opacity)-<percent>" }],
   // line cap
   ["stroke-cap-square", { "stroke-linecap": "square" }],
   ["stroke-cap-round", { "stroke-linecap": "round" }],