@unocss/preset-mini 0.21.2 → 0.22.3

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,6 +46,16 @@ const variantCombinators = [
   variants$1.variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
+const variantMotions = [
+  variants$1.variantParentMatcher("motion-reduce", "@media (prefers-reduced-motion: reduce)"),
+  variants$1.variantParentMatcher("motion-safe", "@media (prefers-reduced-motion: no-preference)")
+];
+const variantOrientations = [
+  variants$1.variantParentMatcher("landscape", "@media (orientation: landscape)"),
+  variants$1.variantParentMatcher("portrait", "@media (orientation: portrait)")
+];
+const variantPrint = variants$1.variantParentMatcher("print", "@media print");
+
 const variantColorsMediaOrClass = (options = {}) => {
   if (options?.dark === "class") {
     return [
@@ -98,17 +108,147 @@ const variantNegative = {
   }
 };
 
-const variantMotions = [
-  variants$1.variantParentMatcher("motion-reduce", "@media (prefers-reduced-motion: reduce)"),
-  variants$1.variantParentMatcher("motion-safe", "@media (prefers-reduced-motion: no-preference)")
-];
-
-const variantOrientations = [
-  variants$1.variantParentMatcher("landscape", "@media (orientation: landscape)"),
-  variants$1.variantParentMatcher("portrait", "@media (orientation: portrait)")
+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 variantPrint = variants$1.variantParentMatcher("print", "@media print");
+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})[:-]`);
+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) => 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) => `${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) => `${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) => `${s}::${part}`
+      };
+    }
+  },
+  multiPass: true
+};
 
 const variants = (options) => [
   variantNegative,
@@ -118,15 +258,16 @@ 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.partClasses = partClasses;
 exports.variantBreakpoints = variantBreakpoints;
 exports.variantColorsMediaOrClass = variantColorsMediaOrClass;
 exports.variantCombinators = variantCombinators;
@@ -136,4 +277,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,6 +44,16 @@ const variantCombinators = [
   variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
+const variantMotions = [
+  variantParentMatcher("motion-reduce", "@media (prefers-reduced-motion: reduce)"),
+  variantParentMatcher("motion-safe", "@media (prefers-reduced-motion: no-preference)")
+];
+const variantOrientations = [
+  variantParentMatcher("landscape", "@media (orientation: landscape)"),
+  variantParentMatcher("portrait", "@media (orientation: portrait)")
+];
+const variantPrint = variantParentMatcher("print", "@media print");
+
 const variantColorsMediaOrClass = (options = {}) => {
   if (options?.dark === "class") {
     return [
@@ -96,17 +106,147 @@ const variantNegative = {
   }
 };
 
-const variantMotions = [
-  variantParentMatcher("motion-reduce", "@media (prefers-reduced-motion: reduce)"),
-  variantParentMatcher("motion-safe", "@media (prefers-reduced-motion: no-preference)")
-];
-
-const variantOrientations = [
-  variantParentMatcher("landscape", "@media (orientation: landscape)"),
-  variantParentMatcher("portrait", "@media (orientation: portrait)")
+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 variantPrint = variantParentMatcher("print", "@media print");
+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})[:-]`);
+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) => 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) => `${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) => `${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) => `${s}::${part}`
+      };
+    }
+  },
+  multiPass: true
+};
 
 const variants = (options) => [
   variantNegative,
@@ -125,4 +265,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 { variantBreakpoints as a, variantCombinators as b, variantMotions as c, variantOrientations as d, variantPrint as e, variantColorsMediaOrClass as f, variantLanguageDirections as g, variantImportant as h, variantNegative 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

@@ -12,13 +12,29 @@ const directionMap = {
   "x": ["-left", "-right"],
   "y": ["-top", "-bottom"],
   "": [""],
-  "a": [""]
+  "bs": ["-block-start"],
+  "be": ["-block-end"],
+  "is": ["-inline-start"],
+  "ie": ["-inline-end"],
+  "block": ["-block-start", "-block-end"],
+  "inline": ["-inline-start", "-inline-end"]
+};
+const insetMap = {
+  ...directionMap,
+  s: ["-inset-inline-start"],
+  e: ["-inset-inline-end"],
+  bs: ["-inset-block-start"],
+  be: ["-inset-block-end"],
+  is: ["-inset-inline-start"],
+  ie: ["-inset-inline-end"],
+  block: ["-inset-block-start", "-inset-block-end"],
+  inline: ["-inset-inline-start", "-inset-inline-end"]
 };
 const cornerMap = {
-  "t": ["-top-left", "-top-right"],
+  "l": ["-top-left", "-bottom-left"],
   "r": ["-top-right", "-bottom-right"],
+  "t": ["-top-left", "-top-right"],
   "b": ["-bottom-left", "-bottom-right"],
-  "l": ["-bottom-left", "-top-left"],
   "tl": ["-top-left"],
   "lt": ["-top-left"],
   "tr": ["-top-right"],
@@ -27,7 +43,19 @@ const cornerMap = {
   "lb": ["-bottom-left"],
   "br": ["-bottom-right"],
   "rb": ["-bottom-right"],
-  "": [""]
+  "": [""],
+  "bs": ["-start-start", "-start-end"],
+  "be": ["-end-start", "-end-end"],
+  "is": ["-end-start", "-start-start"],
+  "ie": ["-start-end", "-end-end"],
+  "bs-is": ["-start-start"],
+  "is-bs": ["-start-start"],
+  "bs-ie": ["-start-end"],
+  "ie-bs": ["-start-end"],
+  "be-is": ["-end-start"],
+  "is-be": ["-end-start"],
+  "be-ie": ["-end-end"],
+  "ie-be": ["-end-end"]
 };
 const xyzMap = {
   "x": ["-x"],
@@ -178,7 +206,7 @@ function fraction(str) {
 }
 function bracket(str) {
   if (str && str[0] === "[" && str[str.length - 1] === "]") {
-    return str.slice(1, -1).replace(/_/g, " ").replace(/calc\((.*)/g, (v) => {
+    return str.slice(1, -1).replace(/(url\(.*?\))/g, (v) => v.replace(/_/g, "\\_")).replace(/(?<!\\)_/g, " ").replace(/calc\((.*)/g, (v) => {
       return v.replace(/(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ");
     });
   }
@@ -197,7 +225,7 @@ function time(str) {
     return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
 }
 function degree(str) {
-  const match = str.match(/^(-?[0-9.]+)(deg)?$/i);
+  const match = str.match(/^(-?[0-9.]+)(deg|rad|grad|turn)?$/i);
   if (!match)
     return;
   const [, n, unit] = match;
@@ -237,11 +265,8 @@ const valueHandlers = {
 const handler = core.createValueHandler(valueHandlers);
 const h = handler;
 
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
 const directionSize = (propertyPrefix) => ([_, direction, size]) => {
-  const v = handler.bracket.auto.rem.fraction.cssvar(size);
+  const v = handler.bracket.cssvar.auto.fraction.rem(size);
   if (v !== void 0)
     return directionMap[direction].map((i) => [`${propertyPrefix}${i}`, v]);
 };
@@ -325,13 +350,13 @@ const colorResolver = (property, varName) => ([, body], { theme }) => {
   }
 };
 
-exports.capitalize = capitalize;
 exports.colorResolver = colorResolver;
 exports.cornerMap = cornerMap;
 exports.directionMap = directionMap;
 exports.directionSize = directionSize;
 exports.h = h;
 exports.handler = handler;
+exports.insetMap = insetMap;
 exports.parseColor = parseColor;
 exports.positionMap = positionMap;
 exports.valueHandlers = valueHandlers;

package/dist/chunks/utilities.mjs

@@ -10,13 +10,29 @@ const directionMap = {
   "x": ["-left", "-right"],
   "y": ["-top", "-bottom"],
   "": [""],
-  "a": [""]
+  "bs": ["-block-start"],
+  "be": ["-block-end"],
+  "is": ["-inline-start"],
+  "ie": ["-inline-end"],
+  "block": ["-block-start", "-block-end"],
+  "inline": ["-inline-start", "-inline-end"]
+};
+const insetMap = {
+  ...directionMap,
+  s: ["-inset-inline-start"],
+  e: ["-inset-inline-end"],
+  bs: ["-inset-block-start"],
+  be: ["-inset-block-end"],
+  is: ["-inset-inline-start"],
+  ie: ["-inset-inline-end"],
+  block: ["-inset-block-start", "-inset-block-end"],
+  inline: ["-inset-inline-start", "-inset-inline-end"]
 };
 const cornerMap = {
-  "t": ["-top-left", "-top-right"],
+  "l": ["-top-left", "-bottom-left"],
   "r": ["-top-right", "-bottom-right"],
+  "t": ["-top-left", "-top-right"],
   "b": ["-bottom-left", "-bottom-right"],
-  "l": ["-bottom-left", "-top-left"],
   "tl": ["-top-left"],
   "lt": ["-top-left"],
   "tr": ["-top-right"],
@@ -25,7 +41,19 @@ const cornerMap = {
   "lb": ["-bottom-left"],
   "br": ["-bottom-right"],
   "rb": ["-bottom-right"],
-  "": [""]
+  "": [""],
+  "bs": ["-start-start", "-start-end"],
+  "be": ["-end-start", "-end-end"],
+  "is": ["-end-start", "-start-start"],
+  "ie": ["-start-end", "-end-end"],
+  "bs-is": ["-start-start"],
+  "is-bs": ["-start-start"],
+  "bs-ie": ["-start-end"],
+  "ie-bs": ["-start-end"],
+  "be-is": ["-end-start"],
+  "is-be": ["-end-start"],
+  "be-ie": ["-end-end"],
+  "ie-be": ["-end-end"]
 };
 const xyzMap = {
   "x": ["-x"],
@@ -176,7 +204,7 @@ function fraction(str) {
 }
 function bracket(str) {
   if (str && str[0] === "[" && str[str.length - 1] === "]") {
-    return str.slice(1, -1).replace(/_/g, " ").replace(/calc\((.*)/g, (v) => {
+    return str.slice(1, -1).replace(/(url\(.*?\))/g, (v) => v.replace(/_/g, "\\_")).replace(/(?<!\\)_/g, " ").replace(/calc\((.*)/g, (v) => {
       return v.replace(/(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ");
     });
   }
@@ -195,7 +223,7 @@ function time(str) {
     return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
 }
 function degree(str) {
-  const match = str.match(/^(-?[0-9.]+)(deg)?$/i);
+  const match = str.match(/^(-?[0-9.]+)(deg|rad|grad|turn)?$/i);
   if (!match)
     return;
   const [, n, unit] = match;
@@ -235,11 +263,8 @@ const valueHandlers = {
 const handler = createValueHandler(valueHandlers);
 const h = handler;
 
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
 const directionSize = (propertyPrefix) => ([_, direction, size]) => {
-  const v = handler.bracket.auto.rem.fraction.cssvar(size);
+  const v = handler.bracket.cssvar.auto.fraction.rem(size);
   if (v !== void 0)
     return directionMap[direction].map((i) => [`${propertyPrefix}${i}`, v]);
 };
@@ -323,4 +348,4 @@ const colorResolver = (property, varName) => ([, body], { theme }) => {
   }
 };
 
-export { cornerMap as a, capitalize as b, colorResolver as c, directionMap as d, directionSize as e, positionMap as f, h as g, handler as h, parseColor as p, valueHandlers as v, xyzMap as x };
+export { cornerMap as a, directionSize as b, colorResolver as c, directionMap as d, positionMap as e, h as f, handler as h, insetMap as i, parseColor as p, valueHandlers as v, xyzMap as x };

package/dist/{colors-6d634692.d.ts → colors-338f482c.d.ts}

@@ -1,4 +1,4 @@
-import { T as Theme } from './types-a2d2b52f';
+import { T as Theme } from './types-c14b808b';
 
 declare const colors: Theme['colors'];
 

package/dist/colors.d.ts

@@ -1,2 +1,2 @@
-export { c as colors } from './colors-6d634692';
-import './types-a2d2b52f';
+export { c as colors } from './colors-338f482c';
+import './types-c14b808b';

package/dist/{default-958434b6.d.ts → default-17948303.d.ts}

@@ -1,4 +1,4 @@
-import { T as Theme } from './types-a2d2b52f';
+import { T as Theme } from './types-c14b808b';
 
 declare const theme: Theme;
 

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

@@ -1,8 +1,9 @@
 import { PresetOptions, Preset } from '@unocss/core';
-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';
+import { T as Theme } from './types-c14b808b';
+export { T as Theme, a as ThemeAnimation } from './types-c14b808b';
+export { t as theme } from './default-17948303';
+export { c as colors } from './colors-338f482c';
+export { p as parseColor } from './utilities-29b01158';
 
 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');
 
 
 
@@ -18,7 +17,9 @@ exports.borders = _default.borders;
 exports.boxShadows = _default.boxShadows;
 exports.boxSizing = _default.boxSizing;
 exports.breaks = _default.breaks;
+exports.colorableShadows = _default.colorableShadows;
 exports.contents = _default.contents;
+exports.cssProperty = _default.cssProperty;
 exports.cssVariables = _default.cssVariables;
 exports.cursors = _default.cursors;
 exports.displays = _default.displays;
@@ -44,6 +45,7 @@ exports.questionMark = _default.questionMark;
 exports.resizes = _default.resizes;
 exports.rings = _default.rings;
 exports.rules = _default.rules;
+exports.shadowBase = _default.shadowBase;
 exports.sizes = _default.sizes;
 exports.svgUtilities = _default.svgUtilities;
 exports.tabSizes = _default.tabSizes;