@unocss/preset-mini 0.17.2 → 0.19.0

package/dist/chunks/default2.cjs

@@ -19,38 +19,12 @@ const textAligns = [
   ["text-justify", { "text-align": "justify" }]
 ];
 
-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 = utilities.handler.bracket.fraction.auto.rem(s.replace(/^(offset\-|width\-|size\-)/, ""));
-  if (size) {
-    return {
-      [`outline-${propName}`]: size
-    };
-  }
-};
 const outline = [
+  [/^outline-(?:width-|size-)?(.+)$/, ([, d]) => ({ "outline-width": utilities.handler.bracket.fraction.auto.rem(d) })],
+  [/^outline-(?:color-)?(.+)$/, utilities.colorResolver("outline-color", "outline-color")],
+  [/^outline-offset-(.+)$/, ([, d]) => ({ "outline-offset": utilities.handler.bracket.fraction.auto.rem(d) })],
   ["outline", { "outline-style": "solid" }],
-  [
-    /^outline-(.+)$/,
-    (match, config) => {
-      const [, d] = match;
-      if (outlineStyle.includes(d)) {
-        return {
-          "outline-style": d
-        };
-      }
-      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-(auto|dotted|dashed|solid|double|groove|ridge|inset|outset|inherit|initial|revert|unset)$/, ([, c]) => ({ "outline-style": c })],
   ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }]
 ];
 const appearance = [
@@ -59,21 +33,6 @@ const appearance = [
     "-webkit-appearance": "none"
   }]
 ];
-const placeholder = [
-  [
-    /^placeholder-opacity-(\d+)$/,
-    ([, d]) => ({
-      "placeholder-opacity": utilities.handler.bracket.percent(d)
-    })
-  ],
-  [
-    /^placeholder-(?!opacity)(.+)$/,
-    (match, config) => {
-      match[1] = match[1].replace(/^color-/, "");
-      return utilities.colorResolver("placeholder-color", "placeholder-color")(match, config);
-    }
-  ]
-];
 const willChange = [
   [/^will-change-(.+)/, ([, p]) => ({ "will-change": utilities.handler.properties.global(p) })]
 ];
@@ -86,16 +45,59 @@ const borders = [
   [/^(?:border|b)-([^-]+)-size-(.+)$/, handlerBorderSize],
   [/^(?:border|b)()-(.+)$/, handlerBorderColor],
   [/^(?:border|b)-([^-]+)(?:-(.+))?$/, handlerBorderColor],
-  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-border-opacity": utilities.handler.bracket.percent(opacity) })],
+  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity], { options: { variablePrefix: p } }) => ({ [`--${p}border-opacity`]: utilities.handler.bracket.percent(opacity) })],
+  [/^(?:border|b)-([^-]+)-op(?:acity)?-?(.+)$/, ([, a, opacity], { options: { variablePrefix: p } }) => {
+    const v = utilities.handler.bracket.percent(opacity);
+    const d = utilities.directionMap[a];
+    if (v !== void 0 && d)
+      return d.map((i) => [`--${p}border${i}-opacity`, v]);
+  }],
+  [/^(?:border-)?(?:rounded|rd)$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-(.+))?$/, handlerRounded],
   ["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-none", { "border-style": "none" }]
 ];
