@unocss/preset-mini 0.20.0 → 0.21.0

package/dist/chunks/default3.cjs

@@ -46,43 +46,22 @@ const variantCombinators = [
   variants$1.variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
-const variantColorsMediaOrClass = [
-  (v, { options: { dark } }) => {
-    if (dark === "class") {
-      const match = variants$1.variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
-      if (match)
-        return match;
-    }
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "class") {
-      const match = variants$1.variantMatcher("light", (input) => `.light $$ ${input}`)(v);
-      if (match)
-        return match;
-    }
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "media") {
-      const match = variants$1.variantMatcher("dark")(v);
-      if (match) {
-        return {
-          ...match,
-          parent: "@media (prefers-color-scheme: dark)"
-        };
-      }
-    }
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "media") {
-      const match = variants$1.variantMatcher("light")(v);
-      if (match) {
-        return {
-          ...match,
-          parent: "@media (prefers-color-scheme: light)"
-        };
-      }
-    }
+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}`),
+  variants$1.variantMatcher("ltr", (input) => `[dir="ltr"] $$ ${input}`)
 ];
 
 const variantImportant = {
@@ -118,47 +97,43 @@ const variantNegative = {
     }
   }
 };
-const variantSpace = (matcher) => {
-  if (/^space-?([xy])-?(-?.+)$/.test(matcher) || /^divide-/.test(matcher)) {
-    return {
-      matcher,
-      selector: (input) => {
-        return `${input}>:not([hidden])~:not([hidden])`;
-      }
-    };
-  }
-};
 
-const variantPrint = (v) => {
-  const print = variants$1.variantMatcher("print")(v);
-  if (print) {
-    return {
-      ...print,
-      parent: "@media print"
-    };
-  }
-};
+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 variants = [
-  variantSpace,
+const variants = (options) => [
   variantNegative,
   variantImportant,
   variantPrint,
+  ...variantOrientations,
+  ...variantMotions,
   variantBreakpoints,
   ...variantCombinators,
   pseudo.variantPseudoClasses,
   pseudo.variantPseudoClassFunctions,
-  pseudo.variantTaggedPseudoClasses,
+  ...pseudo.variantTaggedPseudoClasses(options),
   pseudo.variantPseudoElements,
   pseudo.partClasses,
-  ...variantColorsMediaOrClass
+  ...variantColorsMediaOrClass(options),
+  ...variantLanguageDirections
 ];
 
 exports.variantBreakpoints = variantBreakpoints;
 exports.variantColorsMediaOrClass = variantColorsMediaOrClass;
 exports.variantCombinators = variantCombinators;
 exports.variantImportant = variantImportant;
+exports.variantLanguageDirections = variantLanguageDirections;
+exports.variantMotions = variantMotions;
 exports.variantNegative = variantNegative;
+exports.variantOrientations = variantOrientations;
 exports.variantPrint = variantPrint;
-exports.variantSpace = variantSpace;
 exports.variants = variants;

package/dist/chunks/default3.mjs

@@ -1,4 +1,4 @@
-import { v as variantMatcher } from './variants.mjs';
+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';
 
 const regexCache = {};
@@ -44,43 +44,22 @@ const variantCombinators = [
   variantMatcher("svg", (input) => `${input} svg *`)
 ];
 
-const variantColorsMediaOrClass = [
-  (v, { options: { dark } }) => {
-    if (dark === "class") {
-      const match = variantMatcher("dark", (input) => `.dark $$ ${input}`)(v);
-      if (match)
-        return match;
-    }
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "class") {
-      const match = variantMatcher("light", (input) => `.light $$ ${input}`)(v);
-      if (match)
-        return match;
-    }
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "media") {
-      const match = variantMatcher("dark")(v);
-      if (match) {
-        return {
-          ...match,
-          parent: "@media (prefers-color-scheme: dark)"
-        };
-      }
-    }
-  },
-  (v, { options: { dark } }) => {
-    if (dark === "media") {
-      const match = variantMatcher("light")(v);
-      if (match) {
-        return {
-          ...match,
-          parent: "@media (prefers-color-scheme: light)"
-        };
-      }
-    }
+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}`),
+  variantMatcher("ltr", (input) => `[dir="ltr"] $$ ${input}`)
 ];
 
 const variantImportant = {
@@ -116,40 +95,34 @@ const variantNegative = {
     }
   }
 };
