@unocss/preset-mini 66.1.3 → 66.2.0

package/dist/index.mjs

@@ -2,8 +2,8 @@ import { entriesToCss, toArray, definePreset } from '@unocss/core';
 import { extractorArbitraryVariants } from '@unocss/extractor-arbitrary-variants';
 import { g as globalKeywords } from './shared/preset-mini.DrfPDgwn.mjs';
 export { k as parseColor } from './shared/preset-mini.DrfPDgwn.mjs';
-import { i as variants } from './shared/preset-mini.D2M6e9t5.mjs';
-import { r as rules } from './shared/preset-mini.0ybCwWTx.mjs';
+import { i as variants } from './shared/preset-mini.CHzPf0gx.mjs';
+import { r as rules } from './shared/preset-mini.Pwva_x9U.mjs';
 import { t as theme } from './shared/preset-mini.BsxsSmTL.mjs';
 export { colors } from './colors.mjs';
 import '@unocss/rule-utils';

package/dist/rules.mjs

@@ -1,4 +1,4 @@
-export { s as alignments, a as appearance, E as aspectRatio, e as bgColors, b as borderStyles, c as borders, B as boxSizing, f as colorScheme, g as containerParent, P as cssProperty, O as cssVariables, j as flex, x as flexGridJustifiesAlignments, z as floats, J as fonts, k as gaps, l as grids, h as handlerBorderStyle, y as insets, n as justifies, G as margins, d as opacity, q as orders, o as outline, m as overflows, F as paddings, u as placements, p as positions, C as questionMark, r as rules, D as sizes, H as svgUtilities, K as tabSizes, t as textAligns, i as textDecorations, L as textIndents, N as textShadows, M as textStrokes, I as transitions, v as verticalAligns, w as willChange, A as zIndexes } from './shared/preset-mini.0ybCwWTx.mjs';
+export { s as alignments, a as appearance, E as aspectRatio, e as bgColors, b as borderStyles, c as borders, B as boxSizing, f as colorScheme, g as containerParent, P as cssProperty, O as cssVariables, j as flex, x as flexGridJustifiesAlignments, z as floats, J as fonts, k as gaps, l as grids, h as handlerBorderStyle, y as insets, n as justifies, G as margins, d as opacity, q as orders, o as outline, m as overflows, F as paddings, u as placements, p as positions, C as questionMark, r as rules, D as sizes, H as svgUtilities, K as tabSizes, t as textAligns, i as textDecorations, L as textIndents, N as textShadows, M as textStrokes, I as transitions, v as verticalAligns, w as willChange, A as zIndexes } from './shared/preset-mini.Pwva_x9U.mjs';
 export { e as appearances, c as boxShadows, b as boxShadowsBase, k as breaks, g as contains, i as contentVisibility, j as contents, f as cursors, d as displays, q as fieldSizing, o as fontSmoothings, n as fontStyles, p as pointerEvents, h as resizes, r as ringBase, a as rings, l as textOverflows, m as textTransforms, t as textWraps, s as transformBase, x as transforms, u as userSelects, v as varEmpty, w as whitespaces } from './shared/preset-mini.DxJ0TbJb.mjs';
 import './shared/preset-mini.DrfPDgwn.mjs';
 import '@unocss/core';

package/dist/shared/{preset-mini.D2M6e9t5.mjs → preset-mini.CHzPf0gx.mjs}

@@ -1,6 +1,6 @@
-import { variantGetParameter, calcMaxWidthBySize, variantMatcher, variantGetBracket, variantParentMatcher, getBracket, hasThemeFn, transformThemeFn, getStringComponent } from '@unocss/rule-utils';
+import { variantGetParameter, calcMaxWidthBySize, variantMatcher, variantGetBracket, variantParentMatcher, getBracket, hasThemeFn, transformThemeFn, getStringComponent, createPartClasses, createPseudoClassesAndElements, createPseudoClassFunctions, createTaggedPseudoClasses } from '@unocss/rule-utils';
 import { a as h, r as resolveBreakpoints, C as CONTROL_MINI_NO_NEGATIVE, e as cssMathFnRE, f as cssVarFnRE } from './preset-mini.DrfPDgwn.mjs';
