@unocss/preset-mini 0.35.1 → 0.35.4

package/dist/chunks/default2.cjs

@@ -19,14 +19,14 @@ const verticalAlignAlias = {
 const verticalAligns = [
   [/^(?:vertical|align|v)-(.+)$/, ([, v]) => ({ "vertical-align": verticalAlignAlias[v] }), { autocomplete: `(vertical|align|v)-(${Object.keys(verticalAlignAlias).join("|")})` }]
 ];
-const textAligns = ["center", "left", "right", "justify", "start", "end", "inherit", "initial", "unset", "revert"].map((v) => [`text-${v}`, { "text-align": v }]);
+const textAligns = ["center", "left", "right", "justify", "start", "end", ...utilities.globalKeywords].map((v) => [`text-${v}`, { "text-align": v }]);
 
 const outline = [
   [/^outline-(?:width-|size-)?(.+)$/, ([, d], { theme }) => ({ "outline-width": theme.lineWidth?.[d] ?? utilities.handler.bracket.cssvar.px(d) }), { autocomplete: "outline-(width|size)-<num>" }],
   [/^outline-(?:color-)?(.+)$/, utilities.colorResolver("outline-color", "outline-color"), { autocomplete: "outline-$colors" }],
   [/^outline-offset-(.+)$/, ([, d], { theme }) => ({ "outline-offset": theme.lineWidth?.[d] ?? utilities.handler.bracket.cssvar.px(d) }), { autocomplete: "outline-(offset)-<num>" }],
   ["outline", { "outline-style": "solid" }],
-  ...["auto", "dashed", "dotted", "double", "hidden", "solid", "groove", "ridge", "inset", "outset", "inherit", "initial", "revert", "unset"].map((v) => [`outline-${v}`, { "outline-style": v }]),
+  ...["auto", "dashed", "dotted", "double", "hidden", "solid", "groove", "ridge", "inset", "outset", ...utilities.globalKeywords].map((v) => [`outline-${v}`, { "outline-style": v }]),
   ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }]
 ];
 const appearance = [
@@ -45,7 +45,7 @@ const willChange = [
   [/^will-change-(.+)/, ([, p]) => ({ "will-change": willChangeProperty(p) })]
 ];
 
-const borderStyles = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", "initial", "inherit", "revert", "unset"];
+const borderStyles = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", ...utilities.globalKeywords];
 const borders = [
   [/^(?:border|b)()(?:-(.+))?$/, handlerBorder, { autocomplete: "(border|b)-<directions>" }],
   [/^(?:border|b)-([xy])(?:-(.+))?$/, handlerBorder],
@@ -195,7 +195,7 @@ const transitions = [
   [
     /^(?:transition-)?property-(.+)$/,
     ([, v]) => ({ "transition-property": utilities.handler.global(v) || transitionProperty(v) }),
-    { autocomplete: [`transition-property-(${["inherit", "initial", "revert", "unset", ...Object.keys(transitionPropertyGroup)].join("|")})`] }
+    { autocomplete: [`transition-property-(${[...utilities.globalKeywords, ...Object.keys(transitionPropertyGroup)].join("|")})`] }
   ],
   ["transition-none", { transition: "none" }]
 ];
@@ -374,7 +374,7 @@ const grids = [
   [/^(?:grid-)?(row|col)-end-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-end`]: utilities.handler.bracket.cssvar(v) ?? v })],
   [/^(?:grid-)?auto-(rows|cols)-(.+)$/, ([, c, v], { theme }) => ({ [`grid-auto-${rowCol(c)}`]: autoDirection(c, theme, v) })],
   [/^(?:grid-auto-flow|auto-flow|grid-flow)-(.+)$/, ([, v]) => ({ "grid-auto-flow": utilities.handler.bracket.cssvar(v) })],
-  [/^(?:grid-auto-flow|auto-flow|grid-flow)-((?:row|col)(?:-dense)?)$/, ([, v]) => ({ "grid-auto-flow": rowCol(v).replace("-", " ") })],
+  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(row|col|dense|row-dense|col-dense)$/, ([, v]) => ({ "grid-auto-flow": rowCol(v).replace("-", " ") })],
   [/^grid-(rows|cols)-(.+)$/, ([, c, v], { theme }) => ({
     [`grid-template-${rowCol(c)}`]: theme[`gridTemplate${rowColTheme(c)}`]?.[v] ?? utilities.handler.bracket.cssvar(v)
   })],
@@ -907,6 +907,7 @@ ${constructCSS({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
   ]
 ];
 
+const decorationStyles = ["solid", "double", "dotted", "dashed", "wavy", ...utilities.globalKeywords];
 const textDecorations = [
   [/^(?:decoration-)?(underline|overline|line-through)$/, ([, s]) => ({ "text-decoration-line": s }), { autocomplete: "decoration-(underline|overline|line-through)" }],
   [/^(?:underline|decoration)-(?:size-)?(.+)$/, ([, s], { theme }) => ({ "text-decoration-thickness": theme.lineWidth?.[s] ?? utilities.handler.bracket.cssvar.px(s) }), { autocomplete: "(underline|decoration)-<num>" }],
@@ -922,7 +923,8 @@ const textDecorations = [
   }, { autocomplete: "(underline|decoration)-$colors" }],
   [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": utilities.handler.bracket.percent(opacity) }), { autocomplete: "(underline|decoration)-(op|opacity)-<percent>" }],
   [/^(?:underline|decoration)-offset-(.+)$/, ([, s], { theme }) => ({ "text-underline-offset": theme.lineWidth?.[s] ?? utilities.handler.auto.bracket.cssvar.px(s) }), { autocomplete: "(underline|decoration)-(offset)-<num>" }],
-  [/^(?:underline|decoration)-(solid|double|dotted|dashed|wavy|inherit|initial|revert|unset)$/, ([, d]) => ({ "text-decoration-style": d }), { autocomplete: "(underline|decoration)-(solid|double|dotted|dashed|wavy|inherit|initial|revert|unset)" }],
+  ...decorationStyles.map((v) => [`underline-${v}`, { "text-decoration-style": v }]),
+  ...decorationStyles.map((v) => [`decoration-${v}`, { "text-decoration-style": v }]),
   ["no-underline", { "text-decoration": "none" }],
   ["decoration-none", { "text-decoration": "none" }]
 ];

package/dist/chunks/default2.mjs

@@ -1,4 +1,4 @@
-import { h as handler, c as colorResolver, d as directionMap, a as hasParseableColor, p as parseColor, b as colorToString, e as cornerMap, f as colorableShadows, i as insetMap, r as resolveVerticalBreakpoints, g as resolveBreakpoints, j as directionSize, C as CONTROL_MINI_NO_NEGATIVE, k as positionMap, x as xyzMap } from './utilities.mjs';
+import { g as globalKeywords, h as handler, c as colorResolver, d as directionMap, a as hasParseableColor, p as parseColor, b as colorToString, e as cornerMap, f as colorableShadows, i as insetMap, r as resolveVerticalBreakpoints, j as resolveBreakpoints, k as directionSize, C as CONTROL_MINI_NO_NEGATIVE, l as positionMap, x as xyzMap } from './utilities.mjs';
 import { toArray, CONTROL_SHORTCUT_NO_MERGE } from '@unocss/core';
 
 const verticalAlignAlias = {
@@ -17,14 +17,14 @@ const verticalAlignAlias = {
 const verticalAligns = [
   [/^(?:vertical|align|v)-(.+)$/, ([, v]) => ({ "vertical-align": verticalAlignAlias[v] }), { autocomplete: `(vertical|align|v)-(${Object.keys(verticalAlignAlias).join("|")})` }]
 ];
-const textAligns = ["center", "left", "right", "justify", "start", "end", "inherit", "initial", "unset", "revert"].map((v) => [`text-${v}`, { "text-align": v }]);
+const textAligns = ["center", "left", "right", "justify", "start", "end", ...globalKeywords].map((v) => [`text-${v}`, { "text-align": v }]);
 
 const outline = [
   [/^outline-(?:width-|size-)?(.+)$/, ([, d], { theme }) => ({ "outline-width": theme.lineWidth?.[d] ?? handler.bracket.cssvar.px(d) }), { autocomplete: "outline-(width|size)-<num>" }],
   [/^outline-(?:color-)?(.+)$/, colorResolver("outline-color", "outline-color"), { autocomplete: "outline-$colors" }],
   [/^outline-offset-(.+)$/, ([, d], { theme }) => ({ "outline-offset": theme.lineWidth?.[d] ?? handler.bracket.cssvar.px(d) }), { autocomplete: "outline-(offset)-<num>" }],
   ["outline", { "outline-style": "solid" }],
-  ...["auto", "dashed", "dotted", "double", "hidden", "solid", "groove", "ridge", "inset", "outset", "inherit", "initial", "revert", "unset"].map((v) => [`outline-${v}`, { "outline-style": v }]),
+  ...["auto", "dashed", "dotted", "double", "hidden", "solid", "groove", "ridge", "inset", "outset", ...globalKeywords].map((v) => [`outline-${v}`, { "outline-style": v }]),
   ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }]
 ];
 const appearance = [
@@ -43,7 +43,7 @@ const willChange = [
   [/^will-change-(.+)/, ([, p]) => ({ "will-change": willChangeProperty(p) })]
 ];
 
-const borderStyles = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", "initial", "inherit", "revert", "unset"];
+const borderStyles = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", ...globalKeywords];
 const borders = [
   [/^(?:border|b)()(?:-(.+))?$/, handlerBorder, { autocomplete: "(border|b)-<directions>" }],
   [/^(?:border|b)-([xy])(?:-(.+))?$/, handlerBorder],
@@ -193,7 +193,7 @@ const transitions = [
   [
     /^(?:transition-)?property-(.+)$/,
     ([, v]) => ({ "transition-property": handler.global(v) || transitionProperty(v) }),
-    { autocomplete: [`transition-property-(${["inherit", "initial", "revert", "unset", ...Object.keys(transitionPropertyGroup)].join("|")})`] }
+    { autocomplete: [`transition-property-(${[...globalKeywords, ...Object.keys(transitionPropertyGroup)].join("|")})`] }
   ],
   ["transition-none", { transition: "none" }]
 ];
@@ -372,7 +372,7 @@ const grids = [
   [/^(?:grid-)?(row|col)-end-(.+)$/, ([, c, v]) => ({ [`grid-${rowCol(c)}-end`]: handler.bracket.cssvar(v) ?? v })],
   [/^(?:grid-)?auto-(rows|cols)-(.+)$/, ([, c, v], { theme }) => ({ [`grid-auto-${rowCol(c)}`]: autoDirection(c, theme, v) })],
   [/^(?:grid-auto-flow|auto-flow|grid-flow)-(.+)$/, ([, v]) => ({ "grid-auto-flow": handler.bracket.cssvar(v) })],
-  [/^(?:grid-auto-flow|auto-flow|grid-flow)-((?:row|col)(?:-dense)?)$/, ([, v]) => ({ "grid-auto-flow": rowCol(v).replace("-", " ") })],
+  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(row|col|dense|row-dense|col-dense)$/, ([, v]) => ({ "grid-auto-flow": rowCol(v).replace("-", " ") })],
   [/^grid-(rows|cols)-(.+)$/, ([, c, v], { theme }) => ({
     [`grid-template-${rowCol(c)}`]: theme[`gridTemplate${rowColTheme(c)}`]?.[v] ?? handler.bracket.cssvar(v)
   })],
@@ -905,6 +905,7 @@ ${constructCSS({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
   ]
 ];
 
+const decorationStyles = ["solid", "double", "dotted", "dashed", "wavy", ...globalKeywords];
 const textDecorations = [
   [/^(?:decoration-)?(underline|overline|line-through)$/, ([, s]) => ({ "text-decoration-line": s }), { autocomplete: "decoration-(underline|overline|line-through)" }],
   [/^(?:underline|decoration)-(?:size-)?(.+)$/, ([, s], { theme }) => ({ "text-decoration-thickness": theme.lineWidth?.[s] ?? handler.bracket.cssvar.px(s) }), { autocomplete: "(underline|decoration)-<num>" }],
@@ -920,7 +921,8 @@ const textDecorations = [
   }, { autocomplete: "(underline|decoration)-$colors" }],
   [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, opacity]) => ({ "--un-line-opacity": handler.bracket.percent(opacity) }), { autocomplete: "(underline|decoration)-(op|opacity)-<percent>" }],
   [/^(?:underline|decoration)-offset-(.+)$/, ([, s], { theme }) => ({ "text-underline-offset": theme.lineWidth?.[s] ?? handler.auto.bracket.cssvar.px(s) }), { autocomplete: "(underline|decoration)-(offset)-<num>" }],
-  [/^(?:underline|decoration)-(solid|double|dotted|dashed|wavy|inherit|initial|revert|unset)$/, ([, d]) => ({ "text-decoration-style": d }), { autocomplete: "(underline|decoration)-(solid|double|dotted|dashed|wavy|inherit|initial|revert|unset)" }],
+  ...decorationStyles.map((v) => [`underline-${v}`, { "text-decoration-style": v }]),
+  ...decorationStyles.map((v) => [`decoration-${v}`, { "text-decoration-style": v }]),
   ["no-underline", { "text-decoration": "none" }],
   ["decoration-none", { "text-decoration": "none" }]
 ];

package/dist/chunks/default3.cjs

@@ -240,7 +240,10 @@ const PseudoClasses = Object.fromEntries([
   ["selection", "::selection"],
   ["marker", "::marker"],
   ["file", "::file-selector-button"]
-].map((key) => typeof key === "string" ? [key, `:${key}`] : key));
+].map((key) => Array.isArray(key) ? key : [key, `:${key}`]));
+const PseudoClassesColon = Object.fromEntries([
+  ["backdrop", "::backdrop"]
+].map((key) => Array.isArray(key) ? key : [key, `:${key}`]));
 const PseudoClassFunctions = [
   "not",
   "is",
@@ -248,20 +251,22 @@ const PseudoClassFunctions = [
   "has"
 ];
 const PseudoClassesStr = Object.entries(PseudoClasses).filter(([, pseudo]) => !pseudo.startsWith("::")).map(([key]) => key).join("|");
+const PseudoClassesColonStr = Object.entries(PseudoClassesColon).filter(([, pseudo]) => !pseudo.startsWith("::")).map(([key]) => key).join("|");
 const PseudoClassFunctionsStr = PseudoClassFunctions.join("|");
 const sortValue = (pseudo) => {
   if (pseudo === "active")
     return 1;
 };
 const taggedPseudoClassMatcher = (tag, parent, combinator) => {
-  const re = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))[:-]`);
   const rawRe = new RegExp(`^${core.escapeRegExp(parent)}:`);
+  const pseudoRE = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))[:-]`);
+  const pseudoColonRE = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesColonStr}))[:]`);
   return {
     name: `pseudo:${tag}`,
     match(input) {
-      const match = input.match(re);
+      const match = input.match(pseudoRE) || input.match(pseudoColonRE);
       if (match) {
-        let pseudo = PseudoClasses[match[3]] || `:${match[3]}`;
+        let pseudo = PseudoClasses[match[3]] || PseudoClassesColon[match[3]] || `:${match[3]}`;
         if (match[2])
           pseudo = `:${match[2]}(${pseudo})`;
         return {
@@ -274,13 +279,15 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
   };
 };
 const PseudoClassesAndElementsStr = Object.entries(PseudoClasses).map(([key]) => key).join("|");
+const PseudoClassesAndElementsColonStr = Object.entries(PseudoClassesColon).map(([key]) => key).join("|");
 const PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})[:-]`);
+const PseudoClassesAndElementsColonRE = new RegExp(`^(${PseudoClassesAndElementsColonStr})[:]`);
 const variantPseudoClassesAndElements = {
   name: "pseudo",
   match: (input) => {
-    const match = input.match(PseudoClassesAndElementsRE);
+    const match = input.match(PseudoClassesAndElementsRE) || input.match(PseudoClassesAndElementsColonRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
+      const pseudo = PseudoClasses[match[1]] || PseudoClassesColon[match[1]] || `:${match[1]}`;
       return {
         matcher: input.slice(match[0].length),
         selector: (s) => `${s}${pseudo}`,
@@ -292,12 +299,13 @@ const variantPseudoClassesAndElements = {
   autocomplete: `(${PseudoClassesAndElementsStr}):`
 };
 const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
+const PseudoClassColonFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesColonStr})[:]`);
 const variantPseudoClassFunctions = {
   match: (input) => {
-    const match = input.match(PseudoClassFunctionsRE);
+    const match = input.match(PseudoClassFunctionsRE) || input.match(PseudoClassColonFunctionsRE);
     if (match) {
       const fn = match[1];
-      const pseudo = PseudoClasses[match[2]] || `:${match[2]}`;
+      const pseudo = PseudoClasses[match[2]] || PseudoClassesColon[match[2]] || `:${match[2]}`;
       return {
         matcher: input.slice(match[0].length),
         selector: (s) => `${s}:${fn}(${pseudo})`
@@ -305,7 +313,7 @@ const variantPseudoClassFunctions = {
     }
   },
   multiPass: true,
-  autocomplete: `(${PseudoClassFunctionsStr})-(${PseudoClassesStr}):`
+  autocomplete: `(${PseudoClassFunctionsStr})-(${PseudoClassesStr}|${PseudoClassesColonStr}):`
 };
 const variantTaggedPseudoClasses = (options = {}) => {
   const attributify = !!options?.attributifyPseudo;

package/dist/chunks/default3.mjs

@@ -1,4 +1,4 @@
-import { g as resolveBreakpoints, C as CONTROL_MINI_NO_NEGATIVE } from './utilities.mjs';
+import { j as resolveBreakpoints, C as CONTROL_MINI_NO_NEGATIVE } from './utilities.mjs';
 import { v as variantParentMatcher, a as variantMatcher } from './variants.mjs';
 import { escapeRegExp } from '@unocss/core';
 
@@ -238,7 +238,10 @@ const PseudoClasses = Object.fromEntries([
   ["selection", "::selection"],
   ["marker", "::marker"],
   ["file", "::file-selector-button"]
-].map((key) => typeof key === "string" ? [key, `:${key}`] : key));
+].map((key) => Array.isArray(key) ? key : [key, `:${key}`]));
+const PseudoClassesColon = Object.fromEntries([
+  ["backdrop", "::backdrop"]
+].map((key) => Array.isArray(key) ? key : [key, `:${key}`]));
 const PseudoClassFunctions = [
   "not",
   "is",
@@ -246,20 +249,22 @@ const PseudoClassFunctions = [
   "has"
 ];
 const PseudoClassesStr = Object.entries(PseudoClasses).filter(([, pseudo]) => !pseudo.startsWith("::")).map(([key]) => key).join("|");
+const PseudoClassesColonStr = Object.entries(PseudoClassesColon).filter(([, pseudo]) => !pseudo.startsWith("::")).map(([key]) => key).join("|");
 const PseudoClassFunctionsStr = PseudoClassFunctions.join("|");
 const sortValue = (pseudo) => {
   if (pseudo === "active")
     return 1;
 };
 const taggedPseudoClassMatcher = (tag, parent, combinator) => {
-  const re = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))[:-]`);
   const rawRe = new RegExp(`^${escapeRegExp(parent)}:`);
+  const pseudoRE = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesStr}))[:-]`);
+  const pseudoColonRE = new RegExp(`^${tag}-((?:(${PseudoClassFunctionsStr})-)?(${PseudoClassesColonStr}))[:]`);
   return {
     name: `pseudo:${tag}`,
     match(input) {
-      const match = input.match(re);
+      const match = input.match(pseudoRE) || input.match(pseudoColonRE);
       if (match) {
-        let pseudo = PseudoClasses[match[3]] || `:${match[3]}`;
+        let pseudo = PseudoClasses[match[3]] || PseudoClassesColon[match[3]] || `:${match[3]}`;
         if (match[2])
           pseudo = `:${match[2]}(${pseudo})`;
         return {
@@ -272,13 +277,15 @@ const taggedPseudoClassMatcher = (tag, parent, combinator) => {
   };
 };
 const PseudoClassesAndElementsStr = Object.entries(PseudoClasses).map(([key]) => key).join("|");
+const PseudoClassesAndElementsColonStr = Object.entries(PseudoClassesColon).map(([key]) => key).join("|");
 const PseudoClassesAndElementsRE = new RegExp(`^(${PseudoClassesAndElementsStr})[:-]`);
+const PseudoClassesAndElementsColonRE = new RegExp(`^(${PseudoClassesAndElementsColonStr})[:]`);
 const variantPseudoClassesAndElements = {
   name: "pseudo",
   match: (input) => {
-    const match = input.match(PseudoClassesAndElementsRE);
+    const match = input.match(PseudoClassesAndElementsRE) || input.match(PseudoClassesAndElementsColonRE);
     if (match) {
-      const pseudo = PseudoClasses[match[1]] || `:${match[1]}`;
+      const pseudo = PseudoClasses[match[1]] || PseudoClassesColon[match[1]] || `:${match[1]}`;
       return {
         matcher: input.slice(match[0].length),
         selector: (s) => `${s}${pseudo}`,
@@ -290,12 +297,13 @@ const variantPseudoClassesAndElements = {
   autocomplete: `(${PseudoClassesAndElementsStr}):`
 };
 const PseudoClassFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesStr})[:-]`);
+const PseudoClassColonFunctionsRE = new RegExp(`^(${PseudoClassFunctionsStr})-(${PseudoClassesColonStr})[:]`);
 const variantPseudoClassFunctions = {
   match: (input) => {
-    const match = input.match(PseudoClassFunctionsRE);
+    const match = input.match(PseudoClassFunctionsRE) || input.match(PseudoClassColonFunctionsRE);
     if (match) {
       const fn = match[1];
-      const pseudo = PseudoClasses[match[2]] || `:${match[2]}`;
+      const pseudo = PseudoClasses[match[2]] || PseudoClassesColon[match[2]] || `:${match[2]}`;
       return {
         matcher: input.slice(match[0].length),
         selector: (s) => `${s}:${fn}(${pseudo})`
@@ -303,7 +311,7 @@ const variantPseudoClassFunctions = {
     }
   },
   multiPass: true,
-  autocomplete: `(${PseudoClassFunctionsStr})-(${PseudoClassesStr}):`
+  autocomplete: `(${PseudoClassFunctionsStr})-(${PseudoClassesStr}|${PseudoClassesColonStr}):`
 };
 const variantTaggedPseudoClasses = (options = {}) => {
   const attributify = !!options?.attributifyPseudo;

package/dist/chunks/utilities.cjs

@@ -2,6 +2,100 @@
 
 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"],
+  "": [""],
+  "bs": ["-block-start"],
+  "be": ["-block-end"],
+  "is": ["-inline-start"],
+  "ie": ["-inline-end"],
+  "block": ["-block-start", "-block-end"],
+  "inline": ["-inline-start", "-inline-end"]
+};
+const insetMap = {
+  ...directionMap,
+  s: ["-inset-inline-start"],
+  e: ["-inset-inline-end"],
+  bs: ["-inset-block-start"],
+  be: ["-inset-block-end"],
+  is: ["-inset-inline-start"],
+  ie: ["-inset-inline-end"],
+  block: ["-inset-block-start", "-inset-block-end"],
+  inline: ["-inset-inline-start", "-inset-inline-end"]
+};
+const cornerMap = {
+  "l": ["-top-left", "-bottom-left"],
+  "r": ["-top-right", "-bottom-right"],
+  "t": ["-top-left", "-top-right"],
+  "b": ["-bottom-left", "-bottom-right"],
+  "tl": ["-top-left"],
+  "lt": ["-top-left"],
+  "tr": ["-top-right"],
+  "rt": ["-top-right"],
+  "bl": ["-bottom-left"],
+  "lb": ["-bottom-left"],
+  "br": ["-bottom-right"],
+  "rb": ["-bottom-right"],
+  "": [""],
+  "bs": ["-start-start", "-start-end"],
+  "be": ["-end-start", "-end-end"],
+  "is": ["-end-start", "-start-start"],
+  "ie": ["-start-end", "-end-end"],
+  "bs-is": ["-start-start"],
+  "is-bs": ["-start-start"],
+  "bs-ie": ["-start-end"],
+  "ie-bs": ["-start-end"],
+  "be-is": ["-end-start"],
+  "is-be": ["-end-start"],
+  "be-ie": ["-end-end"],
+  "ie-be": ["-end-end"]
+};
+const xyzMap = {
+  "x": ["-x"],
+  "y": ["-y"],
+  "z": ["-z"],
+  "": ["-x", "-y"]
+};
+const basePositionMap = [
+  "top",
+  "top center",
+  "top left",
+  "top right",
+  "bottom",
+  "bottom center",
+  "bottom left",
+  "bottom right",
+  "left",
+  "left center",
+  "left top",
+  "left bottom",
+  "right",
+  "right center",
+  "right top",
+  "right bottom",
+  "center",
+  "center top",
+  "center bottom",
+  "center left",
+  "center right",
+  "center center"
+];
+const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
+const globalKeywords = [
+  "inherit",
+  "initial",
+  "revert",
+  "revert-layer",
+  "unset"
+];
+
 const cssColorFunctions = ["hsl", "hsla", "hwb", "lab", "lch", "oklab", "oklch", "rgb", "rgba"];
 function hex2rgba(hex = "") {
   const color = parseHexColor(hex);
@@ -221,93 +315,6 @@ function getComponents(str, separator, limit) {
     return components;
 }
 
-const directionMap = {
-  "l": ["-left"],
-  "r": ["-right"],
-  "t": ["-top"],
-  "b": ["-bottom"],
-  "s": ["-inline-start"],
-  "e": ["-inline-end"],
-  "x": ["-left", "-right"],
-  "y": ["-top", "-bottom"],
-  "": [""],
-  "bs": ["-block-start"],
-  "be": ["-block-end"],
-  "is": ["-inline-start"],
-  "ie": ["-inline-end"],
-  "block": ["-block-start", "-block-end"],
-  "inline": ["-inline-start", "-inline-end"]
-};
-const insetMap = {
-  ...directionMap,
-  s: ["-inset-inline-start"],
-  e: ["-inset-inline-end"],
-  bs: ["-inset-block-start"],
-  be: ["-inset-block-end"],
-  is: ["-inset-inline-start"],
-  ie: ["-inset-inline-end"],
-  block: ["-inset-block-start", "-inset-block-end"],
-  inline: ["-inset-inline-start", "-inset-inline-end"]
-};
-const cornerMap = {
-  "l": ["-top-left", "-bottom-left"],
-  "r": ["-top-right", "-bottom-right"],
-  "t": ["-top-left", "-top-right"],
-  "b": ["-bottom-left", "-bottom-right"],
-  "tl": ["-top-left"],
-  "lt": ["-top-left"],
-  "tr": ["-top-right"],
-  "rt": ["-top-right"],
-  "bl": ["-bottom-left"],
-  "lb": ["-bottom-left"],
-  "br": ["-bottom-right"],
-  "rb": ["-bottom-right"],
-  "": [""],
-  "bs": ["-start-start", "-start-end"],
-  "be": ["-end-start", "-end-end"],
-  "is": ["-end-start", "-start-start"],
-  "ie": ["-start-end", "-end-end"],
-  "bs-is": ["-start-start"],
-  "is-bs": ["-start-start"],
-  "bs-ie": ["-start-end"],
-  "ie-bs": ["-start-end"],
-  "be-is": ["-end-start"],
-  "is-be": ["-end-start"],
-  "be-ie": ["-end-end"],
-  "ie-be": ["-end-end"]
-};
-const xyzMap = {
-  "x": ["-x"],
-  "y": ["-y"],
-  "z": ["-z"],
-  "": ["-x", "-y"]
-};
-const basePositionMap = [
-  "top",
-  "top center",
-  "top left",
-  "top right",
-  "bottom",
-  "bottom center",
-  "bottom left",
-  "bottom right",
-  "left",
-  "left center",
-  "left top",
-  "left bottom",
-  "right",
-  "right center",
-  "right top",
-  "right bottom",
-  "center",
-  "center top",
-  "center bottom",
-  "center left",
-  "center right",
-  "center center"
-];
-const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
-
 const cssProps = [
   "color",
   "border-color",
@@ -424,10 +431,11 @@ function fraction(str) {
   if (!Number.isNaN(num))
     return `${round(num * 100)}%`;
 }
+const bracketTypeRe = /^\[(color|length|position):/i;
 function bracketWithType(str, type) {
   if (str && str.startsWith("[") && str.endsWith("]")) {
     let base;
-    const match = str.match(/^\[(color|length|position):/i);
+    const match = str.match(bracketTypeRe);
     if (!match)
       base = str.slice(1, -1);
     else if (type && match[1] === type)
@@ -474,13 +482,17 @@ function degree(str) {
     return unit ? `${round(num)}${unit}` : `${round(num)}deg`;
 }
 function global(str) {
-  if (["inherit", "initial", "revert", "unset"].includes(str))
+  if (globalKeywords.includes(str))
     return str;
 }
 function properties(str) {
   if (str.split(",").every((prop) => cssProps.includes(prop)))
     return str;
 }
+function position(str) {
+  if (["top", "left", "right", "bottom", "center"].includes(str))
+    return str;
+}
 
 const valueHandlers = {
   __proto__: null,
@@ -499,7 +511,8 @@ const valueHandlers = {
   time: time,
   degree: degree,
   global: global,
-  properties: properties
+  properties: properties,
+  position: position
 };
 
 const handler = core.createValueHandler(valueHandlers);
@@ -627,6 +640,7 @@ exports.cornerMap = cornerMap;
 exports.directionMap = directionMap;
 exports.directionSize = directionSize;
 exports.getComponents = getComponents;
+exports.globalKeywords = globalKeywords;
 exports.h = h;
 exports.handler = handler;
 exports.hasParseableColor = hasParseableColor;

package/dist/chunks/utilities.mjs

@@ -1,5 +1,99 @@
 import { escapeSelector, createValueHandler, toArray } from '@unocss/core';
 
+const directionMap = {
+  "l": ["-left"],
+  "r": ["-right"],
+  "t": ["-top"],
+  "b": ["-bottom"],
+  "s": ["-inline-start"],
+  "e": ["-inline-end"],
+  "x": ["-left", "-right"],
+  "y": ["-top", "-bottom"],
+  "": [""],
+  "bs": ["-block-start"],
+  "be": ["-block-end"],
+  "is": ["-inline-start"],
+  "ie": ["-inline-end"],
+  "block": ["-block-start", "-block-end"],
+  "inline": ["-inline-start", "-inline-end"]
+};
+const insetMap = {
+  ...directionMap,
+  s: ["-inset-inline-start"],
+  e: ["-inset-inline-end"],
+  bs: ["-inset-block-start"],
+  be: ["-inset-block-end"],
+  is: ["-inset-inline-start"],
+  ie: ["-inset-inline-end"],
+  block: ["-inset-block-start", "-inset-block-end"],
+  inline: ["-inset-inline-start", "-inset-inline-end"]
+};
+const cornerMap = {
+  "l": ["-top-left", "-bottom-left"],
+  "r": ["-top-right", "-bottom-right"],
+  "t": ["-top-left", "-top-right"],
+  "b": ["-bottom-left", "-bottom-right"],
+  "tl": ["-top-left"],
+  "lt": ["-top-left"],
+  "tr": ["-top-right"],
+  "rt": ["-top-right"],
+  "bl": ["-bottom-left"],
+  "lb": ["-bottom-left"],
+  "br": ["-bottom-right"],
+  "rb": ["-bottom-right"],
+  "": [""],
+  "bs": ["-start-start", "-start-end"],
+  "be": ["-end-start", "-end-end"],
+  "is": ["-end-start", "-start-start"],
+  "ie": ["-start-end", "-end-end"],
+  "bs-is": ["-start-start"],
+  "is-bs": ["-start-start"],
+  "bs-ie": ["-start-end"],
+  "ie-bs": ["-start-end"],
+  "be-is": ["-end-start"],
+  "is-be": ["-end-start"],
+  "be-ie": ["-end-end"],
+  "ie-be": ["-end-end"]
+};
+const xyzMap = {
+  "x": ["-x"],
+  "y": ["-y"],
+  "z": ["-z"],
+  "": ["-x", "-y"]
+};
+const basePositionMap = [
+  "top",
+  "top center",
+  "top left",
+  "top right",
+  "bottom",
+  "bottom center",
+  "bottom left",
+  "bottom right",
+  "left",
+  "left center",
+  "left top",
+  "left bottom",
+  "right",
+  "right center",
+  "right top",
+  "right bottom",
+  "center",
+  "center top",
+  "center bottom",
+  "center left",
+  "center right",
+  "center center"
+];
+const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
+const globalKeywords = [
+  "inherit",
+  "initial",
+  "revert",
+  "revert-layer",
+  "unset"
+];
+
 const cssColorFunctions = ["hsl", "hsla", "hwb", "lab", "lch", "oklab", "oklch", "rgb", "rgba"];
 function hex2rgba(hex = "") {
   const color = parseHexColor(hex);
@@ -219,93 +313,6 @@ function getComponents(str, separator, limit) {
     return components;
 }
 
-const directionMap = {
-  "l": ["-left"],
-  "r": ["-right"],
-  "t": ["-top"],
-  "b": ["-bottom"],
-  "s": ["-inline-start"],
-  "e": ["-inline-end"],
-  "x": ["-left", "-right"],
-  "y": ["-top", "-bottom"],
-  "": [""],
-  "bs": ["-block-start"],
-  "be": ["-block-end"],
-  "is": ["-inline-start"],
-  "ie": ["-inline-end"],
-  "block": ["-block-start", "-block-end"],
-  "inline": ["-inline-start", "-inline-end"]
-};
-const insetMap = {
-  ...directionMap,
-  s: ["-inset-inline-start"],
-  e: ["-inset-inline-end"],
-  bs: ["-inset-block-start"],
-  be: ["-inset-block-end"],
-  is: ["-inset-inline-start"],
-  ie: ["-inset-inline-end"],
-  block: ["-inset-block-start", "-inset-block-end"],
-  inline: ["-inset-inline-start", "-inset-inline-end"]
-};
-const cornerMap = {
-  "l": ["-top-left", "-bottom-left"],
-  "r": ["-top-right", "-bottom-right"],
-  "t": ["-top-left", "-top-right"],
-  "b": ["-bottom-left", "-bottom-right"],
-  "tl": ["-top-left"],
-  "lt": ["-top-left"],
-  "tr": ["-top-right"],
-  "rt": ["-top-right"],
-  "bl": ["-bottom-left"],
-  "lb": ["-bottom-left"],
-  "br": ["-bottom-right"],
-  "rb": ["-bottom-right"],
-  "": [""],
-  "bs": ["-start-start", "-start-end"],
-  "be": ["-end-start", "-end-end"],
-  "is": ["-end-start", "-start-start"],
-  "ie": ["-start-end", "-end-end"],
-  "bs-is": ["-start-start"],
-  "is-bs": ["-start-start"],
-  "bs-ie": ["-start-end"],
-  "ie-bs": ["-start-end"],
-  "be-is": ["-end-start"],
-  "is-be": ["-end-start"],
-  "be-ie": ["-end-end"],
-  "ie-be": ["-end-end"]
-};
-const xyzMap = {
-  "x": ["-x"],
-  "y": ["-y"],
-  "z": ["-z"],
-  "": ["-x", "-y"]
-};
-const basePositionMap = [
-  "top",
-  "top center",
-  "top left",
-  "top right",
-  "bottom",
-  "bottom center",
-  "bottom left",
-  "bottom right",
-  "left",
-  "left center",
-  "left top",
-  "left bottom",
-  "right",
-  "right center",
-  "right top",
-  "right bottom",
-  "center",
-  "center top",
-  "center bottom",
-  "center left",
-  "center right",
-  "center center"
-];
-const positionMap = Object.assign({}, ...basePositionMap.map((p) => ({ [p.replace(/ /, "-")]: p })), ...basePositionMap.map((p) => ({ [p.replace(/\b(\w)\w+/g, "$1").replace(/ /, "")]: p })));
-
 const cssProps = [
   "color",
   "border-color",
@@ -422,10 +429,11 @@ function fraction(str) {
   if (!Number.isNaN(num))
     return `${round(num * 100)}%`;
 }
+const bracketTypeRe = /^\[(color|length|position):/i;
 function bracketWithType(str, type) {
   if (str && str.startsWith("[") && str.endsWith("]")) {
     let base;
-    const match = str.match(/^\[(color|length|position):/i);
+    const match = str.match(bracketTypeRe);
     if (!match)
       base = str.slice(1, -1);
     else if (type && match[1] === type)
@@ -472,13 +480,17 @@ function degree(str) {
     return unit ? `${round(num)}${unit}` : `${round(num)}deg`;
 }
 function global(str) {
-  if (["inherit", "initial", "revert", "unset"].includes(str))
+  if (globalKeywords.includes(str))
     return str;
 }
 function properties(str) {
   if (str.split(",").every((prop) => cssProps.includes(prop)))
     return str;
 }
+function position(str) {
+  if (["top", "left", "right", "bottom", "center"].includes(str))
+    return str;
+}
 
 const valueHandlers = {
   __proto__: null,
@@ -497,7 +509,8 @@ const valueHandlers = {
   time: time,
   degree: degree,
   global: global,
-  properties: properties
+  properties: properties,
+  position: position
 };
 
 const handler = createValueHandler(valueHandlers);
@@ -617,4 +630,4 @@ const resolveVerticalBreakpoints = ({ theme, generator }) => {
   return verticalBreakpoints;
 };
 
-export { CONTROL_MINI_NO_NEGATIVE as C, hasParseableColor as a, colorToString as b, colorResolver as c, directionMap as d, cornerMap as e, colorableShadows as f, resolveBreakpoints as g, handler as h, insetMap as i, directionSize as j, positionMap as k, hex2rgba as l, parseCssColor as m, getComponents as n, h as o, parseColor as p, resolveVerticalBreakpoints as r, valueHandlers as v, xyzMap as x };
+export { CONTROL_MINI_NO_NEGATIVE as C, hasParseableColor as a, colorToString as b, colorResolver as c, directionMap as d, cornerMap as e, colorableShadows as f, globalKeywords as g, handler as h, insetMap as i, resolveBreakpoints as j, directionSize as k, positionMap as l, hex2rgba as m, parseCssColor as n, getComponents as o, parseColor as p, h as q, resolveVerticalBreakpoints as r, valueHandlers as v, xyzMap as x };

package/dist/utils.cjs

@@ -16,6 +16,7 @@ exports.cornerMap = utilities.cornerMap;
 exports.directionMap = utilities.directionMap;
 exports.directionSize = utilities.directionSize;
 exports.getComponents = utilities.getComponents;
+exports.globalKeywords = utilities.globalKeywords;
 exports.h = utilities.h;
 exports.handler = utilities.handler;
 exports.hasParseableColor = utilities.hasParseableColor;

package/dist/utils.d.ts

@@ -13,6 +13,7 @@ declare const insetMap: Record<string, string[]>;
 declare const cornerMap: Record<string, string[]>;
 declare const xyzMap: Record<string, string[]>;
 declare const positionMap: Record<string, string>;
+declare const globalKeywords: string[];
 
 declare function numberWithUnit(str: string): string | undefined;
 declare function auto(str: string): "auto" | undefined;
@@ -30,6 +31,7 @@ declare function time(str: string): string | undefined;
 declare function degree(str: string): string | undefined;
 declare function global(str: string): string | undefined;
 declare function properties(str: string): string | undefined;
+declare function position(str: string): string | undefined;
 
 declare const handlers_numberWithUnit: typeof numberWithUnit;
 declare const handlers_auto: typeof auto;
@@ -47,6 +49,7 @@ declare const handlers_time: typeof time;
 declare const handlers_degree: typeof degree;
 declare const handlers_global: typeof global;
 declare const handlers_properties: typeof properties;
+declare const handlers_position: typeof position;
 declare namespace handlers {
   export {
     handlers_numberWithUnit as numberWithUnit,
@@ -65,13 +68,14 @@ declare namespace handlers {
     handlers_degree as degree,
     handlers_global as global,
     handlers_properties as properties,
+    handlers_position as position,
   };
 }
 
-declare const handler: _unocss_core.ValueHandler<"number" | "global" | "auto" | "numberWithUnit" | "rem" | "px" | "percent" | "fraction" | "bracket" | "bracketOfColor" | "bracketOfLength" | "bracketOfPosition" | "cssvar" | "time" | "degree" | "properties">;
-declare const h: _unocss_core.ValueHandler<"number" | "global" | "auto" | "numberWithUnit" | "rem" | "px" | "percent" | "fraction" | "bracket" | "bracketOfColor" | "bracketOfLength" | "bracketOfPosition" | "cssvar" | "time" | "degree" | "properties">;
+declare const handler: _unocss_core.ValueHandler<"number" | "global" | "auto" | "position" | "numberWithUnit" | "rem" | "px" | "percent" | "fraction" | "bracket" | "bracketOfColor" | "bracketOfLength" | "bracketOfPosition" | "cssvar" | "time" | "degree" | "properties">;
+declare const h: _unocss_core.ValueHandler<"number" | "global" | "auto" | "position" | "numberWithUnit" | "rem" | "px" | "percent" | "fraction" | "bracket" | "bracketOfColor" | "bracketOfLength" | "bracketOfPosition" | "cssvar" | "time" | "degree" | "properties">;
 
 declare const variantMatcher: (name: string, selector?: ((input: string) => string | undefined) | undefined) => VariantObject;
 declare const variantParentMatcher: (name: string, parent: string) => VariantObject;
 
-export { colorToString, cornerMap, directionMap, getComponents, h, handler, hex2rgba, insetMap, parseCssColor, positionMap, handlers as valueHandlers, variantMatcher, variantParentMatcher, xyzMap };
+export { colorToString, cornerMap, directionMap, getComponents, globalKeywords, h, handler, hex2rgba, insetMap, parseCssColor, positionMap, handlers as valueHandlers, variantMatcher, variantParentMatcher, xyzMap };

package/dist/utils.mjs

@@ -1,3 +1,3 @@
-export { C as CONTROL_MINI_NO_NEGATIVE, c as colorResolver, b as colorToString, f as colorableShadows, e as cornerMap, d as directionMap, j as directionSize, n as getComponents, o as h, h as handler, a as hasParseableColor, l as hex2rgba, i as insetMap, p as parseColor, m as parseCssColor, k as positionMap, g as resolveBreakpoints, r as resolveVerticalBreakpoints, v as valueHandlers, x as xyzMap } from './chunks/utilities.mjs';
+export { C as CONTROL_MINI_NO_NEGATIVE, c as colorResolver, b as colorToString, f as colorableShadows, e as cornerMap, d as directionMap, k as directionSize, o as getComponents, g as globalKeywords, q as h, h as handler, a as hasParseableColor, m as hex2rgba, i as insetMap, p as parseColor, n as parseCssColor, l as positionMap, j as resolveBreakpoints, r as resolveVerticalBreakpoints, v as valueHandlers, x as xyzMap } from './chunks/utilities.mjs';
 export { a as variantMatcher, v as variantParentMatcher } from './chunks/variants.mjs';
 import '@unocss/core';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unocss/preset-mini",
-  "version": "0.35.1",
+  "version": "0.35.4",
   "description": "The minimal preset for UnoCSS",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -22,33 +22,33 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
     },
     "./theme": {
       "types": "./dist/theme.d.ts",
-      "import": "./dist/theme.mjs",
-      "require": "./dist/theme.cjs"
+      "require": "./dist/theme.cjs",
+      "import": "./dist/theme.mjs"
     },
     "./variants": {
       "types": "./dist/variants.d.ts",
-      "import": "./dist/variants.mjs",
-      "require": "./dist/variants.cjs"
+      "require": "./dist/variants.cjs",
+      "import": "./dist/variants.mjs"
     },
     "./rules": {
       "types": "./dist/rules.d.ts",
-      "import": "./dist/rules.mjs",
-      "require": "./dist/rules.cjs"
+      "require": "./dist/rules.cjs",
+      "import": "./dist/rules.mjs"
     },
     "./colors": {
       "types": "./dist/colors.d.ts",
-      "import": "./dist/colors.mjs",
-      "require": "./dist/colors.cjs"
+      "require": "./dist/colors.cjs",
+      "import": "./dist/colors.mjs"
     },
     "./utils": {
       "types": "./dist/utils.d.ts",
-      "import": "./dist/utils.mjs",
-      "require": "./dist/utils.cjs"
+      "require": "./dist/utils.cjs",
+      "import": "./dist/utils.mjs"
     },
     "./*": "./*"
   },
@@ -61,7 +61,7 @@
     "*.css"
   ],
   "dependencies": {
-    "@unocss/core": "0.35.1"
+    "@unocss/core": "0.35.4"
   },
   "scripts": {
     "build": "unbuild",