@unocss/preset-mini 0.42.1 → 0.43.2

package/dist/chunks/default2.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const utilities = require('./utilities.cjs');
+const colors = require('./colors2.cjs');
 const core = require('@unocss/core');
 const transform = require('./transform.cjs');
 
@@ -16,19 +16,19 @@ const verticalAlignAlias = {
   "text-bottom": "text-bottom",
   "sub": "sub",
   "super": "super",
-  ...Object.fromEntries(utilities.globalKeywords.map((x) => [x, x]))
+  ...Object.fromEntries(colors.globalKeywords.map((x) => [x, x]))
 };
 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", ...utilities.globalKeywords].map((v) => [`text-${v}`, { "text-align": v }]);
+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] ?? utilities.handler.bracket.cssvar.global.px(d) }), { autocomplete: "outline-(width|size)-<num>" }],
-  [/^outline-(?:color-)?(.+)$/, utilities.colorResolver("outline-color", "outline-color"), { autocomplete: "outline-$colors" }],
-  [/^outline-offset-(.+)$/, ([, d], { theme }) => ({ "outline-offset": theme.lineWidth?.[d] ?? utilities.handler.bracket.cssvar.global.px(d) }), { autocomplete: "outline-(offset)-<num>" }],
+  [/^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", ...utilities.globalKeywords].map((v) => [`outline-${v}`, { "outline-style": v }]),
+  ...["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 = [
@@ -38,7 +38,7 @@ const appearance = [
   }]
 ];
 const willChangeProperty = (prop) => {
-  return utilities.handler.properties.auto.global(prop) ?? {
+  return colors.handler.properties.auto.global(prop) ?? {
     contents: "contents",
     scroll: "scroll-position"
   }[prop];
@@ -47,7 +47,7 @@ const willChange = [
   [/^will-change-(.+)/, ([, p]) => ({ "will-change": willChangeProperty(p) })]
 ];
 
-const borderStyles = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", ...utilities.globalKeywords];
+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],
@@ -81,31 +81,31 @@ const borders = [
   [/^(?:border|b)-([bi][se])-(?:style-)?(.+)$/, handlerBorderStyle]
 ];
 const borderColorResolver = (direction) => ([, body], theme) => {
-  const data = utilities.parseColor(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`]: utilities.colorToString(cssColor, alpha)
+        [`border${direction}-color`]: colors.colorToString(cssColor, alpha)
       };
     }
     if (direction === "") {
       return {
-        "--un-border-opacity": utilities.colorOpacityToString(cssColor),
-        "border-color": utilities.colorToString(cssColor, "var(--un-border-opacity)")
+        "--un-border-opacity": colors.colorOpacityToString(cssColor),
+        "border-color": colors.colorToString(cssColor, "var(--un-border-opacity)")
       };
     } else {
       return {
-        "--un-border-opacity": utilities.colorOpacityToString(cssColor),
+        "--un-border-opacity": colors.colorOpacityToString(cssColor),
         [`--un-border${direction}-opacity`]: "var(--un-border-opacity)",
-        [`border${direction}-color`]: utilities.colorToString(cssColor, `var(--un-border${direction}-opacity)`)
+        [`border${direction}-color`]: colors.colorToString(cssColor, `var(--un-border${direction}-opacity)`)
       };
     }
   } else if (color) {
     return {
-      [`border${direction}-color`]: utilities.colorToString(color, alpha)
+      [`border${direction}-color`]: colors.colorToString(color, alpha)
     };
   }
 };
@@ -120,40 +120,40 @@ function handlerBorder(m, ctx) {
   }
 }
 function handlerBorderSize([, a = "", b], { theme }) {
-  const v = theme.lineWidth?.[b || "DEFAULT"] ?? utilities.handler.bracket.cssvar.global.px(b || "1");
-  if (a in utilities.directionMap && v != null)
-    return utilities.directionMap[a].map((i) => [`border${i}-width`, v]);
+  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 utilities.directionMap && utilities.hasParseableColor(c, theme)) {
-    return Object.assign({}, ...utilities.directionMap[a].map((i) => borderColorResolver(i)(["", 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 = utilities.handler.bracket.percent(opacity);
-  if (a in utilities.directionMap && v != null)
-    return utilities.directionMap[a].map((i) => [`--un-border${i}-opacity`, v]);
+  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"] || utilities.handler.bracket.cssvar.global.fraction.rem(s || "1");
-  if (a in utilities.cornerMap && v != null)
-    return utilities.cornerMap[a].map((i) => [`border${i}-radius`, v]);
+  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 utilities.directionMap)
-    return utilities.directionMap[a].map((i) => [`border${i}-style`, 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: utilities.handler.bracket.percent.cssvar(d) })]
+  [/^op(?:acity)?-?(.+)$/, ([, d]) => ({ opacity: colors.handler.bracket.percent.cssvar(d) })]
 ];
 const textColors = [
-  [/^(?:text|color|c)-(.+)$/, utilities.colorResolver("color", "text"), { autocomplete: "(text|color|c)-$colors" }],
-  [/^(?:text|color|c)-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-text-opacity": utilities.handler.bracket.percent(opacity2) }), { autocomplete: "(text|color|c)-(op|opacity)-<percent>" }]
+  [/^(?:text|color|c)-(.+)$/, colors.colorResolver("color", "text"), { 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-(.+)$/, utilities.colorResolver("background-color", "bg"), { autocomplete: "bg-$colors" }],
-  [/^bg-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-bg-opacity": utilities.handler.bracket.percent(opacity2) }), { autocomplete: "bg-(op|opacity)-<percent>" }]
+  [/^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 = {
@@ -165,13 +165,13 @@ const transitionPropertyGroup = {
   transform: "transform"
 };
 const transitionProperty = (prop) => {
-  return utilities.handler.properties(prop) ?? transitionPropertyGroup[prop];
+  return colors.handler.properties(prop) ?? transitionPropertyGroup[prop];
 };
 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"] ?? utilities.handler.time(d || "150");
+      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)",
@@ -181,33 +181,33 @@ const transitions = [
   }, { autocomplete: `transition-(${Object.keys(transitionPropertyGroup).join("|")})` }],
   [
     /^(?:transition-)?duration-(.+)$/,
-    ([, d], { theme }) => ({ "transition-duration": theme.duration?.[d || "DEFAULT"] ?? utilities.handler.bracket.cssvar.time(d) }),
+    ([, 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"] ?? utilities.handler.bracket.cssvar.time(d) }),
+    ([, 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"] ?? utilities.handler.bracket.cssvar(d) }),
+    ([, 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": utilities.handler.global(v) || transitionProperty(v) }),
-    { autocomplete: [`transition-property-(${[...utilities.globalKeywords, ...Object.keys(transitionPropertyGroup)].join("|")})`] }
+    ([, v]) => ({ "transition-property": colors.handler.global(v) || transitionProperty(v) }),
+    { autocomplete: [`transition-property-(${[...colors.globalKeywords, ...Object.keys(transitionPropertyGroup)].join("|")})`] }
   ],
   ["transition-none", { transition: "none" }],
-  ...utilities.makeGlobalStaticRules("transition")
+  ...colors.makeGlobalStaticRules("transition")
 ];
 
 const flex = [
   ["flex", { display: "flex" }],
   ["inline-flex", { display: "inline-flex" }],
   ["flex-inline", { display: "inline-flex" }],
-  [/^flex-(.*)$/, ([, d]) => ({ flex: utilities.handler.bracket(d) != null ? utilities.handler.bracket(d).split(" ").map((e) => utilities.handler.cssvar.fraction(e) ?? e).join(" ") : utilities.handler.cssvar.fraction(d) })],
+  [/^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" }],
@@ -216,7 +216,7 @@ const flex = [
   [/^(?:flex-)?shrink-0$/, () => ({ "flex-shrink": 0 })],
   [/^(?:flex-)?grow$/, () => ({ "flex-grow": 1 })],
   [/^(?:flex-)?grow-0$/, () => ({ "flex-grow": 0 })],
-  [/^(?:flex-)?basis-(.+)$/, ([, d], { theme }) => ({ "flex-basis": theme.spacing?.[d] ?? utilities.handler.bracket.cssvar.auto.fraction.rem(d) })],
+  [/^(?:flex-)?basis-(.+)$/, ([, d], { theme }) => ({ "flex-basis": theme.spacing?.[d] ?? colors.handler.bracket.cssvar.auto.fraction.rem(d) })],
   ["flex-row", { "flex-direction": "row" }],
   ["flex-row-reverse", { "flex-direction": "row-reverse" }],
   ["flex-col", { "flex-direction": "column" }],
@@ -240,7 +240,7 @@ const weightMap = {
 const fonts = [
   [
     /^font-(.+)$/,
-    ([, d], { theme }) => ({ "font-family": theme.fontFamily?.[d] || utilities.handler.bracket.cssvar.global(d) }),
+    ([, d], { theme }) => ({ "font-family": theme.fontFamily?.[d] || colors.handler.bracket.cssvar.global(d) }),
     { autocomplete: "font-$fontFamily" }
   ],
   [
@@ -254,45 +254,45 @@ const fonts = [
           "line-height": height
         };
       }
-      return { "font-size": utilities.handler.bracketOfLength.rem(s) };
+      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] ?? utilities.handler.bracket.cssvar.global.rem(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] || utilities.handler.global.number(s) }),
+    ([, 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] || utilities.handler.bracket.cssvar.global.rem(s) }),
+    ([, 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": utilities.handler.bracket.cssvar.global(s) })],
+  [/^font-synthesis-(.+)$/, ([, s]) => ({ "font-synthesis": colors.handler.bracket.cssvar.global(s) })],
   [
     /^(?:font-)?tracking-(.+)$/,
-    ([, s], { theme }) => ({ "letter-spacing": theme.letterSpacing?.[s] || utilities.handler.bracket.cssvar.global.rem(s) }),
+    ([, 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] || utilities.handler.bracket.cssvar.global.rem(s) }),
+    ([, s], { theme }) => ({ "word-spacing": theme.wordSpacing?.[s] || colors.handler.bracket.cssvar.global.rem(s) }),
     { autocomplete: "word-spacing-$wordSpacing" }
   ]
 ];
 const tabSizes = [
   [/^tab(?:-(.+))?$/, ([, s]) => {
-    const v = utilities.handler.bracket.cssvar.global.number(s || "4");
+    const v = colors.handler.bracket.cssvar.global.number(s || "4");
     if (v != null) {
       return {
         "-moz-tab-size": v,
@@ -303,26 +303,26 @@ const tabSizes = [
   }]
 ];
 const textIndents = [
-  [/^indent(?:-(.+))?$/, ([, s], { theme }) => ({ "text-indent": theme.textIndent?.[s || "DEFAULT"] || utilities.handler.bracket.cssvar.global.fraction.rem(s) }), { autocomplete: "indent-$textIndent" }]
+  [/^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"] || utilities.handler.bracket.cssvar.px(s) }), { autocomplete: "text-stroke-$textStrokeWidth" }],
-  [/^text-stroke-(.+)$/, utilities.colorResolver("-webkit-text-stroke-color", "text-stroke"), { autocomplete: "text-stroke-$colors" }],
-  [/^text-stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-stroke-opacity": utilities.handler.bracket.percent(opacity) }), { autocomplete: "text-stroke-(op|opacity)-<percent>" }]
+  [/^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": utilities.colorableShadows(v, "--un-text-shadow-color").join(","),
+        "--un-text-shadow": colors.colorableShadows(v, "--un-text-shadow-color").join(","),
         "text-shadow": "var(--un-text-shadow)"
       };
     }
-    return { "text-shadow": utilities.handler.bracket.cssvar.global(s) };
+    return { "text-shadow": colors.handler.bracket.cssvar.global(s) };
   }, { autocomplete: "text-shadow-$textShadow" }],
-  [/^text-shadow-color-(.+)$/, utilities.colorResolver("--un-text-shadow-color", "text-shadow"), { autocomplete: "text-shadow-color-$colors" }],
-  [/^text-shadow-color-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-shadow-opacity": utilities.handler.bracket.percent(opacity) }), { autocomplete: "text-shadow-color-(op|opacity)-<percent>" }]
+  [/^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 directions = {
@@ -331,7 +331,7 @@ const directions = {
   "y": "row-"
 };
 const handleGap = ([, d = "", s], { theme }) => {
-  const v = theme.spacing?.[s] ?? utilities.handler.bracket.cssvar.global.rem(s);
+  const v = theme.spacing?.[s] ?? colors.handler.bracket.cssvar.global.rem(s);
   if (v != null) {
     return {
       [`grid-${directions[d]}gap`]: v,
@@ -358,31 +358,31 @@ const autoDirection = (c, theme, prop) => {
     case "fr":
       return "minmax(0,1fr)";
   }
-  return utilities.handler.bracket.cssvar.auto.rem(prop);
+  return colors.handler.bracket.cssvar.auto.rem(prop);
 };
 const grids = [
   ["grid", { display: "grid" }],
   ["inline-grid", { display: "inline-grid" }],
   [/^(?:grid-)?(row|col)-(.+)$/, ([, c, v], { theme }) => ({
-    [`grid-${rowCol(c)}`]: theme[`grid${rowColTheme(c)}`]?.[v] ?? utilities.handler.bracket.cssvar.auto(v)
+    [`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 = utilities.handler.bracket.number(s);
+    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`]: utilities.handler.bracket.cssvar(v) ?? v })],
-  [/^(?:grid-)?(row|col)-end-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-end`]: utilities.handler.bracket.cssvar(v) ?? v })],
-  [/^(?:grid-)?auto-(rows|cols)-(.+)$/, ([, c, v], { theme }) => ({ [`grid-auto-${rowCol(c)}`]: autoDirection(c, theme, v) })],
-  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(.+)$/, ([, v]) => ({ "grid-auto-flow": utilities.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("-", " ") })],
+  [/^(?: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] ?? utilities.handler.bracket.cssvar(v)
+    [`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))` })],
+  [/^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" }]
 ];