-import { toArray, escapeRegExp, escapeSelector } from '@unocss/core';
+import { toArray } from '@unocss/core';
 
 const variantAria = {
   name: "aria",
@@ -488,302 +488,19 @@ const variantNegative = {
   }
 };
 
-const PseudoPlaceholder = "__pseudo_placeholder__";
-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",
-  "popover-open",
-  // 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)"],
-  ["nth", `:nth-child(${PseudoPlaceholder})`],
-  "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"],
-  ["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 PseudoClassesMulti = Object.fromEntries([
-  ["selection", ["::selection", " *::selection"]],
-  ["marker", ["::marker", " *::marker"]]
-]);
-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("|");
-const PseudoClassesMultiStr = Object.keys(PseudoClassesMulti).sort((a, b) => b.length - a.length).join("|");
-function taggedPseudoClassMatcher(tag, parent, combinator) {
-  const rawRE = new RegExp(`^(${escapeRegExp(parent)}:)(\\S+)${escapeRegExp(combinator)}\\1`);
-  let splitRE;
-  let pseudoRE;
-  let pseudoColonRE;
-  let pseudoVarRE;
-  const matchBracket = (input) => {
-    const body = variantGetBracket(`${tag}-`, input, []);
-    if (!body)
-      return;
-    const [match, rest] = body;
-    const bracketValue = h.bracket(match);
-    if (bracketValue == null)
-      return;
-    const label = rest.split(splitRE, 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}`,
-      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}${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;
-      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;
-  let PseudoClassesMultiRE;
-  return [
-    {
-      name: "pseudo",
-      match(input, ctx) {
-        if (!(PseudoClassesAndElementsRE && PseudoClassesAndElementsColonRE)) {
-          PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})(?:-(\\[\\w+\\]))?(?:${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) {
-          let pseudo = PseudoClasses[match[1]] || PseudoClassesColon[match[1]] || `:${match[1]}`;
-          if (match[2]) {
-            const anPlusB = h.bracket(match[2]);
-            if (anPlusB) {
-              pseudo = pseudo.replace(PseudoPlaceholder, anPlusB);
-            }
-          }
-          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.includes("::") && !excludedPseudo.includes(pseudo) ? {
-                pseudo: `${input2.pseudo}${pseudo}`
-              } : {
-                selector: `${input2.selector}${pseudo}`
-              };
-              return next({
-                ...input2,
-                ...selectors,
-                sort: index,
-                noMerge: true
-              });
-            }
-          };
-        }
-      },
-      multiPass: true,
-      autocomplete: `(${PseudoClassesAndElementsStr}|${PseudoClassesAndElementsColonStr}):`
-    },
-    {
-      name: "pseudo:multi",
-      match(input, ctx) {
-        if (!PseudoClassesMultiRE) {
-          PseudoClassesMultiRE = new RegExp(`^(${PseudoClassesMultiStr})(?:${ctx.generator.config.separators.join("|")})`);
-        }
-        const match = input.match(PseudoClassesMultiRE);
-        if (match) {
-          const pseudos = PseudoClassesMulti[match[1]];
-          return pseudos.map((pseudo) => {
-            return {
-              matcher: input.slice(match[0].length),
-              handle: (input2, next) => next({
-                ...input2,
-                pseudo: `${input2.pseudo}${pseudo}`
-              })
-            };
-          });
-        }
-      },
-      multiPass: false,
-      autocomplete: `(${PseudoClassesMultiStr}):`
-    }
-  ];
+  const utils = { getBracket, h, variantGetBracket };
+  return createPseudoClassesAndElements(utils);
 }
 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 = getBracket(match[2], "[", "]");
-        const pseudo = fnVal ? 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}):`
-  };
+  const utils = { getBracket, h, variantGetBracket };
+  return createPseudoClassFunctions(utils);
 }
 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", "+"),
