@unocss/preset-mini 0.58.0 → 0.58.2

package/dist/shared/preset-mini.jXC5Sr98.cjs

@@ -0,0 +1,772 @@
+'use strict';
+
+const utilities = require('./preset-mini.UhMMbd34.cjs');
+const ruleUtils = require('@unocss/rule-utils');
+const core = require('@unocss/core');
+
+const variantAria = {
+  name: "aria",
+  match(matcher, ctx) {
+    const variant = ruleUtils.variantGetParameter("aria-", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest] = variant;
+      const aria = utilities.h.bracket(match) ?? ctx.theme.aria?.[match] ?? "";
+      if (aria) {
+        return {
+          matcher: rest,
+          selector: (s) => `${s}[aria-${aria}]`
+        };
+      }
+    }
+  }
+};
+
+function calcMaxWidthBySize(size) {
+  const value = size.match(/^-?[0-9]+\.?[0-9]*/)?.[0] || "";
+  const unit = size.slice(value.length);
+  if (unit === "px") {
+    const maxWidth = Number.parseFloat(value) - 0.1;
+    return Number.isNaN(maxWidth) ? size : `${maxWidth}${unit}`;
+  }
+  return `calc(${size} - 0.1px)`;
+}
+function variantBreakpoints() {
+  const regexCache = {};
+  return {
+    name: "breakpoints",
+    match(matcher, context) {
+      const variantEntries = (utilities.resolveBreakpoints(context) ?? []).map(({ point, size }, idx) => [point, size, idx]);
+      for (const [point, size, idx] of variantEntries) {
+        if (!regexCache[point])
+          regexCache[point] = new RegExp(`^((?:([al]t-|[<~]|max-))?${point}(?:${context.generator.config.separators.join("|")}))`);
+        const match = matcher.match(regexCache[point]);
+        if (!match)
+          continue;
+        const [, pre] = match;
+        const m = matcher.slice(pre.length);
+        if (m === "container")
+          continue;
+        const isLtPrefix = pre.startsWith("lt-") || pre.startsWith("<") || pre.startsWith("max-");
+        const isAtPrefix = pre.startsWith("at-") || pre.startsWith("~");
+        let order = 1e3;
+        if (isLtPrefix) {
+          order -= idx + 1;
+          return {
+            matcher: m,
+            handle: (input, next) => next({
+              ...input,
+              parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (max-width: ${calcMaxWidthBySize(size)})`,
+              parentOrder: order
+            })
+          };
+        }
+        order += idx + 1;
+        if (isAtPrefix && idx < variantEntries.length - 1) {
+          return {
+            matcher: m,
+            handle: (input, next) => next({
+              ...input,
+              parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (min-width: ${size}) and (max-width: ${calcMaxWidthBySize(variantEntries[idx + 1][1])})`,
+              parentOrder: order
+            })
+          };
+        }
+        return {
+          matcher: m,
+          handle: (input, next) => next({
+            ...input,
+            parent: `${input.parent ? `${input.parent} $$ ` : ""}@media (min-width: ${size})`,
+            parentOrder: order
+          })
+        };
+      }
+    },
+    multiPass: true,
+    autocomplete: "(at-|lt-|max-|)$breakpoints:"
+  };
+}
+
+function scopeMatcher(name, combinator) {
+  return {
+    name: `combinator:${name}`,
+    match(matcher, ctx) {
+      if (!matcher.startsWith(name))
+        return;
+      const separators = ctx.generator.config.separators;
+      let body = ruleUtils.variantGetBracket(`${name}-`, matcher, separators);
+      if (!body) {
+        for (const separator of separators) {
+          if (matcher.startsWith(`${name}${separator}`)) {
+            body = ["", matcher.slice(name.length + separator.length)];
+            break;
+          }
+        }
+        if (!body)
+          return;
+      }
+      let bracketValue = utilities.h.bracket(body[0]) ?? "";
+      if (bracketValue === "")
+        bracketValue = "*";
+      return {
+        matcher: body[1],
+        selector: (s) => `${s}${combinator}${bracketValue}`
+      };
+    },
+    multiPass: true
+  };
+}
+const variantCombinators = [
+  scopeMatcher("all", " "),
+  scopeMatcher("children", ">"),
+  scopeMatcher("next", "+"),
+  scopeMatcher("sibling", "+"),
+  scopeMatcher("siblings", "~")
+];
+
+const variantContainerQuery = {
+  name: "@",
+  match(matcher, ctx) {
+    if (matcher.startsWith("@container"))
+      return;
+    const variant = ruleUtils.variantGetParameter("@", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest, label] = variant;
+      const unbracket = utilities.h.bracket(match);
+      let container;
+      if (unbracket) {
+        const minWidth = utilities.h.numberWithUnit(unbracket);
+        if (minWidth)
+          container = `(min-width: ${minWidth})`;
+      } else {
+        container = ctx.theme.containers?.[match] ?? "";
+      }
+      if (container) {
+        core.warnOnce("The container query variant is experimental and may not follow semver.");
+        return {
+          matcher: rest,
+          handle: (input, next) => next({
+            ...input,
+            parent: `${input.parent ? `${input.parent} $$ ` : ""}@container${label ? ` ${label} ` : " "}${container}`
+          })
+        };
+      }
+    }
+  },
+  multiPass: true
+};
+
+function variantColorsMediaOrClass(options = {}) {
+  if (options?.dark === "class" || typeof options.dark === "object") {
+    const { dark = ".dark", light = ".light" } = typeof options.dark === "string" ? {} : options.dark;
+    return [
+      ruleUtils.variantMatcher("dark", (input) => ({ prefix: `${dark} $$ ${input.prefix}` })),
+      ruleUtils.variantMatcher("light", (input) => ({ prefix: `${light} $$ ${input.prefix}` }))
+    ];
+  }
+  return [
+    ruleUtils.variantParentMatcher("dark", "@media (prefers-color-scheme: dark)"),
+    ruleUtils.variantParentMatcher("light", "@media (prefers-color-scheme: light)")
+  ];
+}
+
+const variantDataAttribute = {
+  name: "data",
+  match(matcher, ctx) {
+    const variant = ruleUtils.variantGetParameter("data-", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest] = variant;
+      const dataAttribute = utilities.h.bracket(match) ?? ctx.theme.data?.[match] ?? "";
+      if (dataAttribute) {
+        return {
+          matcher: rest,
+          selector: (s) => `${s}[data-${dataAttribute}]`
+        };
+      }
+    }
+  }
+};
+function taggedData(tagName) {
+  return {
+    name: `${tagName}-data`,
+    match(matcher, ctx) {
+      const variant = ruleUtils.variantGetParameter(`${tagName}-data-`, matcher, ctx.generator.config.separators);
+      if (variant) {
+        const [match, rest] = variant;
+        const dataAttribute = utilities.h.bracket(match) ?? ctx.theme.data?.[match] ?? "";
+        if (dataAttribute) {
+          return {
+            matcher: `${tagName}-[[data-${dataAttribute}]]:${rest}`
+          };
+        }
+      }
+    }
+  };
+}
+const variantTaggedDataAttributes = [
+  taggedData("group"),
+  taggedData("peer"),
+  taggedData("parent"),
+  taggedData("previous")
+];
+
+const variantLanguageDirections = [
+  ruleUtils.variantMatcher("rtl", (input) => ({ prefix: `[dir="rtl"] $$ ${input.prefix}` })),
+  ruleUtils.variantMatcher("ltr", (input) => ({ prefix: `[dir="ltr"] $$ ${input.prefix}` }))
+];
+
+const variantSelector = {
+  name: "selector",
+  match(matcher, ctx) {
+    const variant = ruleUtils.variantGetBracket("selector-", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest] = variant;
+      const selector = utilities.h.bracket(match);
+      if (selector) {
+        return {
+          matcher: rest,
+          selector: () => selector
+        };
+      }
+    }
+  }
+};
+const variantCssLayer = {
+  name: "layer",
+  match(matcher, ctx) {
+    const variant = ruleUtils.variantGetParameter("layer-", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest] = variant;
+      const layer = utilities.h.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, ctx) {
+    const variant = ruleUtils.variantGetParameter("uno-layer-", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest] = variant;
+      const layer = utilities.h.bracket(match) ?? match;
+      if (layer) {
+        return {
+          matcher: rest,
+          layer
+        };
+      }
+    }
+  }
+};
+const variantScope = {
+  name: "scope",
+  match(matcher, ctx) {
+    const variant = ruleUtils.variantGetBracket("scope-", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest] = variant;
+      const scope = utilities.h.bracket(match);
+      if (scope) {
+        return {
+          matcher: rest,
+          selector: (s) => `${scope} $$ ${s}`
+        };
+      }
+    }
+  }
+};
+const variantVariables = {
+  name: "variables",
+  match(matcher, ctx) {
+    if (!matcher.startsWith("["))
+      return;
+    const [match, rest] = ruleUtils.getBracket(matcher, "[", "]") ?? [];
+    if (!(match && rest))
+      return;
+    let newMatcher;
+    for (const separator of ctx.generator.config.separators) {
+      if (rest.startsWith(separator)) {
+        newMatcher = rest.slice(separator.length);
+        break;
+      }
+    }
+    if (newMatcher == null)
+      return;
+    const variant = utilities.h.bracket(match) ?? "";
+    const useParent = variant.startsWith("@");
+    if (!(useParent || variant.includes("&")))
+      return;
+    return {
+      matcher: newMatcher,
+      handle(input, next) {
+        const updates = useParent ? {
+          parent: `${input.parent ? `${input.parent} $$ ` : ""}${variant}`
+        } : {
+          selector: variant.replace(/&/g, input.selector)
+        };
+        return next({
+          ...input,
+          ...updates
+        });
+      }
+    };
+  },
+  multiPass: true
+};
+
+const anchoredNumberRE = /^-?[0-9.]+(?:[a-z]+|%)?$/;
+const numberRE = /-?[0-9.]+(?:[a-z]+|%)?/;
+const ignoreProps = [
+  /\b(opacity|color|flex|backdrop-filter|^filter|transform)\b/
+];
+function negateMathFunction(value) {
+  const match = value.match(utilities.cssMathFnRE);
+  if (match) {
+    const [fnBody, rest] = ruleUtils.getStringComponent(`(${match[2]})${match[3]}`, "(", ")", " ") ?? [];
+    if (fnBody)
+      return `calc(${match[1]}${fnBody} * -1)${rest ? ` ${rest}` : ""}`;
+  }
+}
+const negateFunctionBodyRE = /\b(hue-rotate)\s*(\(.*)/;
+function negateFunctionBody(value) {
+  const match = value.match(negateFunctionBodyRE);
+  if (match) {
+    const [fnBody, rest] = ruleUtils.getStringComponent(match[2], "(", ")", " ") ?? [];
+    if (fnBody) {
+      const body = anchoredNumberRE.test(fnBody.slice(1, -1)) ? fnBody.replace(numberRE, (i) => i.startsWith("-") ? i.slice(1) : `-${i}`) : `(calc(${fnBody} * -1))`;
+      return `${match[1]}${body}${rest ? ` ${rest}` : ""}`;
+    }
+  }
+}
+const variantNegative = {
+  name: "negative",
+  match(matcher) {
+    if (!matcher.startsWith("-"))
+      return;
+    return {
+      matcher: matcher.slice(1),
+      body: (body) => {
+        if (body.find((v) => v[0] === utilities.CONTROL_MINI_NO_NEGATIVE))
+          return;
+        let changed = false;
+        body.forEach((v) => {
+          const value = v[1]?.toString();
+          if (!value || value === "0")
+            return;
+          if (ignoreProps.some((i) => i.test(v[0])))
+            return;
+          const negatedFn = negateMathFunction(value);
+          if (negatedFn) {
+            v[1] = negatedFn;
+            changed = true;
+            return;
+          }
+          const negatedBody = negateFunctionBody(value);
+          if (negatedBody) {
+            v[1] = negatedBody;
+            changed = true;
+            return;
+          }
+          if (anchoredNumberRE.test(value)) {
+            v[1] = value.replace(numberRE, (i) => i.startsWith("-") ? i.slice(1) : `-${i}`);
+            changed = true;
+          }
+        });
+        if (changed)
+          return body;
+        return [];
+      }
+    };
+  }
+};
+
+function variantImportant() {
+  let re;
+  return {
+    name: "important",
+    match(matcher, ctx) {
+      if (!re)
+        re = new RegExp(`^(important(?:${ctx.generator.config.separators.join("|")})|!)`);
+      let base;
+      const match = matcher.match(re);
+      if (match)
+        base = matcher.slice(match[0].length);
+      else if (matcher.endsWith("!"))
+        base = matcher.slice(0, -1);
+      if (base) {
+        return {
+          matcher: base,
+          body: (body) => {
+            body.forEach((v) => {
+              if (v[1])
+                v[1] += " !important";
+            });
+            return body;
+          }
+        };
+      }
+    }
+  };
+}
+
+const variantPrint = ruleUtils.variantParentMatcher("print", "@media print");
+const variantCustomMedia = {
+  name: "media",
+  match(matcher, ctx) {
+    const variant = ruleUtils.variantGetParameter("media-", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest] = variant;
+      let media = utilities.h.bracket(match) ?? "";
+      if (media === "")
+        media = ctx.theme.media?.[match] ?? "";
+      if (media) {
+        return {
+          matcher: rest,
+          handle: (input, next) => next({
+            ...input,
+            parent: `${input.parent ? `${input.parent} $$ ` : ""}@media ${media}`
+          })
+        };
+      }
+    }
+  },
+  multiPass: true
+};
+
+const variantSupports = {
+  name: "supports",
+  match(matcher, ctx) {
+    const variant = ruleUtils.variantGetParameter("supports-", matcher, ctx.generator.config.separators);
+    if (variant) {
+      const [match, rest] = variant;
+      let supports = utilities.h.bracket(match) ?? "";
+      if (supports === "")
+        supports = ctx.theme.supports?.[match] ?? "";
+      if (supports) {
+        return {
+          matcher: rest,
+          handle: (input, next) => next({
+            ...input,
+            parent: `${input.parent ? `${input.parent} $$ ` : ""}@supports ${supports}`
+          })
+        };
+      }
+    }
+  },
+  multiPass: true
+};
+
+const PseudoClasses = Object.fromEntries([
+  // pseudo elements part 1
+  ["first-letter", "::first-letter"],
+  ["first-line", "::first-line"],
+  // location
+  "any-link",
+  "link",
+  "visited",
+  "target",
+  ["open", "[open]"],
+  // forms
+  "default",
+  "checked",
+  "indeterminate",
+  "placeholder-shown",
+  "autofill",
+  "optional",
+  "required",
+  "valid",
+  "invalid",
+  "user-valid",
+  "user-invalid",
+  "in-range",
+  "out-of-range",
+  "read-only",
+  "read-write",
+  // content
+  "empty",
+  // interactions
+  "focus-within",
+  "hover",
+  "focus",
+  "focus-visible",
+  "active",
+  "enabled",
+  "disabled",
+  // tree-structural
+  "root",
+  "empty",
+  ["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"],
+  "last-of-type",
+  ["last", ":last-child"],
+  "only-child",
+  "only-of-type",
+  // pseudo elements part 2
+  ["backdrop-element", "::backdrop"],
+  ["placeholder", "::placeholder"],
+  ["before", "::before"],
+  ["after", "::after"],
+  ["selection", "::selection"],
+  ["marker", "::marker"],
+  ["file", "::file-selector-button"]
+].map((key) => Array.isArray(key) ? key : [key, `:${key}`]));
+const PseudoClassesKeys = Object.keys(PseudoClasses);
+const PseudoClassesColon = Object.fromEntries([
+  ["backdrop", "::backdrop"]
+].map((key) => Array.isArray(key) ? key : [key, `:${key}`]));
+const PseudoClassesColonKeys = Object.keys(PseudoClassesColon);
+const PseudoClassFunctions = [
+  "not",
+  "is",
+  "where",
+  "has"
+];
+const PseudoClassesStr = Object.entries(PseudoClasses).filter(([, pseudo]) => !pseudo.startsWith("::")).map(([key]) => key).sort((a, b) => b.length - a.length).join("|");
+const PseudoClassesColonStr = Object.entries(PseudoClassesColon).filter(([, pseudo]) => !pseudo.startsWith("::")).map(([key]) => key).sort((a, b) => b.length - a.length).join("|");
+const PseudoClassFunctionsStr = PseudoClassFunctions.join("|");
+function taggedPseudoClassMatcher(tag, parent, combinator) {
+  const rawRE = new RegExp(`^(${core.escapeRegExp(parent)}:)(\\S+)${core.escapeRegExp(combinator)}\\1`);
+  let splitRE;
+  let pseudoRE;
+  let pseudoColonRE;
+  let pseudoVarRE;
+  const matchBracket = (input) => {
+    const body = ruleUtils.variantGetBracket(`${tag}-`, input, []);
+    if (!body)
+      return;
+    const [match, rest] = body;
+    const bracketValue = utilities.h.bracket(match);
+    if (bracketValue == null)
+      return;
+    const label = rest.split(splitRE, 1)?.[0] ?? "";
+    const prefix = `${parent}${core.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}${core.escapeSelector(label)}${pseudo}`,
+      pseudoKey
+    ];
+  };
+  const matchPseudoVar = (input) => {
+    const match = input.match(pseudoVarRE);
+    if (!match)
+      return;
+    const [original, fn, pseudoValue] = match;
+    const label = match[3] ?? "";
+    const pseudo = `:${fn}(${pseudoValue})`;
+    return [
+      label,
+      input.slice(original.length),
+      `${parent}${core.escapeSelector(label)}${pseudo}`
+    ];
+  };
+  return {
+    name: `pseudo:${tag}`,
+    match(input, ctx) {
+      if (!(splitRE && pseudoRE && pseudoColonRE)) {
+        splitRE = new RegExp(`(?:${ctx.generator.config.separators.join("|")})`);
+        pseudoRE = new RegExp(`^${tag}-(?:(?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))(?:(/\\w+))?(?:${ctx.generator.config.separators.join("|")})`);
+        pseudoColonRE = new RegExp(`^${tag}-(?:(?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesColonStr}))(?:(/\\w+))?(?:${ctx.generator.config.separators.filter((x) => x !== "-").join("|")})`);
+        pseudoVarRE = new RegExp(`^${tag}-(?:(${PseudoClassFunctionsStr})-)?\\[(.+)\\](?:(/\\w+))?(?:${ctx.generator.config.separators.filter((x) => x !== "-").join("|")})`);
+      }
+      if (!input.startsWith(tag))
+        return;
+      const result = matchBracket(input) || matchPseudo(input) || matchPseudoVar(input);
+      if (!result)
+        return;
+      const [label, matcher, prefix, pseudoName = ""] = result;
+      if (label !== "")
+        core.warnOnce("The labeled variant is experimental and may not follow semver.");
+      return {
+        matcher,
+        handle: (input2, next) => next({
+          ...input2,
+          prefix: `${prefix}${combinator}${input2.prefix}`.replace(rawRE, "$1$2:"),
+          sort: PseudoClassesKeys.indexOf(pseudoName) ?? PseudoClassesColonKeys.indexOf(pseudoName)
+        })
+      };
+    },
+    multiPass: true
+  };
+}
+const excludedPseudo = [
+  "::-webkit-resizer",
+  "::-webkit-scrollbar",
+  "::-webkit-scrollbar-button",
+  "::-webkit-scrollbar-corner",
+  "::-webkit-scrollbar-thumb",
+  "::-webkit-scrollbar-track",
+  "::-webkit-scrollbar-track-piece",
+  "::file-selector-button"
+];
+const PseudoClassesAndElementsStr = Object.entries(PseudoClasses).map(([key]) => key).sort((a, b) => b.length - a.length).join("|");
+const PseudoClassesAndElementsColonStr = Object.entries(PseudoClassesColon).map(([key]) => key).sort((a, b) => b.length - a.length).join("|");
+function variantPseudoClassesAndElements() {
+  let PseudoClassesAndElementsRE;
+  let PseudoClassesAndElementsColonRE;
+  return {
+    name: "pseudo",
+    match(input, ctx) {
+      if (!(PseudoClassesAndElementsRE && PseudoClassesAndElementsRE)) {
+        PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})(?:${ctx.generator.config.separators.join("|")})`);
+        PseudoClassesAndElementsColonRE = new RegExp(`^(${PseudoClassesAndElementsColonStr})(?:${ctx.generator.config.separators.filter((x) => x !== "-").join("|")})`);
+      }
+      const match = input.match(PseudoClassesAndElementsRE) || input.match(PseudoClassesAndElementsColonRE);
+      if (match) {
+        const pseudo = PseudoClasses[match[1]] || PseudoClassesColon[match[1]] || `:${match[1]}`;
+        let index = PseudoClassesKeys.indexOf(match[1]);
+        if (index === -1)
+          index = PseudoClassesColonKeys.indexOf(match[1]);
+        if (index === -1)
+          index = void 0;
+        return {
+          matcher: input.slice(match[0].length),
+          handle: (input2, next) => {
+            const selectors = pseudo.startsWith("::") && !excludedPseudo.includes(pseudo) ? {
+              pseudo: `${input2.pseudo}${pseudo}`
+            } : {
+              selector: `${input2.selector}${pseudo}`
+            };
+            return next({
+              ...input2,
+              ...selectors,
+              sort: index,
+              noMerge: true
+            });
+          }
+        };
+      }
+    },
+    multiPass: true,
+    autocomplete: `(${PseudoClassesAndElementsStr}|${PseudoClassesAndElementsColonStr}):`
+  };
+}
+function variantPseudoClassFunctions() {
+  let PseudoClassFunctionsRE;
+  let PseudoClassColonFunctionsRE;
+  let PseudoClassVarFunctionRE;
+  return {
+    match(input, ctx) {
+      if (!(PseudoClassFunctionsRE && PseudoClassColonFunctionsRE)) {
+        PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})(?:${ctx.generator.config.separators.join("|")})`);
+        PseudoClassColonFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesColonStr})(?:${ctx.generator.config.separators.filter((x) => x !== "-").join("|")})`);
+        PseudoClassVarFunctionRE = new RegExp(`^(${PseudoClassFunctionsStr})-(\\[.+\\])(?:${ctx.generator.config.separators.filter((x) => x !== "-").join("|")})`);
+      }
+      const match = input.match(PseudoClassFunctionsRE) || input.match(PseudoClassColonFunctionsRE) || input.match(PseudoClassVarFunctionRE);
+      if (match) {
+        const fn = match[1];
+        const fnVal = ruleUtils.getBracket(match[2], "[", "]");
+        const pseudo = fnVal ? utilities.h.bracket(match[2]) : PseudoClasses[match[2]] || PseudoClassesColon[match[2]] || `:${match[2]}`;
+        return {
+          matcher: input.slice(match[0].length),
+          selector: (s) => `${s}:${fn}(${pseudo})`
+        };
+      }
+    },
+    multiPass: true,
+    autocomplete: `(${PseudoClassFunctionsStr})-(${PseudoClassesStr}|${PseudoClassesColonStr}):`
+  };
+}
+function variantTaggedPseudoClasses(options = {}) {
+  const attributify = !!options?.attributifyPseudo;
+  let firstPrefix = options?.prefix ?? "";
+  firstPrefix = (Array.isArray(firstPrefix) ? firstPrefix : [firstPrefix]).filter(Boolean)[0] ?? "";
+  const tagWithPrefix = (tag, combinator) => taggedPseudoClassMatcher(tag, attributify ? `[${firstPrefix}${tag}=""]` : `.${firstPrefix}${tag}`, combinator);
+  return [
+    tagWithPrefix("group", " "),
+    tagWithPrefix("peer", "~"),
+    tagWithPrefix("parent", ">"),
+    tagWithPrefix("previous", "+")
+  ];
+}
+const PartClassesRE = /(part-\[(.+)]:)(.+)/;
+const variantPartClasses = {
+  match(input) {
+    const match = input.match(PartClassesRE);
+    if (match) {
+      const part = `part(${match[2]})`;
+      return {
+        matcher: input.slice(match[1].length),
+        selector: (s) => `${s}::${part}`
+      };
+    }
+  },
+  multiPass: true
+};
+
+function variants(options) {
+  return [
+    variantAria,
+    variantDataAttribute,
+    variantCssLayer,
+    variantSelector,
+    variantInternalLayer,
+    variantNegative,
+    variantImportant(),
+    variantSupports,
+    variantPrint,
+    variantCustomMedia,
+    variantBreakpoints(),
+    ...variantCombinators,
+    variantPseudoClassesAndElements(),
+    variantPseudoClassFunctions(),
+    ...variantTaggedPseudoClasses(options),
+    variantPartClasses,
+    ...variantColorsMediaOrClass(options),
+    ...variantLanguageDirections,
+    variantScope,
+    variantContainerQuery,
+    variantVariables,
+    ...variantTaggedDataAttributes
+  ];
+}
+
+exports.calcMaxWidthBySize = calcMaxWidthBySize;
+exports.variantAria = variantAria;
+exports.variantBreakpoints = variantBreakpoints;
+exports.variantColorsMediaOrClass = variantColorsMediaOrClass;
+exports.variantCombinators = variantCombinators;
+exports.variantContainerQuery = variantContainerQuery;
+exports.variantCssLayer = variantCssLayer;
+exports.variantCustomMedia = variantCustomMedia;
+exports.variantDataAttribute = variantDataAttribute;
+exports.variantImportant = variantImportant;
+exports.variantInternalLayer = variantInternalLayer;
+exports.variantLanguageDirections = variantLanguageDirections;
+exports.variantNegative = variantNegative;
+exports.variantPartClasses = variantPartClasses;
+exports.variantPrint = variantPrint;
+exports.variantPseudoClassFunctions = variantPseudoClassFunctions;
+exports.variantPseudoClassesAndElements = variantPseudoClassesAndElements;
+exports.variantScope = variantScope;
+exports.variantSelector = variantSelector;
+exports.variantSupports = variantSupports;
+exports.variantTaggedDataAttributes = variantTaggedDataAttributes;
+exports.variantTaggedPseudoClasses = variantTaggedPseudoClasses;
+exports.variantVariables = variantVariables;
+exports.variants = variants;