@@ -393,7 +393,7 @@ const overflowValues = [
   "clip",
   "visible",
   "scroll",
-  ...utilities.globalKeywords
+  ...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("|")})`] }],
@@ -402,7 +402,7 @@ const overflows = [
 
 const positions = [
   [/^(?:position-|pos-)?(relative|absolute|fixed|sticky)$/, ([, v]) => ({ position: v })],
-  [/^(?:position-|pos-)([-\w]+)$/, ([, v]) => utilities.globalKeywords.includes(v) ? { position: v } : void 0],
+  [/^(?:position-|pos-)([-\w]+)$/, ([, v]) => colors.globalKeywords.includes(v) ? { position: v } : void 0],
   [/^(?:position-|pos-)?(static)$/, ([, v]) => ({ position: v })]
 ];
 const justifies = [
@@ -412,21 +412,21 @@ const justifies = [
   ["justify-between", { "justify-content": "space-between" }],
   ["justify-around", { "justify-content": "space-around" }],
   ["justify-evenly", { "justify-content": "space-evenly" }],
-  ...utilities.makeGlobalStaticRules("justify", "justify-content"),
+  ...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" }],
-  ...utilities.makeGlobalStaticRules("justify-items"),
+  ...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" }],
-  ...utilities.makeGlobalStaticRules("justify-self")
+  ...colors.makeGlobalStaticRules("justify-self")
 ];
 const orders = [
-  [/^order-(.+)$/, ([, v]) => ({ order: utilities.handler.bracket.cssvar.number(v) })],
+  [/^order-(.+)$/, ([, v]) => ({ order: colors.handler.bracket.cssvar.number(v) })],
   ["order-first", { order: "-9999" }],
   ["order-last", { order: "9999" }],
   ["order-none", { order: "0" }]
@@ -438,20 +438,20 @@ const alignments = [
   ["content-between", { "align-content": "space-between" }],
   ["content-around", { "align-content": "space-around" }],
   ["content-evenly", { "align-content": "space-evenly" }],
-  ...utilities.makeGlobalStaticRules("content", "align-content"),
+  ...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" }],
-  ...utilities.makeGlobalStaticRules("items", "align-items"),
+  ...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" }],
-  ...utilities.makeGlobalStaticRules("self", "align-self")
+  ...colors.makeGlobalStaticRules("self", "align-self")
 ];
 const placements = [
   ["place-content-center", { "place-content": "center" }],
@@ -461,26 +461,26 @@ const placements = [
   ["place-content-around", { "place-content": "space-around" }],
   ["place-content-evenly", { "place-content": "space-evenly" }],
   ["place-content-stretch", { "place-content": "stretch" }],
-  ...utilities.makeGlobalStaticRules("place-content"),
+  ...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" }],
-  ...utilities.makeGlobalStaticRules("place-items"),
+  ...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" }],
-  ...utilities.makeGlobalStaticRules("place-self")
+  ...colors.makeGlobalStaticRules("place-self")
 ];
 function handleInsetValue(v, { theme }) {
-  return theme.spacing?.[v] ?? utilities.handler.bracket.cssvar.global.auto.fraction.rem(v);
+  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 utilities.insetMap)
-    return utilities.insetMap[d].map((i) => [i.slice(1), r]);
+  if (r != null && d in colors.insetMap)
+    return colors.insetMap[d].map((i) => [i.slice(1), r]);
 }
 const insets = [
   [
@@ -505,21 +505,21 @@ const floats = [
   ["float-left", { float: "left" }],
   ["float-right", { float: "right" }],
   ["float-none", { float: "none" }],
-  ...utilities.makeGlobalStaticRules("float"),
+  ...colors.makeGlobalStaticRules("float"),
   ["clear-left", { clear: "left" }],
   ["clear-right", { clear: "right" }],
   ["clear-both", { clear: "both" }],
   ["clear-none", { clear: "none" }],
-  ...utilities.makeGlobalStaticRules("clear")
+  ...colors.makeGlobalStaticRules("clear")
 ];
 const zIndexes = [
-  [/^z([\d.]+)$/, ([, v]) => ({ "z-index": utilities.handler.number(v) })],
-  [/^z-(.+)$/, ([, v]) => ({ "z-index": utilities.handler.bracket.cssvar.global.auto.number(v) }), { autocomplete: "z-<num>" }]
+  [/^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" }],
-  ...utilities.makeGlobalStaticRules("box", "box-sizing")
+  ...colors.makeGlobalStaticRules("box", "box-sizing")
 ];
 
 const sizeMapping = {
@@ -542,7 +542,7 @@ function getSizeValue(minmax, hw, theme, prop) {
     case "min":
       return `${prop}-content`;
   }
-  return utilities.handler.bracket.cssvar.global.auto.fraction.rem(prop);
+  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) })],
@@ -554,8 +554,8 @@ const sizes = [
       "(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)]: utilities.resolveVerticalBreakpoints(context)?.[s] })],
-  [/^(min-|max-)?(w)-screen-(.+)$/, ([, m, w, s], context) => ({ [getPropName(m, w)]: utilities.resolveBreakpoints(context)?.[s] }), {
+  [/^(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",
@@ -575,27 +575,27 @@ function getAspectRatio(prop) {
     case "video":
       return "16/9";
   }
-  return utilities.handler.bracket.cssvar.global.auto.number(prop);
+  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?()-?(-?.+)$/, utilities.directionSize("padding"), { autocomplete: ["(m|p)<num>", "(m|p)-<num>"] }],
-  [/^p-?xy()()$/, utilities.directionSize("padding"), { autocomplete: "(m|p)-(xy)" }],
-  [/^p-?([xy])(?:-?(-?.+))?$/, utilities.directionSize("padding")],
-  [/^p-?([rltbse])(?:-?(-?.+))?$/, utilities.directionSize("padding"), { autocomplete: "(m|p)<directions>-<num>" }],
-  [/^p-(block|inline)(?:-(-?.+))?$/, utilities.directionSize("padding"), { autocomplete: "(m|p)-(block|inline)-<num>" }],
-  [/^p-?([bi][se])(?:-?(-?.+))?$/, utilities.directionSize("padding"), { autocomplete: "(m|p)-(bs|be|is|ie)-<num>" }]
+  [/^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?()-?(-?.+)$/, utilities.directionSize("margin")],
-  [/^m-?xy()()$/, utilities.directionSize("margin")],
-  [/^m-?([xy])(?:-?(-?.+))?$/, utilities.directionSize("margin")],
-  [/^m-?([rltbse])(?:-?(-?.+))?$/, utilities.directionSize("margin")],
-  [/^m-(block|inline)(?:-(-?.+))?$/, utilities.directionSize("margin")],
-  [/^m-?([bi][se])(?:-?(-?.+))?$/, utilities.directionSize("margin")]
+  [/^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 = {
@@ -617,11 +617,11 @@ const cssVariables = [
   [/^(.+?)-(\$.+)$/, ([, name, varname]) => {
     const prop = variablesAbbrMap[name];
     if (prop)
-      return { [prop]: utilities.handler.cssvar(varname) };
+      return { [prop]: colors.handler.cssvar(varname) };
   }]
 ];
 const cssProperty = [
-  [/^\[([\w_-]+):([^'"]+)\]$/, ([, prop, value]) => ({ [prop]: utilities.handler.bracket(`[${value}]`) })]
+  [/^\[([\w_-]+):([^'"]+)\]$/, ([, prop, value]) => ({ [prop]: colors.handler.bracket(`[${value}]`) })]
 ];
 
 const questionMark = [
@@ -635,13 +635,13 @@ ${constructCSS({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
   ]
 ];
 
-const decorationStyles = ["solid", "double", "dotted", "dashed", "wavy", ...utilities.globalKeywords];
+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] ?? utilities.handler.bracket.cssvar.global.px(s) }), { autocomplete: "(underline|decoration)-<num>" }],
+  [/^(?: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 = utilities.colorResolver("text-decoration-color", "line")(match, ctx);
+    const result = colors.colorResolver("text-decoration-color", "line")(match, ctx);
     if (result) {
       return {
         "-webkit-text-decoration-color": result["text-decoration-color"],
@@ -649,8 +649,8 @@ const textDecorations = [
       };
     }
   }, { autocomplete: "(underline|decoration)-$colors" }],
-  [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": utilities.handler.bracket.percent(opacity) }), { autocomplete: "(underline|decoration)-(op|opacity)-<percent>" }],
-  [/^(?:underline|decoration)-offset-(.+)$/, ([, s], { theme }) => ({ "text-underline-offset": theme.lineWidth?.[s] ?? utilities.handler.auto.bracket.cssvar.global.px(s) }), { autocomplete: "(underline|decoration)-(offset)-<num>" }],
+  [/^(?: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" }],
@@ -658,14 +658,14 @@ const textDecorations = [
 ];
 
 const svgUtilities = [
-  [/^fill-(.+)$/, utilities.colorResolver("fill", "fill"), { autocomplete: "fill-$colors" }],
-  [/^fill-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-fill-opacity": utilities.handler.bracket.percent(opacity) }), { autocomplete: "fill-(op|opacity)-<percent>" }],
+  [/^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] ?? utilities.handler.bracket.cssvar.fraction.px.number(s) }), { autocomplete: ["stroke-width-$lineWidth", "stroke-size-$lineWidth"] }],
-  [/^stroke-dash-(.+)$/, ([, s]) => ({ "stroke-dasharray": utilities.handler.bracket.cssvar.number(s) }), { autocomplete: "stroke-dash-<num>" }],
-  [/^stroke-offset-(.+)$/, ([, s], { theme }) => ({ "stroke-dashoffset": theme.lineWidth?.[s] ?? utilities.handler.bracket.cssvar.px.numberWithUnit(s) }), { autocomplete: "stroke-offset-$lineWidth" }],
-  [/^stroke-(.+)$/, utilities.colorResolver("stroke", "stroke"), { autocomplete: "stroke-$colors" }],
-  [/^stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-stroke-opacity": utilities.handler.bracket.percent(opacity) }), { autocomplete: "stroke-(op|opacity)-<percent>" }],
+  [/^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" }],
@@ -747,6 +747,7 @@ exports.floats = floats;
 exports.fonts = fonts;
 exports.gaps = gaps;
 exports.grids = grids;
+exports.handlerBorderStyle = handlerBorderStyle;
 exports.insets = insets;
 exports.justifies = justifies;
 exports.margins = margins;