@unocss/preset-mini 0.21.0 → 0.22.1

package/dist/chunks/default2.mjs

@@ -1,6 +1,5 @@
-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';
+import { h as handler, c as colorResolver, d as directionMap, p as parseColor, a as cornerMap, i as insetMap, b as directionSize, e as positionMap, x as xyzMap } from './utilities.mjs';
+import { toArray, CONTROL_SHORTCUT_NO_MERGE } from '@unocss/core';
 
 const verticalAlignAlias = {
   mid: "middle",
@@ -31,27 +30,42 @@ const appearance = [
     "-webkit-appearance": "none"
   }]
 ];
+const willChangeProperty = (prop) => {
+  return handler.properties.auto.global(prop) ?? {
+    contents: "contents",
+    scroll: "scroll-position"
+  }[prop];
+};
 const willChange = [
-  [/^will-change-(.+)/, ([, p]) => ({ "will-change": handler.properties.auto.global(p) })]
+  [/^will-change-(.+)/, ([, p]) => ({ "will-change": willChangeProperty(p) })]
 ];
 
 const borders = [
   [/^(?: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)-(block|inline)(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)-([bi][se])(?:-(.+))?$/, handlerBorder],
+  [/^(?:border|b)-()(?:width|size)-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-([xy])-(?:width|size)-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-([rltbse])-(?:width|size)-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-(block|inline)-(?:width|size)-(.+)$/, handlerBorderSize],
+  [/^(?:border|b)-([bi][se])-(?:width|size)-(.+)$/, handlerBorderSize],
   [/^(?:border|b)-()(?:color-)?(.+)$/, handlerBorderColor],
   [/^(?:border|b)-([xy])-(?:color-)?(.+)$/, handlerBorderColor],
   [/^(?:border|b)-([rltbse])-(?:color-)?(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-(block|inline)-(?:color-)?(.+)$/, handlerBorderColor],
+  [/^(?:border|b)-([bi][se])-(?:color-)?(.+)$/, handlerBorderColor],
   [/^(?:border|b)-()op(?:acity)?-?(.+)$/, handlerBorderOpacity],
   [/^(?:border|b)-([xy])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
   [/^(?:border|b)-([rltbse])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
+  [/^(?:border|b)-(block|inline)-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
+  [/^(?:border|b)-([bi][se])-op(?:acity)?-?(.+)$/, handlerBorderOpacity],
   [/^(?:border-)?(?:rounded|rd)()(?:-(.+))?$/, handlerRounded],
-  [/^(?:border-)?(?:rounded|rd)-([xy])(?:-(.+))?$/, handlerRounded],
   [/^(?:border-)?(?:rounded|rd)-([rltb])(?:-(.+))?$/, handlerRounded],
   [/^(?:border-)?(?:rounded|rd)-([rltb]{2})(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)-([bi][se])(?:-(.+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)-([bi][se]-[bi][se])(?:-(.+))?$/, handlerRounded],
   ["border-solid", { "border-style": "solid" }],
   ["border-dashed", { "border-style": "dashed" }],
   ["border-dotted", { "border-style": "dotted" }],
@@ -208,17 +222,15 @@ const weightMap = {
 const fonts = [
   [/^font-(\w+)$/, ([, d], { theme }) => ({ "font-family": theme.fontFamily?.[d] })],
   [/^text-(.+)$/, ([, s = "base"], { theme }) => {
-    const size = handler.bracket.auto.rem(s);
-    if (size)
-      return { "font-size": size };
     const themed = toArray(theme.fontSize?.[s]);
     if (themed?.[0]) {
-      const [size2, height] = themed;
+      const [size, height = "1"] = themed;
       return {
-        "font-size": size2,
+        "font-size": size,
         "line-height": height
       };
     }
+    return { "font-size": handler.bracket.auto.rem(s) };
   }],
   [/^text-size-(.+)$/, ([, s]) => ({ "font-size": handler.bracket.auto.rem(s) })],
   [/^(?:font|fw)-?([^-]+)$/, ([, s]) => ({ "font-weight": weightMap[s] || handler.number(s) })],
@@ -247,7 +259,29 @@ const textStrokes = [
   [/^text-stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-stroke-opacity": handler.bracket.percent(opacity) })]
 ];
 const textShadows = [
-  [/^text-shadow(?:-(.+))?$/, ([, s], { theme }) => ({ "text-shadow": theme.textShadow?.[s || "DEFAULT"] || handler.bracket.cssvar(s) })]
+  [/^text-shadow(?:-(.+))?$/, ([, s], { theme }) => {
+    const v = theme.textShadow?.[s || "DEFAULT"];
+    if (v != null) {
+      const shadow = toArray(v);
+      const colored = shadow.map((s2) => s2.replace(/\s\S+$/, " var(--un-text-shadow-color)"));
+      return {
+        "--un-text-shadow": shadow.join(","),
+        "--un-text-shadow-colored": colored.join(","),
+        "text-shadow": "var(--un-text-shadow)"
+      };
+    }
+    return { "text-shadow": handler.bracket.cssvar(s) };
+  }],
+  [/^text-shadow-color-(.+)$/, (m, ctx) => {
+    const color = colorResolver("--un-text-shadow-color", "text-shadow")(m, ctx);
+    if (color) {
+      return {
+        ...color,
+        "--un-text-shadow": "var(--un-text-shadow-colored)"
+      };
+    }
+  }],
+  [/^text-shadow-color-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-text-shadow-opacity": handler.bracket.percent(opacity) })]
 ];
 
 const directions = {
@@ -383,16 +417,18 @@ const placements = [
   ["place-self-stretch", { "place-self": "stretch" }]
 ];
 function handleInsetValue(v) {
-  return { auto: "auto", full: "100%" }[v] ?? handler.bracket.fraction.cssvar.auto.rem(v);
+  return 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]);
+  if (r != null && d in insetMap)
+    return insetMap[d].map((i) => [i.slice(1), r]);
 }
 const insets = [
   [/^(?:position-|pos-)?inset-(.+)$/, ([, v]) => ({ inset: handleInsetValue(v) })],
   [/^(?:position-|pos-)?inset-([xy])-(.+)$/, handleInsetValues],
+  [/^(?:position-|pos-)?inset-(block|inline)-(.+)$/, handleInsetValues],
+  [/^(?:position-|pos-)?inset-([bi][se])-(.+)$/, handleInsetValues],
   [/^(?:position-|pos-)?(top|left|right|bottom)-(.+)$/, ([, d, v]) => ({ [d]: handleInsetValue(v) })]
 ];
 const floats = [
@@ -452,7 +488,8 @@ const whitespaces = [
   [/^(?:whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)$/, ([, v]) => ({ "white-space": v })]
 ];
 const contents = [
-  ["content-empty", { content: '""' }]
+  ["content-empty", { content: '""' }],
+  ["content-none", { content: '""' }]
 ];
 const breaks = [
   ["break-normal", { "overflow-wrap": "normal", "word-break": "normal" }],
@@ -487,19 +524,62 @@ const fontSmoothings = [
   }]
 ];
 
+const shadowBase = {
+  [CONTROL_SHORTCUT_NO_MERGE]: "",
+  "--un-ring-offset-shadow": "0 0 #0000",
+  "--un-ring-shadow": "0 0 #0000",
+  "--un-shadow-inset": varEmpty,
+  "--un-shadow": "0 0 #0000",
+  "--un-shadow-colored": "0 0 #0000"
+};
+const boxShadows = [
+  [/^shadow(?:-(.+))?$/, ([, d], { theme }) => {
+    const v = theme.boxShadow?.[d || "DEFAULT"];
+    if (v) {
+      const shadow = toArray(v);
+      const colored = shadow.map((s) => s.replace(/\s\S+$/, " var(--un-shadow-color)"));
+      return [
+        shadowBase,
+        {
+          "--un-shadow": shadow.join(","),
+          "--un-shadow-colored": colored.join(","),
+          "box-shadow": "var(--un-ring-offset-shadow, 0 0 #0000), var(--un-ring-shadow, 0 0 #0000), var(--un-shadow)"
+        }
+      ];
+    }
+  }],
+  [/^shadow-(.+)$/, (m, ctx) => {
+    const color = colorResolver("--un-shadow-color", "shadow")(m, ctx);
+    if (color) {
+      return {
+        ...color,
+        "--un-shadow": "var(--un-shadow-colored)"
+      };
+    }
+  }],
+  [/^shadow-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-shadow-opacity": handler.bracket.percent.cssvar(opacity) })],
+  ["shadow-inset", { "--un-shadow-inset": "inset" }]
+];
+
+const ringBase = {
+  "--un-ring-inset": varEmpty,
+  "--un-ring-offset-width": "0px",
+  "--un-ring-offset-color": "#fff",
+  "--un-ring-color": "rgba(147,197,253,0.5)",
+  ...shadowBase
+};
 const rings = [
   [/^ring(?:-(.+))?$/, ([, d]) => {
     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(147, 197, 253, .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)`,
-        "box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000)"
-      };
+      return [
+        ringBase,
+        {
+          "--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)`,
+          "box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000)"
+        }
+      ];
     }
   }],
   ["ring-offset", { "--un-ring-offset-width": "1px" }],
@@ -511,46 +591,17 @@ const rings = [
   ["ring-inset", { "--un-ring-inset": "inset" }]
 ];
 
-const shadowColorResolver = (body, theme) => {
-  const data = parseColor(body, theme);
-  if (!data)
-    return;
-  const { color, rgba } = data;
-  if (!color)
-    return;
-  if (rgba) {
-    return {
-      "--un-shadow-color": `${rgba.slice(0, 3).join(",")}`
-    };
-  } else {
-    return {
-      "--un-shadow-color": color
-    };
-  }
+const sizeMapping = {
+  h: "height",
+  w: "width",
+  inline: "inline-size",
+  block: "block-size"
 };
-const boxShadows = [
-  [/^shadow(?:-(.+))?$/, ([, d], { theme }) => {
-    const value = theme.boxShadow?.[d || "DEFAULT"];
-    if (value) {
-      return {
-        "--un-shadow-inset": varEmpty,
-        "--un-shadow-color": "0,0,0",
-        "--un-shadow": value,
-        "box-shadow": "var(--un-ring-offset-shadow, 0 0 #0000), var(--un-ring-shadow, 0 0 #0000), var(--un-shadow)"
-      };
-    }
-  }],
-  [/^shadow-(.+)$/, ([, d], { theme }) => shadowColorResolver(d, theme)],
-  ["shadow-inset", { "--un-shadow-inset": "inset" }]
-];
-
 function getPropName(minmax, hw) {
-  return `${minmax ? `${minmax}-` : ""}${hw === "h" ? "height" : "width"}`;
+  return `${minmax || ""}${sizeMapping[hw]}`;
 }
 function getSizeValue(minmax, hw, theme, prop) {
-  let str = `${hw === "h" ? "height" : "width"}`;
-  if (minmax)
-    str = `${minmax}${capitalize(str)}`;
+  const str = getPropName(minmax, hw).replace(/-(\w)/g, (_, p) => p.toUpperCase());
   const v = theme[str]?.[prop];
   if (v != null)
     return v;
@@ -563,8 +614,9 @@ function getSizeValue(minmax, hw, theme, prop) {
   return handler.bracket.cssvar.fraction.auto.rem(prop);
 }
 const sizes = [
-  [/^(?:(min|max)-)?(w|h)-(.+)$/, ([, m, w, s], { theme }) => ({ [getPropName(m, w)]: getSizeValue(m, w, theme, s) })],
-  [/^(?:(min|max)-)?(w)-screen-(.+)$/, ([, m, w, s], { theme }) => ({ [getPropName(m, w)]: theme.breakpoints?.[s] })]
+  [/^(min-|max-)?([wh])-(.+)$/, ([, m, w, s], { theme }) => ({ [getPropName(m, w)]: getSizeValue(m, w, theme, s) })],
+  [/^(min-|max-)?(block|inline)-(.+)$/, ([, m, w, s], { theme }) => ({ [getPropName(m, w)]: getSizeValue(m, w, theme, s) })],
+  [/^(min-|max-)?(w)-screen-(.+)$/, ([, m, w, s], { theme }) => ({ [getPropName(m, w)]: theme.breakpoints?.[s] })]
 ];
 function getAspectRatio(prop) {
   if (/^\d+\/\d+$/.test(prop))
@@ -584,24 +636,53 @@ const aspectRatio = [
 const paddings = [
   [/^pa?()-?(-?.+)$/, directionSize("padding")],
   [/^p-?([xy])-?(-?.+)$/, directionSize("padding")],
-  [/^p-?([rltbse])-?(-?.+)$/, directionSize("padding")]
+  [/^p-?([rltbse])-?(-?.+)$/, directionSize("padding")],
+  [/^p-(inline|block)-(-?.+)$/, directionSize("padding")],
+  [/^p-?([bi][se])-?(-?.+)$/, directionSize("padding")]
 ];
 const margins = [
   [/^ma?()-?(-?.+)$/, directionSize("margin")],
   [/^m-?([xy])-?(-?.+)$/, directionSize("margin")],
-  [/^m-?([rltbse])-?(-?.+)$/, directionSize("margin")]
+  [/^m-?([rltbse])-?(-?.+)$/, directionSize("margin")],
+  [/^m-(inline|block)-(-?.+)$/, directionSize("margin")],
+  [/^m-?([bi][se])-?(-?.+)$/, directionSize("margin")]
 ];
 
 const transformGpu = {
-  transform: "rotate(var(--un-rotate)) scaleX(var(--un-scale-x)) scaleY(var(--un-scale-y)) scaleZ(var(--un-scale-z)) skewX(var(--un-skew-x)) skewY(var(--un-skew-y)) translate3d(var(--un-translate-x), var(--un-translate-y), var(--un-translate-z))",
-  [CONTROL_BYPASS_PSEUDO_CLASS]: ""
+  "--un-transform": [
+    "translate3d(var(--un-translate-x), var(--un-translate-y), var(--un-translate-z))",
+    "rotate(var(--un-rotate))",
+    "rotateX(var(--un-rotate-x))",
+    "rotateY(var(--un-rotate-y))",
+    "rotateZ(var(--un-rotate-z))",
+    "skewX(var(--un-skew-x))",
+    "skewY(var(--un-skew-y))",
+    "scaleX(var(--un-scale-x))",
+    "scaleY(var(--un-scale-y))",
+    "scaleZ(var(--un-scale-z))"
+  ].join(" ")
 };
 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_CLASS]: ""
+  "--un-transform": [
+    "translateX(var(--un-translate-x))",
+    "translateY(var(--un-translate-y))",
+    "translateZ(var(--un-translate-z))",
+    "rotate(var(--un-rotate))",
+    "rotateX(var(--un-rotate-x))",
+    "rotateY(var(--un-rotate-y))",
+    "rotateZ(var(--un-rotate-z))",
+    "skewX(var(--un-skew-x))",
+    "skewY(var(--un-skew-y))",
+    "scaleX(var(--un-scale-x))",
+    "scaleY(var(--un-scale-y))",
+    "scaleZ(var(--un-scale-z))"
+  ].join(" ")
 };
 const transformBase = {
   "--un-rotate": 0,
+  "--un-rotate-x": 0,
+  "--un-rotate-y": 0,
+  "--un-rotate-z": 0,
   "--un-scale-x": 1,
   "--un-scale-y": 1,
   "--un-scale-z": 1,
@@ -610,20 +691,43 @@ const transformBase = {
   "--un-translate-x": 0,
   "--un-translate-y": 0,
   "--un-translate-z": 0,
-  ...transformCpu
+  ...transformCpu,
+  [CONTROL_SHORTCUT_NO_MERGE]: ""
 };
 const transforms = [
-  ["transform", transformBase],
   [/^origin-([-\w]{3,})$/, ([, s]) => ({ "transform-origin": positionMap[s] })],
+  [/^perspect-(.+)$/, ([, s]) => {
+    const v = handler.px.numberWithUnit(s);
+    if (v != null) {
+      return {
+        "-webkit-perspective": v,
+        "perspective": v
+      };
+    }
+  }],
+  [/^perspect-origin-(.+)$/, ([, s]) => {
+    const v = handler.bracket(s) ?? (s.length >= 3 ? positionMap[s] : void 0);
+    if (v != null) {
+      return {
+        "-webkit-perspective-origin": v,
+        "perspective-origin": v
+      };
+    }
+  }],
   [/^translate-()(.+)$/, handleTranslate],
   [/^translate-([xyz])-(.+)$/, handleTranslate],
-  [/^rotate-(.+)$/, handleRotate],
+  [/^rotate-()(.+)$/, handleRotate],
+  [/^rotate(-[xyz])-(.+)$/, handleRotate],
   [/^skew-()(.+)$/, handleSkew],
   [/^skew-([xy])-(.+)$/, handleSkew],
   [/^scale-()(.+)$/, handleScale],
   [/^scale-([xyz])-(.+)$/, handleScale],
   ["preserve-3d", { "transform-style": "preserve-3d" }],
   ["preserve-flat", { "transform-style": "flat" }],
+  [/^transform$/, () => [
+    transformBase,
+    { transform: "var(--un-transform)" }
+  ]],
   ["transform-gpu", transformGpu],
   ["transform-cpu", transformCpu],
   ["transform-none", { transform: "none" }]
@@ -633,7 +737,10 @@ function handleTranslate([, d, b]) {
   if (v != null) {
     return [
       transformBase,
-      xyzMap[d].map((i) => [`--un-translate${i}`, v])
+      [
+        ...xyzMap[d].map((i) => [`--un-translate${i}`, v]),
+        ["transform", "var(--un-transform)"]
+      ]
     ];
   }
 }
@@ -642,16 +749,22 @@ function handleScale([, d, b]) {
   if (v != null) {
     return [
       transformBase,
-      xyzMap[d].map((i) => [`--un-scale${i}`, v])
+      [
+        ...xyzMap[d].map((i) => [`--un-scale${i}`, v]),
+        ["transform", "var(--un-transform)"]
+      ]
     ];
   }
 }
-function handleRotate([, b]) {
+function handleRotate([, d, b]) {
   const v = handler.bracket.degree(b);
   if (v != null) {
     return [
       transformBase,
-      { "--un-rotate": v }
+      {
+        [`--un-rotate${d || ""}`]: v,
+        transform: "var(--un-transform)"
+      }
     ];
   }
 }
@@ -660,7 +773,10 @@ function handleSkew([, d, b]) {
   if (v != null) {
     return [
       transformBase,
-      { [`--un-skew-${d}`]: v }
+      {
+        [`--un-skew-${d}`]: v,
+        transform: "var(--un-transform)"
+      }
     ];
   }
 }
@@ -696,6 +812,9 @@ const cssVariables = [
       return { [prop]: `var(--${varname})` };
   }]
 ];
+const cssProperty = [
+  [/^\[(.+):(.+)\]$/, ([, prop, value]) => ({ [prop]: handler.bracket(`[${value}]`) })]
+];
 
 const questionMark = [
   [
@@ -736,14 +855,25 @@ const svgUtilities = [
   [/^fill-(.+)$/, colorResolver("fill", "fill")],
   [/^fill-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-fill-opacity": handler.bracket.percent(opacity) })],
   ["fill-none", { fill: "none" }],
-  [/^stroke-(?:size-|width-)?(.+)$/, ([, s]) => ({ "stroke-width": handler.bracket.fraction.px.number(s) })],
+  [/^stroke-(?:width-|size-)?(.+)$/, ([, s]) => ({ "stroke-width": handler.bracket.fraction.px.number(s) })],
+  [/^stroke-dash-(.+)$/, ([, s]) => ({ "stroke-dasharray": handler.bracket.number(s) })],
+  [/^stroke-offset-(.+)$/, ([, s]) => ({ "stroke-dashoffset": handler.bracket.px.numberWithUnit(s) })],
   [/^stroke-(.+)$/, colorResolver("stroke", "stroke")],
   [/^stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-stroke-opacity": handler.bracket.percent(opacity) })],
+  ["stroke-cap-square", { "stroke-linecap": "square" }],
+  ["stroke-cap-round", { "stroke-linecap": "round" }],
+  ["stroke-cap-auto", { "stroke-linecap": "butt" }],
+  ["stroke-join-arcs", { "stroke-linejoin": "arcs" }],
+  ["stroke-join-bevel", { "stroke-linejoin": "bevel" }],
+  ["stroke-join-clip", { "stroke-linejoin": "miter-clip" }],
+  ["stroke-join-round", { "stroke-linejoin": "round" }],
+  ["stroke-join-auto", { "stroke-linejoin": "miter" }],
   ["stroke-none", { stroke: "none" }]
 ];
 
 const rules = [
   cssVariables,
+  cssProperty,
   paddings,
   margins,
   displays,
@@ -798,4 +928,4 @@ const rules = [
   questionMark
 ].flat(1);
 
-export { textDecorations as $, sizes as A, aspectRatio as B, paddings as C, margins as D, varEmpty as E, displays as F, appearances as G, cursors as H, pointerEvents as I, resizes as J, userSelects as K, whitespaces as L, contents as M, breaks as N, textOverflows as O, textTransforms as P, fontStyles as Q, fontSmoothings as R, svgUtilities as S, transforms as T, transitions as U, fonts as V, tabSizes as W, textIndents as X, textStrokes as Y, textShadows as Z, cssVariables as _, appearance as a, 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 };
+export { cssVariables as $, boxShadows as A, sizes as B, aspectRatio as C, paddings as D, margins 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, cssProperty as a0, textDecorations as a1, 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, shadowBase as y, zIndexes as z };

package/dist/chunks/default3.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const variants$1 = require('./variants.cjs');
-const pseudo = require('./pseudo.cjs');
+const core = require('@unocss/core');
 
 const regexCache = {};
 const variantBreakpoints = (matcher, { theme }) => {
@@ -110,6 +110,156 @@ const variantOrientations = [
 
 const variantPrint = variants$1.variantParentMatcher("print", "@media print");
 
+const CONTROL_BYPASS_PSEUDO_CLASS = "$$no-pseudo";
+const PseudoClasses = Object.fromEntries([
+  "any-link",
+  "link",
+  "visited",
+  "target",
+  ["open", "[open]"],
+  "hover",
+  "active",
+  "focus-visible",
+  "focus-within",
+  "focus",
+  "autofill",
+  "enabled",
+  "disabled",
+  "read-only",
+  "read-write",
+  "placeholder-shown",
+  "default",
+  "checked",
+  "indeterminate",
+  "valid",
+  "invalid",
+  "in-range",
+  "out-of-range",
+  "required",
+  "optional",
+  "root",
+  "empty",
+  ["even-of-type", ":nth-of-type(even)"],
+  ["even", ":nth-child(even)"],
+  ["odd-of-type", ":nth-of-type(odd)"],
+  ["odd", ":nth-child(odd)"],
+  "first-of-type",
+  ["first", ":first-child"],
+  "last-of-type",
+  ["last", ":last-child"],
+  "only-child",
+  "only-of-type"
+].map(core.toArray));
+const PseudoElements = Object.fromEntries([
+  "placeholder",
+  "before",
+  "after",
+  "first-letter",
+  "first-line",
+  "selection",
+  "marker",
+  ["file", "::file-selector-button"]
+].map(core.toArray));
+const PseudoClassFunctions = [
+  "not",
+  "is",
+  "where",
+  "has"
+];
+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) {
+  return !entires.find((i) => i[0] === CONTROL_BYPASS_PSEUDO_CLASS) || void 0;
+}
+const taggedPseudoClassMatcher = (tag, parent, combinator) => {
+  const re = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))[:-]`);
+  const rawRe = new RegExp(`^${core.escapeRegExp(parent)}:`);
+  return (input) => {
+    const match = input.match(re);
+    if (match) {
+      let pseudo = PseudoClasses[match[3]] || `:${match[3]}`;
+      if (match[2])
+        pseudo = `:${match[2]}(${pseudo})`;
+      return {
+        matcher: input.slice(match[1].length + tag.length + 2),
+        selector: (s, body) => {
+          return shouldAdd(body) && rawRe.test(s) ? s.replace(rawRe, `${parent}${pseudo}:`) : `${parent}${pseudo}${combinator}${s}`;
+        }
+      };
+    }
+  };
+};
+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}${pseudo}`
+    };
+  }
+};
+const variantPseudoClasses = {
+  match: (input) => {
+    const match = input.match(PseudoClassesRE);
+    if (match) {
+      const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
+      return {
+        matcher: input.slice(match[1].length + 1),
+        selector: (s, body) => shouldAdd(body) && `${s}${pseudo}`
+      };
+    }
+  },
+  multiPass: true
+};
+const variantPseudoClassFunctions = {
+  match: (input) => {
+    const match = input.match(PseudoClassFunctionsRE);
+    if (match) {
+      const fn = match[1];
+      const pseudo = PseudoClasses[match[2]] || `:${match[2]}`;
+      return {
+        matcher: input.slice(match[1].length + match[2].length + 2),
+        selector: (s, body) => shouldAdd(body) && `${s}:${fn}(${pseudo})`
+      };
+    }
+  },
+  multiPass: true
+};
+const variantTaggedPseudoClasses = (options = {}) => {
+  const attributify = !!options?.attributifyPseudo;
+  return [
+    {
+      match: taggedPseudoClassMatcher("group", attributify ? '[group=""]' : ".group", " "),
+      multiPass: true
+    },
+    {
+      match: taggedPseudoClassMatcher("peer", attributify ? '[peer=""]' : ".peer", "~"),
+      multiPass: true
+    }
+  ];
+};
+const partClasses = {
+  match: (input) => {
+    const match = input.match(PartClassesRE);
+    if (match) {
+      const part = `part(${match[2]})`;
+      return {
+        matcher: input.slice(match[1].length),
+        selector: (s, body) => {
+          return shouldAdd(body) && `${s}::${part}`;
+        }
+      };
+    }
+  },
+  multiPass: true
+};
+
 const variants = (options) => [
   variantNegative,
   variantImportant,
@@ -118,15 +268,17 @@ const variants = (options) => [
   ...variantMotions,
   variantBreakpoints,
   ...variantCombinators,
-  pseudo.variantPseudoClasses,
-  pseudo.variantPseudoClassFunctions,
-  ...pseudo.variantTaggedPseudoClasses(options),
-  pseudo.variantPseudoElements,
-  pseudo.partClasses,
+  variantPseudoClasses,
+  variantPseudoClassFunctions,
+  ...variantTaggedPseudoClasses(options),
+  variantPseudoElements,
+  partClasses,
   ...variantColorsMediaOrClass(options),
   ...variantLanguageDirections
 ];
 
+exports.CONTROL_BYPASS_PSEUDO_CLASS = CONTROL_BYPASS_PSEUDO_CLASS;
+exports.partClasses = partClasses;
 exports.variantBreakpoints = variantBreakpoints;
 exports.variantColorsMediaOrClass = variantColorsMediaOrClass;
 exports.variantCombinators = variantCombinators;
@@ -136,4 +288,8 @@ exports.variantMotions = variantMotions;
 exports.variantNegative = variantNegative;
 exports.variantOrientations = variantOrientations;
 exports.variantPrint = variantPrint;
+exports.variantPseudoClassFunctions = variantPseudoClassFunctions;
+exports.variantPseudoClasses = variantPseudoClasses;
+exports.variantPseudoElements = variantPseudoElements;
+exports.variantTaggedPseudoClasses = variantTaggedPseudoClasses;
 exports.variants = variants;