@unocss/preset-mini 0.20.2 → 0.20.4

package/dist/chunks/default2.cjs

@@ -38,27 +38,27 @@ const willChange = [
 ];
 
 const borders = [
-  [/^border$/, 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": utilities.handler.bracket.percent(opacity) })],
-  [/^(?:border|b)-([^-]+)-op(?:acity)?-?(.+)$/, ([, a, opacity]) => {
-    const v = utilities.handler.bracket.percent(opacity);
-    const d = utilities.directionMap[a];
-    if (v !== void 0 && d)
-      return d.map((i) => [`--un-border${i}-opacity`, v]);
-  }],
-  [/^(?:border-)?(?:rounded|rd)$/, handlerRounded],
-  [/^(?:border-)?(?:rounded|rd)(?:-(.+))?$/, handlerRounded],
-  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-(.+))?$/, handlerRounded],
+  [/^(?:border|b)()(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)-([xy])(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)-([rltbse])(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)-()size-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-([xy])-size-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-([rltbse])-size-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-()(?:color-)?(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-([xy])-(?:color-)?(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-([rltbse])-(?:color-)?(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-()op(?:acity)?-?(.+)$/, handlerBorderOpacity],
+  [/^(?:border|b)-([xy])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
+  [/^(?:border|b)-([rltbse])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
+  [/^(?:border-)?(?:rounded|rd)()(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)-([xy])(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)-([rltb])(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)-([rltb]{2})(?:-(.+))?$/, handlerRounded],
   ["border-solid", { "border-style": "solid" }],
   ["border-dashed", { "border-style": "dashed" }],
   ["border-dotted", { "border-style": "dotted" }],
   ["border-double", { "border-style": "double" }],
+  ["border-hidden", { "border-style": "hidden" }],
   ["border-none", { "border-style": "none" }]
 ];
 const borderHasColor = (color, { theme }) => {
@@ -105,22 +105,25 @@ function handlerBorder(m) {
     ];
   }
 }
-function handlerBorderSize([, a, b]) {
-  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 handlerBorderSize([, a = "", b = "1"]) {
+  const v = utilities.handler.bracket.px(b);
+  if (a in utilities.directionMap && v != null)
+    return utilities.directionMap[a].map((i) => [`border${i}-width`, v]);
 }
-function handlerBorderColor([, a, c], ctx) {
-  if (borderHasColor(c, ctx)) {
-    return Object.assign({}, ...utilities.directionMap[utilities.directionMap[a] ? a : ""].map((i) => borderColorResolver(i)(["", c], ctx)));
+function handlerBorderColor([, a = "", c], ctx) {
+  if (a in utilities.directionMap && borderHasColor(c, ctx)) {
+    return Object.assign({}, ...utilities.directionMap[a].map((i) => borderColorResolver(i)(["", c], ctx)));
   }
 }
-function handlerRounded([, a, b], { theme }) {
-  const [d, s = "DEFAULT"] = utilities.cornerMap[a] ? [a, b] : ["", a];
+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]);
+}
+function handlerRounded([, a = "", s = "DEFAULT"], { theme }) {
   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]);
+  if (a in utilities.cornerMap && v != null)
+    return utilities.cornerMap[a].map((i) => [`border${i}-radius`, v]);
 }
 
 const opacity = [
@@ -135,12 +138,19 @@ const bgColors = [
   [/^bg-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-bg-opacity": utilities.handler.bracket.percent(opacity2) })]
 ];
 
+const transitionPropertyGroup = {
+  all: "all",
+  colors: ["color", "background-color", "border-color", "text-decoration-color", "fill", "stroke"].join(","),
+  opacity: "opacity",
+  shadow: "box-shadow",
+  transform: "transform"
+};
 const transitionProperty = (prop) => {
-  return utilities.handler.properties(prop) || (prop === "all" ? prop : void 0);
+  return utilities.handler.properties(prop) ?? transitionPropertyGroup[prop];
 };
 const transitions = [
-  [/^transition(?:-([a-z-]+(?:,[a-z-]+)*))?(?:-(\d+))?$/, ([, prop = "all", duration = "150"]) => {
-    const p = transitionProperty(prop);
+  [/^transition(?:-([a-z-]+(?:,[a-z-]+)*))?(?:-(\d+))?$/, ([, prop, duration = "150"]) => {
+    const p = prop != null ? transitionProperty(prop) : [transitionPropertyGroup.colors, "opacity", "box-shadow", "transform", "filter", "backdrop-filter"].join(",");
     if (p) {
       return {
         "transition-property": p,
@@ -149,14 +159,14 @@ const transitions = [
       };
     }
   }],
-  [/^duration-(\d+)$/, ([, duration = "150"]) => ({ "transition-duration": `${duration}ms` })],
+  [/^(?:transition-)?delay-(.+)(?:s|ms)?$/, ([, d]) => ({ "transition-delay": utilities.handler.bracket.time(d) })],
+  [/^(?:transition-)?duration-(.+)(?:s|ms)?$/, ([, d]) => ({ "transition-duration": utilities.handler.bracket.time(d) })],
+  [/^ease-(.+)$/, ([, d]) => ({ "transition-timing-function": utilities.handler.bracket(d) })],
   ["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-(.+)$/, ([, v]) => ({ "transition-property": utilities.handler.global(v) || transitionProperty(v) })],
   ["transition-property-none", { "transition-property": "none" }],
   ["property-none", { "transition-property": "none" }],
@@ -176,6 +186,7 @@ const flex = [
   ["flex-shrink-0", { "flex-shrink": 0 }],
   ["flex-grow", { "flex-grow": 1 }],
   ["flex-grow-0", { "flex-grow": 0 }],
+  [/^(?:flex-)?basis-(.+)$/, ([, d]) => ({ "flex-basis": utilities.handler.bracket.fraction.auto.rem(d) })],
   ["flex-row", { "flex-direction": "row" }],
   ["flex-row-reverse", { "flex-direction": "row-reverse" }],
   ["flex-col", { "flex-direction": "column" }],
@@ -243,19 +254,21 @@ const textShadows = [
 
 const directions = {
   "": "",
-  "x-": "column-",
-  "y-": "row-"
+  "x": "column-",
+  "y": "row-"
+};
+const handleGap = ([, d = "", s]) => {
+  const v = utilities.handler.bracket.auto.rem(s);
+  if (v != null) {
+    return {
+      [`grid-${directions[d]}gap`]: v,
+      [`${directions[d]}gap`]: v
+    };
+  }
 };
 const gaps = [
-  [/^(?:flex-|grid-)?gap-(x-|y-)?([^-]+)$/, ([, d = "", s]) => {
-    const v = utilities.handler.bracket.auto.rem(s);
-    if (v != null) {
-      return {
-        [`grid-${directions[d]}gap`]: v,
-        [`${directions[d]}gap`]: v
-      };
-    }
-  }]
+  [/^(?:flex-|grid-)?gap-()([^-]+)$/, handleGap],
+  [/^(?:flex-|grid-)?gap-([xy])-([^-]+)$/, handleGap]
 ];
 
 const calSize = (s, theme) => core.toArray(theme.fontSize?.[s] || utilities.handler.bracket.auto.rem(s))[0];
@@ -313,7 +326,6 @@ const overflows = [
   [/^(?:overflow|of)-([xy])-(.+)$/, ([, d, v]) => overflowValues.includes(v) ? { [`overflow-${d}`]: v } : void 0]
 ];
 
-const basicSet = ["auto", "start", "end", "center", "stretch"];
 const positions = [
   [/^(?:position-|pos-)?(relative|absolute|fixed|sticky)$/, ([, v]) => ({ position: v })],
   [/^(?:position-|pos-)?(static)$/, ([, v]) => ({ position: v })]
@@ -325,8 +337,15 @@ const justifies = [
   ["justify-between", { "justify-content": "space-between" }],
   ["justify-around", { "justify-content": "space-around" }],
   ["justify-evenly", { "justify-content": "space-evenly" }],
-  ...basicSet.map((i) => [`justify-items-${i}`, { "justify-items": i }]),
-  ...basicSet.map((i) => [`justify-self-${i}`, { "justify-self": i }])
+  ["justify-items-start", { "justify-items": "start" }],
+  ["justify-items-end", { "justify-items": "end" }],
+  ["justify-items-center", { "justify-items": "center" }],
+  ["justify-items-stretch", { "justify-items": "stretch" }],
+  ["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" }]
 ];
 const orders = [
   [/^order-(.+)$/, ([, v]) => ({ order: utilities.handler.bracket.number(v) })],
@@ -335,9 +354,9 @@ const orders = [
   ["order-none", { order: "0" }]
 ];
 const alignments = [
+  ["content-center", { "align-content": "center" }],
   ["content-start", { "align-content": "flex-start" }],
   ["content-end", { "align-content": "flex-end" }],
-  ["content-center", { "align-content": "center" }],
   ["content-between", { "align-content": "space-between" }],
   ["content-around", { "align-content": "space-around" }],
   ["content-evenly", { "align-content": "space-evenly" }],
@@ -350,29 +369,39 @@ const alignments = [
   ["self-start", { "align-self": "flex-start" }],
   ["self-end", { "align-self": "flex-end" }],
   ["self-center", { "align-self": "center" }],
-  ["self-stretch", { "align-self": "stretch" }]
+  ["self-stretch", { "align-self": "stretch" }],
+  ["self-baseline", { "align-self": "baseline" }]
 ];
 const placements = [
+  ["place-content-center", { "place-content": "center" }],
   ["place-content-start", { "place-content": "start" }],
   ["place-content-end", { "place-content": "end" }],
-  ["place-content-center", { "place-content": "center" }],
   ["place-content-between", { "place-content": "space-between" }],
   ["place-content-around", { "place-content": "space-around" }],
   ["place-content-evenly", { "place-content": "space-evenly" }],
   ["place-content-stretch", { "place-content": "stretch" }],
-  ...basicSet.map((i) => [`place-items-${i}`, { "place-items": i }]),
-  ...basicSet.map((i) => [`place-self-${i}`, { "place-self": i }])
+  ["place-items-start", { "place-items": "start" }],
+  ["place-items-end", { "place-items": "end" }],
+  ["place-items-center", { "place-items": "center" }],
+  ["place-items-stretch", { "place-items": "stretch" }],
+  ["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" }]
 ];
 function handleInsetValue(v) {
   return { auto: "auto", full: "100%" }[v] ?? utilities.handler.bracket.fraction.cssvar.auto.rem(v);
 }
+function handleInsetValues([, d, v]) {
+  const r = handleInsetValue(v);
+  if (r != null && d in utilities.directionMap)
+    return utilities.directionMap[d].map((i) => [i.slice(1), r]);
+}
 const insets = [
-  [/^(?: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]);
-  }]
+  [/^(?:position-|pos-)?inset-()(.+)$/, handleInsetValues],
+  [/^(?:position-|pos-)?inset-([xy])-(.+)$/, handleInsetValues],
+  [/^(?:position-|pos-)?(top|left|right|bottom)-(.+)$/, ([, d, v]) => ({ [d]: handleInsetValue(v) })]
 ];
 const floats = [
   ["float-left", { float: "left" }],
@@ -545,8 +574,18 @@ const sizes = [
   }]
 ];
 const aspectRatio = [
-  ["aspect-ratio-auto", { "aspect-ratio": "auto" }],
-  [/^aspect-ratio-(.+)$/, ([, d]) => ({ "aspect-ratio": (/^\d+\/\d+$/.test(d) ? d : null) || utilities.handler.bracket.cssvar.number(d) })]
+  [/^aspect-(?:ratio-)?(.+)$/, ([, d]) => {
+    if (/^\d+\/\d+$/.test(d))
+      return { "aspect-ratio": d };
+    const v = {
+      auto: "auto",
+      square: "1/1",
+      video: "16/9"
+    }[d];
+    if (v != null)
+      return { "aspect-ratio": v };
+    return { "aspect-ratio": utilities.handler.bracket.cssvar.number(d) };
+  }]
 ];
 
 const paddings = [
@@ -594,15 +633,7 @@ const transforms = [
   ["transform-gpu", transformGpu],
   ["transform-cpu", transformCpu],
   ["transform-none", { transform: "none" }],
-  ["origin-center", { "transform-origin": "center" }],
-  ["origin-top", { "transform-origin": "top" }],
-  ["origin-top-right", { "transform-origin": "top right" }],
-  ["origin-right", { "transform-origin": "right" }],
-  ["origin-bottom-right", { "transform-origin": "bottom right" }],
-  ["origin-bottom", { "transform-origin": "bottom" }],
-  ["origin-bottom-left", { "transform-origin": "bottom left" }],
-  ["origin-left", { "transform-origin": "left" }],
-  ["origin-top-left", { "transform-origin": "top left" }]
+  [/^origin-([-\w]{3,})$/, ([, s]) => ({ "transform-origin": utilities.positionMap[s] })]
 ];
 function handleTranslate([, d, b]) {
   const v = utilities.handler.bracket.fraction.auto.rem(b);

package/dist/chunks/default2.mjs

@@ -1,4 +1,4 @@
-import { h as handler, c as colorResolver, d as directionMap, p as parseColor, a as cornerMap, b as capitalize, e as directionSize, x as xyzMap } from './utilities.mjs';
+import { h as handler, c as colorResolver, d as directionMap, p as parseColor, a as cornerMap, b as capitalize, e as directionSize, f as positionMap, x as xyzMap } from './utilities.mjs';
 import { toArray } from '@unocss/core';
 import { C as CONTROL_BYPASS_PSEUDO_CLASS } from './pseudo.mjs';
 
@@ -36,27 +36,27 @@ const willChange = [
 ];
 
 const borders = [
-  [/^border$/, 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": handler.bracket.percent(opacity) })],
-  [/^(?:border|b)-([^-]+)-op(?:acity)?-?(.+)$/, ([, a, opacity]) => {
-    const v = handler.bracket.percent(opacity);
-    const d = directionMap[a];
-    if (v !== void 0 && d)
-      return d.map((i) => [`--un-border${i}-opacity`, v]);
-  }],
-  [/^(?:border-)?(?:rounded|rd)$/, handlerRounded],
-  [/^(?:border-)?(?:rounded|rd)(?:-(.+))?$/, handlerRounded],
-  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-(.+))?$/, handlerRounded],
+  [/^(?:border|b)()(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)-([xy])(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)-([rltbse])(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)-()size-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-([xy])-size-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-([rltbse])-size-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-()(?:color-)?(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-([xy])-(?:color-)?(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-([rltbse])-(?:color-)?(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-()op(?:acity)?-?(.+)$/, handlerBorderOpacity],
+  [/^(?:border|b)-([xy])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
+  [/^(?:border|b)-([rltbse])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
+  [/^(?:border-)?(?:rounded|rd)()(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)-([xy])(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)-([rltb])(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)-([rltb]{2})(?:-(.+))?$/, handlerRounded],
   ["border-solid", { "border-style": "solid" }],
   ["border-dashed", { "border-style": "dashed" }],
   ["border-dotted", { "border-style": "dotted" }],
   ["border-double", { "border-style": "double" }],
+  ["border-hidden", { "border-style": "hidden" }],
   ["border-none", { "border-style": "none" }]
 ];
 const borderHasColor = (color, { theme }) => {
@@ -103,22 +103,25 @@ function handlerBorder(m) {
     ];
   }
 }
-function handlerBorderSize([, a, b]) {
-  const [d, s = "1"] = directionMap[a] ? [a, b] : ["", a];
-  const v = handler.bracket.px(s);
-  if (v !== void 0)
-    return directionMap[d].map((i) => [`border${i}-width`, v]);
+function handlerBorderSize([, a = "", b = "1"]) {
+  const v = handler.bracket.px(b);
+  if (a in directionMap && v != null)
+    return directionMap[a].map((i) => [`border${i}-width`, v]);
 }
-function handlerBorderColor([, a, c], ctx) {
-  if (borderHasColor(c, ctx)) {
-    return Object.assign({}, ...directionMap[directionMap[a] ? a : ""].map((i) => borderColorResolver(i)(["", c], ctx)));
+function handlerBorderColor([, a = "", c], ctx) {
+  if (a in directionMap && borderHasColor(c, ctx)) {
+    return Object.assign({}, ...directionMap[a].map((i) => borderColorResolver(i)(["", c], ctx)));
   }
 }
-function handlerRounded([, a, b], { theme }) {
-  const [d, s = "DEFAULT"] = cornerMap[a] ? [a, b] : ["", a];
+function handlerBorderOpacity([, a = "", opacity]) {
+  const v = handler.bracket.percent(opacity);
+  if (a in directionMap && v != null)
+    return directionMap[a].map((i) => [`--un-border${i}-opacity`, v]);
+}
+function handlerRounded([, a = "", s = "DEFAULT"], { theme }) {
   const v = theme.borderRadius?.[s] || handler.auto.rem.fraction.bracket.cssvar(s);
-  if (v !== void 0)
-    return cornerMap[d].map((i) => [`border${i}-radius`, v]);
+  if (a in cornerMap && v != null)
+    return cornerMap[a].map((i) => [`border${i}-radius`, v]);
 }
 
 const opacity = [
@@ -133,12 +136,19 @@ const bgColors = [
   [/^bg-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-bg-opacity": handler.bracket.percent(opacity2) })]
 ];
 
+const transitionPropertyGroup = {
+  all: "all",
+  colors: ["color", "background-color", "border-color", "text-decoration-color", "fill", "stroke"].join(","),
+  opacity: "opacity",
+  shadow: "box-shadow",
+  transform: "transform"
+};
 const transitionProperty = (prop) => {
-  return handler.properties(prop) || (prop === "all" ? prop : void 0);
+  return handler.properties(prop) ?? transitionPropertyGroup[prop];
 };
 const transitions = [
-  [/^transition(?:-([a-z-]+(?:,[a-z-]+)*))?(?:-(\d+))?$/, ([, prop = "all", duration = "150"]) => {
-    const p = transitionProperty(prop);
+  [/^transition(?:-([a-z-]+(?:,[a-z-]+)*))?(?:-(\d+))?$/, ([, prop, duration = "150"]) => {
+    const p = prop != null ? transitionProperty(prop) : [transitionPropertyGroup.colors, "opacity", "box-shadow", "transform", "filter", "backdrop-filter"].join(",");
     if (p) {
       return {
         "transition-property": p,
@@ -147,14 +157,14 @@ const transitions = [
       };
     }
   }],
-  [/^duration-(\d+)$/, ([, duration = "150"]) => ({ "transition-duration": `${duration}ms` })],
+  [/^(?:transition-)?delay-(.+)(?:s|ms)?$/, ([, d]) => ({ "transition-delay": handler.bracket.time(d) })],
+  [/^(?:transition-)?duration-(.+)(?:s|ms)?$/, ([, d]) => ({ "transition-duration": handler.bracket.time(d) })],
+  [/^ease-(.+)$/, ([, d]) => ({ "transition-timing-function": handler.bracket(d) })],
   ["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-(.+)$/, ([, v]) => ({ "transition-property": handler.global(v) || transitionProperty(v) })],
   ["transition-property-none", { "transition-property": "none" }],
   ["property-none", { "transition-property": "none" }],
@@ -174,6 +184,7 @@ const flex = [
   ["flex-shrink-0", { "flex-shrink": 0 }],
   ["flex-grow", { "flex-grow": 1 }],
   ["flex-grow-0", { "flex-grow": 0 }],
+  [/^(?:flex-)?basis-(.+)$/, ([, d]) => ({ "flex-basis": handler.bracket.fraction.auto.rem(d) })],
   ["flex-row", { "flex-direction": "row" }],
   ["flex-row-reverse", { "flex-direction": "row-reverse" }],
   ["flex-col", { "flex-direction": "column" }],
@@ -241,19 +252,21 @@ const textShadows = [
 
 const directions = {
   "": "",
-  "x-": "column-",
-  "y-": "row-"
+  "x": "column-",
+  "y": "row-"
+};
+const handleGap = ([, d = "", s]) => {
+  const v = handler.bracket.auto.rem(s);
+  if (v != null) {
+    return {
+      [`grid-${directions[d]}gap`]: v,
+      [`${directions[d]}gap`]: v
+    };
+  }
 };
 const gaps = [
-  [/^(?:flex-|grid-)?gap-(x-|y-)?([^-]+)$/, ([, d = "", s]) => {
-    const v = handler.bracket.auto.rem(s);
-    if (v != null) {
-      return {
-        [`grid-${directions[d]}gap`]: v,
-        [`${directions[d]}gap`]: v
-      };
-    }
-  }]
+  [/^(?:flex-|grid-)?gap-()([^-]+)$/, handleGap],
+  [/^(?:flex-|grid-)?gap-([xy])-([^-]+)$/, handleGap]
 ];
 
 const calSize = (s, theme) => toArray(theme.fontSize?.[s] || handler.bracket.auto.rem(s))[0];
@@ -311,7 +324,6 @@ const overflows = [
   [/^(?:overflow|of)-([xy])-(.+)$/, ([, d, v]) => overflowValues.includes(v) ? { [`overflow-${d}`]: v } : void 0]
 ];
 
-const basicSet = ["auto", "start", "end", "center", "stretch"];
 const positions = [
   [/^(?:position-|pos-)?(relative|absolute|fixed|sticky)$/, ([, v]) => ({ position: v })],
   [/^(?:position-|pos-)?(static)$/, ([, v]) => ({ position: v })]
@@ -323,8 +335,15 @@ const justifies = [
   ["justify-between", { "justify-content": "space-between" }],
   ["justify-around", { "justify-content": "space-around" }],
   ["justify-evenly", { "justify-content": "space-evenly" }],
-  ...basicSet.map((i) => [`justify-items-${i}`, { "justify-items": i }]),
-  ...basicSet.map((i) => [`justify-self-${i}`, { "justify-self": i }])
+  ["justify-items-start", { "justify-items": "start" }],
+  ["justify-items-end", { "justify-items": "end" }],
+  ["justify-items-center", { "justify-items": "center" }],
+  ["justify-items-stretch", { "justify-items": "stretch" }],
+  ["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" }]
 ];
 const orders = [
   [/^order-(.+)$/, ([, v]) => ({ order: handler.bracket.number(v) })],
@@ -333,9 +352,9 @@ const orders = [
   ["order-none", { order: "0" }]
 ];
 const alignments = [
+  ["content-center", { "align-content": "center" }],
   ["content-start", { "align-content": "flex-start" }],
   ["content-end", { "align-content": "flex-end" }],
-  ["content-center", { "align-content": "center" }],
   ["content-between", { "align-content": "space-between" }],
   ["content-around", { "align-content": "space-around" }],
   ["content-evenly", { "align-content": "space-evenly" }],
@@ -348,29 +367,39 @@ const alignments = [
   ["self-start", { "align-self": "flex-start" }],
   ["self-end", { "align-self": "flex-end" }],
   ["self-center", { "align-self": "center" }],
-  ["self-stretch", { "align-self": "stretch" }]
+  ["self-stretch", { "align-self": "stretch" }],
+  ["self-baseline", { "align-self": "baseline" }]
 ];
 const placements = [
+  ["place-content-center", { "place-content": "center" }],
   ["place-content-start", { "place-content": "start" }],
   ["place-content-end", { "place-content": "end" }],
-  ["place-content-center", { "place-content": "center" }],
   ["place-content-between", { "place-content": "space-between" }],
   ["place-content-around", { "place-content": "space-around" }],
   ["place-content-evenly", { "place-content": "space-evenly" }],
   ["place-content-stretch", { "place-content": "stretch" }],
-  ...basicSet.map((i) => [`place-items-${i}`, { "place-items": i }]),
-  ...basicSet.map((i) => [`place-self-${i}`, { "place-self": i }])
+  ["place-items-start", { "place-items": "start" }],
+  ["place-items-end", { "place-items": "end" }],
+  ["place-items-center", { "place-items": "center" }],
+  ["place-items-stretch", { "place-items": "stretch" }],
+  ["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" }]
 ];
 function handleInsetValue(v) {
   return { auto: "auto", full: "100%" }[v] ?? handler.bracket.fraction.cssvar.auto.rem(v);
 }
+function handleInsetValues([, d, v]) {
+  const r = handleInsetValue(v);
+  if (r != null && d in directionMap)
+    return directionMap[d].map((i) => [i.slice(1), r]);
+}
 const insets = [
-  [/^(?: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 directionMap)
-      return directionMap[d].map((i) => [i.slice(1), r]);
-  }]
+  [/^(?:position-|pos-)?inset-()(.+)$/, handleInsetValues],
+  [/^(?:position-|pos-)?inset-([xy])-(.+)$/, handleInsetValues],
+  [/^(?:position-|pos-)?(top|left|right|bottom)-(.+)$/, ([, d, v]) => ({ [d]: handleInsetValue(v) })]
 ];
 const floats = [
   ["float-left", { float: "left" }],
@@ -543,8 +572,18 @@ const sizes = [
   }]
 ];
 const aspectRatio = [
-  ["aspect-ratio-auto", { "aspect-ratio": "auto" }],
-  [/^aspect-ratio-(.+)$/, ([, d]) => ({ "aspect-ratio": (/^\d+\/\d+$/.test(d) ? d : null) || handler.bracket.cssvar.number(d) })]
+  [/^aspect-(?:ratio-)?(.+)$/, ([, d]) => {
+    if (/^\d+\/\d+$/.test(d))
+      return { "aspect-ratio": d };
+    const v = {
+      auto: "auto",
+      square: "1/1",
+      video: "16/9"
+    }[d];
+    if (v != null)
+      return { "aspect-ratio": v };
+    return { "aspect-ratio": handler.bracket.cssvar.number(d) };
+  }]
 ];
 
 const paddings = [
@@ -592,15 +631,7 @@ const transforms = [
   ["transform-gpu", transformGpu],
   ["transform-cpu", transformCpu],
   ["transform-none", { transform: "none" }],
-  ["origin-center", { "transform-origin": "center" }],
-  ["origin-top", { "transform-origin": "top" }],
-  ["origin-top-right", { "transform-origin": "top right" }],
-  ["origin-right", { "transform-origin": "right" }],
-  ["origin-bottom-right", { "transform-origin": "bottom right" }],
-  ["origin-bottom", { "transform-origin": "bottom" }],
-  ["origin-bottom-left", { "transform-origin": "bottom left" }],
-  ["origin-left", { "transform-origin": "left" }],
-  ["origin-top-left", { "transform-origin": "top left" }]
+  [/^origin-([-\w]{3,})$/, ([, s]) => ({ "transform-origin": positionMap[s] })]
 ];
 function handleTranslate([, d, b]) {
   const v = handler.bracket.fraction.auto.rem(b);

package/dist/chunks/default3.cjs

@@ -103,16 +103,6 @@ const variantNegative = {
     }
   }
 };
-const variantSpace = (matcher) => {
-  if (/^space-?([xy])-?(-?.+)$/.test(matcher) || /^divide-/.test(matcher)) {
-    return {
-      matcher,
-      selector: (input) => {
-        return `${input}>:not([hidden])~:not([hidden])`;
-      }
-    };
-  }
-};
 
 const variantMotions = [
   variants$1.variantParentMatcher("motion-reduce", "@media (prefers-reduced-motion: reduce)"),
@@ -127,7 +117,6 @@ const variantOrientations = [
 const variantPrint = variants$1.variantParentMatcher("print", "@media print");
 
 const variants = [
-  variantSpace,
   variantNegative,
   variantImportant,
   variantPrint,
@@ -153,5 +142,4 @@ exports.variantMotions = variantMotions;
 exports.variantNegative = variantNegative;
 exports.variantOrientations = variantOrientations;
 exports.variantPrint = variantPrint;
-exports.variantSpace = variantSpace;
 exports.variants = variants;

package/dist/chunks/default3.mjs

@@ -101,16 +101,6 @@ const variantNegative = {
     }
   }
 };
-const variantSpace = (matcher) => {
-  if (/^space-?([xy])-?(-?.+)$/.test(matcher) || /^divide-/.test(matcher)) {
-    return {
-      matcher,
-      selector: (input) => {
-        return `${input}>:not([hidden])~:not([hidden])`;
-      }
-    };
-  }
-};
 
 const variantMotions = [
   variantParentMatcher("motion-reduce", "@media (prefers-reduced-motion: reduce)"),
@@ -125,7 +115,6 @@ const variantOrientations = [
 const variantPrint = variantParentMatcher("print", "@media print");
 
 const variants = [
-  variantSpace,
   variantNegative,
   variantImportant,
   variantPrint,
@@ -142,4 +131,4 @@ const variants = [
   ...variantLanguageDirections
 ];
 
-export { variantBreakpoints as a, variantCombinators as b, variantColorsMediaOrClass as c, variantLanguageDirections as d, variantImportant as e, variantNegative as f, variantSpace as g, variantMotions as h, variantOrientations as i, variantPrint as j, variants as v };
+export { variantBreakpoints as a, variantCombinators as b, variantColorsMediaOrClass as c, variantLanguageDirections as d, variantImportant as e, variantNegative as f, variantMotions as g, variantOrientations as h, variantPrint as i, variants as v };

package/dist/chunks/pseudo.cjs

@@ -42,25 +42,27 @@ const PseudoClasses = Object.fromEntries([
   "only-child",
   "only-of-type"
 ].map(core.toArray));
-const PseudoElements = [
+const PseudoElements = Object.fromEntries([
   "placeholder",
   "before",
   "after",
   "first-letter",
   "first-line",
   "selection",
-  "marker"
-];
+  "marker",
+  ["file", "::file-selector-button"]
+].map(core.toArray));
 const PseudoClassFunctions = [
   "not",
   "is",
   "where",
   "has"
 ];
-const PartClassesRE = /(part-\[(.+)]:)(.+)/;
-const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
+const PseudoElementsStr = Object.keys(PseudoElements).join("|");
 const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
 const PseudoClassFunctionsStr = PseudoClassFunctions.join("|");
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
+const PseudoElementsRE = new RegExp(`^(${PseudoElementsStr})[:-]`);
 const PseudoClassesRE = new RegExp(`^(${PseudoClassesStr})[:-]`);
 const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
 function shouldAdd(entires) {
@@ -87,9 +89,10 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
 const variantPseudoElements = (input) => {
   const match = input.match(PseudoElementsRE);
   if (match) {
+    const pseudo = PseudoElements[match[1]] || `::${match[1]}`;
     return {
       matcher: input.slice(match[1].length + 1),
-      selector: (s) => `${s}::${match[1]}`
+      selector: (s) => `${s}${pseudo}`
     };
   }
 };

package/dist/chunks/pseudo.mjs

@@ -40,25 +40,27 @@ const PseudoClasses = Object.fromEntries([
   "only-child",
   "only-of-type"
 ].map(toArray));
-const PseudoElements = [
+const PseudoElements = Object.fromEntries([
   "placeholder",
   "before",
   "after",
   "first-letter",
   "first-line",
   "selection",
-  "marker"
-];
+  "marker",
+  ["file", "::file-selector-button"]
+].map(toArray));
 const PseudoClassFunctions = [
   "not",
   "is",
   "where",
   "has"
 ];
-const PartClassesRE = /(part-\[(.+)]:)(.+)/;
-const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
+const PseudoElementsStr = Object.keys(PseudoElements).join("|");
 const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
 const PseudoClassFunctionsStr = PseudoClassFunctions.join("|");
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
+const PseudoElementsRE = new RegExp(`^(${PseudoElementsStr})[:-]`);
 const PseudoClassesRE = new RegExp(`^(${PseudoClassesStr})[:-]`);
 const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
 function shouldAdd(entires) {
@@ -85,9 +87,10 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
 const variantPseudoElements = (input) => {
   const match = input.match(PseudoElementsRE);
   if (match) {
+    const pseudo = PseudoElements[match[1]] || `::${match[1]}`;
     return {
       matcher: input.slice(match[1].length + 1),
-      selector: (s) => `${s}::${match[1]}`
+      selector: (s) => `${s}${pseudo}`
     };
   }
 };

package/dist/chunks/utilities.cjs

@@ -35,6 +35,31 @@ const xyzMap = {
   "z": ["-z"],
   "": ["-x", "-y"]
 };
+const basePositionMap = [
+  "top",
+  "top center",
+  "top left",
+  "top right",
+  "bottom",
+  "bottom center",
+  "bottom left",
+  "bottom right",
+  "left",
+  "left center",
+  "left top",
+  "left bottom",
+  "right",
+  "right center",
+  "right top",
+  "right bottom",
+  "center",
+  "center top",
+  "center bottom",
+  "center left",
+  "center right",
+  "center center"
+];
+const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
 
 const cssBasicProps = [
   "color",
@@ -93,13 +118,17 @@ const cssProps = [
 const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
 const numberRE = /^(-?[0-9.]+)$/i;
 const unitOnlyRE = /^(px)$/i;
+function round(n) {
+  return n.toFixed(10).replace(/\.0+$/, "").replace(/(\.\d+?)0+$/, "$1");
+}
 function numberWithUnit(str) {
   const match = str.match(numberWithUnitRE);
   if (!match)
     return;
-  const [, , unit] = match;
-  if (unit)
-    return str;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (unit && !Number.isNaN(num))
+    return `${round(num)}${unit}`;
 }
 function auto(str) {
   if (str === "auto" || str === "a")
@@ -112,11 +141,9 @@ function rem(str) {
   if (!match)
     return;
   const [, n, unit] = match;
-  if (unit)
-    return str;
   const num = parseFloat(n);
   if (!Number.isNaN(num))
-    return `${num / 4}rem`;
+    return unit ? `${round(num)}${unit}` : `${round(num / 4)}rem`;
 }
 function px(str) {
   if (str.match(unitOnlyRE))
@@ -125,25 +152,23 @@ function px(str) {
   if (!match)
     return;
   const [, n, unit] = match;
-  if (unit)
-    return str;
   const num = parseFloat(n);
   if (!Number.isNaN(num))
-    return `${num}px`;
+    return unit ? `${round(num)}${unit}` : `${round(num)}px`;
 }
 function number(str) {
   if (!numberRE.test(str))
     return;
   const num = parseFloat(str);
   if (!Number.isNaN(num))
-    return num;
+    return round(num);
 }
 function percent(str) {
   if (str.endsWith("%"))
     str = str.slice(0, -1);
   const num = parseFloat(str);
   if (!Number.isNaN(num))
-    return `${num / 100}`;
+    return `${round(num / 100)}`;
 }
 function fraction(str) {
   if (str === "full")
@@ -151,7 +176,7 @@ function fraction(str) {
   const [left, right] = str.split("/");
   const num = parseFloat(left) / parseFloat(right);
   if (!Number.isNaN(num))
-    return `${num * 100}%`;
+    return `${round(num * 100)}%`;
 }
 function bracket(str) {
   if (str && str[0] === "[" && str[str.length - 1] === "]") {
@@ -165,20 +190,19 @@ function cssvar(str) {
     return `var(--${str.slice(1)})`;
 }
 function time(str) {
-  const duration = Number(str.replace(/(s|ms)$/, ""));
-  if (isNaN(duration))
+  const match = str.match(/^(-?[0-9.]+)(s|ms)?$/i);
+  if (!match)
     return;
-  if (/(s|ms)$/.test(str))
-    return str;
-  return `${str}ms`;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
 }
 function global(str) {
   if (["inherit", "initial", "revert", "unset"].includes(str))
     return str;
 }
 function properties(str) {
-  if (str === void 0)
-    return;
   for (const prop of str.split(",")) {
     if (!cssProps.includes(prop))
       return;
@@ -301,5 +325,6 @@ exports.directionSize = directionSize;
 exports.h = h;
 exports.handler = handler;
 exports.parseColor = parseColor;
+exports.positionMap = positionMap;
 exports.valueHandlers = valueHandlers;
 exports.xyzMap = xyzMap;

package/dist/chunks/utilities.mjs

@@ -33,6 +33,31 @@ const xyzMap = {
   "z": ["-z"],
   "": ["-x", "-y"]
 };
+const basePositionMap = [
+  "top",
+  "top center",
+  "top left",
+  "top right",
+  "bottom",
+  "bottom center",
+  "bottom left",
+  "bottom right",
+  "left",
+  "left center",
+  "left top",
+  "left bottom",
+  "right",
+  "right center",
+  "right top",
+  "right bottom",
+  "center",
+  "center top",
+  "center bottom",
+  "center left",
+  "center right",
+  "center center"
+];
+const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
 
 const cssBasicProps = [
   "color",
@@ -91,13 +116,17 @@ const cssProps = [
 const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
 const numberRE = /^(-?[0-9.]+)$/i;
 const unitOnlyRE = /^(px)$/i;
+function round(n) {
+  return n.toFixed(10).replace(/\.0+$/, "").replace(/(\.\d+?)0+$/, "$1");
+}
 function numberWithUnit(str) {
   const match = str.match(numberWithUnitRE);
   if (!match)
     return;
-  const [, , unit] = match;
-  if (unit)
-    return str;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (unit && !Number.isNaN(num))
+    return `${round(num)}${unit}`;
 }
 function auto(str) {
   if (str === "auto" || str === "a")
@@ -110,11 +139,9 @@ function rem(str) {
   if (!match)
     return;
   const [, n, unit] = match;
-  if (unit)
-    return str;
   const num = parseFloat(n);
   if (!Number.isNaN(num))
-    return `${num / 4}rem`;
+    return unit ? `${round(num)}${unit}` : `${round(num / 4)}rem`;
 }
 function px(str) {
   if (str.match(unitOnlyRE))
@@ -123,25 +150,23 @@ function px(str) {
   if (!match)
     return;
   const [, n, unit] = match;
-  if (unit)
-    return str;
   const num = parseFloat(n);
   if (!Number.isNaN(num))
-    return `${num}px`;
+    return unit ? `${round(num)}${unit}` : `${round(num)}px`;
 }
 function number(str) {
   if (!numberRE.test(str))
     return;
   const num = parseFloat(str);
   if (!Number.isNaN(num))
-    return num;
+    return round(num);
 }
 function percent(str) {
   if (str.endsWith("%"))
     str = str.slice(0, -1);
   const num = parseFloat(str);
   if (!Number.isNaN(num))
-    return `${num / 100}`;
+    return `${round(num / 100)}`;
 }
 function fraction(str) {
   if (str === "full")
@@ -149,7 +174,7 @@ function fraction(str) {
   const [left, right] = str.split("/");
   const num = parseFloat(left) / parseFloat(right);
   if (!Number.isNaN(num))
-    return `${num * 100}%`;
+    return `${round(num * 100)}%`;
 }
 function bracket(str) {
   if (str && str[0] === "[" && str[str.length - 1] === "]") {
@@ -163,20 +188,19 @@ function cssvar(str) {
     return `var(--${str.slice(1)})`;
 }
 function time(str) {
-  const duration = Number(str.replace(/(s|ms)$/, ""));
-  if (isNaN(duration))
+  const match = str.match(/^(-?[0-9.]+)(s|ms)?$/i);
+  if (!match)
     return;
-  if (/(s|ms)$/.test(str))
-    return str;
-  return `${str}ms`;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
 }
 function global(str) {
   if (["inherit", "initial", "revert", "unset"].includes(str))
     return str;
 }
 function properties(str) {
-  if (str === void 0)
-    return;
   for (const prop of str.split(",")) {
     if (!cssProps.includes(prop))
       return;
@@ -291,4 +315,4 @@ const colorResolver = (property, varName) => ([, body], { theme }) => {
   }
 };
 
-export { cornerMap as a, capitalize as b, colorResolver as c, directionMap as d, directionSize as e, h as f, handler as h, parseColor as p, valueHandlers as v, xyzMap as x };
+export { cornerMap as a, capitalize as b, colorResolver as c, directionMap as d, directionSize as e, positionMap as f, h as g, handler as h, parseColor as p, valueHandlers as v, xyzMap as x };

package/dist/utils.cjs

@@ -16,6 +16,7 @@ exports.directionSize = utilities.directionSize;
 exports.h = utilities.h;
 exports.handler = utilities.handler;
 exports.parseColor = utilities.parseColor;
+exports.positionMap = utilities.positionMap;
 exports.valueHandlers = utilities.valueHandlers;
 exports.xyzMap = utilities.xyzMap;
 exports.variantMatcher = variants.variantMatcher;

package/dist/utils.d.ts

@@ -5,12 +5,13 @@ import { T as Theme } from './types-a2d2b52f';
 declare const directionMap: Record<string, string[]>;
 declare const cornerMap: Record<string, string[]>;
 declare const xyzMap: Record<string, string[]>;
+declare const positionMap: Record<string, string>;
 
 declare function numberWithUnit(str: string): string | undefined;
 declare function auto(str: string): "auto" | undefined;
 declare function rem(str: string): string | undefined;
 declare function px(str: string): string | undefined;
-declare function number(str: string): number | undefined;
+declare function number(str: string): string | undefined;
 declare function percent(str: string): string | undefined;
 declare function fraction(str: string): string | undefined;
 declare function bracket(str: string): string | undefined;
@@ -106,4 +107,4 @@ declare const parseColor: (body: string, theme: Theme) => ParsedColorValue | und
  */
 declare const colorResolver: (property: string, varName: string) => DynamicMatcher;
 
-export { capitalize, colorResolver, cornerMap, directionMap, directionSize, h, handler, parseColor, handlers as valueHandlers, variantMatcher, variantParentMatcher, xyzMap };
+export { capitalize, colorResolver, cornerMap, directionMap, directionSize, h, handler, parseColor, positionMap, handlers as valueHandlers, variantMatcher, variantParentMatcher, xyzMap };

package/dist/utils.mjs

@@ -1,3 +1,3 @@
-export { b as capitalize, c as colorResolver, a as cornerMap, d as directionMap, e as directionSize, f as h, h as handler, p as parseColor, v as valueHandlers, x as xyzMap } from './chunks/utilities.mjs';
+export { b as capitalize, c as colorResolver, a as cornerMap, d as directionMap, e as directionSize, g as h, h as handler, p as parseColor, f as positionMap, v as valueHandlers, x as xyzMap } from './chunks/utilities.mjs';
 export { v as variantMatcher, a as variantParentMatcher } from './chunks/variants.mjs';
 import '@unocss/core';

package/dist/variants.cjs

@@ -18,7 +18,6 @@ exports.variantMotions = _default.variantMotions;
 exports.variantNegative = _default.variantNegative;
 exports.variantOrientations = _default.variantOrientations;
 exports.variantPrint = _default.variantPrint;
-exports.variantSpace = _default.variantSpace;
 exports.variants = _default.variants;
 exports.CONTROL_BYPASS_PSEUDO_CLASS = pseudo.CONTROL_BYPASS_PSEUDO_CLASS;
 exports.partClasses = pseudo.partClasses;

package/dist/variants.d.ts

@@ -14,7 +14,6 @@ declare const variants: Variant<Theme>[];
 
 declare const variantImportant: Variant;
 declare const variantNegative: Variant;
-declare const variantSpace: Variant;
 
 declare const variantMotions: Variant[];
 
@@ -29,4 +28,4 @@ declare const variantPseudoClassFunctions: VariantObject;
 declare const variantTaggedPseudoClasses: VariantObject;
 declare const partClasses: VariantObject;
 
-export { CONTROL_BYPASS_PSEUDO_CLASS, partClasses, variantBreakpoints, variantColorsMediaOrClass, variantCombinators, variantImportant, variantLanguageDirections, variantMotions, variantNegative, variantOrientations, variantPrint, variantPseudoClassFunctions, variantPseudoClasses, variantPseudoElements, variantSpace, variantTaggedPseudoClasses, variants };
+export { CONTROL_BYPASS_PSEUDO_CLASS, partClasses, variantBreakpoints, variantColorsMediaOrClass, variantCombinators, variantImportant, variantLanguageDirections, variantMotions, variantNegative, variantOrientations, variantPrint, variantPseudoClassFunctions, variantPseudoClasses, variantPseudoElements, variantTaggedPseudoClasses, variants };

package/dist/variants.mjs

@@ -1,4 +1,4 @@
-export { a as variantBreakpoints, c as variantColorsMediaOrClass, b as variantCombinators, e as variantImportant, d as variantLanguageDirections, h as variantMotions, f as variantNegative, i as variantOrientations, j as variantPrint, g as variantSpace, v as variants } from './chunks/default3.mjs';
+export { a as variantBreakpoints, c as variantColorsMediaOrClass, b as variantCombinators, e as variantImportant, d as variantLanguageDirections, g as variantMotions, f as variantNegative, h as variantOrientations, i as variantPrint, v as variants } from './chunks/default3.mjs';
 export { C as CONTROL_BYPASS_PSEUDO_CLASS, p as partClasses, a as variantPseudoClassFunctions, v as variantPseudoClasses, c as variantPseudoElements, b as variantTaggedPseudoClasses } from './chunks/pseudo.mjs';
 import './chunks/variants.mjs';
 import '@unocss/core';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unocss/preset-mini",
-  "version": "0.20.2",
+  "version": "0.20.4",
   "description": "The minimal preset for UnoCSS",
   "keywords": [
     "unocss",
@@ -61,7 +61,7 @@
     "*.css"
   ],
   "dependencies": {
-    "@unocss/core": "0.20.2"
+    "@unocss/core": "0.20.4"
   },
   "scripts": {
     "build": "unbuild",