-const variantSpace = (matcher) => {
-  if (/^space-?([xy])-?(-?.+)$/.test(matcher) || /^divide-/.test(matcher)) {
-    return {
-      matcher,
-      selector: (input) => {
-        return `${input}>:not([hidden])~:not([hidden])`;
-      }
-    };
-  }
-};
 
-const variantPrint = (v) => {
-  const print = variantMatcher("print")(v);
-  if (print) {
-    return {
-      ...print,
-      parent: "@media print"
-    };
-  }
-};
+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 variants = [
-  variantSpace,
+const variants = (options) => [
   variantNegative,
   variantImportant,
   variantPrint,
+  ...variantOrientations,
+  ...variantMotions,
   variantBreakpoints,
   ...variantCombinators,
   variantPseudoClasses,
   variantPseudoClassFunctions,
-  variantTaggedPseudoClasses,
+  ...variantTaggedPseudoClasses(options),
   variantPseudoElements,
   partClasses,
-  ...variantColorsMediaOrClass
+  ...variantColorsMediaOrClass(options),
+  ...variantLanguageDirections
 ];
 
-export { variantBreakpoints as a, variantCombinators as b, variantColorsMediaOrClass as c, variantImportant as d, variantNegative as e, variantSpace as f, variantPrint as g, variants as v };
+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 };

package/dist/chunks/pseudo.cjs

@@ -8,6 +8,7 @@ const PseudoClasses = Object.fromEntries([
   "link",
   "visited",
   "target",
+  ["open", "[open]"],
   "hover",
   "active",
   "focus-visible",
@@ -24,39 +25,44 @@ const PseudoClasses = Object.fromEntries([
   "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)"],
+  ["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"],
+  ["first", ":first-child"],
   "last-of-type",
-  ["last", "last-child"],
+  ["last", ":last-child"],
   "only-child",
   "only-of-type"
 ].map(core.toArray));
-const PseudoElements = [
+const PseudoElements = Object.fromEntries([
   "placeholder",
   "before",
   "after",
   "first-letter",
   "first-line",
-  "selection"
-];
+  "selection",
+  "marker",
+  ["file", "::file-selector-button"]
+].map(core.toArray));
 const PseudoClassFunctions = [
   "not",
   "is",
   "where",
   "has"
 ];
-const PartClassesRE = /(part-\[(.+)]:)(.+)/;
-const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
+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) {
@@ -68,13 +74,13 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
   return (input) => {
     const match = input.match(re);
     if (match) {
-      let pseudo = PseudoClasses[match[3]] || match[3];
+      let pseudo = PseudoClasses[match[3]] || `:${match[3]}`;
       if (match[2])
-        pseudo = `${match[2]}(:${pseudo})`;
+        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}`;
+          return shouldAdd(body) && rawRe.test(s) ? s.replace(rawRe, `${parent}${pseudo}:`) : `${parent}${pseudo}${combinator}${s}`;
         }
       };
     }
@@ -83,9 +89,10 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
 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}::${match[1]}`
+      selector: (s) => `${s}${pseudo}`
     };
   }
 };
