@unocss/preset-mini 0.31.16 → 0.32.1

package/dist/chunks/default2.cjs

@@ -540,7 +540,10 @@ const whitespaces = [
   [/^(?:whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)$/, ([, v]) => ({ "white-space": v }), { autocomplete: "(whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)" }]
 ];
 const contents = [
-  [/^content-\[(.+)\]$/, ([, v]) => ({ content: `"${v}"` })],
+  [/^content-(.+)$/, ([, v]) => {
+    const c = utilities.handler.bracket.cssvar(v);
+    return { content: c == null ? `"${v}"` : c };
+  }],
   ["content-empty", { content: '""' }],
   ["content-none", { content: '""' }]
 ];

package/dist/chunks/default2.mjs

@@ -538,7 +538,10 @@ const whitespaces = [
   [/^(?:whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)$/, ([, v]) => ({ "white-space": v }), { autocomplete: "(whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)" }]
 ];
 const contents = [
-  [/^content-\[(.+)\]$/, ([, v]) => ({ content: `"${v}"` })],
+  [/^content-(.+)$/, ([, v]) => {
+    const c = handler.bracket.cssvar(v);
+    return { content: c == null ? `"${v}"` : c };
+  }],
   ["content-empty", { content: '""' }],
   ["content-none", { content: '""' }]
 ];

package/dist/chunks/default3.cjs

@@ -155,25 +155,34 @@ const variantImportant = {
   },
   autocomplete: "(important)"
 };
+const numberRE = /[0-9.]+(?:[a-z]+|%)?/;
 const variantNegative = {
   match(matcher) {
-    if (matcher.startsWith("-")) {
-      return {
-        matcher: matcher.slice(1),
-        body: (body) => {
-          body.forEach((v) => {
-            if (v[0].startsWith("--un-scale") || v[1]?.toString() === "0")
-              return;
-            v[1] = v[1]?.toString().replace(/[0-9.]+(?:[a-z]+|%)?/, (i) => `-${i}`);
-          });
+    if (!matcher.startsWith("-") || !matcher.match(/\d|-px|-full/))
+      return;
+    return {
+      matcher: matcher.slice(1),
+      body: (body) => {
+        let changed = false;
+        body.forEach((v) => {
+          const value = v[1]?.toString();
+          if (!value || v[0].startsWith("--un-scale") || value === "0")
+            return;
+          if (numberRE.test(value)) {
+            v[1] = value.replace(numberRE, (i) => `-${i}`);
+            changed = true;
+          }
+        });
+        if (changed)
           return body;
-        }
-      };
-    }
+      }
+    };
   }
 };
 
 const PseudoClasses = Object.fromEntries([
+  ["first-letter", "::first"],
+  ["first-line", "::first"],
   "any-link",
   "link",
   "visited",
@@ -210,31 +219,22 @@ const PseudoClasses = Object.fromEntries([
   "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",
+  "only-of-type",
+  ["placeholder", "::placeholder"],
+  ["before", "::before"],
+  ["after", "::after"],
+  ["selection", "::selection"],
+  ["marker", "::marker"],
   ["file", "::file-selector-button"]
-].map(core.toArray));
+].map((key) => typeof key === "string" ? [key, `:${key}`] : key));
 const PseudoClassFunctions = [
   "not",
   "is",
   "where",
   "has"
 ];
-const PseudoElementsStr = Object.keys(PseudoElements).join("|");
-const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
+const PseudoClassesStr = Object.entries(PseudoClasses).filter(([, pseudo]) => !pseudo.startsWith("::")).map(([key]) => key).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 sortValue = (pseudo) => {
   if (pseudo === "active")
     return 1;
@@ -256,22 +256,11 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
     }
   };
 };
