@unocss/preset-mini 0.16.1 → 0.17.2

package/dist/chunks/default3.cjs

@@ -8,20 +8,22 @@ const variantBreakpoints = (matcher, _, theme) => {
   const variantEntries = Object.entries(theme.breakpoints || {}).map(([point, size], idx) => [point, size, idx]);
   for (const [point, size, idx] of variantEntries) {
     if (!regexCache[point])
-      regexCache[point] = new RegExp(`^((?:[a|l]t-)?${point}[:-])`);
+      regexCache[point] = new RegExp(`^((?:[al]t-)?${point}[:-])`);
     const match = matcher.match(regexCache[point]);
     if (!match)
       continue;
     const [, pre] = match;
+    const m = matcher.slice(pre.length);
+    if (m === "container")
+      continue;
     let direction = "min";
-    let order = parseInt(size);
+    let order = 1e3;
     if (pre.startsWith("lt-")) {
       direction = "max";
-      order = -order;
+      order -= idx + 1;
+    } else {
+      order += idx + 1;
     }
-    const m = matcher.slice(pre.length);
-    if (m === "container")
-      continue;
     if (pre.startsWith("at-") && idx < variantEntries.length - 1) {
       return {
         matcher: m,
@@ -35,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 = [
@@ -113,15 +118,16 @@ const variants = [
   variantNegative,
   variantImportant,
   variantBreakpoints,
-  ...variantChildren,
+  ...variantCombinators,
   pseudo.variantPseudoClasses,
-  pseudo.variantPseudoElements
+  pseudo.variantPseudoElements,
+  pseudo.partClasses
 ];
 
 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,25 +1,27 @@
 import { v as variantMatcher } from './variants.mjs';
-import { v as variantPseudoClasses, a as variantPseudoElements } from './pseudo.mjs';
+import { v as variantPseudoClasses, a as variantPseudoElements, p as partClasses } from './pseudo.mjs';
 
 const regexCache = {};
 const variantBreakpoints = (matcher, _, theme) => {
   const variantEntries = Object.entries(theme.breakpoints || {}).map(([point, size], idx) => [point, size, idx]);
   for (const [point, size, idx] of variantEntries) {
     if (!regexCache[point])
-      regexCache[point] = new RegExp(`^((?:[a|l]t-)?${point}[:-])`);
+      regexCache[point] = new RegExp(`^((?:[al]t-)?${point}[:-])`);
     const match = matcher.match(regexCache[point]);
     if (!match)
       continue;
     const [, pre] = match;
+    const m = matcher.slice(pre.length);
+    if (m === "container")
+      continue;
     let direction = "min";
-    let order = parseInt(size);
+    let order = 1e3;
     if (pre.startsWith("lt-")) {
       direction = "max";
-      order = -order;
+      order -= idx + 1;
+    } else {
+      order += idx + 1;
     }
-    const m = matcher.slice(pre.length);
-    if (m === "container")
-      continue;
     if (pre.startsWith("at-") && idx < variantEntries.length - 1) {
       return {
         matcher: m,
@@ -33,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 = [
@@ -111,9 +116,10 @@ const variants = [
   variantNegative,
   variantImportant,
   variantBreakpoints,
-  ...variantChildren,
+  ...variantCombinators,
   variantPseudoClasses,
-  variantPseudoElements
+  variantPseudoElements,
+  partClasses
 ];
 
-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 { variantColorsMedia as a, variantColorsClass as b, variantBreakpoints as c, variantCombinators as d, variantImportant as e, variantNegative as f, variantSpace as g, variants as v };

package/dist/chunks/pseudo.cjs

@@ -2,40 +2,42 @@
 
 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 = [
   "before",
@@ -44,23 +46,24 @@ const PseudoElements = [
   "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})[:-]`);
+const PseudoClassesGroupRE = new RegExp(`^group-((not-)?(${PseudoClassesStr}))[:-]`);
+const PseudoClassesPeerRE = new RegExp(`^peer-((not-)?(${PseudoClassesStr}))[:-]`);
 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;
+  return !entires.find((i) => i[0] === CONTROL_BYPASS_PSEUDO_CLASS) || void 0;
 }
 const variantPseudoClasses = {
   match: (input) => {
@@ -82,7 +85,9 @@ const variantPseudoClasses = {
     }
     match = input.match(PseudoClassesGroupRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      let pseudo = PseudoClasses[match[3]] || match[3];
+      if (match[2])
+        pseudo = `not(:${pseudo})`;
       return {
         matcher: input.slice(match[1].length + 7),
         selector: (s, body) => shouldAdd(body) && s.includes(".group:") ? s.replace(/\.group:/, `.group:${pseudo}:`) : `.group:${pseudo} ${s}`
@@ -90,17 +95,35 @@ const variantPseudoClasses = {
     }
     match = input.match(PseudoClassesPeerRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      let pseudo = PseudoClasses[match[3]] || match[3];
+      if (match[2])
+        pseudo = `not(:${pseudo})`;
       return {
         matcher: input.slice(match[1].length + 6),
-        selector: (s, body) => shouldAdd(body) && s.includes(".peer:") ? s.replace(/\.peer:/, `.peer:${pseudo}:`) : `.peer:${pseudo} ~ ${s}`
+        selector: (s, body) => shouldAdd(body) && s.includes(".peer:") ? s.replace(/\.peer:/, `.peer:${pseudo}:`) : `.peer:${pseudo}~${s}`
+      };
+    }
+  },
+  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 = CONTROL_BYPASS_PSEUDO;
+exports.CONTROL_BYPASS_PSEUDO_CLASS = CONTROL_BYPASS_PSEUDO_CLASS;
 exports.PseudoClasses = PseudoClasses;
+exports.partClasses = partClasses;
 exports.variantPseudoClasses = variantPseudoClasses;
 exports.variantPseudoElements = variantPseudoElements;

package/dist/chunks/pseudo.mjs

@@ -1,39 +1,41 @@
 import { toArray } 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 = [
   "before",
@@ -42,23 +44,24 @@ const PseudoElements = [
   "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})[:-]`);
+const PseudoClassesGroupRE = new RegExp(`^group-((not-)?(${PseudoClassesStr}))[:-]`);
+const PseudoClassesPeerRE = new RegExp(`^peer-((not-)?(${PseudoClassesStr}))[:-]`);
 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;
+  return !entires.find((i) => i[0] === CONTROL_BYPASS_PSEUDO_CLASS) || void 0;
 }
 const variantPseudoClasses = {
   match: (input) => {
@@ -80,7 +83,9 @@ const variantPseudoClasses = {
     }
     match = input.match(PseudoClassesGroupRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      let pseudo = PseudoClasses[match[3]] || match[3];
+      if (match[2])
+        pseudo = `not(:${pseudo})`;
       return {
         matcher: input.slice(match[1].length + 7),
         selector: (s, body) => shouldAdd(body) && s.includes(".group:") ? s.replace(/\.group:/, `.group:${pseudo}:`) : `.group:${pseudo} ${s}`
@@ -88,14 +93,31 @@ const variantPseudoClasses = {
     }
     match = input.match(PseudoClassesPeerRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      let pseudo = PseudoClasses[match[3]] || match[3];
+      if (match[2])
+        pseudo = `not(:${pseudo})`;
       return {
         matcher: input.slice(match[1].length + 6),
-        selector: (s, body) => shouldAdd(body) && s.includes(".peer:") ? s.replace(/\.peer:/, `.peer:${pseudo}:`) : `.peer:${pseudo} ~ ${s}`
+        selector: (s, body) => shouldAdd(body) && s.includes(".peer:") ? s.replace(/\.peer:/, `.peer:${pseudo}:`) : `.peer:${pseudo}~${s}`
+      };
+    }
+  },
+  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 as C, PseudoClasses as P, variantPseudoElements as a, variantPseudoClasses as v };
+export { CONTROL_BYPASS_PSEUDO_CLASS as C, PseudoClasses as P, variantPseudoElements as a, partClasses as p, variantPseudoClasses as v };