@unocss/preset-mini 0.16.0 → 0.16.4

package/dist/chunks/default2.mjs

@@ -1,6 +1,6 @@
 import { hex2rgba, toArray } from '@unocss/core';
-import { h as handler, d as directionMap, c as cornerMap, a as capitalize, x as xyzMap } from './index.mjs';
-import { C as CONTROL_BYPASS_PSEUDO } from './pseudo.mjs';
+import { h as handler, d as directionMap, c as cornerMap, a as capitalize, b as directionSize, x as xyzMap } from './utilities.mjs';
+import { C as CONTROL_BYPASS_PSEUDO_CLASS } from './pseudo.mjs';
 
 const verticalAlignAlias = {
   mid: "middle",
@@ -19,7 +19,8 @@ const textAligns = [
 
 const parseColorUtil = (body, theme) => {
   const [main, opacity2] = body.split(/(?:\/|:)/);
-  const [name, no = "DEFAULT"] = main.replace(/([a-z])([0-9])/g, "$1-$2").split(/-/g);
+  const colors = main.replace(/([a-z])([0-9])/g, "$1-$2").split(/-/g);
+  const [name] = colors;
   if (!name)
     return;
   let color;
@@ -30,8 +31,16 @@ const parseColorUtil = (body, theme) => {
   if (bracketOrMain.startsWith("hex-"))
     color = bracketOrMain.slice(4);
   color = color || bracket;
+  let no = "DEFAULT";
   if (!color) {
-    const colorData = theme.colors?.[name];
+    let colorData = theme.colors?.[name];
+    if (colorData) {
+      [, no = no] = colors;
+    } else {
+      if (colors.slice(-1)[0].match(/^\d+$/))
+        no = colors.pop();
+      colorData = theme.colors?.[colors.join("-").replace(/(-[a-z])/g, (n) => n.slice(1).toUpperCase())];
+    }
     if (typeof colorData === "string")
       color = colorData;
     else if (no && colorData)
@@ -94,16 +103,136 @@ const ringOffsetColors = [
   [/^ring-offset-(.+)$/, colorResolver$1("--un-ring-offset-color", "ring-offset")],
   [/^ring-offset-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-ring-offset-opacity": handler.bracket.percent(opacity2) })]
 ];
-const fillColors = [
-  ["fill-none", { fill: "none" }],
-  [/^fill-(.+)$/, colorResolver$1("fill", "fill")],
-  [/^fill-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-fill-opacity": handler.bracket.percent(opacity2) })]
+
+const cssBasicProps = [
+  "color",
+  "border-color",
+  "background-color",
+  "flex-grow",
+  "flex",
+  "flex-shrink",
+  "caret-color",
+  "font",
+  "gap",
+  "opacity",
+  "visibility",
+  "z-index",
+  "font-weight",
+  "zoom",
+  "text-shadow",
+  "transform",
+  "box-shadow"
+];
+const cssPositionProps = [
+  "backround-position",
+  "left",
+  "right",
+  "top",
+  "bottom",
+  "object-position"
+];
+const cssSizeProps = [
+  "max-height",
+  "min-height",
+  "max-width",
+  "min-width",
+  "height",
+  "width",
+  "border-width",
+  "margin",
+  "padding",
+  "outline-width",
+  "outline-offset",
+  "font-size",
+  "line-height",
+  "text-indent",
+  "vertical-align",
+  "border-spacing",
+  "letter-spacing",
+  "word-spacing"
+];
+const cssEnhanceProps = ["stroke", "filter", "backdrop-filter", "fill", "mask", "mask-size", "mask-border", "clip-path", "clip"];
+const cssProps = [
+  ...cssBasicProps,
+  ...cssPositionProps,
+  ...cssSizeProps,
+  ...cssEnhanceProps
+];
+const varEmpty = "var(--un-empty,/*!*/ /*!*/)";
+const displays = [
+  ["inline", { display: "inline" }],
+  ["block", { display: "block" }],
+  ["inline-block", { display: "inline-block" }],
+  ["contents", { display: "contents" }],
+  ["flow-root", { display: "flow-root" }],
+  ["list-item", { display: "list-item" }],
+  ["hidden", { display: "none" }]
+];
+const appearances = [
+  ["visible", { visibility: "visible" }],
+  ["invisible", { visibility: "hidden" }],
+  ["backface-visible", { "backface-visibility": "visible" }],
+  ["backface-hidden", { "backface-visibility": "hidden" }]
+];
+const cursors = [
+  [/^cursor-(.+)$/, ([, c]) => ({ cursor: c })]
+];
+const pointerEvents = [
+  ["pointer-events-none", { "pointer-events": "none" }],
+  ["pointer-events-auto", { "pointer-events": "auto" }]
+];
+const resizes = [
+  ["resize-none", { resize: "none" }],
+  ["resize-x", { resize: "horizontal" }],
+  ["resize-y", { resize: "vertical" }],
+  ["resize", { resize: "both" }]
+];
+const userSelects = [
+  [/^select-(none|text|all|auto)$/, ([, v]) => ({ "user-select": v })]
+];
+const whitespaces = [
+  [/^(?:whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)$/, ([, v]) => ({ "white-space": v })]
+];
+const contents = [
+  ["content-empty", { content: '""' }]
+];
+const breaks = [
+  ["break-normal", { "overflow-wrap": "normal", "word-break": "normal" }],
+  ["break-word", { "overflow-wrap": "break-word" }],
+  ["break-all", { "word-break": "break-all" }]
+];
+const textOverflows = [
+  ["truncate", { "overflow": "hidden", "text-overflow": "ellipsis", "white-space": "nowrap" }],
+  ["text-ellipsis", { "text-overflow": "ellipsis" }],
+  ["text-clip", { "text-overflow": "clip" }]
+];
+const textTransforms = [
+  ["case-upper", { "text-transform": "uppercase" }],
+  ["case-lower", { "text-transform": "lowercase" }],
+  ["case-capital", { "text-transform": "capitalize" }],
+  ["case-normal", { "text-transform": "none" }]
+];
+const fontStyles = [
+  ["italic", { "font-style": "italic" }],
+  ["not-italic", { "font-style": "normal" }]
+];
+const fontSmoothings = [
+  ["antialiased", {
+    "-webkit-font-smoothing": "antialiased",
+    "-moz-osx-font-smoothing": "grayscale",
+    "font-smoothing": "grayscale"
+  }],
+  ["subpixel-antialiased", {
+    "-webkit-font-smoothing": "auto",
+    "-moz-osx-font-smoothing": "auto",
+    "font-smoothing": "auto"
+  }]
 ];
 
 const outlineStyle = ["none", "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.rem(s.replace(/^(offset\-|width\-)/, ""));
+  const size = handler.bracket.fraction.rem(s.replace(/^(offset\-|width\-|size\-)/, ""));
   if (size) {
     return {
       [`outline-${propName}`]: size
@@ -128,15 +257,15 @@ const outline = [
           "outline-style": d
         };
       }
-      const sizeSheet = parseOutlineSize(d);
-      if (sizeSheet)
-        return sizeSheet;
       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;
     }
   ]
 ];
@@ -161,11 +290,29 @@ const placeholder = [
     }
   ]
 ];
+const cssPropsStr = cssProps.join(", ");
+const validateProperty$1 = (prop) => {
+  if (prop && !cssProps.includes(prop))
+    return;
+  return prop || cssPropsStr;
+};
+const willChange = [
+  [/^will-change-(.*)/, ([, p]) => {
+    const w = validateProperty$1(p) || handler.global(p);
+    if (w)
+      return { "will-change": w };
+  }]
+];
 
 const borders = [
   [/^border$/, handlerBorder],
-  [/^(?:border|b)(?:-([^-]+))?$/, handlerBorder],
-  [/^(?:border|b)(?:-([^-]+))?(?:-([^-]+))?$/, handlerBorder],
+  [/^(?:border|b)()-(.+)$/, handlerBorder],
+  [/^(?:border|b)-([^-]+)(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)()-size-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-([^-]+)-size-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)()-(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-([^-]+)(?:-(.+))?$/, handlerBorderColor],
+  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-border-opacity": handler.bracket.percent(opacity) })],
   ["border-solid", { "border-style": "solid" }],
   ["border-dashed", { "border-style": "dashed" }],
   ["border-dotted", { "border-style": "dotted" }],
@@ -173,20 +320,37 @@ const borders = [
   ["border-none", { "border-style": "none" }],
   [/^(?:border-)?(?:rounded|rd)$/, handlerRounded],
   [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?$/, handlerRounded],
-  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-([^-]+))?$/, handlerRounded],
-  [/^(?:border|b)-(.+)$/, colorResolver$1("border-color", "border")],
-  [/^(?:border|b)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-border-opacity": handler.bracket.percent(opacity) })]
+  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-([^-]+))?$/, handlerRounded]
 ];
-function handlerBorder([, a, b]) {
+function handlerBorder(m) {
+  const borderSizes = handlerBorderSize(m);
+  if (borderSizes) {
+    return [
+      ...borderSizes,
+      ["border-style", "solid"]
+    ];
+  }
+}
+function handlerBorderSize([, a, b]) {
   const [d, s = "1"] = directionMap[a] ? [a, b] : ["", a];
   const v = handler.bracket.px(s);
   if (v != null) {
     return [
-      ...directionMap[d].map((i) => [`border${i}-width`, v]),
-      ["border-style", "solid"]
+      ...directionMap[d].map((i) => [`border${i}-width`, v])
     ];
   }
 }
+function handlerBorderColor([, a, c], ctx) {
+  if (c !== void 0) {
+    const ofColor = colorResolver$1("border-color", "border")(["", c], ctx);
+    if (ofColor) {
+      const borders2 = directionMap[directionMap[a] ? a : ""].map((i) => colorResolver$1(`border${i}-color`, "border")(["", c], ctx));
+      const borderObject = {};
+      Object.assign(borderObject, ...borders2);
+      return borderObject;
+    }
+  }
+}
 function handlerRounded([, a, b], { theme }) {
   const [d, s = "DEFAULT"] = cornerMap[a] ? [a, b] : ["", a];
   const v = theme.borderRadius?.[s] || handler.bracket.fraction.rem(s);
@@ -194,64 +358,10 @@ function handlerRounded([, a, b], { theme }) {
     return cornerMap[d].map((i) => [`border${i}-radius`, v]);
 }
 
-const transitionBasicProps = [
-  "color",
-  "border-color",
-  "background-color",
-  "flex-grow",
-  "flex",
-  "flex-shrink",
-  "caret-color",
-  "font",
-  "gap",
-  "opacity",
-  "visibility",
-  "z-index",
-  "font-weight",
-  "zoom",
-  "text-shadow",
-  "transform",
-  "box-shadow"
-];
-const transitionPositionProps = [
-  "backround-position",
-  "left",
-  "right",
-  "top",
-  "bottom",
-  "object-position"
-];
-const transitionSizeProps = [
-  "max-height",
-  "min-height",
-  "max-width",
-  "min-width",
-  "height",
-  "width",
-  "border-width",
-  "margin",
-  "padding",
-  "outline-width",
-  "outline-offset",
-  "font-size",
-  "line-height",
-  "text-indent",
-  "vertical-align",
-  "border-spacing",
-  "letter-spacing",
-  "word-spacing"
-];
 const transitionSwitchProps = ["all", "none"];
-const transitionEnhanceProps = ["stroke", "filter", "backdrop-filter", "fill", "mask", "mask-size", "mask-border", "clip-path", "clip"];
-const transitionProps = [
-  ...transitionBasicProps,
-  ...transitionPositionProps,
-  ...transitionSizeProps,
-  ...transitionEnhanceProps
-];
-const transitionPropsStr = transitionProps.join(", ");
+const transitionPropsStr = cssProps.join(", ");
 const validateProperty = (prop) => {
-  if (prop && ![...transitionProps, ...transitionSwitchProps].includes(prop))
+  if (prop && ![...cssProps, ...transitionSwitchProps].includes(prop))
     return;
   return prop || transitionPropsStr;
 };
@@ -576,8 +686,8 @@ const rings = [
         "--un-ring-color": "rgba(59, 130, 246, .5)",
         "--un-ring-offset-shadow": "var(--un-ring-inset) 0 0 0 var(--un-ring-offset-width) var(--un-ring-offset-color)",
         "--un-ring-shadow": `var(--un-ring-inset) 0 0 0 calc(${value} + var(--un-ring-offset-width)) var(--un-ring-color)`,
-        "-webkit-box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000);",
-        "box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000);"
+        "-webkit-box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000)",
+        "box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000)"
       };
     }
   }],
@@ -657,11 +767,6 @@ const aspectRatio = [
   }]
 ];
 
