@unocss/preset-mini 0.45.29 → 0.46.0

package/dist/shared/{preset-mini.d7aeeb41.mjs → preset-mini.9e26490c.mjs}

@@ -1,6 +1,6 @@
-import { l as resolveBreakpoints, q as getComponent, h as handler, C as CONTROL_MINI_NO_NEGATIVE } from './preset-mini.42e5e280.mjs';
-import { escapeRegExp } from '@unocss/core';
-import { v as variantParentMatcher, a as variantMatcher } from './preset-mini.f73f9ed7.mjs';
+import { l as resolveBreakpoints, h as handler, q as getBracket, C as CONTROL_MINI_NO_NEGATIVE, s as getComponent } from './preset-mini.9c5f881e.mjs';
+import { escapeRegExp, warnOnce, escapeSelector } from '@unocss/core';
+import { v as variantGetBracket, a as variantParentMatcher, b as variantGetParameter, c as variantMatcher } from './preset-mini.154e3363.mjs';
 
 const regexCache = {};
 const calcMaxWidthBySize = (size) => {
@@ -62,48 +62,59 @@ const variantBreakpoints = {
   autocomplete: "(at-|lt-|)$breakpoints:"
 };
 
-const scopeMatcher = (strict, name, template) => {
-  const re = strict ? new RegExp(`^${name}(?:-\\[(.+?)\\])[:-]`) : new RegExp(`^${name}(?:-\\[(.+?)\\])?[:-]`);
-  return {
-    name: `combinator:${name}`,
-    match: (matcher) => {
-      const match = matcher.match(re);
-      if (match) {
-        return {
-          matcher: matcher.slice(match[0].length),
-          selector: (s) => template.replace("&&-s", s).replace("&&-c", match[1] ?? "*")
-        };
+const scopeMatcher = (name, combinator) => ({
+  name: `combinator:${name}`,
+  match(matcher) {
+    if (!matcher.startsWith(name))
+      return;
+    let body = variantGetBracket(name, matcher, [":", "-"]);
+    if (!body) {
+      for (const separator of [":", "-"]) {
+        if (matcher.startsWith(`${name}${separator}`)) {
+          body = ["", matcher.slice(name.length + separator.length)];
+          break;
+        }
       }
-    },
-    multiPass: true
-  };
-};
+      if (!body)
+        return;
+    }
+    let bracketValue = handler.bracket(body[0]) ?? "";
+    if (bracketValue === "")
+      bracketValue = "*";
+    return {
+      matcher: body[1],
+      selector: (s) => `${s}${combinator}${bracketValue}`
+    };
+  },
+  multiPass: true
+});
 const variantCombinators = [
-  scopeMatcher(false, "all", "&&-s &&-c"),
-  scopeMatcher(false, "children", "&&-s>&&-c"),
-  scopeMatcher(false, "next", "&&-s+&&-c"),
-  scopeMatcher(false, "sibling", "&&-s+&&-c"),
-  scopeMatcher(false, "siblings", "&&-s~&&-c"),
-  scopeMatcher(true, "group", "&&-c &&-s"),
-  scopeMatcher(true, "parent", "&&-c>&&-s"),
-  scopeMatcher(true, "previous", "&&-c+&&-s"),
-  scopeMatcher(true, "peer", "&&-c~&&-s")
+  scopeMatcher("all", " "),
+  scopeMatcher("children", ">"),
+  scopeMatcher("next", "+"),
+  scopeMatcher("sibling", "+"),
+  scopeMatcher("siblings", "~")
 ];
 
 const variantPrint = variantParentMatcher("print", "@media print");
 const variantCustomMedia = {
   name: "media",
   match(matcher, { theme }) {
-    const match = matcher.match(/^media-([_\d\w]+)[:-]/);
-    if (match) {
-      const media = theme.media?.[match[1]] ?? `(--${match[1]})`;
-      return {
-        matcher: matcher.slice(match[0].length),
-        handle: (input, next) => next({
-          ...input,
-          parent: `${input.parent ? `${input.parent} $$ ` : ""}@media ${media}`
-        })
-      };
+    const variant = variantGetParameter("media", matcher, [":", "-"]);
+    if (variant) {
+      const [match, rest] = variant;
+      let media = handler.bracket(match) ?? "";
+      if (media === "")
+        media = theme.media?.[match] ?? "";
+      if (media) {
+        return {
+          matcher: rest,
+          handle: (input, next) => next({
+            ...input,
+            parent: `${input.parent ? `${input.parent} $$ ` : ""}@media ${media}`
+          })
+        };
+      }
     }
   },
   multiPass: true
@@ -112,17 +123,12 @@ const variantCustomMedia = {
 const variantSupports = {
   name: "supports",
   match(matcher, { theme }) {
-    if (matcher.startsWith("supports-")) {
-      const matcherValue = matcher.substring(9);
-      const [match, rest] = getComponent(matcherValue, "[", "]", ":") ?? [];
-      if (!(match && rest && rest !== ""))
-        return;
+    const variant = variantGetParameter("supports", matcher, [":", "-"]);
+    if (variant) {
+      const [match, rest] = variant;
       let supports = handler.bracket(match) ?? "";
-      if (supports === "") {
-        const themeValue = theme.supports?.[match];
-        if (themeValue)
-          supports = themeValue;
-      }
+      if (supports === "")
+        supports = theme.supports?.[match] ?? "";
       if (supports) {
         return {
           matcher: rest,
@@ -159,51 +165,67 @@ const variantLanguageDirections = [
 const variantSelector = {
   name: "selector",
   match(matcher) {
-    const match = matcher.match(/^selector-\[(.+?)\][:-]/);
-    if (match) {
-      return {
-        matcher: matcher.slice(match[0].length),
-        selector: () => match[1]
-      };
+    const variant = variantGetBracket("selector", matcher, [":", "-"]);
+    if (variant) {
+      const [match, rest] = variant;
+      const selector = handler.bracket(match);
+      if (selector) {
+        return {
+          matcher: rest,
+          selector: () => selector
+        };
+      }
     }
   }
 };
 const variantCssLayer = {
   name: "layer",
   match(matcher) {
-    const match = matcher.match(/^layer-([_\d\w]+)[:-]/);
-    if (match) {
-      return {
-        matcher: matcher.slice(match[0].length),
-        handle: (input, next) => next({
-          ...input,
-          parent: `${input.parent ? `${input.parent} $$ ` : ""}@layer ${match[1]}`
-        })
-      };
+    const variant = variantGetParameter("layer", matcher, [":", "-"]);
+    if (variant) {
+      const [match, rest] = variant;
+      const layer = handler.bracket(match) ?? match;
+      if (layer) {
+        return {
+          matcher: rest,
+          handle: (input, next) => next({
+            ...input,
+            parent: `${input.parent ? `${input.parent} $$ ` : ""}@layer ${layer}`
+          })
+        };
+      }
     }
   }
 };
 const variantInternalLayer = {
   name: "uno-layer",
   match(matcher) {
-    const match = matcher.match(/^uno-layer-([_\d\w]+)[:-]/);
-    if (match) {
-      return {
-        matcher: matcher.slice(match[0].length),
-        layer: match[1]
-      };
+    const variant = variantGetParameter("uno-layer", matcher, [":", "-"]);
+    if (variant) {
+      const [match, rest] = variant;
+      const layer = handler.bracket(match) ?? match;
+      if (layer) {
+        return {
+          matcher: rest,
+          layer
+        };
+      }
     }
   }
 };
 const variantScope = {
   name: "scope",
   match(matcher) {
-    const match = matcher.match(/^scope-([_\d\w]+)[:-]/);
-    if (match) {
-      return {
-        matcher: matcher.slice(match[0].length),
-        selector: (s) => `.${match[1]} $$ ${s}`
-      };
+    const variant = variantGetBracket("scope", matcher, [":", "-"]);
+    if (variant) {
+      const [match, rest] = variant;
+      const scope = handler.bracket(match);
+      if (scope) {
+        return {
+          matcher: rest,
+          selector: (s) => `${scope} $$ ${s}`
+        };
+      }
     }
   }
 };
@@ -212,16 +234,26 @@ const variantVariables = {
   match(matcher) {
     if (!matcher.startsWith("["))
       return;
-    const [match, rest] = getComponent(matcher, "[", "]", ":") ?? [];
-    if (!(match && rest && rest !== ""))
+    const [match, rest] = getBracket(matcher, "[", "]") ?? [];
+    if (!(match && rest))
+      return;
+    let newMatcher;
+    for (const separator of [":", "-"]) {
+      if (rest.startsWith(separator)) {
+        newMatcher = rest.slice(separator.length);
+        break;
+      }
+    }
+    if (newMatcher == null)
       return;
     const variant = handler.bracket(match) ?? "";
-    if (!(variant.startsWith("@") || variant.includes("&")))
+    const useParent = variant.startsWith("@");
+    if (!(useParent || variant.includes("&")))
       return;
     return {
-      matcher: rest,
+      matcher: newMatcher,
       handle(input, next) {
-        const updates = variant.startsWith("@") ? {
+        const updates = useParent ? {
           parent: `${input.parent ? `${input.parent} $$ ` : ""}${variant}`
         } : {
           selector: variant.replace(/&/g, input.selector)
@@ -240,6 +272,14 @@ const numberRE = /[0-9.]+(?:[a-z]+|%)?/;
 const ignoreProps = [
   /opacity|color|flex/
 ];
+const negateFunctions = (value) => {
+  const match = value.match(/^(calc|clamp|max|min)\s*(\(.*)/);
+  if (match) {
+    const [fnBody, rest] = getComponent(match[2], "(", ")", " ") ?? [];
+    if (fnBody)
+      return `calc(${match[1]}${fnBody} * -1)${rest ? ` ${rest}` : ""}`;
+  }
+};
 const variantNegative = {
   name: "negative",
   match(matcher) {
@@ -257,7 +297,11 @@ const variantNegative = {
             return;
           if (ignoreProps.some((i) => v[0].match(i)))
             return;
-          if (numberRE.test(value)) {
+          const negated = negateFunctions(value);
+          if (negated) {
+            v[1] = negated;
+            changed = true;
+          } else if (numberRE.test(value)) {
             v[1] = value.replace(numberRE, (i) => `-${i}`);
             changed = true;
           }
@@ -358,26 +402,60 @@ const sortValue = (pseudo) => {
     return 1;
 };
 const taggedPseudoClassMatcher = (tag, parent, combinator) => {
-  const rawRe = new RegExp(`^(${escapeRegExp(parent)}:)(\\S+)${escapeRegExp(combinator)}\\1`);
-  const pseudoRE = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))[:-]`);
-  const pseudoColonRE = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesColonStr}))[:]`);
+  const rawRE = new RegExp(`^(${escapeRegExp(parent)}:)(\\S+)${escapeRegExp(combinator)}\\1`);
+  const pseudoRE = new RegExp(`^${tag}-(?:(?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))(?:(/\\w+))?[:-]`);
+  const pseudoColonRE = new RegExp(`^${tag}-(?:(?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesColonStr}))(?:(/\\w+))?[:]`);
+  const matchBracket = (input) => {
+    const body = variantGetBracket(tag, input, []);
+    if (!body)
+      return;
+    const [match, rest] = body;
+    const bracketValue = handler.bracket(match);
+    if (bracketValue == null)
+      return;
+    const label = rest.split(/[:-]/, 1)?.[0] ?? "";
+    const prefix = `${parent}${escapeSelector(label)}`;
+    return [
+      label,
+      input.slice(input.length - (rest.length - label.length - 1)),
+      bracketValue.includes("&") ? bracketValue.replace(/&/g, prefix) : `${prefix}${bracketValue}`
+    ];
+  };
+  const matchPseudo = (input) => {
+    const match = input.match(pseudoRE) || input.match(pseudoColonRE);
+    if (!match)
+      return;
+    const [original, fn, pseudoKey] = match;
+    const label = match[3] ?? "";
+    let pseudo = PseudoClasses[pseudoKey] || PseudoClassesColon[pseudoKey] || `:${pseudoKey}`;
+    if (fn)
+      pseudo = `:${fn}(${pseudo})`;
+    return [
+      label,
+      input.slice(original.length),
+      `${parent}${escapeSelector(label)}${pseudo}`,
+      sortValue(pseudoKey)
+    ];
+  };
   return {
     name: `pseudo:${tag}`,
     match(input) {
-      const match = input.match(pseudoRE) || input.match(pseudoColonRE);
-      if (match) {
-        let pseudo = PseudoClasses[match[3]] || PseudoClassesColon[match[3]] || `:${match[3]}`;
-        if (match[2])
-          pseudo = `:${match[2]}(${pseudo})`;
-        return {
-          matcher: input.slice(match[0].length),
-          handle: (input2, next) => next({
-            ...input2,
-            prefix: `${parent}${pseudo}${combinator}${input2.prefix}`.replace(rawRe, "$1$2:"),
-            sort: sortValue(match[3])
-          })
-        };
-      }
+      if (!input.startsWith(tag))
+        return;
+      const result = matchBracket(input) || matchPseudo(input);
+      if (!result)
+        return;
+      const [label, matcher, prefix, sort] = result;
+      if (label !== "")
+        warnOnce("The labeled pseudo is experimental and may be changed in breaking ways at any time.");
+      return {
+        matcher,
+        handle: (input2, next) => next({
+          ...input2,
+          prefix: `${prefix}${combinator}${input2.prefix}`.replace(rawRE, "$1$2:")
+        }),
+        sort
+      };
     },
     multiPass: true
   };
@@ -388,7 +466,7 @@ const PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})
 const PseudoClassesAndElementsColonRE = new RegExp(`^(${PseudoClassesAndElementsColonStr})[:]`);
 const variantPseudoClassesAndElements = {
   name: "pseudo",
-  match: (input) => {
+  match(input) {
     const match = input.match(PseudoClassesAndElementsRE) || input.match(PseudoClassesAndElementsColonRE);
     if (match) {
       const pseudo = PseudoClasses[match[1]] || PseudoClassesColon[match[1]] || `:${match[1]}`;
@@ -415,7 +493,7 @@ const variantPseudoClassesAndElements = {
 const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
 const PseudoClassColonFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesColonStr})[:]`);
 const variantPseudoClassFunctions = {
-  match: (input) => {
+  match(input) {
     const match = input.match(PseudoClassFunctionsRE) || input.match(PseudoClassColonFunctionsRE);
     if (match) {
       const fn = match[1];
@@ -440,7 +518,7 @@ const variantTaggedPseudoClasses = (options = {}) => {
 };
 const PartClassesRE = /(part-\[(.+)]:)(.+)/;
 const partClasses = {
-  match: (input) => {
+  match(input) {
     const match = input.match(PartClassesRE);
     if (match) {
       const part = `part(${match[2]})`;
@@ -454,7 +532,6 @@ const partClasses = {
 };
 
 const variants = (options) => [
-  variantVariables,
   variantCssLayer,
   variantSelector,
   variantInternalLayer,
@@ -471,7 +548,8 @@ const variants = (options) => [
   partClasses,
   ...variantColorsMediaOrClass(options),
   ...variantLanguageDirections,
-  variantScope
+  variantScope,
+  variantVariables
 ];
 
 export { variantBreakpoints as a, variantCombinators as b, calcMaxWidthBySize as c, variantPrint as d, variantCustomMedia as e, variantSupports as f, variantColorsMediaOrClass as g, variantLanguageDirections as h, variantSelector as i, variantCssLayer as j, variantInternalLayer as k, variantScope as l, variantVariables as m, variantPseudoClassesAndElements as n, variantPseudoClassFunctions as o, variantTaggedPseudoClasses as p, partClasses as q, variantImportant as r, variantNegative as s, variants as v };

package/dist/shared/{preset-mini.85263b33.mjs → preset-mini.ae98d318.mjs}

@@ -1,6 +1,6 @@
 import { c as colors } from './preset-mini.65ac75be.mjs';
-import { O as transformBase, P as boxShadowsBase, Q as ringBase } from './preset-mini.3602602e.mjs';
-import './preset-mini.42e5e280.mjs';
+import { O as transformBase, P as boxShadowsBase, Q as ringBase } from './preset-mini.739fdcc7.mjs';
+import './preset-mini.9c5f881e.mjs';
 import '@unocss/core';
 
 const fontFamily = {

package/dist/shared/{preset-mini.5d1fe287.cjs → preset-mini.f5f22d9a.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-const decoration = require('./preset-mini.b300afab.cjs');
-const colors = require('./preset-mini.7346cef1.cjs');
+const decoration = require('./preset-mini.7f221566.cjs');
+const colors = require('./preset-mini.0109bbf2.cjs');
 require('@unocss/core');
 
 const opacity = [