@unocss/preset-mini 0.16.1 → 0.17.2

package/dist/chunks/default2.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
+const utilities = require('./utilities.cjs');
 const core = require('@unocss/core');
-const index = require('./index.cjs');
 const pseudo = require('./pseudo.cjs');
 
 const verticalAlignAlias = {
@@ -19,93 +19,10 @@ const textAligns = [
   ["text-justify", { "text-align": "justify" }]
 ];
 
-const parseColorUtil = (body, theme) => {
-  const [main, opacity2] = body.split(/(?:\/|:)/);
-  const [name, no = "DEFAULT"] = main.replace(/([a-z])([0-9])/g, "$1-$2").split(/-/g);
-  if (!name)
-    return;
-  let color;
-  const bracket = index.handler.bracket(main);
-  const bracketOrMain = bracket || main;
-  if (bracketOrMain.startsWith("#"))
-    color = bracketOrMain.slice(1);
-  if (bracketOrMain.startsWith("hex-"))
-    color = bracketOrMain.slice(4);
-  color = color || bracket;
-  if (!color) {
-    const colorData = theme.colors?.[name];
-    if (typeof colorData === "string")
-      color = colorData;
-    else if (no && colorData)
-      color = colorData[no];
-  }
-  return {
-    opacity: opacity2,
-    name,
-    no,
-    color,
-    rgba: core.hex2rgba(color)
-  };
-};
-const colorResolver$1 = (attribute, varName) => ([, body], { theme }) => {
-  const data = parseColorUtil(body, theme);
-  if (!data)
-    return;
-  const { opacity: opacity2, color, rgba } = data;
-  if (!color)
-    return;
-  const a = opacity2 ? opacity2[0] === "[" ? index.handler.bracket.percent(opacity2) : parseFloat(opacity2) / 100 : rgba?.[3];
-  if (rgba) {
-    if (a != null && !Number.isNaN(a)) {
-      rgba[3] = typeof a === "string" && !a.includes("%") ? parseFloat(a) : a;
-      return {
-        [attribute]: `rgba(${rgba.join(",")})`
-      };
-    } else {
-      return {
-        [`--un-${varName}-opacity`]: 1,
-        [attribute]: `rgba(${rgba.slice(0, 3).join(",")},var(--un-${varName}-opacity))`
-      };
-    }
-  } else {
-    return {
-      [attribute]: color.replace("%alpha", `${a || 1}`)
-    };
-  }
-};
-const opacity = [
-  [/^op(?:acity)?-?(.+)$/, ([, d]) => ({ opacity: index.handler.bracket.percent.cssvar(d) })]
-];
-const textColors = [
-  [/^(?:text|color|c)-(.+)$/, colorResolver$1("color", "text")],
-  [/^(?:text|color|c)-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-text-opacity": index.handler.bracket.percent.cssvar(opacity2) })]
-];
-const bgColors = [
-  [/^bg-(.+)$/, colorResolver$1("background-color", "bg")],
-  [/^bg-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-bg-opacity": index.handler.bracket.percent(opacity2) })]
-];
-const borderColors = [
-  [/^(?:border|b)-(.+)$/, colorResolver$1("border-color", "border")],
-  [/^(?:border|b)-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-border-opacity": index.handler.bracket.percent(opacity2) })]
-];
-const ringColors = [
-  [/^ring-(.+)$/, colorResolver$1("--un-ring-color", "ring")],
-  [/^ring-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-ring-opacity": index.handler.bracket.percent(opacity2) })]
-];
-const ringOffsetColors = [
-  [/^ring-offset-(.+)$/, colorResolver$1("--un-ring-offset-color", "ring-offset")],
-  [/^ring-offset-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-ring-offset-opacity": index.handler.bracket.percent(opacity2) })]
-];
-const fillColors = [
-  ["fill-none", { fill: "none" }],
-  [/^fill-(.+)$/, colorResolver$1("fill", "fill")],
-  [/^fill-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-fill-opacity": index.handler.bracket.percent(opacity2) })]
-];
-
-const outlineStyle = ["none", "auto", "dotted", "dashed", "solid", "double", "groove", "ridge", "inset", "outset", "inherit", "initial", "revert", "unset"];
+const outlineStyle = ["auto", "dotted", "dashed", "solid", "double", "groove", "ridge", "inset", "outset", "inherit", "initial", "revert", "unset"];
 const parseOutlineSize = (s) => {
   const propName = ["width", "offset"].find((item) => s.startsWith(item)) || "width";
-  const size = index.handler.bracket.fraction.rem(s.replace(/^(offset\-|width\-)/, ""));
+  const size = utilities.handler.bracket.fraction.auto.rem(s.replace(/^(offset\-|width\-|size\-)/, ""));
   if (size) {
     return {
       [`outline-${propName}`]: size
@@ -113,34 +30,28 @@ const parseOutlineSize = (s) => {
   }
 };
 const outline = [
-  ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }],
   ["outline", { "outline-style": "solid" }],
   [
     /^outline-(.+)$/,
     (match, config) => {
       const [, d] = match;
-      if (d === "none") {
-        return {
-          "outline": "2px solid transparent",
-          "outline-offset": "2px"
-        };
-      }
       if (outlineStyle.includes(d)) {
         return {
           "outline-style": d
         };
       }
-      const sizeSheet = parseOutlineSize(d);
-      if (sizeSheet)
-        return sizeSheet;
-      const colorSheet = colorResolver$1("outline-color", "outline-color")([
+      const colorSheet = utilities.colorResolver("outline-color", "outline-color")([
         match[0],
         match[1].replace(/^color-/, "")
       ], config);
       if (colorSheet)
         return colorSheet;
+      const sizeSheet = parseOutlineSize(d);
+      if (sizeSheet)
+        return sizeSheet;
     }
-  ]
+  ],
+  ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }]
 ];
 const appearance = [
   ["appearance-none", {
@@ -152,35 +63,38 @@ const placeholder = [
   [
     /^placeholder-opacity-(\d+)$/,
     ([, d]) => ({
-      "placeholder-opacity": index.handler.bracket.percent(d)
+      "placeholder-opacity": utilities.handler.bracket.percent(d)
     })
   ],
   [
     /^placeholder-(?!opacity)(.+)$/,
     (match, config) => {
       match[1] = match[1].replace(/^color-/, "");
-      return colorResolver$1("placeholder-color", "placeholder-color")(match, config);
+      return utilities.colorResolver("placeholder-color", "placeholder-color")(match, config);
     }
   ]
 ];
+const willChange = [
+  [/^will-change-(.+)/, ([, p]) => ({ "will-change": utilities.handler.properties.global(p) })]
+];
 
 const borders = [
   [/^border$/, handlerBorder],
   [/^(?:border|b)()-(.+)$/, handlerBorder],
-  [/^(?:border|b)-([^-]+)-(.+)$/, handlerBorder],
+  [/^(?:border|b)-([^-]+)(?:-(.+))?$/, handlerBorder],
   [/^(?:border|b)()-size-(.+)$/, handlerBorderSize],
   [/^(?:border|b)-([^-]+)-size-(.+)$/, handlerBorderSize],
   [/^(?:border|b)()-(.+)$/, handlerBorderColor],
-  [/^(?:border|b)-([^-]+)-(.+)$/, handlerBorderColor],
-  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-border-opacity": index.handler.bracket.percent(opacity) })],
+  [/^(?:border|b)-([^-]+)(?:-(.+))?$/, handlerBorderColor],
+  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-border-opacity": utilities.handler.bracket.percent(opacity) })],
   ["border-solid", { "border-style": "solid" }],
   ["border-dashed", { "border-style": "dashed" }],
   ["border-dotted", { "border-style": "dotted" }],
   ["border-double", { "border-style": "double" }],
   ["border-none", { "border-style": "none" }],
   [/^(?:border-)?(?:rounded|rd)$/, handlerRounded],
-  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?$/, handlerRounded],
-  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-([^-]+))?$/, handlerRounded]
+  [/^(?:border-)?(?:rounded|rd)(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-(.+))?$/, handlerRounded]
 ];
 function handlerBorder(m) {
   const borderSizes = handlerBorderSize(m);
@@ -192,118 +106,73 @@ function handlerBorder(m) {
   }
 }
 function handlerBorderSize([, a, b]) {
-  const [d, s = "1"] = index.directionMap[a] ? [a, b] : ["", a];
-  const v = index.handler.bracket.px(s);
-  if (v != null) {
-    return [
-      ...index.directionMap[d].map((i) => [`border${i}-width`, v])
-    ];
-  }
+  const [d, s = "1"] = utilities.directionMap[a] ? [a, b] : ["", a];
+  const v = utilities.handler.bracket.px(s);
+  if (v !== void 0)
+    return utilities.directionMap[d].map((i) => [`border${i}-width`, v]);
 }
 function handlerBorderColor([, a, c], ctx) {
-  const ofColor = colorResolver$1("border-color", "border")(["", c], ctx);
-  if (ofColor) {
-    const borders2 = index.directionMap[index.directionMap[a] ? a : ""].map((i) => colorResolver$1(`border${i}-color`, "border")(["", c], ctx));
-    const borderObject = {};
-    Object.assign(borderObject, ...borders2);
-    return borderObject;
+  if (c !== void 0 && utilities.colorResolver("border-color", "border")(["", c], ctx)) {
+    return Object.assign({}, ...utilities.directionMap[utilities.directionMap[a] ? a : ""].map((i) => utilities.colorResolver(`border${i}-color`, "border")(["", c], ctx)));
   }
 }
 function handlerRounded([, a, b], { theme }) {
-  const [d, s = "DEFAULT"] = index.cornerMap[a] ? [a, b] : ["", a];
-  const v = theme.borderRadius?.[s] || index.handler.bracket.fraction.rem(s);
-  if (v != null)
-    return index.cornerMap[d].map((i) => [`border${i}-radius`, v]);
+  const [d, s = "DEFAULT"] = utilities.cornerMap[a] ? [a, b] : ["", a];
+  const v = theme.borderRadius?.[s] || utilities.handler.auto.rem.fraction.bracket.cssvar(s);
+  if (v !== void 0)
+    return utilities.cornerMap[d].map((i) => [`border${i}-radius`, v]);
 }
 
-const transitionBasicProps = [
-  "color",
-  "border-color",
-  "background-color",
-  "flex-grow",
-  "flex",
-  "flex-shrink",
-  "caret-color",
-  "font",
-  "gap",
-  "opacity",
-  "visibility",
-  "z-index",
-  "font-weight",
-  "zoom",
-  "text-shadow",
-  "transform",
-  "box-shadow"
+const opacity = [
+  [/^op(?:acity)?-?(.+)$/, ([, d]) => ({ opacity: utilities.handler.bracket.percent.cssvar(d) })]
 ];
-const transitionPositionProps = [
-  "backround-position",
-  "left",
-  "right",
-  "top",
-  "bottom",
-  "object-position"
+const textColors = [
+  [/^(?:text|color|c)-(.+)$/, utilities.colorResolver("color", "text")],
+  [/^(?:text|color|c)-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-text-opacity": utilities.handler.bracket.percent.cssvar(opacity2) })]
 ];
-const transitionSizeProps = [
-  "max-height",
-  "min-height",
-  "max-width",
-  "min-width",
-  "height",
-  "width",
-  "border-width",
-  "margin",
-  "padding",
-  "outline-width",
-  "outline-offset",
-  "font-size",
-  "line-height",
-  "text-indent",
-  "vertical-align",
-  "border-spacing",
-  "letter-spacing",
-  "word-spacing"
+const bgColors = [
+  [/^bg-(.+)$/, utilities.colorResolver("background-color", "bg")],
+  [/^bg-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-bg-opacity": utilities.handler.bracket.percent(opacity2) })]
 ];
-const transitionSwitchProps = ["all", "none"];
-const transitionEnhanceProps = ["stroke", "filter", "backdrop-filter", "fill", "mask", "mask-size", "mask-border", "clip-path", "clip"];
-const transitionProps = [
-  ...transitionBasicProps,
-  ...transitionPositionProps,
-  ...transitionSizeProps,
-  ...transitionEnhanceProps
+const borderColors = [
+  [/^(?:border|b)-(.+)$/, utilities.colorResolver("border-color", "border")],
+  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-border-opacity": utilities.handler.bracket.percent(opacity2) })]
 ];
-const transitionPropsStr = transitionProps.join(", ");
-const validateProperty = (prop) => {
-  if (prop && ![...transitionProps, ...transitionSwitchProps].includes(prop))
-    return;
-  return prop || transitionPropsStr;
+const ringColors = [
+  [/^ring-(.+)$/, utilities.colorResolver("--un-ring-color", "ring")],
+  [/^ring-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-ring-opacity": utilities.handler.bracket.percent(opacity2) })]
+];
+const ringOffsetColors = [
+  [/^ring-offset-(.+)$/, utilities.colorResolver("--un-ring-offset-color", "ring-offset")],
+  [/^ring-offset-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-ring-offset-opacity": utilities.handler.bracket.percent(opacity2) })]
+];
+
+const transitionProperty = (prop) => {
+  return utilities.handler.properties(prop) || (prop === "all" ? prop : void 0);
 };
 const transitions = [
-  [/^transition(?:-([a-z-]+))?(?:-(\d+))?$/, ([, prop, duration = "150"]) => {
-    const transitionProperty = validateProperty(prop);
-    if (!transitionProperty)
-      return;
-    return {
-      "transition-property": transitionProperty,
-      "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
-      "transition-duration": `${duration}ms`
-    };
-  }],
-  [/^duration-(\d+)$/, ([, duration = "150"]) => {
-    return {
-      "transition-duration": `${duration}ms`
-    };
+  [/^transition(?:-([a-z-]+(?:,[a-z-]+)*))?(?:-(\d+))?$/, ([, prop = "all", duration = "150"]) => {
+    const p = transitionProperty(prop);
+    if (p) {
+      return {
+        "transition-property": p,
+        "transition-timing-function": "cubic-bezier(0.4,0,0.2,1)",
+        "transition-duration": `${duration}ms`
+      };
+    }
   }],
+  [/^duration-(\d+)$/, ([, duration = "150"]) => ({ "transition-duration": `${duration}ms` })],
   ["ease", { "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)" }],
+  ["ease-linear", { "transition-timing-function": "linear" }],
   ["ease-in", { "transition-timing-function": "cubic-bezier(0.4, 0, 1, 1)" }],
   ["ease-out", { "transition-timing-function": "cubic-bezier(0, 0, 0.2, 1)" }],
   ["ease-in-out", { "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)" }],
   [/^transition-delay-(\d+)$/, ([, v]) => ({ "transition-delay": `${v}ms` })],
   [/^transition-duration-(\d+)$/, ([, v]) => ({ "transition-duration": `${v}ms` })],
-  [/^(?:transition-)?property-([a-z-]+)$/, ([, v]) => {
-    const transitionProperty = validateProperty(v);
-    if (transitionProperty)
-      return { "transition-property": transitionProperty };
-  }]
+  [/^(?:transition-)?property-(.+)$/, ([, v]) => ({ "transition-property": utilities.handler.global(v) || transitionProperty(v) })],
+  ["transition-property-none", { "transition-property": "none" }],
+  ["property-none", { "transition-property": "none" }],
+  ["transition-none", { transition: "none" }]
 ];
 
 const flex = [
@@ -349,7 +218,7 @@ const fonts = [
     }
   }],
   [/^text-(.+)$/, ([, s = "base"], { theme }) => {
-    const size = index.handler.bracket.rem(s);
+    const size = utilities.handler.bracket.auto.rem(s);
     if (size)
       return { "font-size": size };
     const themed = core.toArray(theme.fontSize?.[s]);
@@ -362,27 +231,27 @@ const fonts = [
     }
   }],
   [/^text-size-(.+)$/, ([, s]) => {
-    const raw = index.handler.bracket.rem(s);
+    const raw = utilities.handler.bracket.auto.rem(s);
     if (raw)
       return { "font-size": raw };
   }],
   [/^(?:font|fw)-?([^-]+)$/, ([, s]) => {
-    const v = weightMap[s] || index.handler.number(s);
+    const v = weightMap[s] || utilities.handler.number(s);
     if (v)
       return { "font-weight": v };
   }],
   [/^(?:leading|lh)-([^-]+)$/, ([, s], { theme }) => {
-    const v = theme.lineHeight?.[s] || index.handler.bracket.rem(s);
+    const v = theme.lineHeight?.[s] || utilities.handler.bracket.auto.rem(s);
     if (v !== null)
       return { "line-height": v };
   }],
   [/^tracking-([^-]+)$/, ([, s], { theme }) => {
-    const v = theme.letterSpacing?.[s] || index.handler.bracket.rem(s);
+    const v = theme.letterSpacing?.[s] || utilities.handler.bracket.auto.rem(s);
     if (v !== null)
       return { "letter-spacing": v };
   }],
   [/^word-spacing-([^-]+)$/, ([, s], { theme }) => {
-    const v = theme.wordSpacing?.[s] || index.handler.bracket.rem(s);
+    const v = theme.wordSpacing?.[s] || utilities.handler.bracket.auto.rem(s);
     if (v !== null)
       return { "word-spacing": v };
   }]
@@ -390,7 +259,7 @@ const fonts = [
 const tabSizes = [
   [/^tab-?([^-]*)$/, ([, s]) => {
     s = s || "4";
-    const v = index.handler.bracket.global.number(s);
+    const v = utilities.handler.bracket.global.number(s);
     if (v !== null) {
       return {
         "-moz-tab-size": v,
@@ -402,23 +271,23 @@ const tabSizes = [
 ];
 const textIndents = [
   [/^indent(?:-(.+))?$/, ([, s], { theme }) => {
-    const v = theme.textIndent?.[s || "DEFAULT"] || index.handler.bracket.cssvar.fraction.rem(s);
+    const v = theme.textIndent?.[s || "DEFAULT"] || utilities.handler.bracket.cssvar.fraction.auto.rem(s);
     if (v != null)
       return { "text-indent": v };
   }]
 ];
 const textStrokes = [
   [/^text-stroke(?:-(.+))?$/, ([, s], { theme }) => {
-    const v = theme.textStrokeWidth?.[s || "DEFAULT"] || index.handler.bracket.cssvar.px(s);
+    const v = theme.textStrokeWidth?.[s || "DEFAULT"] || utilities.handler.bracket.cssvar.px(s);
     if (v != null)
       return { "-webkit-text-stroke-width": v };
   }],
-  [/^text-stroke-(.+)$/, colorResolver$1("-webkit-text-stroke-color", "text-stroke")],
-  [/^text-stroke-op(?:acity)?-?(.+)$/m, ([, opacity]) => ({ "--un-text-stroke-opacity": index.handler.bracket.percent(opacity) })]
+  [/^text-stroke-(.+)$/, utilities.colorResolver("-webkit-text-stroke-color", "text-stroke")],
+  [/^text-stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-stroke-opacity": utilities.handler.bracket.percent(opacity) })]
 ];
 const textShadows = [
   [/^text-shadow(?:-(.+))?$/, ([, s], { theme }) => {
-    const v = theme.textShadow?.[s || "DEFAULT"] || index.handler.bracket.cssvar(s);
+    const v = theme.textShadow?.[s || "DEFAULT"] || utilities.handler.bracket.cssvar(s);
     if (v != null)
       return { "text-shadow": v };
   }]
@@ -426,7 +295,7 @@ const textShadows = [
 
 const gaps = [
   [/^(?:flex-|grid-)?gap-([^-]+)$/, ([, s]) => {
-    const v = index.handler.bracket.rem(s);
+    const v = utilities.handler.bracket.auto.rem(s);
     if (v != null) {
       return {
         "grid-gap": v,
@@ -435,7 +304,7 @@ const gaps = [
     }
   }],
   [/^(?:flex-|grid-)?gap-x-([^-]+)$/, ([, s]) => {
-    const v = index.handler.bracket.rem(s);
+    const v = utilities.handler.bracket.auto.rem(s);
     if (v != null) {
       return {
         "grid-column-gap": v,
@@ -444,7 +313,7 @@ const gaps = [
     }
   }],
   [/^(?:flex-|grid-)?gap-y-([^-]+)$/, ([, s]) => {
-    const v = index.handler.bracket.rem(s);
+    const v = utilities.handler.bracket.auto.rem(s);
     if (v != null) {
       return {
         "grid-row-gap": v,
@@ -454,7 +323,7 @@ const gaps = [
   }]
 ];
 
-const calSize = (s, theme) => core.toArray(theme.fontSize?.[s] || index.handler.bracket.rem(s))[0];
+const calSize = (s, theme) => core.toArray(theme.fontSize?.[s] || utilities.handler.bracket.auto.rem(s))[0];
 const autoDirection = (selector, theme) => {
   if (selector === "min")
     return "min-content";
@@ -467,13 +336,13 @@ const autoDirection = (selector, theme) => {
 const grids = [
   ["grid", { display: "grid" }],
   ["inline-grid", { display: "inline-grid" }],
-  [/^(?:grid-)?col-start-([\w.-]+)$/, ([, v]) => ({ "grid-column-start": `${v}` })],
-  [/^(?:grid-)?col-end-([\w.]+)$/, ([, v]) => ({ "grid-column-end": `${v}` })],
-  [/^(?:grid-)?row-start-([\w.-]+)$/, ([, v]) => ({ "grid-row-start": `${v}` })],
-  [/^(?:grid-)?row-end-([\w.-]+)$/, ([, v]) => ({ "grid-row-end": `${v}` })],
+  [/^(?:grid-)?col-start-([\w.-]+)$/, ([, v]) => ({ "grid-column-start": v })],
+  [/^(?:grid-)?col-end-([\w.]+)$/, ([, v]) => ({ "grid-column-end": v })],
+  [/^(?:grid-)?row-start-([\w.-]+)$/, ([, v]) => ({ "grid-row-start": v })],
+  [/^(?:grid-)?row-end-([\w.-]+)$/, ([, v]) => ({ "grid-row-end": v })],
   [/^(?:grid-)?(row|col)-(.+)$/, ([, d, v]) => {
     const key = d === "row" ? "grid-row" : "grid-column";
-    let raw = index.handler.bracket(v);
+    let raw = utilities.handler.bracket(v);
     if (raw)
       return { [key]: raw };
     const parts = v.split("-");
@@ -482,16 +351,16 @@ const grids = [
     if (parts[0] === "span") {
       if (parts[1] === "full")
         return { [key]: "1/-1" };
-      raw = index.handler.number.bracket(parts[1])?.toString().replace(/_/g, " ");
+      raw = utilities.handler.number.bracket(parts[1])?.toString().replace(/_/g, " ");
       if (raw)
         return { [key]: `span ${raw}/span ${raw}` };
     }
   }],
-  [/^(?:grid-)?auto-cols-([\w.-]+)$/, ([, v], { theme }) => ({ "grid-auto-columns": `${autoDirection(v, theme)}` })],
-  [/^(?:grid-)?auto-flow-([\w.-]+)$/, ([, v]) => ({ "grid-auto-flow": `${v.replace("col", "column").split("-").join(" ")}` })],
-  [/^(?:grid-)?auto-rows-([\w.-]+)$/, ([, v], { theme }) => ({ "grid-auto-rows": `${autoDirection(v, theme)}` })],
-  [/^grid-cols-minmax-([\w.-]+)$/, ([, d]) => ({ "grid-template-columns": `repeat(auto-fill, minmax(${d}, 1fr))` })],
-  [/^grid-rows-minmax-([\w.-]+)$/, ([, d]) => ({ "grid-template-rows": `repeat(auto-fill, minmax(${d}, 1fr))` })],
+  [/^(?:grid-)?auto-cols-([\w.-]+)$/, ([, v], { theme }) => ({ "grid-auto-columns": autoDirection(v, theme) })],
+  [/^(?:grid-)?auto-flow-([\w.-]+)$/, ([, v]) => ({ "grid-auto-flow": v.replace("col", "column").split("-").join(" ") })],
+  [/^(?:grid-)?auto-rows-([\w.-]+)$/, ([, v], { theme }) => ({ "grid-auto-rows": autoDirection(v, theme) })],
+  [/^grid-cols-minmax-([\w.-]+)$/, ([, d]) => ({ "grid-template-columns": `repeat(auto-fill,minmax(${d},1fr))` })],
+  [/^grid-rows-minmax-([\w.-]+)$/, ([, d]) => ({ "grid-template-rows": `repeat(auto-fill,minmax(${d},1fr))` })],
   [/^grid-cols-(\d+)$/, ([, d]) => ({ "grid-template-columns": `repeat(${d},minmax(0,1fr))` })],
   [/^grid-rows-(\d+)$/, ([, d]) => ({ "grid-template-rows": `repeat(${d},minmax(0,1fr))` })],
   [/^grid-cols-\[(.+)\]$/, ([, v]) => ({ "grid-template-columns": v.replace(/,/g, " ") })],
@@ -528,7 +397,8 @@ const justifies = [
   ...basicSet.map((i) => [`justify-self-${i}`, { "justify-self": i }])
 ];
 const orders = [
-  [/^order-(.+)$/, ([, v]) => ({ order: { first: "-9999", last: "9999", none: "0" }[v] || index.handler.bracket.number(v) })]
+  [/^order-(.+)$/, ([, v]) => ({ order: { first: "-9999", last: "9999" }[v] || utilities.handler.bracket.number(v) })],
+  ["order-none", { order: "0" }]
 ];
 const alignments = [
   ["content-start", { "align-content": "flex-start" }],
@@ -546,7 +416,7 @@ const alignments = [
   ["self-start", { "align-self": "flex-start" }],
   ["self-end", { "align-self": "flex-end" }],
   ["self-center", { "align-self": "center" }],
-  ["self-stretch", { "align-items": "stretch" }]
+  ["self-stretch", { "align-self": "stretch" }]
 ];
 const placements = [
   ["place-content-start", { "place-content": "start" }],
@@ -560,23 +430,25 @@ const placements = [
   ...basicSet.map((i) => [`place-self-${i}`, { "place-self": i }])
 ];
 function handleInsetValue(v) {
-  return { auto: "auto", full: "100%" }[v] ?? index.handler.bracket.fraction.cssvar.rem(v);
+  return { auto: "auto", full: "100%" }[v] ?? utilities.handler.bracket.fraction.cssvar.auto.rem(v);
 }
 const insets = [
   [/^(top|left|right|bottom|inset)-(.+)$/, ([, d, v]) => ({ [d]: handleInsetValue(v) })],
   [/^inset-([xy])-(.+)$/, ([, d, v]) => {
     const r = handleInsetValue(v);
-    if (r != null && d in index.directionMap)
-      return index.directionMap[d].map((i) => [i.slice(1), r]);
+    if (r != null && d in utilities.directionMap)
+      return utilities.directionMap[d].map((i) => [i.slice(1), r]);
   }]
 ];
 const floats = [
-  [/^float-(left|right|none)$/, ([, value]) => ({ float: value })],
-  [/^clear-(left|right|both|none)$/, ([, value]) => ({ clear: value })]
+  [/^float-(left|right)$/, ([, value]) => ({ float: value })],
+  ["float-none", { float: "none" }],
+  [/^clear-(left|right|both)$/, ([, value]) => ({ clear: value })],
+  ["clear-none", { clear: "none" }]
 ];
 const zIndexes = [
   ["z-auto", { "z-index": "auto" }],
-  [/^z-([^-]+)$/, ([, v]) => ({ "z-index": index.handler.number(v) })]
+  [/^z-([^-]+)$/, ([, v]) => ({ "z-index": utilities.handler.number(v) })]
 ];
 const boxSizing = [
   [
@@ -587,29 +459,99 @@ const boxSizing = [
   ]
 ];
 
+const varEmpty = "var(--un-empty,/*!*/ /*!*/)";
+const displays = [
+  ["inline", { display: "inline" }],
+  ["block", { display: "block" }],
+  ["inline-block", { display: "inline-block" }],
+  ["contents", { display: "contents" }],
+  ["flow-root", { display: "flow-root" }],
+  ["list-item", { display: "list-item" }],
+  ["hidden", { display: "none" }]
+];
+const appearances = [
+  ["visible", { visibility: "visible" }],
+  ["invisible", { visibility: "hidden" }],
+  ["backface-visible", { "backface-visibility": "visible" }],
+  ["backface-hidden", { "backface-visibility": "hidden" }]
+];
+const cursors = [
+  [/^cursor-(.+)$/, ([, c]) => ({ cursor: c })]
+];
+const pointerEvents = [
+  ["pointer-events-auto", { "pointer-events": "auto" }],
+  ["pointer-events-none", { "pointer-events": "none" }]
+];
+const resizes = [
+  ["resize-x", { resize: "horizontal" }],
+  ["resize-y", { resize: "vertical" }],
+  ["resize", { resize: "both" }],
+  ["resize-none", { resize: "none" }]
+];
+const userSelects = [
+  [/^select-(text|all|auto)$/, ([, v]) => ({ "user-select": v })],
+  ["select-none", { "user-select": "none" }]
+];
+const whitespaces = [
+  [/^(?:whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)$/, ([, v]) => ({ "white-space": v })]
+];
+const contents = [
+  ["content-empty", { content: '""' }]
+];
+const breaks = [
+  ["break-normal", { "overflow-wrap": "normal", "word-break": "normal" }],
+  ["break-word", { "overflow-wrap": "break-word" }],
+  ["break-all", { "word-break": "break-all" }]
+];
+const textOverflows = [
+  ["truncate", { "overflow": "hidden", "text-overflow": "ellipsis", "white-space": "nowrap" }],
+  ["text-ellipsis", { "text-overflow": "ellipsis" }],
+  ["text-clip", { "text-overflow": "clip" }]
+];
+const textTransforms = [
+  ["case-upper", { "text-transform": "uppercase" }],
+  ["case-lower", { "text-transform": "lowercase" }],
+  ["case-capital", { "text-transform": "capitalize" }],
+  ["case-normal", { "text-transform": "none" }]
+];
+const fontStyles = [
+  ["italic", { "font-style": "italic" }],
+  ["not-italic", { "font-style": "normal" }]
+];
+const fontSmoothings = [
+  ["antialiased", {
+    "-webkit-font-smoothing": "antialiased",
+    "-moz-osx-font-smoothing": "grayscale",
+    "font-smoothing": "grayscale"
+  }],
+  ["subpixel-antialiased", {
+    "-webkit-font-smoothing": "auto",
+    "-moz-osx-font-smoothing": "auto",
+    "font-smoothing": "auto"
+  }]
+];
+
 const rings = [
   [/^ring-?(.*)$/, ([, d]) => {
-    const value = index.handler.px(d || "1");
+    const value = utilities.handler.px(d || "1");
     if (value) {
       return {
-        "--un-ring-inset": "var(--un-empty, )",
+        "--un-ring-inset": varEmpty,
         "--un-ring-offset-width": "0px",
         "--un-ring-offset-color": "#fff",
         "--un-ring-color": "rgba(59, 130, 246, .5)",
         "--un-ring-offset-shadow": "var(--un-ring-inset) 0 0 0 var(--un-ring-offset-width) var(--un-ring-offset-color)",
         "--un-ring-shadow": `var(--un-ring-inset) 0 0 0 calc(${value} + var(--un-ring-offset-width)) var(--un-ring-color)`,
-        "-webkit-box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000);",
-        "box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000);"
+        "-webkit-box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000)",
+        "box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000)"
       };
     }
   }],
-  [/^ring-offset-?(.*)$/, ([, d]) => {
-    const value = index.handler.px(d || "1");
-    if (value) {
-      return {
-        "--un-ring-offset-width": value
-      };
-    }
+  ["ring-offset", { "--un-ring-offset-width": "1px" }],
+  [/^ring-offset-(.+)$/, ([, d]) => {
+    const value = utilities.handler.px(d || "1");
+    if (value)
+      return { "--un-ring-offset-width": value };
   }],
   ["ring-inset", { "--un-ring-inset": "inset" }],
   ...ringColors,
@@ -617,7 +559,7 @@ const rings = [
 ];
 
 const colorResolver = (body, theme) => {
-  const data = parseColorUtil(body, theme);
+  const data = utilities.parseColor(body, theme);
   if (!data)
     return;
   const { color, rgba } = data;
@@ -635,7 +577,7 @@ const colorResolver = (body, theme) => {
 };
 const boxShadows = [
   [/^shadow-?(.*)$/, ([, d], { theme }) => {
-    const value = theme?.boxShadow?.[d || "DEFAULT"];
+    const value = theme.boxShadow?.[d || "DEFAULT"];
     if (value) {
       return {
         "--un-shadow-color": "0,0,0",
@@ -655,12 +597,12 @@ function getPropName(minmax, hw) {
 function getThemeValue(minmax, hw, theme, prop) {
   let str = `${hw === "h" ? "height" : "width"}`;
   if (minmax)
-    str = `${minmax}${index.capitalize(str)}`;
+    str = `${minmax}${utilities.capitalize(str)}`;
   return theme[str]?.[prop];
 }
 const sizes = [
   [/^(?:(min|max)-)?(w|h)-(.+)$/, ([, m, w, s], { theme }) => {
-    const v = getThemeValue(m, w, theme, s) || index.handler.bracket.cssvar.fraction.rem(s);
+    const v = getThemeValue(m, w, theme, s) || utilities.handler.bracket.cssvar.fraction.auto.rem(s);
     if (v != null)
       return { [getPropName(m, w)]: v };
   }],
@@ -673,106 +615,30 @@ const sizes = [
 const aspectRatio = [
   ["aspect-ratio-auto", { "aspect-ratio": "auto" }],
   [/^aspect-ratio-(.+)$/, ([, d]) => {
-    const v = (/^\d+\/\d+$/.test(d) ? d : null) || index.handler.bracket.cssvar.number(d);
+    const v = (/^\d+\/\d+$/.test(d) ? d : null) || utilities.handler.bracket.cssvar.number(d);
     if (v != null)
       return { "aspect-ratio": v };
   }]
 ];
 
-const directionSize = (prefix) => ([_, direction, size]) => {
-  const v = index.handler.bracket.rem.fraction.cssvar(size);
-  if (v)
-    return index.directionMap[direction].map((i) => [prefix + i, v]);
-};
 const paddings = [
-  [/^pa?()-?(-?.+)$/, directionSize("padding")],
-  [/^p-?([xy])-?(-?.+)$/, directionSize("padding")],
-  [/^p-?([rltbse])-?(-?.+)$/, directionSize("padding")]
+  [/^pa?()-?(-?.+)$/, utilities.directionSize("padding")],
+  [/^p-?([xy])-?(-?.+)$/, utilities.directionSize("padding")],
+  [/^p-?([rltbse])-?(-?.+)$/, utilities.directionSize("padding")]
 ];
 const margins = [
-  [/^ma?()-?(-?.+)$/, directionSize("margin")],
-  [/^m-?([xy])-?(-?.+)$/, directionSize("margin")],
-  [/^m-?([rltbse])-?(-?.+)$/, directionSize("margin")]
-];
-
-const varEmpty = "var(--un-empty,/*!*/ /*!*/)";
-const displays = [
-  ["inline", { display: "inline" }],
-  ["block", { display: "block" }],
-  ["inline-block", { display: "inline-block" }],
-  ["contents", { display: "contents" }],
-  ["flow-root", { display: "flow-root" }],
-  ["list-item", { display: "list-item" }],
-  ["hidden", { display: "none" }]
-];
-const appearances = [
-  ["visible", { visibility: "visible" }],
-  ["invisible", { visibility: "hidden" }],
-  ["backface-visible", { "backface-visibility": "visible" }],
-  ["backface-hidden", { "backface-visibility": "hidden" }]
-];
-const cursors = [
-  [/^cursor-(.+)$/, ([, c]) => ({ cursor: c })]
-];
-const pointerEvents = [
-  ["pointer-events-none", { "pointer-events": "none" }],
-  ["pointer-events-auto", { "pointer-events": "auto" }]
-];
-const resizes = [
-  ["resize-none", { resize: "none" }],
-  ["resize-x", { resize: "horizontal" }],
-  ["resize-y", { resize: "vertical" }],
-  ["resize", { resize: "both" }]
-];
-const userSelects = [
-  [/^select-(none|text|all|auto)$/, ([, v]) => ({ "user-select": v })]
-];
-const whitespaces = [
-  [/^(?:whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)$/, ([, v]) => ({ "white-space": v })]
-];
-const contents = [
-  ["content-empty", { content: '""' }]
-];
-const breaks = [
-  ["break-normal", { "overflow-wrap": "normal", "word-break": "normal" }],
-  ["break-word", { "overflow-wrap": "break-word" }],
-  ["break-all", { "word-break": "break-all" }]
-];
-const textOverflows = [
-  ["truncate", { "overflow": "hidden", "text-overflow": "ellipsis", "white-space": "nowrap" }],
-  ["text-ellipsis", { "text-overflow": "ellipsis" }],
-  ["text-clip", { "text-overflow": "clip" }]
-];
-const textTransforms = [
-  ["case-upper", { "text-transform": "uppercase" }],
-  ["case-lower", { "text-transform": "lowercase" }],
-  ["case-capital", { "text-transform": "capitalize" }],
-  ["case-normal", { "text-transform": "none" }]
-];
-const fontStyles = [
-  ["italic", { "font-style": "italic" }],
-  ["not-italic", { "font-style": "normal" }]
-];
-const fontSmoothings = [
-  ["antialiased", {
-    "-webkit-font-smoothing": "antialiased",
-    "-moz-osx-font-smoothing": "grayscale",
-    "font-smoothing": "grayscale"
-  }],
-  ["subpixel-antialiased", {
-    "-webkit-font-smoothing": "auto",
-    "-moz-osx-font-smoothing": "auto",
-    "font-smoothing": "auto"
-  }]
+  [/^ma?()-?(-?.+)$/, utilities.directionSize("margin")],
+  [/^m-?([xy])-?(-?.+)$/, utilities.directionSize("margin")],
+  [/^m-?([rltbse])-?(-?.+)$/, utilities.directionSize("margin")]
 ];
 
 const transformGpu = {
   transform: "rotate(var(--un-rotate)) scaleX(var(--un-scale-x)) scaleY(var(--un-scale-y)) scaleZ(var(--un-scale-z)) skewX(var(--un-skew-x)) skewY(var(--un-skew-y)) translate3d(var(--un-translate-x), var(--un-translate-y), var(--un-translate-z))",
-  [pseudo.CONTROL_BYPASS_PSEUDO]: ""
+  [pseudo.CONTROL_BYPASS_PSEUDO_CLASS]: ""
 };
 const transformCpu = {
   transform: "rotate(var(--un-rotate)) scaleX(var(--un-scale-x)) scaleY(var(--un-scale-y)) scaleZ(var(--un-scale-z)) skewX(var(--un-skew-x)) skewY(var(--un-skew-y)) translateX(var(--un-translate-x)) translateY(var(--un-translate-y)) translateZ(var(--un-translate-z))",
-  [pseudo.CONTROL_BYPASS_PSEUDO]: ""
+  [pseudo.CONTROL_BYPASS_PSEUDO_CLASS]: ""
 };
 const transformBase = {
   "--un-rotate": 0,
@@ -789,11 +655,12 @@ const transformBase = {
 const transforms = [
   ["transform", transformBase],
   [/^preserve-(3d|flat)$/, ([, value]) => ({ "transform-style": value === "3d" ? `preserve-${value}` : value })],
-  [/^translate()-([^-]+)$/, handleTranslate],
-  [/^translate-([xyz])-([^-]+)$/, handleTranslate],
-  [/^scale()-([^-]+)$/, handleScale],
-  [/^scale-([xyz])-([^-]+)$/, handleScale],
-  [/^rotate-([^-]+)(?:deg)?$/, handleRotate],
+  [/^translate()-(.+)$/, handleTranslate],
+  [/^translate-([xyz])-(.+)$/, handleTranslate],
+  [/^scale()-(.+)$/, handleScale],
+  [/^scale-([xyz])-(.+)$/, handleScale],
+  [/^rotate-(.+)$/, handleRotate],
+  [/^rotate-((?!\[)[^-]+?)(?:deg)?$/, handleRotateWithUnit],
   ["transform-gpu", transformGpu],
   ["transform-cpu", transformCpu],
   ["transform-none", { transform: "none" }],
@@ -808,29 +675,29 @@ const transforms = [
   ["origin-top-left", { "transform-origin": "top left" }]
 ];
 function handleTranslate([, d, b]) {
-  const v = index.handler.bracket.fraction.rem(b);
+  const v = utilities.handler.bracket.fraction.auto.rem(b);
   if (v != null) {
     return [
       transformBase,
       [
-        ...index.xyzMap[d].map((i) => [`--un-translate${i}`, v])
+        ...utilities.xyzMap[d].map((i) => [`--un-translate${i}`, v])
       ]
     ];
   }
 }
 function handleScale([, d, b]) {
-  const v = index.handler.bracket.fraction.percent(b);
+  const v = utilities.handler.bracket.fraction.percent(b);
   if (v != null) {
     return [
       transformBase,
       [
-        ...index.xyzMap[d].map((i) => [`--un-scale${i}`, v])
+        ...utilities.xyzMap[d].map((i) => [`--un-scale${i}`, v])
       ]
     ];
   }
 }
-function handleRotate([, b]) {
-  const v = index.handler.bracket.number(b);
+function handleRotateWithUnit([, b]) {
+  const v = utilities.handler.bracket.number(b);
   if (v != null) {
     return [
       transformBase,
@@ -838,6 +705,15 @@ function handleRotate([, b]) {
     ];
   }
 }
+function handleRotate([, b]) {
+  const v = utilities.handler.bracket(b);
+  if (v != null) {
+    return [
+      transformBase,
+      { "--un-rotate": v }
+    ];
+  }
+}
 
 const variablesAbbrMap = {
   "visible": "visibility",
@@ -878,8 +754,8 @@ const cssVariables = [
     }
   }],
   [/^(?:border|b)-([^-]+)-\$(.+)$/, ([, a, v]) => {
-    if (a in index.directionMap)
-      return index.directionMap[a].map((i) => [`border${i}-color`, `var(--${v})`]);
+    if (a in utilities.directionMap)
+      return utilities.directionMap[a].map((i) => [`border${i}-color`, `var(--${v})`]);
   }]
 ];
 
@@ -887,7 +763,7 @@ const questionMark = [
   [
     /^(where|\?)$/,
     (_, { constructCSS, generator }) => {
-      if (generator.config.envMode === "dev")
+      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" })}`;
     }
@@ -897,20 +773,18 @@ ${constructCSS({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
 const textDecorations = [
   ["underline", { "text-decoration": "underline" }],
   ["line-through", { "text-decoration": "line-through" }],
-  ["no-underline", { "text-decoration": "none" }],
   ["decoration-underline", { "text-decoration": "underline" }],
   ["decoration-line-through", { "text-decoration": "line-through" }],
-  ["decoration-none", { "text-decoration": "none" }],
   [/^(?:underline|decoration)-(solid|double|dotted|dashed|wavy)$/, ([, d]) => ({ "text-decoration-style": d })],
-  [/^(?:underline|decoration)-([^-]+)$/, ([, s]) => ({ "text-decoration-thickness": ["auto", "from-font"].includes(s) ? s : index.handler.bracket.px(s) })],
-  [/^decoration-(.*)$/, ([, d]) => ({ "text-decoration-thickness": index.handler.bracket.px(d) })],
+  [/^(?:underline|decoration)-([^-]+)$/, ([, s]) => ({ "text-decoration-thickness": ["auto", "from-font"].includes(s) ? s : utilities.handler.bracket.px(s) })],
+  [/^decoration-(.+)$/, ([, d]) => ({ "text-decoration-thickness": utilities.handler.bracket.px(d) })],
   [/^underline-offset-([^-]+)$/, ([, s]) => {
-    const v = s === "auto" ? s : index.handler.bracket.px(s);
+    const v = s === "auto" ? s : utilities.handler.bracket.px(s);
     if (v != null)
       return { "text-underline-offset": v };
   }],
   [/^(?:underline|decoration)-(.+)$/, (match, ctx) => {
-    const result = colorResolver$1("text-decoration-color", "line")(match, ctx);
+    const result = utilities.colorResolver("text-decoration-color", "line")(match, ctx);
     if (result) {
       return {
         "-webkit-text-decoration-color": result["text-decoration-color"],
@@ -918,7 +792,23 @@ const textDecorations = [
       };
     }
   }],
-  [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/m, ([, opacity]) => ({ "--un-line-opacity": index.handler.bracket.percent(opacity) })]
+  [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": utilities.handler.bracket.percent(opacity) })],
+  ["no-underline", { "text-decoration": "none" }],
+  ["decoration-none", { "text-decoration": "none" }]
+];
+
+const svgUtilities = [
+  [/^fill-(.+)$/, utilities.colorResolver("fill", "fill")],
+  [/^fill-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-fill-opacity": utilities.handler.bracket.percent(opacity) })],
+  ["fill-none", { fill: "none" }],
+  [/^stroke-(?:size-|width-)?(.+)$/, ([, s]) => {
+    const v = utilities.handler.bracket.fraction.px.number(s);
+    if (v)
+      return { "stroke-width": v };
+  }],
+  [/^stroke-(.+)$/, utilities.colorResolver("stroke", "stroke")],
+  [/^stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-stroke-opacity": utilities.handler.bracket.percent(opacity) })],
+  ["stroke-none", { stroke: "none" }]
 ];
 
 const rules = [
@@ -928,7 +818,7 @@ const rules = [
   displays,
   opacity,
   bgColors,
-  fillColors,
+  svgUtilities,
   borders,
   contents,
   fonts,
@@ -974,6 +864,7 @@ const rules = [
   boxSizing,
   transitions,
   transforms,
+  willChange,
   questionMark
 ].flat(1);
 
@@ -987,12 +878,10 @@ exports.borders = borders;
 exports.boxShadows = boxShadows;
 exports.boxSizing = boxSizing;
 exports.breaks = breaks;
-exports.colorResolver = colorResolver$1;
 exports.contents = contents;
 exports.cssVariables = cssVariables;
 exports.cursors = cursors;
 exports.displays = displays;
-exports.fillColors = fillColors;
 exports.flex = flex;
 exports.floats = floats;
 exports.fontSmoothings = fontSmoothings;
@@ -1008,7 +897,6 @@ exports.orders = orders;
 exports.outline = outline;
 exports.overflows = overflows;
 exports.paddings = paddings;
-exports.parseColorUtil = parseColorUtil;
 exports.placeholder = placeholder;
 exports.placements = placements;
 exports.pointerEvents = pointerEvents;
@@ -1020,6 +908,7 @@ exports.ringOffsetColors = ringOffsetColors;
 exports.rings = rings;
 exports.rules = rules;
 exports.sizes = sizes;
+exports.svgUtilities = svgUtilities;
 exports.tabSizes = tabSizes;
 exports.textAligns = textAligns;
 exports.textColors = textColors;
@@ -1035,4 +924,5 @@ exports.userSelects = userSelects;
 exports.varEmpty = varEmpty;
 exports.verticalAligns = verticalAligns;
 exports.whitespaces = whitespaces;
+exports.willChange = willChange;
 exports.zIndexes = zIndexes;