@unocss/preset-mini 0.16.2 → 0.17.3

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 = [
@@ -115,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,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 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 = [
@@ -113,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,65 +2,69 @@
 
 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})[:-]`);
+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 +86,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 +96,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,64 +1,68 @@
 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 = [
+  "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})[:-]`);
+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 +84,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 +94,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 };

package/dist/chunks/utilities.cjs

@@ -0,0 +1,294 @@
+'use strict';
+
+const core = require('@unocss/core');
+
+const directionMap = {
+  "l": ["-left"],
+  "r": ["-right"],
+  "t": ["-top"],
+  "b": ["-bottom"],
+  "s": ["-inline-start"],
+  "e": ["-inline-end"],
+  "x": ["-left", "-right"],
+  "y": ["-top", "-bottom"],
+  "": [""],
+  "a": [""]
+};
+const cornerMap = {
+  "t": ["-top-left", "-top-right"],
+  "r": ["-top-right", "-bottom-right"],
+  "b": ["-bottom-left", "-bottom-right"],
+  "l": ["-bottom-left", "-top-left"],
+  "tl": ["-top-left"],
+  "lt": ["-top-left"],
+  "tr": ["-top-right"],
+  "rt": ["-top-right"],
+  "bl": ["-bottom-left"],
+  "lb": ["-bottom-left"],
+  "br": ["-bottom-right"],
+  "rb": ["-bottom-right"],
+  "": [""]
+};
+const xyzMap = {
+  "x": ["-x"],
+  "y": ["-y"],
+  "z": ["-z"],
+  "": ["-x", "-y"]
+};
+
+const cssBasicProps = [
+  "color",
+  "border-color",
+  "background-color",
+  "flex-grow",
+  "flex",
+  "flex-shrink",
+  "caret-color",
+  "font",
+  "gap",
+  "opacity",
+  "visibility",
+  "z-index",
+  "font-weight",
+  "zoom",
+  "text-shadow",
+  "transform",
+  "box-shadow"
+];
+const cssPositionProps = [
+  "backround-position",
+  "left",
+  "right",
+  "top",
+  "bottom",
+  "object-position"
+];
+const cssSizeProps = [
+  "max-height",
+  "min-height",
+  "max-width",
+  "min-width",
+  "height",
+  "width",
+  "border-width",
+  "margin",
+  "padding",
+  "outline-width",
+  "outline-offset",
+  "font-size",
+  "line-height",
+  "text-indent",
+  "vertical-align",
+  "border-spacing",
+  "letter-spacing",
+  "word-spacing"
+];
+const cssEnhanceProps = ["stroke", "filter", "backdrop-filter", "fill", "mask", "mask-size", "mask-border", "clip-path", "clip"];
+const cssProps = [
+  ...cssBasicProps,
+  ...cssPositionProps,
+  ...cssSizeProps,
+  ...cssEnhanceProps
+];
+const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
+const numberRE = /^(-?[0-9.]+)$/i;
+const unitOnlyRE = /^(px)$/i;
+function numberWithUnit(str) {
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, , unit] = match;
+  if (unit)
+    return str;
+}
+function auto(str) {
+  if (str === "auto" || str === "a")
+    return "auto";
+}
+function rem(str) {
+  if (str.match(unitOnlyRE))
+    return `1${str}`;
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  if (unit)
+    return str;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return `${num / 4}rem`;
+}
+function px(str) {
+  if (str.match(unitOnlyRE))
+    return `1${str}`;
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  if (unit)
+    return str;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return `${num}px`;
+}
+function number(str) {
+  if (!numberRE.test(str))
+    return;
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return num;
+}
+function percent(str) {
+  if (str.endsWith("%"))
+    str = str.slice(0, -1);
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return `${num / 100}`;
+}
+function fraction(str) {
+  if (str === "full")
+    return "100%";
+  const [left, right] = str.split("/");
+  const num = parseFloat(left) / parseFloat(right);
+  if (!Number.isNaN(num))
+    return `${num * 100}%`;
+}
+function bracket(str) {
+  if (str && str[0] === "[" && str[str.length - 1] === "]") {
+    return str.slice(1, -1).replace(/_/g, " ").replace(/calc\((.*)/g, (v) => {
+      return v.replace(/(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ");
+    });
+  }
+}
+function cssvar(str) {
+  if (str.startsWith("$"))
+    return `var(--${str.slice(1)})`;
+}
+function time(str) {
+  const duration = Number(str.replace(/(s|ms)$/, ""));
+  if (isNaN(duration))
+    return;
+  if (/(s|ms)$/.test(str))
+    return str;
+  return `${str}ms`;
+}
+function global(str) {
+  if (["inherit", "initial", "revert", "unset"].includes(str))
+    return str;
+}
+function properties(str) {
+  if (str === void 0)
+    return;
+  for (const prop of str.split(",")) {
+    if (!cssProps.includes(prop))
+      return;
+  }
+  return str;
+}
+
+const valueHandlers = {
+  __proto__: null,
+  numberWithUnit: numberWithUnit,
+  auto: auto,
+  rem: rem,
+  px: px,
+  number: number,
+  percent: percent,
+  fraction: fraction,
+  bracket: bracket,
+  cssvar: cssvar,
+  time: time,
+  global: global,
+  properties: properties
+};
+
+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);
+  if (v !== void 0)
+    return directionMap[direction].map((i) => [`${propertyPrefix}${i}`, v]);
+};
+const getThemeColor = (theme, colors) => theme.colors?.[colors.join("-").replace(/(-[a-z])/g, (n) => n.slice(1).toUpperCase())];
+const parseColor = (body, theme) => {
+  const [main, opacity] = body.split(/(?:\/|:)/);
+  const colors = main.replace(/([a-z])([0-9])/g, "$1-$2").split(/-/g);
+  const [name] = colors;
+  if (!name)
+    return;
+  let color;
+  const bracket = handler.bracket(main);
+  const bracketOrMain = bracket || main;
+  if (bracketOrMain.startsWith("#"))
+    color = bracketOrMain.slice(1);
+  if (bracketOrMain.startsWith("hex-"))
+    color = bracketOrMain.slice(4);
+  color = color || bracket;
+  let no = "DEFAULT";
+  if (!color) {
+    let colorData;
+    const [scale] = colors.slice(-1);
+    if (scale.match(/^\d+$/)) {
+      no = scale;
+      colorData = getThemeColor(theme, colors.slice(0, -1));
+    } else {
+      colorData = getThemeColor(theme, colors);
+      if (!colorData) {
+        [, no = no] = colors;
+        colorData = getThemeColor(theme, [name]);
+      }
+    }
+    if (typeof colorData === "string")
+      color = colorData;
+    else if (no && colorData)
+      color = colorData[no];
+  }
+  return {
+    opacity,
+    name,
+    no,
+    color,
+    rgba: core.hex2rgba(color)
+  };
+};
+const colorResolver = (property, varName) => ([, body], { theme }) => {
+  const data = parseColor(body, theme);
+  if (!data)
+    return;
+  const { opacity, color, rgba } = data;
+  if (!color)
+    return;
+  const a = opacity ? opacity[0] === "[" ? handler.bracket.percent(opacity) : parseFloat(opacity) / 100 : rgba?.[3];
+  if (rgba) {
+    if (a != null && !Number.isNaN(a)) {
+      rgba[3] = typeof a === "string" && !a.includes("%") ? parseFloat(a) : a;
+      return {
+        [property]: `rgba(${rgba.join(",")})`
+      };
+    } else {
+      return {
+        [`--un-${varName}-opacity`]: 1,
+        [property]: `rgba(${rgba.slice(0, 3).join(",")},var(--un-${varName}-opacity))`
+      };
+    }
+  } else {
+    return {
+      [property]: color.replace("%alpha", `${a || 1}`)
+    };
+  }
+};
+
+exports.capitalize = capitalize;
+exports.colorResolver = colorResolver;
+exports.cornerMap = cornerMap;
+exports.directionMap = directionMap;
+exports.directionSize = directionSize;
+exports.h = h;
+exports.handler = handler;
+exports.parseColor = parseColor;
+exports.valueHandlers = valueHandlers;
+exports.xyzMap = xyzMap;