@unocss/preset-mini 0.21.2 → 0.22.0

package/dist/chunks/default2.cjs

@@ -2,7 +2,6 @@
 
 const utilities = require('./utilities.cjs');
 const core = require('@unocss/core');
-const pseudo = require('./pseudo.cjs');
 
 const verticalAlignAlias = {
   mid: "middle",
@@ -33,8 +32,14 @@ const appearance = [
     "-webkit-appearance": "none"
   }]
 ];
+const willChangeProperty = (prop) => {
+  return utilities.handler.properties.auto.global(prop) ?? {
+    contents: "contents",
+    scroll: "scroll-position"
+  }[prop];
+};
 const willChange = [
-  [/^will-change-(.+)/, ([, p]) => ({ "will-change": utilities.handler.properties.auto.global(p) })]
+  [/^will-change-(.+)/, ([, p]) => ({ "will-change": willChangeProperty(p) })]
 ];
 
 const borders = [
@@ -210,17 +215,15 @@ const weightMap = {
 const fonts = [
   [/^font-(\w+)$/, ([, d], { theme }) => ({ "font-family": theme.fontFamily?.[d] })],
   [/^text-(.+)$/, ([, s = "base"], { theme }) => {
-    const size = utilities.handler.bracket.auto.rem(s);
-    if (size)
-      return { "font-size": size };
     const themed = core.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": utilities.handler.bracket.auto.rem(s) };
   }],
   [/^text-size-(.+)$/, ([, s]) => ({ "font-size": utilities.handler.bracket.auto.rem(s) })],
   [/^(?:font|fw)-?([^-]+)$/, ([, s]) => ({ "font-weight": weightMap[s] || utilities.handler.number(s) })],
@@ -454,7 +457,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" }],
@@ -595,12 +599,10 @@ const margins = [
 ];
 
 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))",
-  [pseudo.CONTROL_BYPASS_PSEUDO_CLASS]: ""
+  "--un-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))"
 };
 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))",
-  [pseudo.CONTROL_BYPASS_PSEUDO_CLASS]: ""
+  "--un-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))"
 };
 const transformBase = {
   "--un-rotate": 0,
@@ -612,11 +614,29 @@ const transformBase = {
   "--un-translate-x": 0,
   "--un-translate-y": 0,
   "--un-translate-z": 0,
-  ...transformCpu
+  ...transformCpu,
+  [core.CONTROL_SHORTCUT_NO_MERGE]: ""
 };
 const transforms = [
-  ["transform", transformBase],
   [/^origin-([-\w]{3,})$/, ([, s]) => ({ "transform-origin": utilities.positionMap[s] })],
+  [/^perspect-(.+)$/, ([, s]) => {
+    const v = utilities.handler.px.numberWithUnit(s);
+    if (v != null) {
+      return {
+        "-webkit-perspective": v,
+        "perspective": v
+      };
+    }
+  }],
+  [/^perspect-origin-(.+)$/, ([, s]) => {
+    const v = utilities.handler.bracket(s) ?? (s.length >= 3 ? utilities.positionMap[s] : void 0);
+    if (v != null) {
+      return {
+        "-webkit-perspective-origin": v,
+        "perspective-origin": v
+      };
+    }
+  }],
   [/^translate-()(.+)$/, handleTranslate],
   [/^translate-([xyz])-(.+)$/, handleTranslate],
   [/^rotate-(.+)$/, handleRotate],
@@ -626,6 +646,10 @@ const transforms = [
   [/^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" }]
@@ -635,7 +659,10 @@ function handleTranslate([, d, b]) {
   if (v != null) {
     return [
       transformBase,
-      utilities.xyzMap[d].map((i) => [`--un-translate${i}`, v])
+      [
+        ...utilities.xyzMap[d].map((i) => [`--un-translate${i}`, v]),
+        ["transform", "var(--un-transform)"]
+      ]
     ];
   }
 }
@@ -644,7 +671,10 @@ function handleScale([, d, b]) {
   if (v != null) {
     return [
       transformBase,
-      utilities.xyzMap[d].map((i) => [`--un-scale${i}`, v])
+      [
+        ...utilities.xyzMap[d].map((i) => [`--un-scale${i}`, v]),
+        ["transform", "var(--un-transform)"]
+      ]
     ];
   }
 }
@@ -653,7 +683,10 @@ function handleRotate([, b]) {
   if (v != null) {
     return [
       transformBase,
-      { "--un-rotate": v }
+      {
+        "--un-rotate": v,
+        "transform": "var(--un-transform)"
+      }
     ];
   }
 }
@@ -662,7 +695,10 @@ function handleSkew([, d, b]) {
   if (v != null) {
     return [
       transformBase,
-      { [`--un-skew-${d}`]: v }
+      {
+        [`--un-skew-${d}`]: v,
+        transform: "var(--un-transform)"
+      }
     ];
   }
 }
@@ -739,8 +775,18 @@ const svgUtilities = [
   [/^fill-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-fill-opacity": utilities.handler.bracket.percent(opacity) })],
   ["fill-none", { fill: "none" }],
   [/^stroke-(?:size-|width-)?(.+)$/, ([, s]) => ({ "stroke-width": utilities.handler.bracket.fraction.px.number(s) })],
+  [/^stroke-dash-(.+)$/, ([, s]) => ({ "stroke-dasharray": utilities.handler.bracket.number(s) })],
+  [/^stroke-offset-(.+)$/, ([, s]) => ({ "stroke-dashoffset": utilities.handler.bracket.px.numberWithUnit(s) })],
   [/^stroke-(.+)$/, utilities.colorResolver("stroke", "stroke")],
   [/^stroke-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-stroke-opacity": utilities.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" }]
 ];
 

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 { toArray, CONTROL_SHORTCUT_NO_MERGE } from '@unocss/core';
 
 const verticalAlignAlias = {
   mid: "middle",
@@ -31,8 +30,14 @@ 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 = [
@@ -208,17 +213,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) })],
@@ -452,7 +455,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" }],
@@ -593,12 +597,10 @@ const margins = [
 ];
 
 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": "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))"
 };
 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": "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))"
 };
 const transformBase = {
   "--un-rotate": 0,
@@ -610,11 +612,29 @@ 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],
@@ -624,6 +644,10 @@ const transforms = [
   [/^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 +657,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,7 +669,10 @@ 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)"]
+      ]
     ];
   }
 }
