@unocss/preset-mini 0.20.4 → 0.22.0

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 }) => {
@@ -46,24 +46,18 @@ const variantCombinators = [
   variants$1.variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
-const variantColorsMediaOrClass = [
-  (v, { options: { dark } }) => {
-    if (dark === "class")
-      return variants$1.variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "class")
-      return variants$1.variantMatcher("light", (input) => `.light $$ ${input}`)(v);
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "media")
-      return variants$1.variantParentMatcher("dark", "@media (prefers-color-scheme: dark)")(v);
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "media")
-      return variants$1.variantParentMatcher("light", "@media (prefers-color-scheme: light)")(v);
+const variantColorsMediaOrClass = (options = {}) => {
+  if (options?.dark === "class") {
+    return [
+      variants$1.variantMatcher("dark", (input) => `.dark $$ ${input}`),
+      variants$1.variantMatcher("light", (input) => `.light $$ ${input}`)
+    ];
   }
-];
+  return [
+    variants$1.variantParentMatcher("dark", "@media (prefers-color-scheme: dark)"),
+    variants$1.variantParentMatcher("light", "@media (prefers-color-scheme: light)")
+  ];
+};
 
 const variantLanguageDirections = [
   variants$1.variantMatcher("rtl", (input) => `[dir="rtl"] $$ ${input}`),
@@ -116,7 +110,157 @@ const variantOrientations = [
 
 const variantPrint = variants$1.variantParentMatcher("print", "@media print");
 
-const variants = [
+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,
   variantPrint,
@@ -124,15 +268,17 @@ const variants = [
   ...variantMotions,
   variantBreakpoints,
   ...variantCombinators,
-  pseudo.variantPseudoClasses,
-  pseudo.variantPseudoClassFunctions,
-  pseudo.variantTaggedPseudoClasses,
-  pseudo.variantPseudoElements,
-  pseudo.partClasses,
-  ...variantColorsMediaOrClass,
+  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;
@@ -142,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 }) => {
@@ -44,24 +44,18 @@ const variantCombinators = [
   variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
-const variantColorsMediaOrClass = [
-  (v, { options: { dark } }) => {
-    if (dark === "class")
-      return variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "class")
-      return variantMatcher("light", (input) => `.light $$ ${input}`)(v);
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "media")
-      return variantParentMatcher("dark", "@media (prefers-color-scheme: dark)")(v);
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "media")
-      return variantParentMatcher("light", "@media (prefers-color-scheme: light)")(v);
+const variantColorsMediaOrClass = (options = {}) => {
+  if (options?.dark === "class") {
+    return [
+      variantMatcher("dark", (input) => `.dark $$ ${input}`),
+      variantMatcher("light", (input) => `.light $$ ${input}`)
+    ];
   }
-];
+  return [
+    variantParentMatcher("dark", "@media (prefers-color-scheme: dark)"),
+    variantParentMatcher("light", "@media (prefers-color-scheme: light)")
+  ];
+};
 
 const variantLanguageDirections = [
   variantMatcher("rtl", (input) => `[dir="rtl"] $$ ${input}`),
@@ -114,7 +108,157 @@ const variantOrientations = [
 
 const variantPrint = variantParentMatcher("print", "@media print");
 
-const variants = [
+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,
   variantPrint,
@@ -124,11 +268,11 @@ const variants = [
   ...variantCombinators,
   variantPseudoClasses,
   variantPseudoClassFunctions,
-  variantTaggedPseudoClasses,
+  ...variantTaggedPseudoClasses(options),
   variantPseudoElements,
   partClasses,
-  ...variantColorsMediaOrClass,
+  ...variantColorsMediaOrClass(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/chunks/utilities.cjs

@@ -61,7 +61,7 @@ const basePositionMap = [
 ];
 const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
 
-const cssBasicProps = [
+const cssProps = [
   "color",
   "border-color",
   "background-color",
@@ -78,17 +78,13 @@ const cssBasicProps = [
   "zoom",
   "text-shadow",
   "transform",
-  "box-shadow"
-];
-const cssPositionProps = [
+  "box-shadow",
   "backround-position",
   "left",
   "right",
   "top",
   "bottom",
-  "object-position"
-];
-const cssSizeProps = [
+  "object-position",
   "max-height",
   "min-height",
   "max-width",
@@ -106,14 +102,16 @@ const cssSizeProps = [
   "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
+  "word-spacing",
+  "stroke",
+  "filter",
+  "backdrop-filter",
+  "fill",
+  "mask",
+  "mask-size",
+  "mask-border",
+  "clip-path",
+  "clip"
 ];
 const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
 const numberRE = /^(-?[0-9.]+)$/i;
@@ -198,6 +196,15 @@ function time(str) {
   if (!Number.isNaN(num))
     return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
 }
+function degree(str) {
+  const match = str.match(/^(-?[0-9.]+)(deg)?$/i);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num)}deg`;
+}
 function global(str) {
   if (["inherit", "initial", "revert", "unset"].includes(str))
     return str;
@@ -222,6 +229,7 @@ const valueHandlers = {
   bracket: bracket,
   cssvar: cssvar,
   time: time,
+  degree: degree,
   global: global,
   properties: properties
 };

package/dist/chunks/utilities.mjs

@@ -59,7 +59,7 @@ const basePositionMap = [
 ];
 const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
 
-const cssBasicProps = [
+const cssProps = [
   "color",
   "border-color",
   "background-color",
@@ -76,17 +76,13 @@ const cssBasicProps = [
   "zoom",
   "text-shadow",
   "transform",
-  "box-shadow"
-];
-const cssPositionProps = [
+  "box-shadow",
   "backround-position",
   "left",
   "right",
   "top",
   "bottom",
-  "object-position"
-];
-const cssSizeProps = [
+  "object-position",
   "max-height",
   "min-height",
   "max-width",
@@ -104,14 +100,16 @@ const cssSizeProps = [
   "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
+  "word-spacing",
+  "stroke",
+  "filter",
+  "backdrop-filter",
+  "fill",
+  "mask",
+  "mask-size",
+  "mask-border",
+  "clip-path",
+  "clip"
 ];
 const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
 const numberRE = /^(-?[0-9.]+)$/i;
@@ -196,6 +194,15 @@ function time(str) {
   if (!Number.isNaN(num))
     return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
 }
+function degree(str) {
+  const match = str.match(/^(-?[0-9.]+)(deg)?$/i);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num)}deg`;
+}
 function global(str) {
   if (["inherit", "initial", "revert", "unset"].includes(str))
     return str;
@@ -220,6 +227,7 @@ const valueHandlers = {
   bracket: bracket,
   cssvar: cssvar,
   time: time,
+  degree: degree,
   global: global,
   properties: properties
 };

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 = {}) => {
@@ -18,7 +17,7 @@ const presetMini = (options = {}) => {
     name: "@unocss/preset-mini",
     theme: _default.theme,
     rules: _default$1.rules,
-    variants: _default$2.variants,
+    variants: _default$2.variants(options),
     options,
     postprocess: options.variablePrefix && options.variablePrefix !== "un-" ? VarPrefixPostprocessor(options.variablePrefix) : void 0
   };
@@ -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 = {}) => {
@@ -15,7 +14,7 @@ const presetMini = (options = {}) => {
     name: "@unocss/preset-mini",
     theme,
     rules,
-    variants,
+    variants: variants(options),
     options,
     postprocess: options.variablePrefix && options.variablePrefix !== "un-" ? VarPrefixPostprocessor(options.variablePrefix) : void 0
   };

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';