-    tagWithPrefix("group-aria", " "),
-    tagWithPrefix("peer-aria", "~"),
-    tagWithPrefix("parent-aria", ">"),
-    tagWithPrefix("previous-aria", "+")
-  ];
+  const utils = { getBracket, h, variantGetBracket };
+  return createTaggedPseudoClasses(options, utils);
 }
-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
-};
+const variantPartClasses = createPartClasses();
 
 const variantStartingStyle = {
   name: "starting",
@@ -810,6 +527,9 @@ const variantSupports = {
       if (supports === "")
         supports = ctx.theme.supports?.[match] ?? "";
       if (supports) {
+        if (!(supports.startsWith("(") && supports.endsWith(")"))) {
+          supports = `(${supports})`;
+        }
         return {
           matcher: rest,
           handle: (input, next) => next({

package/dist/shared/{preset-mini.0ybCwWTx.mjs → preset-mini.Pwva_x9U.mjs}

@@ -405,12 +405,17 @@ const justifies = [
   ["justify-stretch", { "justify-content": "stretch" }],
   ["justify-left", { "justify-content": "left" }],
   ["justify-right", { "justify-content": "right" }],
+  ["justify-center-safe", { "justify-content": "safe center" }],
+  ["justify-end-safe", { "justify-content": "safe flex-end" }],
+  ["justify-normal", { "justify-content": "normal" }],
   ...makeGlobalStaticRules("justify", "justify-content"),
   // items
   ["justify-items-start", { "justify-items": "start" }],
   ["justify-items-end", { "justify-items": "end" }],
   ["justify-items-center", { "justify-items": "center" }],
   ["justify-items-stretch", { "justify-items": "stretch" }],
+  ["justify-items-center-safe", { "justify-items": "safe center" }],
+  ["justify-items-end-safe", { "justify-items": "safe flex-end" }],
   ...makeGlobalStaticRules("justify-items"),
   // selfs
   ["justify-self-auto", { "justify-self": "auto" }],
@@ -418,6 +423,9 @@ const justifies = [
   ["justify-self-end", { "justify-self": "end" }],
   ["justify-self-center", { "justify-self": "center" }],
   ["justify-self-stretch", { "justify-self": "stretch" }],
+  ["justify-self-baseline", { "justify-self": "baseline" }],
+  ["justify-self-center-safe", { "justify-self": "safe center" }],
+  ["justify-self-end-safe", { "justify-self": "safe flex-end" }],
   ...makeGlobalStaticRules("justify-self")
 ];
 const orders = [
@@ -434,6 +442,11 @@ const alignments = [
   ["content-between", { "align-content": "space-between" }],
   ["content-around", { "align-content": "space-around" }],
   ["content-evenly", { "align-content": "space-evenly" }],
+  ["content-baseline", { "align-content": "baseline" }],
+  ["content-center-safe", { "align-content": "safe center" }],
+  ["content-end-safe", { "align-content": "safe flex-end" }],
+  ["content-stretch", { "align-content": "stretch" }],
+  ["content-normal", { "align-content": "normal" }],
   ...makeGlobalStaticRules("content", "align-content"),
   // items
   ["items-start", { "align-items": "flex-start" }],
@@ -441,6 +454,9 @@ const alignments = [
   ["items-center", { "align-items": "center" }],
   ["items-baseline", { "align-items": "baseline" }],
   ["items-stretch", { "align-items": "stretch" }],
+  ["items-baseline-last", { "align-items": "last baseline" }],
+  ["items-center-safe", { "align-items": "safe center" }],
+  ["items-end-safe", { "align-items": "safe flex-end" }],
   ...makeGlobalStaticRules("items", "align-items"),
   // selfs
   ["self-auto", { "align-self": "auto" }],
@@ -449,6 +465,9 @@ const alignments = [
   ["self-center", { "align-self": "center" }],
   ["self-stretch", { "align-self": "stretch" }],
   ["self-baseline", { "align-self": "baseline" }],
+  ["self-baseline-last", { "align-self": "last baseline" }],
+  ["self-center-safe", { "align-self": "safe center" }],
+  ["self-end-safe", { "align-self": "safe flex-end" }],
   ...makeGlobalStaticRules("self", "align-self")
 ];
 const placements = [
@@ -460,12 +479,18 @@ const placements = [
   ["place-content-around", { "place-content": "space-around" }],
   ["place-content-evenly", { "place-content": "space-evenly" }],
   ["place-content-stretch", { "place-content": "stretch" }],
+  ["place-content-baseline", { "place-content": "baseline" }],
+  ["place-content-center-safe", { "place-content": "safe center" }],
+  ["place-content-end-safe", { "place-content": "safe flex-end" }],
   ...makeGlobalStaticRules("place-content"),
   // items
   ["place-items-start", { "place-items": "start" }],
   ["place-items-end", { "place-items": "end" }],
   ["place-items-center", { "place-items": "center" }],
   ["place-items-stretch", { "place-items": "stretch" }],
+  ["place-items-baseline", { "place-items": "baseline" }],
+  ["place-items-center-safe", { "place-items": "safe center" }],
+  ["place-items-end-safe", { "place-items": "safe flex-end" }],
   ...makeGlobalStaticRules("place-items"),
   // selfs
   ["place-self-auto", { "place-self": "auto" }],
@@ -473,6 +498,8 @@ const placements = [
   ["place-self-end", { "place-self": "end" }],
   ["place-self-center", { "place-self": "center" }],
   ["place-self-stretch", { "place-self": "stretch" }],
+  ["place-self-center-safe", { "place-self": "safe center" }],
+  ["place-self-end-safe", { "place-self": "safe flex-end" }],
   ...makeGlobalStaticRules("place-self")
 ];
 const flexGridJustifiesAlignments = [...justifies, ...alignments, ...placements].flatMap(([k, v]) => [

package/dist/variants.mjs

@@ -1,4 +1,4 @@
-export { v as variantAria, b as variantBreakpoints, c as variantChildren, f as variantColorsMediaOrClass, d as variantCombinators, e as variantContainerQuery, o as variantCssLayer, m as variantCustomMedia, g as variantDataAttribute, k as variantImportant, p as variantInternalLayer, j as variantLanguageDirections, t as variantNegative, y as variantPartClasses, l as variantPrint, w as variantPseudoClassFunctions, u as variantPseudoClassesAndElements, q as variantScope, n as variantSelector, z as variantStartingStyle, A as variantSupports, a as variantTaggedAriaAttributes, h as variantTaggedDataAttributes, x as variantTaggedPseudoClasses, s as variantTheme, r as variantVariables, i as variants } from './shared/preset-mini.D2M6e9t5.mjs';
+export { v as variantAria, b as variantBreakpoints, c as variantChildren, f as variantColorsMediaOrClass, d as variantCombinators, e as variantContainerQuery, o as variantCssLayer, m as variantCustomMedia, g as variantDataAttribute, k as variantImportant, p as variantInternalLayer, j as variantLanguageDirections, t as variantNegative, y as variantPartClasses, l as variantPrint, w as variantPseudoClassFunctions, u as variantPseudoClassesAndElements, q as variantScope, n as variantSelector, z as variantStartingStyle, A as variantSupports, a as variantTaggedAriaAttributes, h as variantTaggedDataAttributes, x as variantTaggedPseudoClasses, s as variantTheme, r as variantVariables, i as variants } from './shared/preset-mini.CHzPf0gx.mjs';
 import '@unocss/rule-utils';
 import './shared/preset-mini.DrfPDgwn.mjs';
 import '@unocss/core';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unocss/preset-mini",
   "type": "module",
-  "version": "66.1.3",
+  "version": "66.2.0",
   "description": "The minimal preset for UnoCSS",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -56,9 +56,9 @@
     "dist"
   ],
   "dependencies": {
-    "@unocss/rule-utils": "66.1.3",
-    "@unocss/core": "66.1.3",
-    "@unocss/extractor-arbitrary-variants": "66.1.3"
+    "@unocss/core": "66.2.0",
+    "@unocss/extractor-arbitrary-variants": "66.2.0",
+    "@unocss/rule-utils": "66.2.0"
   },
   "scripts": {
     "build": "unbuild",