@unocss/preset-mini 0.16.3 → 0.18.0

package/dist/chunks/default3.cjs

@@ -37,10 +37,13 @@ const variantBreakpoints = (matcher, _, theme) => {
   }
 };
 
-const variantChildren = [
-  variants$1.variantMatcher("children", (input) => `${input} > *`),
+const variantCombinators = [
   variants$1.variantMatcher("all", (input) => `${input} *`),
-  variants$1.variantMatcher("next", (input) => `${input}+*`)
+  variants$1.variantMatcher("children", (input) => `${input}>*`),
+  variants$1.variantMatcher("next", (input) => `${input}+*`),
+  variants$1.variantMatcher("sibling", (input) => `${input}+*`),
+  variants$1.variantMatcher("siblings", (input) => `${input}~*`),
+  variants$1.variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
 const variantColorsClass = [
@@ -110,20 +113,23 @@ const variantSpace = (matcher) => {
   }
 };
 
-const variants = [
+const variants = (options) => [
   variantSpace,
   variantNegative,
   variantImportant,
   variantBreakpoints,
-  ...variantChildren,
+  ...variantCombinators,
   pseudo.variantPseudoClasses,
-  pseudo.variantPseudoElements
+  pseudo.variantTaggedPseudoClasses(options),
+  pseudo.variantPseudoElements,
+  pseudo.partClasses,
+  ...options.dark === "media" ? variantColorsMedia : variantColorsClass
 ];
 
 exports.variantBreakpoints = variantBreakpoints;
-exports.variantChildren = variantChildren;
 exports.variantColorsClass = variantColorsClass;
 exports.variantColorsMedia = variantColorsMedia;
+exports.variantCombinators = variantCombinators;
 exports.variantImportant = variantImportant;
 exports.variantNegative = variantNegative;
 exports.variantSpace = variantSpace;

package/dist/chunks/default3.mjs

@@ -1,5 +1,5 @@
 import { v as variantMatcher } from './variants.mjs';
-import { v as variantPseudoClasses, a as variantPseudoElements } from './pseudo.mjs';
+import { v as variantPseudoClasses, a as variantTaggedPseudoClasses, b as variantPseudoElements, p as partClasses } from './pseudo.mjs';
 
 const regexCache = {};
 const variantBreakpoints = (matcher, _, theme) => {
@@ -35,10 +35,13 @@ const variantBreakpoints = (matcher, _, theme) => {
   }
 };
 
-const variantChildren = [
-  variantMatcher("children", (input) => `${input} > *`),
+const variantCombinators = [
   variantMatcher("all", (input) => `${input} *`),
-  variantMatcher("next", (input) => `${input}+*`)
+  variantMatcher("children", (input) => `${input}>*`),
+  variantMatcher("next", (input) => `${input}+*`),
+  variantMatcher("sibling", (input) => `${input}+*`),
+  variantMatcher("siblings", (input) => `${input}~*`),
+  variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
 const variantColorsClass = [
@@ -108,14 +111,17 @@ const variantSpace = (matcher) => {
   }
 };
 
-const variants = [
+const variants = (options) => [
   variantSpace,
   variantNegative,
   variantImportant,
   variantBreakpoints,
-  ...variantChildren,
+  ...variantCombinators,
   variantPseudoClasses,
-  variantPseudoElements
+  variantTaggedPseudoClasses(options),
+  variantPseudoElements,
+  partClasses,
+  ...options.dark === "media" ? variantColorsMedia : variantColorsClass
 ];
 
-export { variantColorsMedia as a, variantColorsClass as b, variantBreakpoints as c, variantChildren as d, variantImportant as e, variantNegative as f, variantSpace as g, variants as v };
+export { variantBreakpoints as a, variantCombinators as b, variantColorsClass as c, variantColorsMedia as d, variantImportant as e, variantNegative as f, variantSpace as g, variants as v };

package/dist/chunks/pseudo.cjs

@@ -2,66 +2,86 @@
 
 const core = require('@unocss/core');
 
-const CONTROL_BYPASS_PSEUDO = "$$no-pseudo";
+const CONTROL_BYPASS_PSEUDO_CLASS = "$$no-pseudo";
 const PseudoClasses = Object.fromEntries([
+  "any-link",
+  "link",
+  "visited",
+  "target",
+  "hover",
   "active",
-  "checked",
-  "default",
-  "empty",
-  "enabled",
-  "disabled",
-  "first-of-type",
-  ["first", "first-child"],
   "focus-visible",
   "focus-within",
   "focus",
-  "hover",
-  "indeterminate",
-  "invalid",
-  "last-of-type",
-  ["last", "last-child"],
-  "link",
-  "only-child",
-  "only-of-type",
-  "optional",
-  "placeholder-shown",
+  "autofill",
+  "enabled",
+  "disabled",
   "read-only",
   "read-write",
+  "placeholder-shown",
+  "default",
+  "checked",
+  "indeterminate",
+  "valid",
+  "invalid",
   "required",
+  "optional",
   "root",
-  "target",
-  "valid",
-  "visited",
+  "empty",
   ["even-of-type", "nth-of-type(even)"],
   ["even", "nth-child(even)"],
   ["odd-of-type", "nth-of-type(odd)"],
-  ["odd", "nth-child(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 = [
+  "placeholder",
   "before",
   "after",
   "first-letter",
   "first-line",
   "selection"
 ];
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
 const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
 const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
 const PseudoClassesRE = new RegExp(`^(${PseudoClassesStr})[:-]`);
 const PseudoClassesNotRE = new RegExp(`^not-(${PseudoClassesStr})[:-]`);
-const PseudoClassesGroupRE = new RegExp(`^group-(${PseudoClassesStr})[:-]`);
-const PseudoClassesPeerRE = new RegExp(`^peer-(${PseudoClassesStr})[:-]`);
+function shouldAdd(entires) {
+  return !entires.find((i) => i[0] === CONTROL_BYPASS_PSEUDO_CLASS) || void 0;
+}
+function taggedPseudoClassMatcher(tag, parent, combinator) {
+  const re = new RegExp(`^${tag}-((not-)?(${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 = `not(:${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) {
     return {
       matcher: input.slice(match[1].length + 1),
-      selector: (s, body) => shouldAdd(body) && `${s}::${match[1]}`
+      selector: (s) => `${s}::${match[1]}`
     };
   }
 };
-function shouldAdd(entires) {
-  return !entires.find((i) => i[0] === CONTROL_BYPASS_PSEUDO) || void 0;
-}
 const variantPseudoClasses = {
   match: (input) => {
     let match = input.match(PseudoClassesRE);
@@ -80,27 +100,40 @@ const variantPseudoClasses = {
         selector: (s, body) => shouldAdd(body) && `${s}:not(:${pseudo})`
       };
     }
-    match = input.match(PseudoClassesGroupRE);
-    if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
-      return {
-        matcher: input.slice(match[1].length + 7),
-        selector: (s, body) => shouldAdd(body) && s.includes(".group:") ? s.replace(/\.group:/, `.group:${pseudo}:`) : `.group:${pseudo} ${s}`
-      };
-    }
-    match = input.match(PseudoClassesPeerRE);
+  },
+  multiPass: true
+};
+const variantTaggedPseudoClasses = (options = {}) => ({
+  match: (input) => {
+    const attributify = !!options?.attributifyPseudo;
+    const g = taggedPseudoClassMatcher("group", attributify ? '[group=""]' : ".group", " ")(input);
+    if (g)
+      return g;
+    const p = taggedPseudoClassMatcher("peer", attributify ? '[peer=""]' : ".peer", "~")(input);
+    if (p)
+      return p;
+  },
+  multiPass: true
+});
+const partClasses = {
+  match: (input) => {
+    const match = input.match(PartClassesRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      const part = `part(${match[2]})`;
       return {
-        matcher: input.slice(match[1].length + 6),
-        selector: (s, body) => shouldAdd(body) && s.includes(".peer:") ? s.replace(/\.peer:/, `.peer:${pseudo}:`) : `.peer:${pseudo} ~ ${s}`
+        matcher: input.slice(match[1].length),
+        selector: (s, body) => {
+          return shouldAdd(body) && `${s}::${part}`;
+        }
       };
     }
   },
   multiPass: true
 };
 
-exports.CONTROL_BYPASS_PSEUDO = CONTROL_BYPASS_PSEUDO;
+exports.CONTROL_BYPASS_PSEUDO_CLASS = CONTROL_BYPASS_PSEUDO_CLASS;
 exports.PseudoClasses = PseudoClasses;
+exports.partClasses = partClasses;
 exports.variantPseudoClasses = variantPseudoClasses;
 exports.variantPseudoElements = variantPseudoElements;
+exports.variantTaggedPseudoClasses = variantTaggedPseudoClasses;

package/dist/chunks/pseudo.mjs

@@ -1,65 +1,85 @@
-import { toArray } from '@unocss/core';
+import { toArray, escapeRegExp } from '@unocss/core';
 
-const CONTROL_BYPASS_PSEUDO = "$$no-pseudo";
+const CONTROL_BYPASS_PSEUDO_CLASS = "$$no-pseudo";
 const PseudoClasses = Object.fromEntries([
+  "any-link",
+  "link",
+  "visited",
+  "target",
+  "hover",
   "active",
-  "checked",
-  "default",
-  "empty",
-  "enabled",
-  "disabled",
-  "first-of-type",
-  ["first", "first-child"],
   "focus-visible",
   "focus-within",
   "focus",
-  "hover",
-  "indeterminate",
-  "invalid",
-  "last-of-type",
-  ["last", "last-child"],
-  "link",
-  "only-child",
-  "only-of-type",
-  "optional",
-  "placeholder-shown",
+  "autofill",
+  "enabled",
+  "disabled",
   "read-only",
   "read-write",
+  "placeholder-shown",
+  "default",
+  "checked",
+  "indeterminate",
+  "valid",
+  "invalid",
   "required",
+  "optional",
   "root",
-  "target",
-  "valid",
-  "visited",
+  "empty",
   ["even-of-type", "nth-of-type(even)"],
   ["even", "nth-child(even)"],
   ["odd-of-type", "nth-of-type(odd)"],
-  ["odd", "nth-child(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 = [
+  "placeholder",
   "before",
   "after",
   "first-letter",
   "first-line",
   "selection"
 ];
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
 const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
 const PseudoClassesStr = Object.keys(PseudoClasses).join("|");
 const PseudoClassesRE = new RegExp(`^(${PseudoClassesStr})[:-]`);
 const PseudoClassesNotRE = new RegExp(`^not-(${PseudoClassesStr})[:-]`);
-const PseudoClassesGroupRE = new RegExp(`^group-(${PseudoClassesStr})[:-]`);
-const PseudoClassesPeerRE = new RegExp(`^peer-(${PseudoClassesStr})[:-]`);
+function shouldAdd(entires) {
+  return !entires.find((i) => i[0] === CONTROL_BYPASS_PSEUDO_CLASS) || void 0;
+}
+function taggedPseudoClassMatcher(tag, parent, combinator) {
+  const re = new RegExp(`^${tag}-((not-)?(${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 = `not(:${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) {
     return {
       matcher: input.slice(match[1].length + 1),
-      selector: (s, body) => shouldAdd(body) && `${s}::${match[1]}`
+      selector: (s) => `${s}::${match[1]}`
     };
   }
 };
-function shouldAdd(entires) {
-  return !entires.find((i) => i[0] === CONTROL_BYPASS_PSEUDO) || void 0;
-}
 const variantPseudoClasses = {
   match: (input) => {
     let match = input.match(PseudoClassesRE);
@@ -78,24 +98,35 @@ const variantPseudoClasses = {
         selector: (s, body) => shouldAdd(body) && `${s}:not(:${pseudo})`
       };
     }
-    match = input.match(PseudoClassesGroupRE);
-    if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
-      return {
-        matcher: input.slice(match[1].length + 7),
-        selector: (s, body) => shouldAdd(body) && s.includes(".group:") ? s.replace(/\.group:/, `.group:${pseudo}:`) : `.group:${pseudo} ${s}`
-      };
-    }
-    match = input.match(PseudoClassesPeerRE);
+  },
+  multiPass: true
+};
+const variantTaggedPseudoClasses = (options = {}) => ({
+  match: (input) => {
+    const attributify = !!options?.attributifyPseudo;
+    const g = taggedPseudoClassMatcher("group", attributify ? '[group=""]' : ".group", " ")(input);
+    if (g)
+      return g;
+    const p = taggedPseudoClassMatcher("peer", attributify ? '[peer=""]' : ".peer", "~")(input);
+    if (p)
+      return p;
+  },
+  multiPass: true
+});
+const partClasses = {
+  match: (input) => {
+    const match = input.match(PartClassesRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      const part = `part(${match[2]})`;
       return {
-        matcher: input.slice(match[1].length + 6),
-        selector: (s, body) => shouldAdd(body) && s.includes(".peer:") ? s.replace(/\.peer:/, `.peer:${pseudo}:`) : `.peer:${pseudo} ~ ${s}`
+        matcher: input.slice(match[1].length),
+        selector: (s, body) => {
+          return shouldAdd(body) && `${s}::${part}`;
+        }
       };
     }
   },
   multiPass: true
 };
 
-export { CONTROL_BYPASS_PSEUDO as C, PseudoClasses as P, variantPseudoElements as a, variantPseudoClasses as v };
+export { CONTROL_BYPASS_PSEUDO_CLASS as C, PseudoClasses as P, variantTaggedPseudoClasses as a, variantPseudoElements as b, partClasses as p, variantPseudoClasses as v };