@unocss/preset-mini 0.57.7 → 0.58.1

package/dist/variants.cjs

@@ -1,741 +1,33 @@
 'use strict';
 
-const ruleUtils = require('@unocss/rule-utils');
-const utils = require('./shared/preset-mini.ImRm63ih.cjs');
-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 = utils.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 = (utils.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 = utils.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 = utils.h.bracket(match);
-      let container;
-      if (unbracket) {
-        const minWidth = utils.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 = utils.h.bracket(match) ?? ctx.theme.data?.[match] ?? "";
-      if (dataAttribute) {
-        return {
-          matcher: rest,
-          selector: (s) => `${s}[data-${dataAttribute}]`
-        };
-      }
-    }
-  }
-};
-const variantGroupDataAttribute = {
-  name: "group-data",
-  match(matcher, ctx) {
-    const variant = ruleUtils.variantGetParameter("group-data-", matcher, ctx.generator.config.separators);
-    if (variant) {
-      const [match, rest] = variant;
-      const dataAttribute = utils.h.bracket(match) ?? ctx.theme.data?.[match] ?? "";
-      if (dataAttribute) {
-        return {
-          matcher: `group-[[data-${dataAttribute}]]:${rest}`
-        };
-      }
-    }
-  }
-};
-
-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 = utils.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 = utils.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 = utils.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 = utils.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 = utils.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 numberRE = /[0-9.]+(?:[a-z]+|%)?/;
-const ignoreProps = [
-  /opacity|color|flex/
-];
-function negateFunctions(value) {
-  const match = value.match(/^(calc|clamp|max|min)\s*(\(.*)/);
-  if (match) {
-    const [fnBody, rest] = ruleUtils.getStringComponent(match[2], "(", ")", " ") ?? [];
-    if (fnBody)
-      return `calc(${match[1]}${fnBody} * -1)${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] === utils.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) => v[0].match(i)))
-            return;
-          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;
-          }
-        });
-        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 = utils.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 = utils.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 = utils.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 ? utils.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;
-  return [
-    taggedPseudoClassMatcher("group", attributify ? '[group=""]' : ".group", " "),
-    taggedPseudoClassMatcher("peer", attributify ? '[peer=""]' : ".peer", "~"),
-    taggedPseudoClassMatcher("parent", attributify ? '[parent=""]' : ".parent", ">"),
-    taggedPseudoClassMatcher("previous", attributify ? '[previous=""]' : ".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,
-    variantGroupDataAttribute
-  ];
-}
-
-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.variantGroupDataAttribute = variantGroupDataAttribute;
-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.variantTaggedPseudoClasses = variantTaggedPseudoClasses;
-exports.variantVariables = variantVariables;
-exports.variants = variants;
+const _default = require('./shared/preset-mini.jXC5Sr98.cjs');
+require('./shared/preset-mini.UhMMbd34.cjs');
+require('@unocss/core');
+require('@unocss/rule-utils');
+
+
+
+exports.calcMaxWidthBySize = _default.calcMaxWidthBySize;
+exports.variantAria = _default.variantAria;
+exports.variantBreakpoints = _default.variantBreakpoints;
+exports.variantColorsMediaOrClass = _default.variantColorsMediaOrClass;
+exports.variantCombinators = _default.variantCombinators;
+exports.variantContainerQuery = _default.variantContainerQuery;
+exports.variantCssLayer = _default.variantCssLayer;
+exports.variantCustomMedia = _default.variantCustomMedia;
+exports.variantDataAttribute = _default.variantDataAttribute;
+exports.variantImportant = _default.variantImportant;
+exports.variantInternalLayer = _default.variantInternalLayer;
+exports.variantLanguageDirections = _default.variantLanguageDirections;
+exports.variantNegative = _default.variantNegative;
+exports.variantPartClasses = _default.variantPartClasses;
+exports.variantPrint = _default.variantPrint;
+exports.variantPseudoClassFunctions = _default.variantPseudoClassFunctions;
+exports.variantPseudoClassesAndElements = _default.variantPseudoClassesAndElements;
+exports.variantScope = _default.variantScope;
+exports.variantSelector = _default.variantSelector;
+exports.variantSupports = _default.variantSupports;
+exports.variantTaggedDataAttributes = _default.variantTaggedDataAttributes;
+exports.variantTaggedPseudoClasses = _default.variantTaggedPseudoClasses;
+exports.variantVariables = _default.variantVariables;
+exports.variants = _default.variants;