-const variantPseudoElements = {
+const PseudoClassesAndElementsStr = Object.entries(PseudoClasses).map(([key]) => key).join("|");
+const PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})[:-]`);
+const variantPseudoClassesAndElements = {
   match: (input) => {
-    const match = input.match(PseudoElementsRE);
-    if (match) {
-      const pseudo = PseudoElements[match[1]] || `::${match[1]}`;
-      return {
-        matcher: input.slice(match[0].length),
-        selector: (s) => `${s}${pseudo}`
-      };
-    }
-  },
-  autocomplete: `(${PseudoElementsStr}):`
-};
-const variantPseudoClasses = {
-  match: (input) => {
-    const match = input.match(PseudoClassesRE);
+    const match = input.match(PseudoClassesAndElementsRE);
     if (match) {
       const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
       return {
@@ -282,8 +271,9 @@ const variantPseudoClasses = {
     }
   },
   multiPass: true,
-  autocomplete: `(${PseudoClassesStr}):`
+  autocomplete: `(${PseudoClassesAndElementsStr}):`
 };
+const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
 const variantPseudoClassFunctions = {
   match: (input) => {
     const match = input.match(PseudoClassFunctionsRE);
@@ -320,6 +310,7 @@ const variantTaggedPseudoClasses = (options = {}) => {
     }
   ];
 };
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
 const partClasses = {
   match: (input) => {
     const match = input.match(PartClassesRE);
@@ -343,10 +334,9 @@ const variants = (options) => [
   variantCustomMedia,
   variantBreakpoints,
   ...variantCombinators,
-  variantPseudoClasses,
+  variantPseudoClassesAndElements,
   variantPseudoClassFunctions,
   ...variantTaggedPseudoClasses(options),
-  variantPseudoElements,
   partClasses,
   ...variantColorsMediaOrClass(options),
   ...variantLanguageDirections,
@@ -364,8 +354,7 @@ exports.variantLayer = variantLayer;
 exports.variantNegative = variantNegative;
 exports.variantPrint = variantPrint;
 exports.variantPseudoClassFunctions = variantPseudoClassFunctions;
-exports.variantPseudoClasses = variantPseudoClasses;
-exports.variantPseudoElements = variantPseudoElements;
+exports.variantPseudoClassesAndElements = variantPseudoClassesAndElements;
 exports.variantScope = variantScope;
 exports.variantSelector = variantSelector;
 exports.variantTaggedPseudoClasses = variantTaggedPseudoClasses;

package/dist/chunks/default3.mjs

@@ -1,6 +1,6 @@
 import { g as resolveBreakpoints } from './utilities.mjs';
 import { v as variantParentMatcher, a as variantMatcher } from './variants.mjs';
-import { toArray, escapeRegExp } from '@unocss/core';
+import { escapeRegExp } from '@unocss/core';
 
 const regexCache = {};
 const calcMaxWidthBySize = (size) => {
@@ -153,25 +153,34 @@ const variantImportant = {
   },
   autocomplete: "(important)"
 };
+const numberRE = /[0-9.]+(?:[a-z]+|%)?/;
 const variantNegative = {
   match(matcher) {
-    if (matcher.startsWith("-")) {
-      return {
-        matcher: matcher.slice(1),
-        body: (body) => {
-          body.forEach((v) => {
-            if (v[0].startsWith("--un-scale") || v[1]?.toString() === "0")
-              return;
-            v[1] = v[1]?.toString().replace(/[0-9.]+(?:[a-z]+|%)?/, (i) => `-${i}`);
-          });
+    if (!matcher.startsWith("-") || !matcher.match(/\d|-px|-full/))
+      return;
+    return {
+      matcher: matcher.slice(1),
+      body: (body) => {
+        let changed = false;
+        body.forEach((v) => {
+          const value = v[1]?.toString();
+          if (!value || v[0].startsWith("--un-scale") || value === "0")
+            return;
+          if (numberRE.test(value)) {
+            v[1] = value.replace(numberRE, (i) => `-${i}`);
+            changed = true;
+          }
+        });
+        if (changed)
           return body;
-        }
-      };
-    }
+      }
+    };
   }
 };
 
 const PseudoClasses = Object.fromEntries([
+  ["first-letter", "::first"],
+  ["first-line", "::first"],
   "any-link",
   "link",
   "visited",
@@ -208,31 +217,22 @@ const PseudoClasses = Object.fromEntries([
   "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",
+  "only-of-type",
+  ["placeholder", "::placeholder"],
+  ["before", "::before"],
+  ["after", "::after"],
+  ["selection", "::selection"],
+  ["marker", "::marker"],
   ["file", "::file-selector-button"]
-].map(toArray));
+].map((key) => typeof key === "string" ? [key, `:${key}`] : key));
 const PseudoClassFunctions = [
   "not",
   "is",
   "where",
   "has"
 ];
-const PseudoElementsStr = Object.keys(PseudoElements).join("|");
-const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
+const PseudoClassesStr = Object.entries(PseudoClasses).filter(([, pseudo]) => !pseudo.startsWith("::")).map(([key]) => key).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 sortValue = (pseudo) => {
   if (pseudo === "active")
     return 1;
@@ -254,22 +254,11 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
     }
   };
 };
-const variantPseudoElements = {
+const PseudoClassesAndElementsStr = Object.entries(PseudoClasses).map(([key]) => key).join("|");
+const PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})[:-]`);
+const variantPseudoClassesAndElements = {
   match: (input) => {
-    const match = input.match(PseudoElementsRE);
-    if (match) {
-      const pseudo = PseudoElements[match[1]] || `::${match[1]}`;
-      return {
-        matcher: input.slice(match[0].length),
-        selector: (s) => `${s}${pseudo}`
-      };
-    }
-  },
-  autocomplete: `(${PseudoElementsStr}):`
-};
-const variantPseudoClasses = {
-  match: (input) => {
-    const match = input.match(PseudoClassesRE);
+    const match = input.match(PseudoClassesAndElementsRE);
     if (match) {
       const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
       return {
@@ -280,8 +269,9 @@ const variantPseudoClasses = {
     }
   },
   multiPass: true,
-  autocomplete: `(${PseudoClassesStr}):`
+  autocomplete: `(${PseudoClassesAndElementsStr}):`
 };
+const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
 const variantPseudoClassFunctions = {
   match: (input) => {
     const match = input.match(PseudoClassFunctionsRE);
@@ -318,6 +308,7 @@ const variantTaggedPseudoClasses = (options = {}) => {
     }
   ];
 };
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
 const partClasses = {
   match: (input) => {
     const match = input.match(PartClassesRE);
@@ -341,14 +332,13 @@ const variants = (options) => [
   variantCustomMedia,
   variantBreakpoints,
   ...variantCombinators,
-  variantPseudoClasses,
+  variantPseudoClassesAndElements,
   variantPseudoClassFunctions,
   ...variantTaggedPseudoClasses(options),
-  variantPseudoElements,
   partClasses,
   ...variantColorsMediaOrClass(options),
   ...variantLanguageDirections,
   variantScope
 ];
 
-export { variantBreakpoints as a, variantCombinators as b, variantPrint as c, variantCustomMedia as d, variantColorsMediaOrClass as e, variantLanguageDirections as f, variantSelector as g, variantLayer as h, variantScope as i, variantImportant as j, variantNegative as k, variantPseudoElements as l, variantPseudoClasses as m, variantPseudoClassFunctions as n, variantTaggedPseudoClasses as o, partClasses as p, variants as v };
+export { variantBreakpoints as a, variantCombinators as b, variantPrint as c, variantCustomMedia as d, variantColorsMediaOrClass as e, variantLanguageDirections as f, variantSelector as g, variantLayer as h, variantScope as i, variantImportant as j, variantNegative as k, variantPseudoClassesAndElements as l, variantPseudoClassFunctions as m, variantTaggedPseudoClasses as n, partClasses as p, variants as v };

package/dist/variants.cjs

@@ -20,8 +20,7 @@ exports.variantLayer = _default.variantLayer;
 exports.variantNegative = _default.variantNegative;
 exports.variantPrint = _default.variantPrint;
 exports.variantPseudoClassFunctions = _default.variantPseudoClassFunctions;
-exports.variantPseudoClasses = _default.variantPseudoClasses;
-exports.variantPseudoElements = _default.variantPseudoElements;
+exports.variantPseudoClassesAndElements = _default.variantPseudoClassesAndElements;
 exports.variantScope = _default.variantScope;
 exports.variantSelector = _default.variantSelector;
 exports.variantTaggedPseudoClasses = _default.variantTaggedPseudoClasses;

package/dist/variants.d.ts

@@ -24,10 +24,9 @@ declare const variantScope: Variant;
 declare const variantImportant: Variant;
 declare const variantNegative: Variant;
 
-declare const variantPseudoElements: VariantObject;
-declare const variantPseudoClasses: VariantObject;
+declare const variantPseudoClassesAndElements: VariantObject;
 declare const variantPseudoClassFunctions: VariantObject;
 declare const variantTaggedPseudoClasses: (options?: PresetMiniOptions) => VariantObject[];
 declare const partClasses: VariantObject;
 
-export { partClasses, variantBreakpoints, variantColorsMediaOrClass, variantCombinators, variantCustomMedia, variantImportant, variantLanguageDirections, variantLayer, variantNegative, variantPrint, variantPseudoClassFunctions, variantPseudoClasses, variantPseudoElements, variantScope, variantSelector, variantTaggedPseudoClasses, variants };
+export { partClasses, variantBreakpoints, variantColorsMediaOrClass, variantCombinators, variantCustomMedia, variantImportant, variantLanguageDirections, variantLayer, variantNegative, variantPrint, variantPseudoClassFunctions, variantPseudoClassesAndElements, variantScope, variantSelector, variantTaggedPseudoClasses, variants };

package/dist/variants.mjs

@@ -1,4 +1,4 @@
-export { p as partClasses, a as variantBreakpoints, e as variantColorsMediaOrClass, b as variantCombinators, d as variantCustomMedia, j as variantImportant, f as variantLanguageDirections, h as variantLayer, k as variantNegative, c as variantPrint, n as variantPseudoClassFunctions, m as variantPseudoClasses, l as variantPseudoElements, i as variantScope, g as variantSelector, o as variantTaggedPseudoClasses, v as variants } from './chunks/default3.mjs';
+export { p as partClasses, a as variantBreakpoints, e as variantColorsMediaOrClass, b as variantCombinators, d as variantCustomMedia, j as variantImportant, f as variantLanguageDirections, h as variantLayer, k as variantNegative, c as variantPrint, m as variantPseudoClassFunctions, l as variantPseudoClassesAndElements, i as variantScope, g as variantSelector, n as variantTaggedPseudoClasses, v as variants } from './chunks/default3.mjs';
 import './chunks/utilities.mjs';
 import '@unocss/core';
 import './chunks/variants.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unocss/preset-mini",
-  "version": "0.31.16",
+  "version": "0.32.1",
   "description": "The minimal preset for UnoCSS",
   "keywords": [
     "unocss",
@@ -61,7 +61,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@unocss/core": "0.31.16"
+    "@unocss/core": "0.32.1"
   },
   "scripts": {
     "build": "unbuild",