+const borderHasColor = (color, { theme }) => {
+  return color !== void 0 && !!utilities.parseColor(color, theme)?.color;
+};
+const borderColorResolver = (direction) => ([, body], { theme, options: { variablePrefix: p } }) => {
+  const data = utilities.parseColor(body, theme);
+  if (!data)
+    return;
+  const { opacity, color, rgba } = data;
+  if (!color)
+    return;
+  const a = opacity ? opacity[0] === "[" ? utilities.handler.bracket.percent(opacity) : parseFloat(opacity) / 100 : rgba?.[3];
+  if (rgba) {
+    if (a != null && !Number.isNaN(a)) {
+      rgba[3] = typeof a === "string" && !a.includes("%") ? parseFloat(a) : a;
+      return {
+        [`border${direction}-color`]: `rgba(${rgba.join(",")})`
+      };
+    } else {
+      if (direction === "") {
+        return {
+          [`--${p}border-opacity`]: 1,
+          [`border${direction}-color`]: `rgba(${rgba.slice(0, 3).join(",")},var(--${p}border${direction}-opacity))`
+        };
+      } else {
+        return {
+          [`--${p}border-opacity`]: 1,
+          [`--${p}border${direction}-opacity`]: `var(--${p}border-opacity)`,
+          [`border${direction}-color`]: `rgba(${rgba.slice(0, 3).join(",")},var(--${p}border${direction}-opacity))`
+        };
+      }
+    }
+  } else {
+    return {
+      [`border${direction}-color`]: color.replace("%alpha", `${a || 1}`)
+    };
+  }
+};
 function handlerBorder(m) {
   const borderSizes = handlerBorderSize(m);
   if (borderSizes) {
@@ -112,8 +114,8 @@ function handlerBorderSize([, a, b]) {
     return utilities.directionMap[d].map((i) => [`border${i}-width`, v]);
 }
 function handlerBorderColor([, a, c], ctx) {
-  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)));
+  if (borderHasColor(c, ctx)) {
+    return Object.assign({}, ...utilities.directionMap[utilities.directionMap[a] ? a : ""].map((i) => borderColorResolver(i)(["", c], ctx)));
   }
 }
 function handlerRounded([, a, b], { theme }) {
@@ -134,18 +136,6 @@ const bgColors = [
   [/^bg-(.+)$/, utilities.colorResolver("background-color", "bg")],
   [/^bg-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-bg-opacity": utilities.handler.bracket.percent(opacity2) })]
 ];
-const borderColors = [
-  [/^(?:border|b)-(.+)$/, utilities.colorResolver("border-color", "border")],
-  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-border-opacity": utilities.handler.bracket.percent(opacity2) })]
-];
-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);
@@ -183,7 +173,7 @@ const flex = [
   ["flex-auto", { flex: "1 1 auto" }],
   ["flex-initial", { flex: "0 1 auto" }],
   ["flex-none", { flex: "none" }],
-  [/^flex-\[(.+)\]$/, ([, d]) => ({ flex: d })],
+  [/^flex-(\[.+\])$/, ([, d]) => ({ flex: utilities.handler.bracket(d).replace(/\d+\/\d+/, ($1) => utilities.handler.fraction($1)) })],
   ["flex-shrink", { "flex-shrink": 1 }],
   ["flex-shrink-0", { "flex-shrink": 0 }],
   ["flex-grow", { "flex-grow": 1 }],
@@ -294,30 +284,17 @@ const textShadows = [
 ];
 
 const gaps = [
-  [/^(?:flex-|grid-)?gap-([^-]+)$/, ([, s]) => {
-    const v = utilities.handler.bracket.auto.rem(s);
-    if (v != null) {
-      return {
-        "grid-gap": v,
-        "gap": v
-      };
-    }
-  }],
-  [/^(?:flex-|grid-)?gap-x-([^-]+)$/, ([, s]) => {
+  [/^(?:flex-|grid-)?gap-(x-|y-)?([^-]+)$/, ([, d = "", s]) => {
     const v = utilities.handler.bracket.auto.rem(s);
     if (v != null) {
+      const direction = {
+        "": "",
+        "x-": "column-",
+        "y-": "row-"
+      }[d];
       return {
-        "grid-column-gap": v,
-        "column-gap": v
-      };
-    }
-  }],
-  [/^(?:flex-|grid-)?gap-y-([^-]+)$/, ([, s]) => {
-    const v = utilities.handler.bracket.auto.rem(s);
-    if (v != null) {
-      return {
-        "grid-row-gap": v,
-        "row-gap": v
+        [`grid-${direction}gap`]: v,
+        [`${direction}gap`]: v
       };
     }
   }]
@@ -351,7 +328,7 @@ const grids = [
     if (parts[0] === "span") {
       if (parts[1] === "full")
         return { [key]: "1/-1" };
-      raw = utilities.handler.number.bracket(parts[1])?.toString().replace(/_/g, " ");
+      raw = utilities.handler.number.bracket(parts[1]);
       if (raw)
         return { [key]: `span ${raw}/span ${raw}` };
     }
@@ -359,12 +336,12 @@ const grids = [
   [/^(?: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-(.+)$/, ([, v]) => ({ "grid-template-columns": utilities.handler.bracket(v) })],
+  [/^grid-rows-(.+)$/, ([, v]) => ({ "grid-template-rows": utilities.handler.bracket(v) })],
   [/^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, " ") })],
-  [/^grid-rows-\[(.+)\]$/, ([, v]) => ({ "grid-template-rows": v.replace(/,/g, " ") })]
+  [/^grid-rows-(\d+)$/, ([, d]) => ({ "grid-template-rows": `repeat(${d},minmax(0,1fr))` })]
 ];
 
 const overflowValues = [
@@ -380,11 +357,8 @@ const overflows = [
 
 const basicSet = ["auto", "start", "end", "center", "stretch"];
 const positions = [
-  ["relative", { position: "relative" }],
-  ["absolute", { position: "absolute" }],
-  ["fixed", { position: "fixed" }],
-  ["sticky", { position: "sticky" }],
-  ["static", { position: "static" }]
+  [/^(?:position-|pos-)?(relative|absolute|fixed|sticky)$/, ([, v]) => ({ position: v })],
+  [/^(?:position-|pos-)?(static)$/, ([, v]) => ({ position: v })]
 ];
 const justifies = [
   ["justify-start", { "justify-content": "flex-start" }],
@@ -397,7 +371,9 @@ const justifies = [
   ...basicSet.map((i) => [`justify-self-${i}`, { "justify-self": i }])
 ];
 const orders = [
-  [/^order-(.+)$/, ([, v]) => ({ order: { first: "-9999", last: "9999" }[v] || utilities.handler.bracket.number(v) })],
+  [/^order-(.+)$/, ([, v]) => ({ order: utilities.handler.bracket.number(v) })],
+  ["order-first", { order: "-9999" }],
+  ["order-last", { order: "9999" }],
   ["order-none", { order: "0" }]
 ];
 const alignments = [
@@ -433,17 +409,20 @@ function handleInsetValue(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]) => {
+  [/^(?:position-|pos-)?(top|left|right|bottom|inset)-(.+)$/, ([, d, v]) => ({ [d]: handleInsetValue(v) })],
+  [/^(?:position-|pos-)?inset-([xy])-(.+)$/, ([, d, v]) => {
     const r = handleInsetValue(v);
     if (r != null && d in utilities.directionMap)
       return utilities.directionMap[d].map((i) => [i.slice(1), r]);
   }]
 ];
 const floats = [
-  [/^float-(left|right)$/, ([, value]) => ({ float: value })],
+  ["float-left", { float: "left" }],
+  ["float-right", { float: "right" }],
   ["float-none", { float: "none" }],
-  [/^clear-(left|right|both)$/, ([, value]) => ({ clear: value })],
+  ["clear-left", { clear: "left" }],
+  ["clear-right", { clear: "right" }],
+  ["clear-both", { clear: "both" }],
   ["clear-none", { clear: "none" }]
 ];
 const zIndexes = [
@@ -451,14 +430,11 @@ const zIndexes = [
   [/^z-([^-]+)$/, ([, v]) => ({ "z-index": utilities.handler.number(v) })]
 ];
 const boxSizing = [
-  [
-    /^box-(border|content)$/,
-    ([, value]) => ({
-      "box-sizing": `${value}-box`
-    })
-  ]
+  ["box-border", { "box-sizing": "border-box" }],
+  ["box-content", { "box-sizing": "content-box" }]
 ];
 
+const varEmptyFn = core.cacheFunction((prefix) => `var(--${prefix}empty,/*!*/ /*!*/)`);
 const varEmpty = "var(--un-empty,/*!*/ /*!*/)";
 const displays = [
   ["inline", { display: "inline" }],
@@ -489,7 +465,9 @@ const resizes = [
   ["resize-none", { resize: "none" }]
 ];
 const userSelects = [
-  [/^select-(text|all|auto)$/, ([, v]) => ({ "user-select": v })],
+  ["select-auto", { "user-select": "auto" }],
+  ["select-all", { "user-select": "all" }],
+  ["select-text", { "user-select": "text" }],
   ["select-none", { "user-select": "none" }]
 ];
 const whitespaces = [
@@ -532,30 +510,28 @@ const fontSmoothings = [
 ];
 
 const rings = [
-  [/^ring-?(.*)$/, ([, d]) => {
+  [/^ring-?(.*)$/, ([, d], { options: { variablePrefix: p } }) => {
     const value = utilities.handler.px(d || "1");
     if (value) {
       return {
-        "--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)"
+        [`--${p}ring-inset`]: varEmptyFn(p),
+        [`--${p}ring-offset-width`]: "0px",
+        [`--${p}ring-offset-color`]: "#fff",
+        [`--${p}ring-color`]: "rgba(59, 130, 246, .5)",
+        [`--${p}ring-offset-shadow`]: `var(--${p}ring-inset) 0 0 0 var(--${p}ring-offset-width) var(--${p}ring-offset-color)`,
+        [`--${p}ring-shadow`]: `var(--${p}ring-inset) 0 0 0 calc(${value} + var(--${p}ring-offset-width)) var(--${p}ring-color)`,
+        "-webkit-box-shadow": `var(--${p}ring-offset-shadow), var(--${p}ring-shadow), var(--${p}shadow, 0 0 #0000)`,
+        "box-shadow": `var(--${p}ring-offset-shadow), var(--${p}ring-shadow), var(--${p}shadow, 0 0 #0000)`
       };
     }
   }],
-  ["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,
-  ...ringOffsetColors
+  [/^ring-offset$/, (_, { options: { variablePrefix: p } }) => ({ [`--${p}ring-offset-width`]: "1px" })],
+  [/^ring-offset-(.+)$/, ([, d], { options: { variablePrefix: p } }) => ({ [`--${p}ring-offset-width`]: utilities.handler.px(d || "1") })],
+  [/^ring-(.+)$/, (m, ctx) => utilities.colorResolver(`--${ctx.options.variablePrefix}ring-color`, "ring")(m, ctx)],
+  [/^ring-op(?:acity)?-?(.+)$/, ([, opacity], { options: { variablePrefix: p } }) => ({ [`--${p}ring-opacity`]: utilities.handler.bracket.percent(opacity) })],
+  [/^ring-offset-(.+)$/, (m, ctx) => utilities.colorResolver(`--${ctx.options.variablePrefix}ring-offset-color`, "ring-offset")(m, ctx)],
+  [/^ring-offset-op(?:acity)?-?(.+)$/, ([, opacity], { options: { variablePrefix: p } }) => ({ [`--${p}ring-offset-opacity`]: utilities.handler.bracket.percent(opacity) })],
+  [/^ring-inset$/, (_, { options: { variablePrefix: p } }) => ({ [`--${p}ring-inset`]: "inset" })]
 ];
 
 const colorResolver = (body, theme) => {
@@ -585,10 +561,8 @@ const boxShadows = [
         "box-shadow": "var(--un-ring-offset-shadow, 0 0 #0000), var(--un-ring-shadow, 0 0 #0000), var(--un-shadow)"
       };
     }
-    const color = colorResolver(d, theme);
-    if (color)
-      return color;
-  }]
+  }],
+  [/^shadow-(.+)$/, ([, d], { theme }) => colorResolver(d, theme)]
 ];
 
 function getPropName(minmax, hw) {
@@ -661,6 +635,8 @@ const transforms = [
   [/^scale-([xyz])-(.+)$/, handleScale],
   [/^rotate-(.+)$/, handleRotate],
   [/^rotate-((?!\[)[^-]+?)(?:deg)?$/, handleRotateWithUnit],
+  [/^skew-([xy])-(.+)$/, handleSkew],
+  [/^skew-([xy])-((?!\[)[^-]+?)(?:deg)?$/, handleSkewWithUnit],
   ["transform-gpu", transformGpu],
   ["transform-cpu", transformCpu],
   ["transform-none", { transform: "none" }],
@@ -714,6 +690,24 @@ function handleRotate([, b]) {
     ];
   }
 }
+function handleSkewWithUnit([, d, b]) {
+  const v = utilities.handler.bracket.number(b);
+  if (v != null) {
+    return [
+      transformBase,
+      { [`--un-skew-${d}`]: `${v}deg` }
+    ];
+  }
+}
+function handleSkew([, d, b]) {
+  const v = utilities.handler.bracket(b);
+  if (v != null) {
+    return [
+      transformBase,
+      { [`--un-skew-${d}`]: v }
+    ];
+  }
+}
 
 const variablesAbbrMap = {
   "visible": "visibility",
@@ -775,14 +769,8 @@ const textDecorations = [
   ["line-through", { "text-decoration": "line-through" }],
   ["decoration-underline", { "text-decoration": "underline" }],
   ["decoration-line-through", { "text-decoration": "line-through" }],
-  [/^(?:underline|decoration)-(solid|double|dotted|dashed|wavy)$/, ([, d]) => ({ "text-decoration-style": 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 : utilities.handler.bracket.px(s);
-    if (v != null)
-      return { "text-underline-offset": v };
-  }],
+  [/^(?:underline|decoration)-(?:size-)?(.+)$/, ([, s]) => ({ "text-decoration-thickness": utilities.handler.bracket.px(s) })],
+  [/^(?:underline|decoration)-(auto|from-font)$/, ([, s]) => ({ "text-decoration-thickness": s })],
   [/^(?:underline|decoration)-(.+)$/, (match, ctx) => {
     const result = utilities.colorResolver("text-decoration-color", "line")(match, ctx);
     if (result) {
@@ -793,6 +781,8 @@ const textDecorations = [
     }
   }],
   [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": utilities.handler.bracket.percent(opacity) })],
+  [/^underline-offset-(.+)$/, ([, s]) => ({ "text-underline-offset": utilities.handler.auto.bracket.px(s) })],
+  [/^(?:underline|decoration)-(solid|double|dotted|dashed|wavy|inherit|initial|revert|unset)$/, ([, d]) => ({ "text-decoration-style": d })],
   ["no-underline", { "text-decoration": "none" }],
   ["decoration-none", { "text-decoration": "none" }]
 ];
@@ -852,7 +842,6 @@ const rules = [
   overflows,
   outline,
   appearance,
-  placeholder,
   positions,
   orders,
   justifies,
@@ -873,7 +862,6 @@ exports.appearance = appearance;
 exports.appearances = appearances;
 exports.aspectRatio = aspectRatio;
 exports.bgColors = bgColors;
-exports.borderColors = borderColors;
 exports.borders = borders;
 exports.boxShadows = boxShadows;
 exports.boxSizing = boxSizing;
@@ -897,14 +885,11 @@ exports.orders = orders;
 exports.outline = outline;
 exports.overflows = overflows;
 exports.paddings = paddings;
-exports.placeholder = placeholder;
 exports.placements = placements;
 exports.pointerEvents = pointerEvents;
 exports.positions = positions;
 exports.questionMark = questionMark;
 exports.resizes = resizes;
-exports.ringColors = ringColors;
-exports.ringOffsetColors = ringOffsetColors;
 exports.rings = rings;
 exports.rules = rules;
 exports.sizes = sizes;
@@ -922,6 +907,7 @@ exports.transforms = transforms;
 exports.transitions = transitions;
 exports.userSelects = userSelects;
 exports.varEmpty = varEmpty;
+exports.varEmptyFn = varEmptyFn;
 exports.verticalAligns = verticalAligns;
 exports.whitespaces = whitespaces;
 exports.willChange = willChange;