-const directionSize = (prefix) => ([_, direction, size]) => {
-  const v = handler.bracket.rem.fraction.cssvar(size);
-  if (v)
-    return directionMap[direction].map((i) => [prefix + i, v]);
-};
 const paddings = [
   [/^pa?()-?(-?.+)$/, directionSize("padding")],
   [/^p-?([xy])-?(-?.+)$/, directionSize("padding")],
@@ -673,84 +778,13 @@ const margins = [
   [/^m-?([rltbse])-?(-?.+)$/, directionSize("margin")]
 ];
 
-const varEmpty = "var(--un-empty,/*!*/ /*!*/)";
-const displays = [
-  ["inline", { display: "inline" }],
-  ["block", { display: "block" }],
-  ["inline-block", { display: "inline-block" }],
-  ["contents", { display: "contents" }],
-  ["flow-root", { display: "flow-root" }],
-  ["list-item", { display: "list-item" }],
-  ["hidden", { display: "none" }]
-];
-const appearances = [
-  ["visible", { visibility: "visible" }],
-  ["invisible", { visibility: "hidden" }],
-  ["backface-visible", { "backface-visibility": "visible" }],
-  ["backface-hidden", { "backface-visibility": "hidden" }]
-];
-const cursors = [
-  [/^cursor-(.+)$/, ([, c]) => ({ cursor: c })]
-];
-const pointerEvents = [
-  ["pointer-events-none", { "pointer-events": "none" }],
-  ["pointer-events-auto", { "pointer-events": "auto" }]
-];
-const resizes = [
-  ["resize-none", { resize: "none" }],
-  ["resize-x", { resize: "horizontal" }],
-  ["resize-y", { resize: "vertical" }],
-  ["resize", { resize: "both" }]
-];
-const userSelects = [
-  [/^select-(none|text|all|auto)$/, ([, v]) => ({ "user-select": v })]
-];
-const whitespaces = [
-  [/^(?:whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)$/, ([, v]) => ({ "white-space": v })]
-];
-const contents = [
-  ["content-empty", { content: '""' }]
-];
-const breaks = [
-  ["break-normal", { "overflow-wrap": "normal", "word-break": "normal" }],
-  ["break-word", { "overflow-wrap": "break-word" }],
-  ["break-all", { "word-break": "break-all" }]
-];
-const textOverflows = [
-  ["truncate", { "overflow": "hidden", "text-overflow": "ellipsis", "white-space": "nowrap" }],
-  ["text-ellipsis", { "text-overflow": "ellipsis" }],
-  ["text-clip", { "text-overflow": "clip" }]
-];
-const textTransforms = [
-  ["case-upper", { "text-transform": "uppercase" }],
-  ["case-lower", { "text-transform": "lowercase" }],
-  ["case-capital", { "text-transform": "capitalize" }],
-  ["case-normal", { "text-transform": "none" }]
-];
-const fontStyles = [
-  ["italic", { "font-style": "italic" }],
-  ["not-italic", { "font-style": "normal" }]
-];
-const fontSmoothings = [
-  ["antialiased", {
-    "-webkit-font-smoothing": "antialiased",
-    "-moz-osx-font-smoothing": "grayscale",
-    "font-smoothing": "grayscale"
-  }],
-  ["subpixel-antialiased", {
-    "-webkit-font-smoothing": "auto",
-    "-moz-osx-font-smoothing": "auto",
-    "font-smoothing": "auto"
-  }]
-];
-
 const transformGpu = {
   transform: "rotate(var(--un-rotate)) scaleX(var(--un-scale-x)) scaleY(var(--un-scale-y)) scaleZ(var(--un-scale-z)) skewX(var(--un-skew-x)) skewY(var(--un-skew-y)) translate3d(var(--un-translate-x), var(--un-translate-y), var(--un-translate-z))",
-  [CONTROL_BYPASS_PSEUDO]: ""
+  [CONTROL_BYPASS_PSEUDO_CLASS]: ""
 };
 const transformCpu = {
   transform: "rotate(var(--un-rotate)) scaleX(var(--un-scale-x)) scaleY(var(--un-scale-y)) scaleZ(var(--un-scale-z)) skewX(var(--un-skew-x)) skewY(var(--un-skew-y)) translateX(var(--un-translate-x)) translateY(var(--un-translate-y)) translateZ(var(--un-translate-z))",
-  [CONTROL_BYPASS_PSEUDO]: ""
+  [CONTROL_BYPASS_PSEUDO_CLASS]: ""
 };
 const transformBase = {
   "--un-rotate": 0,
@@ -767,11 +801,12 @@ const transformBase = {
 const transforms = [
   ["transform", transformBase],
   [/^preserve-(3d|flat)$/, ([, value]) => ({ "transform-style": value === "3d" ? `preserve-${value}` : value })],
-  [/^translate()-([^-]+)$/, handleTranslate],
-  [/^translate-([xyz])-([^-]+)$/, handleTranslate],
-  [/^scale()-([^-]+)$/, handleScale],
-  [/^scale-([xyz])-([^-]+)$/, handleScale],
-  [/^rotate-([^-]+)(?:deg)?$/, handleRotate],
+  [/^translate()-(.+)$/, handleTranslate],
+  [/^translate-([xyz])-(.+)$/, handleTranslate],
+  [/^scale()-(.+)$/, handleScale],
+  [/^scale-([xyz])-(.+)$/, handleScale],
+  [/^rotate-(.+)$/, handleRotate],
+  [/^rotate-((?!\[)[^-]+?)(?:deg)?$/, handleRotateWithUnit],
   ["transform-gpu", transformGpu],
   ["transform-cpu", transformCpu],
   ["transform-none", { transform: "none" }],
@@ -807,7 +842,7 @@ function handleScale([, d, b]) {
     ];
   }
 }
-function handleRotate([, b]) {
+function handleRotateWithUnit([, b]) {
   const v = handler.bracket.number(b);
   if (v != null) {
     return [
@@ -816,6 +851,15 @@ function handleRotate([, b]) {
     ];
   }
 }
+function handleRotate([, b]) {
+  const v = handler.bracket(b);
+  if (v != null) {
+    return [
+      transformBase,
+      { "--un-rotate": v }
+    ];
+  }
+}
 
 const variablesAbbrMap = {
   "visible": "visibility",
@@ -824,6 +868,8 @@ const variablesAbbrMap = {
   "backface": "backface-visibility",
   "whitespace": "white-space",
   "break": "word-break",
+  "b": "border-color",
+  "border": "border-color",
   "color": "color",
   "case": "text-transform",
   "origin": "transform-origin",
@@ -844,23 +890,26 @@ const variablesAbbrMap = {
   "self": "align-self",
   "object": "object-fit"
 };
-const cssVariables = [[
-  /^(.+)-\$(.+)$/,
-  ([, name, varname]) => {
+const cssVariables = [
+  [/^(.+)-\$(.+)$/, ([, name, varname]) => {
     const prop = variablesAbbrMap[name];
     if (prop) {
       return {
         [prop]: `var(--${varname})`
       };
     }
-  }
-]];
+  }],
+  [/^(?:border|b)-([^-]+)-\$(.+)$/, ([, a, v]) => {
+    if (a in directionMap)
+      return directionMap[a].map((i) => [`border${i}-color`, `var(--${v})`]);
+  }]
+];
 
 const questionMark = [
   [
     /^(where|\?)$/,
     (_, { constructCSS, generator }) => {
-      if (generator.config.envMode === "dev")
+      if (generator.userConfig.envMode === "dev")
         return `@keyframes __un_qm{0%{box-shadow:inset 4px 4px #ff1e90, inset -4px -4px #ff1e90}100%{box-shadow:inset 8px 8px #3399ff, inset -8px -8px #3399ff}}
 ${constructCSS({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
     }
@@ -894,6 +943,20 @@ const textDecorations = [
   [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/m, ([, opacity]) => ({ "--un-line-opacity": handler.bracket.percent(opacity) })]
 ];
 
+const svgUtilities = [
+  [/^fill-(.+)$/, colorResolver$1("fill", "fill")],
+  [/^fill-op(?:acity)?-?(.+)$/m, ([, opacity]) => ({ "--un-fill-opacity": handler.bracket.percent(opacity) })],
+  ["fill-none", { fill: "none" }],
+  [/^stroke-(?:size-|width-)?(.+)$/, ([, s]) => {
+    const v = handler.bracket.fraction.px.number(s);
+    if (v)
+      return { "stroke-width": v };
+  }],
+  [/^stroke-(.+)$/, colorResolver$1("stroke", "stroke")],
+  [/^stroke-op(?:acity)?-?(.+)$/m, ([, opacity]) => ({ "--un-stroke-opacity": handler.bracket.percent(opacity) })],
+  ["stroke-none", { stroke: "none" }]
+];
+
 const rules = [
   cssVariables,
   paddings,
@@ -901,7 +964,7 @@ const rules = [
   displays,
   opacity,
   bgColors,
-  fillColors,
+  svgUtilities,
   borders,
   contents,
   fonts,
@@ -947,7 +1010,8 @@ const rules = [
   boxSizing,
   transitions,
   transforms,
+  willChange,
   questionMark
 ].flat(1);
 
-export { tabSizes as $, floats as A, zIndexes as B, boxSizing as C, questionMark as D, rings as E, boxShadows as F, sizes as G, aspectRatio as H, paddings as I, margins as J, varEmpty as K, displays as L, appearances as M, cursors as N, pointerEvents as O, resizes as P, userSelects as Q, whitespaces as R, contents as S, breaks as T, textOverflows as U, textTransforms as V, fontStyles as W, fontSmoothings as X, transforms as Y, transitions as Z, fonts as _, appearance as a, textIndents as a0, textStrokes as a1, textShadows as a2, cssVariables as a3, textDecorations as a4, borders as b, parseColorUtil as c, colorResolver$1 as d, opacity as e, textColors as f, bgColors as g, borderColors as h, ringColors as i, ringOffsetColors as j, fillColors as k, flex as l, gaps as m, grids as n, outline as o, placeholder as p, overflows as q, rules as r, positions as s, textAligns as t, justifies as u, verticalAligns as v, orders as w, alignments as x, placements as y, insets as z };
+export { transitions as $, floats as A, zIndexes as B, boxSizing as C, questionMark as D, rings as E, boxShadows as F, sizes as G, aspectRatio as H, paddings as I, margins as J, cssProps as K, varEmpty as L, displays as M, appearances as N, cursors as O, pointerEvents as P, resizes as Q, userSelects as R, whitespaces as S, contents as T, breaks as U, textOverflows as V, textTransforms as W, fontStyles as X, fontSmoothings as Y, svgUtilities as Z, transforms as _, appearance as a, fonts as a0, tabSizes as a1, textIndents as a2, textStrokes as a3, textShadows as a4, cssVariables as a5, textDecorations as a6, borders as b, parseColorUtil as c, colorResolver$1 as d, opacity as e, textColors as f, bgColors as g, borderColors as h, ringColors as i, ringOffsetColors as j, flex as k, gaps as l, grids as m, overflows as n, outline as o, placeholder as p, positions as q, rules as r, justifies as s, textAligns as t, orders as u, verticalAligns as v, willChange as w, alignments as x, placements as y, insets as z };

package/dist/chunks/default3.cjs

@@ -8,20 +8,22 @@ 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])
-      regexCache[point] = new RegExp(`^((?:[a|l]t-)?${point}[:-])`);
+      regexCache[point] = new RegExp(`^((?:[al]t-)?${point}[:-])`);
     const match = matcher.match(regexCache[point]);
     if (!match)
       continue;
     const [, pre] = match;
+    const m = matcher.slice(pre.length);
+    if (m === "container")
+      continue;
     let direction = "min";
-    let order = parseInt(size);
+    let order = 1e3;
     if (pre.startsWith("lt-")) {
       direction = "max";
-      order = -order;
+      order -= idx + 1;
+    } else {
+      order += idx + 1;
     }
-    const m = matcher.slice(pre.length);
-    if (m === "container")
-      continue;
     if (pre.startsWith("at-") && idx < variantEntries.length - 1) {
       return {
         matcher: m,
@@ -35,10 +37,13 @@ const variantBreakpoints = (matcher, _, theme) => {
   }
 };
 
-const variantChildren = [
-  variants$1.variantMatcher("children", (input) => `${input} > *`),
+const variantCombinators = [
   variants$1.variantMatcher("all", (input) => `${input} *`),
-  variants$1.variantMatcher("next", (input) => `${input}+*`)
+  variants$1.variantMatcher("children", (input) => `${input}>*`),
+  variants$1.variantMatcher("next", (input) => `${input}+*`),
+  variants$1.variantMatcher("sibling", (input) => `${input}+*`),
+  variants$1.variantMatcher("siblings", (input) => `${input}~*`),
+  variants$1.variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
 const variantColorsClass = [
@@ -113,15 +118,15 @@ const variants = [
   variantNegative,
   variantImportant,
   variantBreakpoints,
-  ...variantChildren,
+  ...variantCombinators,
   pseudo.variantPseudoClasses,
   pseudo.variantPseudoElements
 ];
 
 exports.variantBreakpoints = variantBreakpoints;
-exports.variantChildren = variantChildren;
 exports.variantColorsClass = variantColorsClass;
 exports.variantColorsMedia = variantColorsMedia;
+exports.variantCombinators = variantCombinators;
 exports.variantImportant = variantImportant;
 exports.variantNegative = variantNegative;
 exports.variantSpace = variantSpace;