@@ -651,7 +681,10 @@ function handleRotate([, b]) {
   if (v != null) {
     return [
       transformBase,
-      { "--un-rotate": v }
+      {
+        "--un-rotate": v,
+        "transform": "var(--un-transform)"
+      }
     ];
   }
 }
@@ -660,7 +693,10 @@ function handleSkew([, d, b]) {
   if (v != null) {
     return [
       transformBase,
-      { [`--un-skew-${d}`]: v }
+      {
+        [`--un-skew-${d}`]: v,
+        transform: "var(--un-transform)"
+      }
     ];
   }
 }
@@ -737,8 +773,18 @@ const svgUtilities = [
   [/^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-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" }]
 ];
 

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;

package/dist/chunks/default3.mjs

@@ -1,5 +1,5 @@
 import { v as variantMatcher, a as variantParentMatcher } from './variants.mjs';
-import { v as variantPseudoClasses, a as variantPseudoClassFunctions, b as variantTaggedPseudoClasses, c as variantPseudoElements, p as partClasses } from './pseudo.mjs';
+import { toArray, escapeRegExp } from '@unocss/core';
 
 const regexCache = {};
 const variantBreakpoints = (matcher, { theme }) => {
@@ -108,6 +108,156 @@ const variantOrientations = [
 
 const variantPrint = 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(toArray));
+const PseudoElements = Object.fromEntries([
+  "placeholder",
+  "before",
+  "after",
+  "first-letter",
+  "first-line",
+  "selection",
+  "marker",
+  ["file", "::file-selector-button"]
+].map(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(`^${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,
@@ -125,4 +275,4 @@ const variants = (options) => [
   ...variantLanguageDirections
 ];
 
-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 };
+export { CONTROL_BYPASS_PSEUDO_CLASS as C, 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, variantPseudoElements as j, variantPseudoClasses as k, variantPseudoClassFunctions as l, variantTaggedPseudoClasses as m, partClasses as p, variants as v };

package/dist/index.cjs

@@ -6,9 +6,8 @@ const _default = require('./chunks/default.cjs');
 const _default$1 = require('./chunks/default2.cjs');
 const _default$2 = require('./chunks/default3.cjs');
 const colors = require('./chunks/colors.cjs');
-require('./chunks/utilities.cjs');
+const utilities = require('./chunks/utilities.cjs');
 require('@unocss/core');
-require('./chunks/pseudo.cjs');
 require('./chunks/variants.cjs');
 
 const presetMini = (options = {}) => {
@@ -35,5 +34,6 @@ function VarPrefixPostprocessor(prefix) {
 
 exports.theme = _default.theme;
 exports.colors = colors.colors;
+exports.parseColor = utilities.parseColor;
 exports["default"] = presetMini;
 exports.presetMini = presetMini;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { T as Theme } from './types-a2d2b52f';
 export { T as Theme, a as ThemeAnimation } from './types-a2d2b52f';
 export { t as theme } from './default-958434b6';
 export { c as colors } from './colors-6d634692';
+export { p as parseColor } from './utilities-22a522e2';
 
 interface PresetMiniOptions extends PresetOptions {
     /**

package/dist/index.mjs

@@ -3,9 +3,8 @@ export { t as theme } from './chunks/default.mjs';
 import { r as rules } from './chunks/default2.mjs';
 import { v as variants } from './chunks/default3.mjs';
 export { c as colors } from './chunks/colors.mjs';
-import './chunks/utilities.mjs';
+export { p as parseColor } from './chunks/utilities.mjs';
 import '@unocss/core';
-import './chunks/pseudo.mjs';
 import './chunks/variants.mjs';
 
 const presetMini = (options = {}) => {

package/dist/rules.cjs

@@ -5,7 +5,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const _default = require('./chunks/default2.cjs');
 require('./chunks/utilities.cjs');
 require('@unocss/core');
-require('./chunks/pseudo.cjs');
 
 
 

package/dist/rules.mjs

@@ -1,4 +1,3 @@
 export { l as alignments, a as appearance, G as appearances, B as aspectRatio, e as bgColors, b as borders, y as boxShadows, s as boxSizing, N as breaks, M as contents, _ as cssVariables, H as cursors, F as displays, f as flex, q as floats, R as fontSmoothings, Q as fontStyles, V as fonts, g as gaps, h as grids, n as insets, j as justifies, D as margins, c as opacity, k as orders, o as outline, i as overflows, C as paddings, m as placements, I as pointerEvents, p as positions, u as questionMark, J as resizes, x as rings, r as rules, A as sizes, S as svgUtilities, W as tabSizes, t as textAligns, d as textColors, $ as textDecorations, X as textIndents, O as textOverflows, Z as textShadows, Y as textStrokes, P as textTransforms, T as transforms, U as transitions, K as userSelects, E as varEmpty, v as verticalAligns, L as whitespaces, w as willChange, z as zIndexes } from './chunks/default2.mjs';
 import './chunks/utilities.mjs';
 import '@unocss/core';
-import './chunks/pseudo.mjs';

package/dist/utilities-22a522e2.d.ts

@@ -0,0 +1,56 @@
+import { DynamicMatcher, ParsedColorValue } from '@unocss/core';
+import { T as Theme } from './types-a2d2b52f';
+
+declare function capitalize<T extends string>(str: T): Capitalize<T>;
+/**
+ * Provide {@link DynamicMatcher} function returning spacing definition. See spacing rules.
+ *
+ * @param {string} propertyPrefix - Property for the css value to be created. Postfix will be appended according to direction matched.
+ * @return {DynamicMatcher}  {@link DynamicMatcher}
+ * @see {@link directionMap}
+ */
+declare const directionSize: (propertyPrefix: string) => DynamicMatcher;
+/**
+ * Parse color string into rgba (if possible) with opacity. Color value will be matched to theme object before converting to rgb value.
+ *
+ * @example Parseable strings:
+ * 'red' // From theme, if 'red' is available
+ * 'red-100' // From theme, plus scale
+ * 'red-100/20' // From theme, plus scale/opacity
+ * '#f12' // Hex color
+ * 'hex-f12' // Alternative hex color
+ * '[rgb(100,2,3)]/[var(--op)]' // Bracket with rgb color and bracket with opacity
+ *
+ * @param {string} body - Color string to be parsed.
+ * @param {Theme} theme - {@link Theme} object.
+ * @return {ParsedColorValue|undefined}  {@link ParsedColorValue} object if string is parseable.
+ */
+declare const parseColor: (body: string, theme: Theme) => ParsedColorValue | undefined;
+/**
+ * Provide {@link DynamicMatcher} function to produce color value matched from rule.
+ *
+ * @see {@link parseColor}
+ *
+ * @example Resolving 'red' from theme:
+ * colorResolver('background-color', 'background')('', 'red')
+ * return { 'background-color': '#f12' }
+ *
+ * @example Resolving 'red-100' from theme:
+ * colorResolver('background-color', 'background')('', 'red-100')
+ * return { '--un-background-opacity': '1', 'background-color': 'rgba(254,226,226,var(--un-bg-opacity))' }
+ *
+ * @example Resolving 'red-100/20' from theme:
+ * colorResolver('background-color', 'background')('', 'red-100/20')
+ * return { 'background-color': 'rgba(204,251,241,0.22)' }
+ *
+ * @example Resolving 'hex-124':
+ * colorResolver('color', 'text')('', 'hex-124')
+ * return { '--un-text-opacity': '1', 'color': 'rgba(17,34,68,var(--un-text-opacity))' }
+ *
+ * @param {string} property - Property for the css value to be created.
+ * @param {string} varName - Base name for the opacity variable.
+ * @return {DynamicMatcher}  {@link DynamicMatcher} object.
+ */
+declare const colorResolver: (property: string, varName: string) => DynamicMatcher;
+
+export { colorResolver as a, capitalize as c, directionSize as d, parseColor as p };

package/dist/utils.d.ts

@@ -1,6 +1,7 @@
 import * as _unocss_core from '@unocss/core';
-import { VariantHandler, DynamicMatcher, ParsedColorValue } from '@unocss/core';
-import { T as Theme } from './types-a2d2b52f';
+import { VariantHandler } from '@unocss/core';
+export { c as capitalize, a as colorResolver, d as directionSize, p as parseColor } from './utilities-22a522e2';
+import './types-a2d2b52f';
 
 declare const directionMap: Record<string, string[]>;
 declare const cornerMap: Record<string, string[]>;
@@ -58,56 +59,4 @@ declare const h: _unocss_core.ValueHandler<"number" | "auto" | "numberWithUnit"
 declare const variantMatcher: (name: string, selector?: ((input: string) => string | undefined) | undefined) => (input: string) => VariantHandler | undefined;
 declare const variantParentMatcher: (name: string, parent: string) => (input: string) => VariantHandler | undefined;
 
-declare function capitalize<T extends string>(str: T): Capitalize<T>;
-/**
- * Provide {@link DynamicMatcher} function returning spacing definition. See spacing rules.
- *
- * @param {string} propertyPrefix - Property for the css value to be created. Postfix will be appended according to direction matched.
- * @return {DynamicMatcher}  {@link DynamicMatcher}
- * @see {@link directionMap}
- */
-declare const directionSize: (propertyPrefix: string) => DynamicMatcher;
-/**
- * Parse color string into rgba (if possible) with opacity opacity. Color value will be matched to theme object before converting to rgb value.
- *
- * @example Parseable strings:
- * 'red' // From theme, if 'red' is available
- * 'red-100' // From theme, plus scale
- * 'red-100/20' // From theme, plus scale/opacity
- * '#f12' // Hex color
- * 'hex-f12' // Alternative hex color
- * '[rgb(100,2,3)]/[var(--op)]' // Bracket with rgb color and bracket with opacity
- *
- * @param {string} body - Color string to be parsed.
- * @param {Theme} theme - {@link Theme} object.
- * @return {ParsedColorValue|undefined}  {@link ParsedColorValue} object if string is parseable.
- */
-declare const parseColor: (body: string, theme: Theme) => ParsedColorValue | undefined;
-/**
- * Provide {@link DynamicMatcher} function to produce color value matched from rule.
- *
- * @see {@link parseColor}
- *
- * @example Resolving 'red' from theme:
- * colorResolver('background-color', 'background')('', 'red')
- * return { 'background-color': '#f12' }
- *
- * @example Resolving 'red-100' from theme:
- * colorResolver('background-color', 'background')('', 'red-100')
- * return { '--un-background-opacity': '1', 'background-color': 'rgba(254,226,226,var(--un-bg-opacity))' }
- *
- * @example Resolving 'red-100/20' from theme:
- * colorResolver('background-color', 'background')('', 'red-100/20')
- * return { 'background-color': 'rgba(204,251,241,0.22)' }
- *
- * @example Resolving 'hex-124':
- * colorResolver('color', 'text')('', 'hex-124')
- * return { '--un-text-opacity': '1', 'color': 'rgba(17,34,68,var(--un-text-opacity))' }
- *
- * @param {string} property - Property for the css value to be created.
- * @param {string} varName - Base name for the opacity variable.
- * @return {DynamicMatcher}  {@link DynamicMatcher} object.
- */
-declare const colorResolver: (property: string, varName: string) => DynamicMatcher;
-
-export { capitalize, colorResolver, cornerMap, directionMap, directionSize, h, handler, parseColor, positionMap, handlers as valueHandlers, variantMatcher, variantParentMatcher, xyzMap };
+export { cornerMap, directionMap, h, handler, positionMap, handlers as valueHandlers, variantMatcher, variantParentMatcher, xyzMap };

package/dist/variants.cjs

@@ -3,12 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const _default = require('./chunks/default3.cjs');
-const pseudo = require('./chunks/pseudo.cjs');
 require('./chunks/variants.cjs');
 require('@unocss/core');
 
 
 
+exports.CONTROL_BYPASS_PSEUDO_CLASS = _default.CONTROL_BYPASS_PSEUDO_CLASS;
+exports.partClasses = _default.partClasses;
 exports.variantBreakpoints = _default.variantBreakpoints;
 exports.variantColorsMediaOrClass = _default.variantColorsMediaOrClass;
 exports.variantCombinators = _default.variantCombinators;
@@ -18,10 +19,8 @@ exports.variantMotions = _default.variantMotions;
 exports.variantNegative = _default.variantNegative;
 exports.variantOrientations = _default.variantOrientations;
 exports.variantPrint = _default.variantPrint;
+exports.variantPseudoClassFunctions = _default.variantPseudoClassFunctions;
+exports.variantPseudoClasses = _default.variantPseudoClasses;
+exports.variantPseudoElements = _default.variantPseudoElements;
+exports.variantTaggedPseudoClasses = _default.variantTaggedPseudoClasses;
 exports.variants = _default.variants;
-exports.CONTROL_BYPASS_PSEUDO_CLASS = pseudo.CONTROL_BYPASS_PSEUDO_CLASS;
-exports.partClasses = pseudo.partClasses;
-exports.variantPseudoClassFunctions = pseudo.variantPseudoClassFunctions;
-exports.variantPseudoClasses = pseudo.variantPseudoClasses;
-exports.variantPseudoElements = pseudo.variantPseudoElements;
-exports.variantTaggedPseudoClasses = pseudo.variantTaggedPseudoClasses;

package/dist/variants.d.ts

@@ -4,6 +4,7 @@ import { T as Theme } from './types-a2d2b52f';
 import { PresetMiniOptions } from './index';
 import './default-958434b6';
 import './colors-6d634692';
+import './utilities-22a522e2';
 
 declare const variantBreakpoints: Variant<Theme>;
 

package/dist/variants.mjs

@@ -1,4 +1,3 @@
-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';
+export { C as CONTROL_BYPASS_PSEUDO_CLASS, p as partClasses, 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, l as variantPseudoClassFunctions, k as variantPseudoClasses, j as variantPseudoElements, m as variantTaggedPseudoClasses, v as variants } from './chunks/default3.mjs';
 import './chunks/variants.mjs';
 import '@unocss/core';

package/package.json

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

package/dist/chunks/pseudo.cjs

@@ -1,160 +0,0 @@
-'use strict';
-
-const core = require('@unocss/core');
-
-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
-};
-
-exports.CONTROL_BYPASS_PSEUDO_CLASS = CONTROL_BYPASS_PSEUDO_CLASS;
-exports.partClasses = partClasses;
-exports.variantPseudoClassFunctions = variantPseudoClassFunctions;
-exports.variantPseudoClasses = variantPseudoClasses;
-exports.variantPseudoElements = variantPseudoElements;
-exports.variantTaggedPseudoClasses = variantTaggedPseudoClasses;

package/dist/chunks/pseudo.mjs

@@ -1,153 +0,0 @@
-import { toArray, escapeRegExp } from '@unocss/core';
-
-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(toArray));
-const PseudoElements = Object.fromEntries([
-  "placeholder",
-  "before",
-  "after",
-  "first-letter",
-  "first-line",
-  "selection",
-  "marker",
-  ["file", "::file-selector-button"]
-].map(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(`^${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
-};
-
-export { CONTROL_BYPASS_PSEUDO_CLASS as C, variantPseudoClassFunctions as a, variantTaggedPseudoClasses as b, variantPseudoElements as c, partClasses as p, variantPseudoClasses as v };