@unocss/preset-mini 0.17.2 → 0.19.0

package/dist/chunks/default2.mjs

@@ -1,5 +1,5 @@
-import { c as colorResolver$1, h as handler, d as directionMap, a as cornerMap, p as parseColor, b as capitalize, e as directionSize, x as xyzMap } from './utilities.mjs';
-import { toArray } from '@unocss/core';
+import { h as handler, c as colorResolver$1, d as directionMap, p as parseColor, a as cornerMap, b as capitalize, e as directionSize, x as xyzMap } from './utilities.mjs';
+import { toArray, cacheFunction } from '@unocss/core';
 import { C as CONTROL_BYPASS_PSEUDO_CLASS } from './pseudo.mjs';
 
 const verticalAlignAlias = {
@@ -17,38 +17,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 = handler.bracket.fraction.auto.rem(s.replace(/^(offset\-|width\-|size\-)/, ""));
-  if (size) {
-    return {
-      [`outline-${propName}`]: size
-    };
-  }
-};
 const outline = [
+  [/^outline-(?:width-|size-)?(.+)$/, ([, d]) => ({ "outline-width": handler.bracket.fraction.auto.rem(d) })],
+  [/^outline-(?:color-)?(.+)$/, colorResolver$1("outline-color", "outline-color")],
+  [/^outline-offset-(.+)$/, ([, d]) => ({ "outline-offset": 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 = colorResolver$1("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 = [
@@ -57,21 +31,6 @@ const appearance = [
     "-webkit-appearance": "none"
   }]
 ];
-const placeholder = [
-  [
-    /^placeholder-opacity-(\d+)$/,
-    ([, d]) => ({
-      "placeholder-opacity": handler.bracket.percent(d)
-    })
-  ],
-  [
-    /^placeholder-(?!opacity)(.+)$/,
-    (match, config) => {
-      match[1] = match[1].replace(/^color-/, "");
-      return colorResolver$1("placeholder-color", "placeholder-color")(match, config);
-    }
-  ]
-];
 const willChange = [
   [/^will-change-(.+)/, ([, p]) => ({ "will-change": handler.properties.global(p) })]
 ];
@@ -84,16 +43,59 @@ const borders = [
   [/^(?: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)?-?(.+)$/, ([, opacity], { options: { variablePrefix: p } }) => ({ [`--${p}border-opacity`]: handler.bracket.percent(opacity) })],
+  [/^(?:border|b)-([^-]+)-op(?:acity)?-?(.+)$/, ([, a, opacity], { options: { variablePrefix: p } }) => {
+    const v = handler.bracket.percent(opacity);
+    const d = 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 && !!parseColor(color, theme)?.color;
+};
+const borderColorResolver = (direction) => ([, body], { theme, options: { variablePrefix: p } }) => {
+  const data = parseColor(body, theme);
+  if (!data)
+    return;
+  const { opacity, color, rgba } = data;
+  if (!color)
+    return;
+  const a = opacity ? opacity[0] === "[" ? 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) {
@@ -110,8 +112,8 @@ function handlerBorderSize([, a, b]) {
     return directionMap[d].map((i) => [`border${i}-width`, v]);
 }
 function handlerBorderColor([, a, c], ctx) {
-  if (c !== void 0 && colorResolver$1("border-color", "border")(["", c], ctx)) {
-    return Object.assign({}, ...directionMap[directionMap[a] ? a : ""].map((i) => colorResolver$1(`border${i}-color`, "border")(["", c], ctx)));
+  if (borderHasColor(c, ctx)) {
+    return Object.assign({}, ...directionMap[directionMap[a] ? a : ""].map((i) => borderColorResolver(i)(["", c], ctx)));
   }
 }
 function handlerRounded([, a, b], { theme }) {
@@ -132,18 +134,6 @@ const bgColors = [
   [/^bg-(.+)$/, colorResolver$1("background-color", "bg")],
   [/^bg-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-bg-opacity": handler.bracket.percent(opacity2) })]
 ];
-const borderColors = [
-  [/^(?:border|b)-(.+)$/, colorResolver$1("border-color", "border")],
-  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-border-opacity": handler.bracket.percent(opacity2) })]
-];
-const ringColors = [
-  [/^ring-(.+)$/, colorResolver$1("--un-ring-color", "ring")],
-  [/^ring-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-ring-opacity": handler.bracket.percent(opacity2) })]
-];
-const ringOffsetColors = [
-  [/^ring-offset-(.+)$/, colorResolver$1("--un-ring-offset-color", "ring-offset")],
-  [/^ring-offset-op(?:acity)?-?(.+)$/, ([, opacity2]) => ({ "--un-ring-offset-opacity": handler.bracket.percent(opacity2) })]
-];
 
 const transitionProperty = (prop) => {
   return handler.properties(prop) || (prop === "all" ? prop : void 0);
@@ -181,7 +171,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: handler.bracket(d).replace(/\d+\/\d+/, ($1) => handler.fraction($1)) })],
   ["flex-shrink", { "flex-shrink": 1 }],
   ["flex-shrink-0", { "flex-shrink": 0 }],
   ["flex-grow", { "flex-grow": 1 }],
@@ -292,30 +282,17 @@ const textShadows = [
 ];
 
 const gaps = [
-  [/^(?:flex-|grid-)?gap-([^-]+)$/, ([, s]) => {
-    const v = 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 = 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 = handler.bracket.auto.rem(s);
-    if (v != null) {
-      return {
-        "grid-row-gap": v,
-        "row-gap": v
+        [`grid-${direction}gap`]: v,
+        [`${direction}gap`]: v
       };
     }
   }]
@@ -349,7 +326,7 @@ const grids = [
     if (parts[0] === "span") {
       if (parts[1] === "full")
         return { [key]: "1/-1" };
-      raw = handler.number.bracket(parts[1])?.toString().replace(/_/g, " ");
+      raw = handler.number.bracket(parts[1]);
       if (raw)
         return { [key]: `span ${raw}/span ${raw}` };
     }
@@ -357,12 +334,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": handler.bracket(v) })],
+  [/^grid-rows-(.+)$/, ([, v]) => ({ "grid-template-rows": 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 = [
@@ -378,11 +355,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" }],
@@ -395,7 +369,9 @@ const justifies = [
   ...basicSet.map((i) => [`justify-self-${i}`, { "justify-self": i }])
 ];
 const orders = [
-  [/^order-(.+)$/, ([, v]) => ({ order: { first: "-9999", last: "9999" }[v] || handler.bracket.number(v) })],
+  [/^order-(.+)$/, ([, v]) => ({ order: handler.bracket.number(v) })],
+  ["order-first", { order: "-9999" }],
+  ["order-last", { order: "9999" }],
   ["order-none", { order: "0" }]
 ];
 const alignments = [
@@ -431,17 +407,20 @@ function handleInsetValue(v) {
   return { auto: "auto", full: "100%" }[v] ?? 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 directionMap)
       return 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 = [
@@ -449,14 +428,11 @@ const zIndexes = [
   [/^z-([^-]+)$/, ([, v]) => ({ "z-index": 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 = cacheFunction((prefix) => `var(--${prefix}empty,/*!*/ /*!*/)`);
 const varEmpty = "var(--un-empty,/*!*/ /*!*/)";
 const displays = [
   ["inline", { display: "inline" }],
@@ -487,7 +463,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 = [
@@ -530,30 +508,28 @@ const fontSmoothings = [
 ];
 
 const rings = [
-  [/^ring-?(.*)$/, ([, d]) => {
+  [/^ring-?(.*)$/, ([, d], { options: { variablePrefix: p } }) => {
     const value = 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 = 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`]: handler.px(d || "1") })],
+  [/^ring-(.+)$/, (m, ctx) => colorResolver$1(`--${ctx.options.variablePrefix}ring-color`, "ring")(m, ctx)],
+  [/^ring-op(?:acity)?-?(.+)$/, ([, opacity], { options: { variablePrefix: p } }) => ({ [`--${p}ring-opacity`]: handler.bracket.percent(opacity) })],
+  [/^ring-offset-(.+)$/, (m, ctx) => colorResolver$1(`--${ctx.options.variablePrefix}ring-offset-color`, "ring-offset")(m, ctx)],
+  [/^ring-offset-op(?:acity)?-?(.+)$/, ([, opacity], { options: { variablePrefix: p } }) => ({ [`--${p}ring-offset-opacity`]: handler.bracket.percent(opacity) })],
+  [/^ring-inset$/, (_, { options: { variablePrefix: p } }) => ({ [`--${p}ring-inset`]: "inset" })]
 ];
 
 const colorResolver = (body, theme) => {
@@ -583,10 +559,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) {
@@ -659,6 +633,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" }],
@@ -712,6 +688,24 @@ function handleRotate([, b]) {
     ];
   }
 }
+function handleSkewWithUnit([, d, b]) {
+  const v = handler.bracket.number(b);
+  if (v != null) {
+    return [
+      transformBase,
+      { [`--un-skew-${d}`]: `${v}deg` }
+    ];
+  }
+}
+function handleSkew([, d, b]) {
+  const v = handler.bracket(b);
+  if (v != null) {
+    return [
+      transformBase,
+      { [`--un-skew-${d}`]: v }
+    ];
+  }
+}
 
 const variablesAbbrMap = {
   "visible": "visibility",
@@ -773,14 +767,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 : handler.bracket.px(s) })],
-  [/^decoration-(.+)$/, ([, d]) => ({ "text-decoration-thickness": handler.bracket.px(d) })],
-  [/^underline-offset-([^-]+)$/, ([, s]) => {
-    const v = s === "auto" ? s : handler.bracket.px(s);
-    if (v != null)
-      return { "text-underline-offset": v };
-  }],
+  [/^(?:underline|decoration)-(?:size-)?(.+)$/, ([, s]) => ({ "text-decoration-thickness": handler.bracket.px(s) })],
+  [/^(?:underline|decoration)-(auto|from-font)$/, ([, s]) => ({ "text-decoration-thickness": s })],
   [/^(?:underline|decoration)-(.+)$/, (match, ctx) => {
     const result = colorResolver$1("text-decoration-color", "line")(match, ctx);
     if (result) {
@@ -791,6 +779,8 @@ const textDecorations = [
     }
   }],
   [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": handler.bracket.percent(opacity) })],
+  [/^underline-offset-(.+)$/, ([, s]) => ({ "text-underline-offset": 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" }]
 ];
@@ -850,7 +840,6 @@ const rules = [
   overflows,
   outline,
   appearance,
-  placeholder,
   positions,
   orders,
   justifies,
@@ -866,4 +855,4 @@ const rules = [
   questionMark
 ].flat(1);
 
-export { textIndents as $, boxSizing as A, questionMark as B, rings as C, boxShadows as D, sizes as E, aspectRatio as F, paddings as G, margins as H, varEmpty as I, displays as J, appearances as K, cursors as L, pointerEvents as M, resizes as N, userSelects as O, whitespaces as P, contents as Q, breaks as R, textOverflows as S, textTransforms as T, fontStyles as U, fontSmoothings as V, svgUtilities as W, transforms as X, transitions as Y, fonts as Z, tabSizes as _, appearance as a, textStrokes as a0, textShadows as a1, cssVariables as a2, textDecorations as a3, borders as b, opacity as c, textColors as d, bgColors as e, borderColors as f, ringColors as g, ringOffsetColors as h, flex as i, gaps as j, grids as k, overflows as l, positions as m, justifies as n, outline as o, placeholder as p, orders as q, rules as r, alignments as s, textAligns as t, placements as u, verticalAligns as v, willChange as w, insets as x, floats as y, zIndexes as z };
+export { cssVariables as $, sizes as A, aspectRatio as B, paddings as C, margins as D, varEmptyFn as E, varEmpty as F, displays as G, appearances as H, cursors as I, pointerEvents as J, resizes as K, userSelects as L, whitespaces as M, contents as N, breaks as O, textOverflows as P, textTransforms as Q, fontStyles as R, fontSmoothings as S, svgUtilities as T, transforms as U, transitions as V, fonts as W, tabSizes as X, textIndents as Y, textStrokes as Z, textShadows as _, appearance as a, textDecorations as a0, borders as b, opacity as c, textColors as d, bgColors as e, flex as f, gaps as g, grids as h, overflows as i, justifies as j, orders as k, alignments as l, placements as m, insets as n, outline as o, positions as p, floats as q, rules as r, boxSizing as s, textAligns as t, questionMark as u, verticalAligns as v, willChange as w, rings as x, boxShadows as y, zIndexes as z };

package/dist/chunks/default3.cjs

@@ -4,7 +4,7 @@ const variants$1 = require('./variants.cjs');
 const pseudo = require('./pseudo.cjs');
 
 const regexCache = {};
-const variantBreakpoints = (matcher, _, theme) => {
+const variantBreakpoints = (matcher, { theme }) => {
   const variantEntries = Object.entries(theme.breakpoints || {}).map(([point, size], idx) => [point, size, idx]);
   for (const [point, size, idx] of variantEntries) {
     if (!regexCache[point])
@@ -46,25 +46,41 @@ const variantCombinators = [
   variants$1.variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
-const variantColorsClass = [
-  variants$1.variantMatcher("dark", (input) => `.dark $$ ${input}`),
-  variants$1.variantMatcher("light", (input) => `.light $$ ${input}`)
-];
-const variantColorsMedia = [
-  (v) => {
-    const dark = variants$1.variantMatcher("dark")(v);
-    if (dark) {
-      return {
-        ...dark,
-        parent: "@media (prefers-color-scheme: dark)"
-      };
+const variantColorsMediaOrClass = [
+  (v, { options: { dark } }) => {
+    if (dark === "class") {
+      const match = variants$1.variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
+      if (match)
+        return match;
     }
-    const light = variants$1.variantMatcher("light")(v);
-    if (light) {
-      return {
-        ...light,
-        parent: "@media (prefers-color-scheme: light)"
-      };
+  },
+  (v, { options: { dark } }) => {
+    if (dark === "class") {
+      const match = variants$1.variantMatcher("light", (input) => `.light $$ ${input}`)(v);
+      if (match)
+        return match;
+    }
+  },
+  (v, { options: { dark } }) => {
+    if (dark === "media") {
+      const match = variants$1.variantMatcher("dark")(v);
+      if (match) {
+        return {
+          ...match,
+          parent: "@media (prefers-color-scheme: dark)"
+        };
+      }
+    }
+  },
+  (v, { options: { dark } }) => {
+    if (dark === "media") {
+      const match = variants$1.variantMatcher("light")(v);
+      if (match) {
+        return {
+          ...match,
+          parent: "@media (prefers-color-scheme: light)"
+        };
+      }
     }
   }
 ];
@@ -120,13 +136,15 @@ const variants = [
   variantBreakpoints,
   ...variantCombinators,
   pseudo.variantPseudoClasses,
+  pseudo.variantPseudoClassFunctions,
+  pseudo.variantTaggedPseudoClasses,
   pseudo.variantPseudoElements,
-  pseudo.partClasses
+  pseudo.partClasses,
+  ...variantColorsMediaOrClass
 ];
 
 exports.variantBreakpoints = variantBreakpoints;
-exports.variantColorsClass = variantColorsClass;
-exports.variantColorsMedia = variantColorsMedia;
+exports.variantColorsMediaOrClass = variantColorsMediaOrClass;
 exports.variantCombinators = variantCombinators;
 exports.variantImportant = variantImportant;
 exports.variantNegative = variantNegative;

package/dist/chunks/default3.mjs

@@ -1,8 +1,8 @@
 import { v as variantMatcher } from './variants.mjs';
-import { v as variantPseudoClasses, a as variantPseudoElements, p as partClasses } from './pseudo.mjs';
+import { v as variantPseudoClasses, a as variantPseudoClassFunctions, b as variantTaggedPseudoClasses, c as variantPseudoElements, p as partClasses } from './pseudo.mjs';
 
 const regexCache = {};
-const variantBreakpoints = (matcher, _, theme) => {
+const variantBreakpoints = (matcher, { theme }) => {
   const variantEntries = Object.entries(theme.breakpoints || {}).map(([point, size], idx) => [point, size, idx]);
   for (const [point, size, idx] of variantEntries) {
     if (!regexCache[point])
@@ -44,25 +44,41 @@ const variantCombinators = [
   variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
-const variantColorsClass = [
-  variantMatcher("dark", (input) => `.dark $$ ${input}`),
-  variantMatcher("light", (input) => `.light $$ ${input}`)
-];
-const variantColorsMedia = [
-  (v) => {
-    const dark = variantMatcher("dark")(v);
-    if (dark) {
-      return {
-        ...dark,
-        parent: "@media (prefers-color-scheme: dark)"
-      };
+const variantColorsMediaOrClass = [
+  (v, { options: { dark } }) => {
+    if (dark === "class") {
+      const match = variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
+      if (match)
+        return match;
     }
-    const light = variantMatcher("light")(v);
-    if (light) {
-      return {
-        ...light,
-        parent: "@media (prefers-color-scheme: light)"
-      };
+  },
+  (v, { options: { dark } }) => {
+    if (dark === "class") {
+      const match = variantMatcher("light", (input) => `.light $$ ${input}`)(v);
+      if (match)
+        return match;
+    }
+  },
+  (v, { options: { dark } }) => {
+    if (dark === "media") {
+      const match = variantMatcher("dark")(v);
+      if (match) {
+        return {
+          ...match,
+          parent: "@media (prefers-color-scheme: dark)"
+        };
+      }
+    }
+  },
+  (v, { options: { dark } }) => {
+    if (dark === "media") {
+      const match = variantMatcher("light")(v);
+      if (match) {
+        return {
+          ...match,
+          parent: "@media (prefers-color-scheme: light)"
+        };
+      }
     }
   }
 ];
@@ -118,8 +134,11 @@ const variants = [
   variantBreakpoints,
   ...variantCombinators,
   variantPseudoClasses,
+  variantPseudoClassFunctions,
+  variantTaggedPseudoClasses,
   variantPseudoElements,
-  partClasses
+  partClasses,
+  ...variantColorsMediaOrClass
 ];
 
-export { variantColorsMedia as a, variantColorsClass as b, variantBreakpoints as c, variantCombinators as d, variantImportant as e, variantNegative as f, variantSpace as g, variants as v };
+export { variantBreakpoints as a, variantCombinators as b, variantColorsMediaOrClass as c, variantImportant as d, variantNegative as e, variantSpace as f, variants as v };