@@ -93,10 +100,10 @@ const variantPseudoClasses = {
   match: (input) => {
     const match = input.match(PseudoClassesRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
       return {
         matcher: input.slice(match[1].length + 1),
-        selector: (s, body) => shouldAdd(body) && `${s}:${pseudo}`
+        selector: (s, body) => shouldAdd(body) && `${s}${pseudo}`
       };
     }
   },
@@ -107,25 +114,27 @@ const variantPseudoClassFunctions = {
     const match = input.match(PseudoClassFunctionsRE);
     if (match) {
       const fn = match[1];
-      const pseudo = PseudoClasses[match[2]] || match[2];
+      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})`
+        selector: (s, body) => shouldAdd(body) && `${s}:${fn}(${pseudo})`
       };
     }
   },
   multiPass: true
 };
-const variantTaggedPseudoClasses = {
-  match: (input, { options: { attributifyPseudo } }) => {
-    const g = taggedPseudoClassMatcher("group", attributifyPseudo ? '[group=""]' : ".group", " ")(input);
-    if (g)
-      return g;
-    const p = taggedPseudoClassMatcher("peer", attributifyPseudo ? '[peer=""]' : ".peer", "~")(input);
-    if (p)
-      return p;
-  },
-  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) => {

package/dist/chunks/pseudo.mjs

@@ -6,6 +6,7 @@ const PseudoClasses = Object.fromEntries([
   "link",
   "visited",
   "target",
+  ["open", "[open]"],
   "hover",
   "active",
   "focus-visible",
@@ -22,39 +23,44 @@ const PseudoClasses = Object.fromEntries([
   "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)"],
+  ["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"],
+  ["first", ":first-child"],
   "last-of-type",
-  ["last", "last-child"],
+  ["last", ":last-child"],
   "only-child",
   "only-of-type"
 ].map(toArray));
-const PseudoElements = [
+const PseudoElements = Object.fromEntries([
   "placeholder",
   "before",
   "after",
   "first-letter",
   "first-line",
-  "selection"
-];
+  "selection",
+  "marker",
+  ["file", "::file-selector-button"]
+].map(toArray));
 const PseudoClassFunctions = [
   "not",
   "is",
   "where",
   "has"
 ];
-const PartClassesRE = /(part-\[(.+)]:)(.+)/;
-const PseudoElementsRE = new RegExp(`^(${PseudoElements.join("|")})[:-]`);
+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) {
@@ -66,13 +72,13 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
   return (input) => {
     const match = input.match(re);
     if (match) {
-      let pseudo = PseudoClasses[match[3]] || match[3];
+      let pseudo = PseudoClasses[match[3]] || `:${match[3]}`;
       if (match[2])
-        pseudo = `${match[2]}(:${pseudo})`;
+        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}`;
+          return shouldAdd(body) && rawRe.test(s) ? s.replace(rawRe, `${parent}${pseudo}:`) : `${parent}${pseudo}${combinator}${s}`;
         }
       };
     }
@@ -81,9 +87,10 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
 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}::${match[1]}`
+      selector: (s) => `${s}${pseudo}`
     };
   }
 };
@@ -91,10 +98,10 @@ const variantPseudoClasses = {
   match: (input) => {
     const match = input.match(PseudoClassesRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || match[1];
+      const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
       return {
         matcher: input.slice(match[1].length + 1),
-        selector: (s, body) => shouldAdd(body) && `${s}:${pseudo}`
+        selector: (s, body) => shouldAdd(body) && `${s}${pseudo}`
       };
     }
   },
@@ -105,25 +112,27 @@ const variantPseudoClassFunctions = {
     const match = input.match(PseudoClassFunctionsRE);
     if (match) {
       const fn = match[1];
-      const pseudo = PseudoClasses[match[2]] || match[2];
+      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})`
+        selector: (s, body) => shouldAdd(body) && `${s}:${fn}(${pseudo})`
       };
     }
   },
   multiPass: true
 };
-const variantTaggedPseudoClasses = {
-  match: (input, { options: { attributifyPseudo } }) => {
-    const g = taggedPseudoClassMatcher("group", attributifyPseudo ? '[group=""]' : ".group", " ")(input);
-    if (g)
-      return g;
-    const p = taggedPseudoClassMatcher("peer", attributifyPseudo ? '[peer=""]' : ".peer", "~")(input);
-    if (p)
-      return p;
-  },
-  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) => {