@unocss/preset-mini 0.22.6 → 0.22.7

package/dist/chunks/default3.cjs

@@ -74,6 +74,17 @@ const variantLanguageDirections = [
   variants$1.variantMatcher("ltr", (input) => `[dir="ltr"] $$ ${input}`)
 ];
 
+const variantLayer = {
+  match(matcher) {
+    const match = matcher.match(/layer-([\d\w]+)[:-]/);
+    if (match) {
+      return {
+        matcher: matcher.slice(match[0].length),
+        layer: match[1]
+      };
+    }
+  }
+};
 const variantImportant = {
   match(matcher) {
     if (matcher.startsWith("!")) {
@@ -233,6 +244,10 @@ const variantTaggedPseudoClasses = (options = {}) => {
     {
       match: taggedPseudoClassMatcher("peer", attributify ? '[peer=""]' : ".peer", "~"),
       multiPass: true
+    },
+    {
+      match: taggedPseudoClassMatcher("parent", attributify ? '[parent=""]' : ".parent", ">"),
+      multiPass: true
     }
   ];
 };
@@ -251,6 +266,7 @@ const partClasses = {
 };
 
 const variants = (options) => [
+  variantLayer,
   variantNegative,
   variantImportant,
   variantPrint,
@@ -273,6 +289,7 @@ exports.variantColorsMediaOrClass = variantColorsMediaOrClass;
 exports.variantCombinators = variantCombinators;
 exports.variantImportant = variantImportant;
 exports.variantLanguageDirections = variantLanguageDirections;
+exports.variantLayer = variantLayer;
 exports.variantMotions = variantMotions;
 exports.variantNegative = variantNegative;
 exports.variantOrientations = variantOrientations;

package/dist/chunks/default3.mjs

@@ -72,6 +72,17 @@ const variantLanguageDirections = [
   variantMatcher("ltr", (input) => `[dir="ltr"] $$ ${input}`)
 ];
 
+const variantLayer = {
+  match(matcher) {
+    const match = matcher.match(/layer-([\d\w]+)[:-]/);
+    if (match) {
+      return {
+        matcher: matcher.slice(match[0].length),
+        layer: match[1]
+      };
+    }
+  }
+};
 const variantImportant = {
   match(matcher) {
     if (matcher.startsWith("!")) {
@@ -231,6 +242,10 @@ const variantTaggedPseudoClasses = (options = {}) => {
     {
       match: taggedPseudoClassMatcher("peer", attributify ? '[peer=""]' : ".peer", "~"),
       multiPass: true
+    },
+    {
+      match: taggedPseudoClassMatcher("parent", attributify ? '[parent=""]' : ".parent", ">"),
+      multiPass: true
     }
   ];
 };
@@ -249,6 +264,7 @@ const partClasses = {
 };
 
 const variants = (options) => [
+  variantLayer,
   variantNegative,
   variantImportant,
   variantPrint,
@@ -265,4 +281,4 @@ const variants = (options) => [
   ...variantLanguageDirections
 ];
 
-export { variantBreakpoints as a, variantCombinators as b, variantMotions as c, variantOrientations as d, variantPrint as e, variantColorsMediaOrClass as f, variantLanguageDirections as g, variantImportant as h, variantNegative as i, variantPseudoElements as j, variantPseudoClasses as k, variantPseudoClassFunctions as l, variantTaggedPseudoClasses as m, partClasses as p, variants as v };
+export { variantBreakpoints as a, variantCombinators as b, variantMotions as c, variantOrientations as d, variantPrint as e, variantColorsMediaOrClass as f, variantLanguageDirections as g, variantLayer as h, variantImportant as i, variantNegative as j, variantPseudoElements as k, variantPseudoClasses as l, variantPseudoClassFunctions as m, variantTaggedPseudoClasses as n, partClasses as p, variants as v };

package/dist/chunks/utilities.cjs

@@ -2,6 +2,209 @@
 
 const core = require('@unocss/core');
 
+function hex2rgba(hex = "") {
+  const color = parseHexColor(hex);
+  if (color != null) {
+    const { components, alpha } = color;
+    if (alpha === void 0)
+      return components;
+    return [...components, alpha];
+  }
+}
+function parseHexColor(str) {
+  const [, body] = str.match(/^#?([\da-f]+)$/i) || [];
+  if (!body)
+    return;
+  switch (body.length) {
+    case 3:
+    case 4:
+      const digits = Array.from(body, (s) => Number.parseInt(s, 16)).map((n) => n << 4 | n);
+      return {
+        type: "rgb",
+        components: digits.slice(0, 3),
+        alpha: body.length === 3 ? void 0 : Math.round(digits[3] / 255 * 100) / 100
+      };
+    case 6:
+    case 8:
+      const value = Number.parseInt(body, 16);
+      return {
+        type: "rgb",
+        components: body.length === 6 ? [value >> 16 & 255, value >> 8 & 255, value & 255] : [value >> 24 & 255, value >> 16 & 255, value >> 8 & 255],
+        alpha: body.length === 6 ? void 0 : Math.round((value & 255) / 255 * 100) / 100
+      };
+  }
+}
+function parseCssColor(str = "") {
+  const color = parseColor$1(str);
+  if (color == null)
+    return;
+  const { type: casedType, components, alpha } = color;
+  const type = casedType.toLowerCase();
+  if (["rgba", "hsla"].includes(type) && alpha === void 0)
+    return;
+  if (["rgb", "hsl", "hwb", "lab", "lch", "oklab", "oklch"].includes(type) && components.length !== 3)
+    return;
+  return { type, components, alpha };
+}
+function parseColor$1(str) {
+  if (!str)
+    return;
+  let color = parseHexColor(str);
+  if (color != null)
+    return color;
+  color = cssColorKeyword(str);
+  if (color != null)
+    return color;
+  color = parseCssCommaColorFunction(str);
+  if (color != null)
+    return color;
+  color = parseCssSpaceColorFunction(str);
+  if (color != null)
+    return color;
+  color = parseCssColorFunction(str);
+  if (color != null)
+    return color;
+}
+function cssColorKeyword(str) {
+  const color = {
+    rebeccapurple: [102, 51, 153, 1],
+    transparent: [0, 0, 0, 0]
+  }[str];
+  if (color != null) {
+    return {
+      type: "rgb",
+      components: color.slice(0, 3),
+      alpha: color[3]
+    };
+  }
+}
+function getComponent(separator, str) {
+  const component = str.trim();
+  if (component === "")
+    return;
+  const l = str.length;
+  let parenthesis = 0;
+  for (let i = 0; i < l; i++) {
+    switch (str[i]) {
+      case "(":
+        parenthesis++;
+        break;
+      case ")":
+        if (--parenthesis < 0)
+          return;
+        break;
+      case separator:
+        if (parenthesis === 0) {
+          const component2 = str.slice(0, i).trim();
+          if (component2 === "")
+            return;
+          return [
+            str.slice(0, i).trim(),
+            str.slice(i + 1).trim()
+          ];
+        }
+    }
+  }
+  return [
+    str.trim(),
+    ""
+  ];
+}
+function parseCssCommaColorFunction(color) {
+  const match = color.match(/^(rgb|rgba|hsl|hsla)\((.+)\)$/i);
+  if (!match)
+    return;
+  const [, type, componentString] = match;
+  const components = [];
+  let cs = componentString;
+  for (let c = 5; c > 0 && cs !== ""; --c) {
+    const componentValue = getComponent(",", cs);
+    if (!componentValue)
+      return;
+    const [component, rest] = componentValue;
+    components.push(component);
+    cs = rest;
+  }
+  if ([3, 4].includes(components.length)) {
+    return {
+      type,
+      components: components.slice(0, 3),
+      alpha: components[3]
+    };
+  }
+}
+function parseCssSpaceColorFunction(color) {
+  const match = color.match(/^(rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch)\((.+)\)$/i);
+  if (!match)
+    return;
+  const [, fn, componentString] = match;
+  const parsed = parseCssSpaceColorValues(`${fn} ${componentString}`);
+  if (parsed) {
+    const { alpha, components: [type, ...components] } = parsed;
+    return {
+      type,
+      components,
+      alpha
+    };
+  }
+}
+function parseCssColorFunction(color) {
+  const match = color.match(/^color\((.+)\)$/);
+  if (!match)
+    return;
+  const parsed = parseCssSpaceColorValues(match[1]);
+  if (parsed) {
+    const { alpha, components: [type, ...components] } = parsed;
+    return {
+      type,
+      components,
+      alpha
+    };
+  }
+}
+function parseCssSpaceColorValues(componentString) {
+  let cs = componentString;
+  const components = [];
+  while (cs !== "") {
+    const cc = getComponent(" ", cs);
+    if (!cc)
+      return;
+    const [component, rest] = cc;
+    components.push(component);
+    cs = rest;
+  }
+  let totalComponents = components.length;
+  if (components[totalComponents - 2] === "/") {
+    return {
+      components: components.slice(0, totalComponents - 2),
+      alpha: components[totalComponents - 1]
+    };
+  }
+  if (components[totalComponents - 2].endsWith("/") || components[totalComponents - 1].startsWith("/")) {
+    const removed = components.splice(totalComponents - 2);
+    components.push(removed.join(" "));
+    --totalComponents;
+  }
+  cs = components[totalComponents - 1];
+  const withAlpha = [];
+  while (cs !== "") {
+    const cc = getComponent("/", cs);
+    if (!cc)
+      return;
+    const [component, rest] = cc;
+    withAlpha.push(component);
+    cs = rest;
+  }
+  if (withAlpha.length === 1 || withAlpha[withAlpha.length - 1] === "")
+    return { components };
+  const alpha = withAlpha.pop();
+  components[totalComponents - 1] = withAlpha.join("/");
+  return {
+    components,
+    alpha
+  };
+}
+
 const directionMap = {
   "l": ["-left"],
   "r": ["-right"],
@@ -141,7 +344,7 @@ const cssProps = [
   "clip-path",
   "clip"
 ];
-const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
+const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax|rpx)?$/i;
 const numberRE = /^(-?[0-9.]+)$/i;
 const unitOnlyRE = /^(px)$/i;
 function round(n) {
@@ -306,7 +509,7 @@ const parseColor = (body, theme) => {
     else if (no && colorData)
       color = colorData[no];
   }
-  const rgba = core.hex2rgba(color);
+  const rgba = hex2rgba(color);
   const alpha = opacity ? opacity[0] === "[" ? handler.bracket.percent(opacity) : parseFloat(opacity) / 100 : rgba?.[3];
   const hasAlpha = alpha != null && !Number.isNaN(alpha);
   if (rgba) {
@@ -356,8 +559,10 @@ exports.directionMap = directionMap;
 exports.directionSize = directionSize;
 exports.h = h;
 exports.handler = handler;
+exports.hex2rgba = hex2rgba;
 exports.insetMap = insetMap;
 exports.parseColor = parseColor;
+exports.parseCssColor = parseCssColor;
 exports.positionMap = positionMap;
 exports.valueHandlers = valueHandlers;
 exports.xyzMap = xyzMap;

package/dist/chunks/utilities.mjs

@@ -1,4 +1,207 @@
-import { escapeSelector, createValueHandler, hex2rgba } from '@unocss/core';
+import { escapeSelector, createValueHandler } from '@unocss/core';
+
+function hex2rgba(hex = "") {
+  const color = parseHexColor(hex);
+  if (color != null) {
+    const { components, alpha } = color;
+    if (alpha === void 0)
+      return components;
+    return [...components, alpha];
+  }
+}
+function parseHexColor(str) {
+  const [, body] = str.match(/^#?([\da-f]+)$/i) || [];
+  if (!body)
+    return;
+  switch (body.length) {
+    case 3:
+    case 4:
+      const digits = Array.from(body, (s) => Number.parseInt(s, 16)).map((n) => n << 4 | n);
+      return {
+        type: "rgb",
+        components: digits.slice(0, 3),
+        alpha: body.length === 3 ? void 0 : Math.round(digits[3] / 255 * 100) / 100
+      };
+    case 6:
+    case 8:
+      const value = Number.parseInt(body, 16);
+      return {
+        type: "rgb",
+        components: body.length === 6 ? [value >> 16 & 255, value >> 8 & 255, value & 255] : [value >> 24 & 255, value >> 16 & 255, value >> 8 & 255],
+        alpha: body.length === 6 ? void 0 : Math.round((value & 255) / 255 * 100) / 100
+      };
+  }
+}
+function parseCssColor(str = "") {
+  const color = parseColor$1(str);
+  if (color == null)
+    return;
+  const { type: casedType, components, alpha } = color;
+  const type = casedType.toLowerCase();
+  if (["rgba", "hsla"].includes(type) && alpha === void 0)
+    return;
+  if (["rgb", "hsl", "hwb", "lab", "lch", "oklab", "oklch"].includes(type) && components.length !== 3)
+    return;
+  return { type, components, alpha };
+}
+function parseColor$1(str) {
+  if (!str)
+    return;
+  let color = parseHexColor(str);
+  if (color != null)
+    return color;
+  color = cssColorKeyword(str);
+  if (color != null)
+    return color;
+  color = parseCssCommaColorFunction(str);
+  if (color != null)
+    return color;
+  color = parseCssSpaceColorFunction(str);
+  if (color != null)
+    return color;
+  color = parseCssColorFunction(str);
+  if (color != null)
+    return color;
+}
+function cssColorKeyword(str) {
+  const color = {
+    rebeccapurple: [102, 51, 153, 1],
+    transparent: [0, 0, 0, 0]
+  }[str];
+  if (color != null) {
+    return {
+      type: "rgb",
+      components: color.slice(0, 3),
+      alpha: color[3]
+    };
+  }
+}
+function getComponent(separator, str) {
+  const component = str.trim();
+  if (component === "")
+    return;
+  const l = str.length;
+  let parenthesis = 0;
+  for (let i = 0; i < l; i++) {
+    switch (str[i]) {
+      case "(":
+        parenthesis++;
+        break;
+      case ")":
+        if (--parenthesis < 0)
+          return;
+        break;
+      case separator:
+        if (parenthesis === 0) {
+          const component2 = str.slice(0, i).trim();
+          if (component2 === "")
+            return;
+          return [
+            str.slice(0, i).trim(),
+            str.slice(i + 1).trim()
+          ];
+        }
+    }
+  }
+  return [
+    str.trim(),
+    ""
+  ];
+}
+function parseCssCommaColorFunction(color) {
+  const match = color.match(/^(rgb|rgba|hsl|hsla)\((.+)\)$/i);
+  if (!match)
+    return;
+  const [, type, componentString] = match;
+  const components = [];
+  let cs = componentString;
+  for (let c = 5; c > 0 && cs !== ""; --c) {
+    const componentValue = getComponent(",", cs);
+    if (!componentValue)
+      return;
+    const [component, rest] = componentValue;
+    components.push(component);
+    cs = rest;
+  }
+  if ([3, 4].includes(components.length)) {
+    return {
+      type,
+      components: components.slice(0, 3),
+      alpha: components[3]
+    };
+  }
+}
+function parseCssSpaceColorFunction(color) {
+  const match = color.match(/^(rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch)\((.+)\)$/i);
+  if (!match)
+    return;
+  const [, fn, componentString] = match;
+  const parsed = parseCssSpaceColorValues(`${fn} ${componentString}`);
+  if (parsed) {
+    const { alpha, components: [type, ...components] } = parsed;
+    return {
+      type,
+      components,
+      alpha
+    };
+  }
+}
+function parseCssColorFunction(color) {
+  const match = color.match(/^color\((.+)\)$/);
+  if (!match)
+    return;
+  const parsed = parseCssSpaceColorValues(match[1]);
+  if (parsed) {
+    const { alpha, components: [type, ...components] } = parsed;
+    return {
+      type,
+      components,
+      alpha
+    };
+  }
+}
+function parseCssSpaceColorValues(componentString) {
+  let cs = componentString;
+  const components = [];
+  while (cs !== "") {
+    const cc = getComponent(" ", cs);
+    if (!cc)
+      return;
+    const [component, rest] = cc;
+    components.push(component);
+    cs = rest;
+  }
+  let totalComponents = components.length;
+  if (components[totalComponents - 2] === "/") {
+    return {
+      components: components.slice(0, totalComponents - 2),
+      alpha: components[totalComponents - 1]
+    };
+  }
+  if (components[totalComponents - 2].endsWith("/") || components[totalComponents - 1].startsWith("/")) {
+    const removed = components.splice(totalComponents - 2);
+    components.push(removed.join(" "));
+    --totalComponents;
+  }
+  cs = components[totalComponents - 1];
+  const withAlpha = [];
+  while (cs !== "") {
+    const cc = getComponent("/", cs);
+    if (!cc)
+      return;
+    const [component, rest] = cc;
+    withAlpha.push(component);
+    cs = rest;
+  }
+  if (withAlpha.length === 1 || withAlpha[withAlpha.length - 1] === "")
+    return { components };
+  const alpha = withAlpha.pop();
+  components[totalComponents - 1] = withAlpha.join("/");
+  return {
+    components,
+    alpha
+  };
+}
 
 const directionMap = {
   "l": ["-left"],
@@ -139,7 +342,7 @@ const cssProps = [
   "clip-path",
   "clip"
 ];
-const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax)?$/i;
+const numberWithUnitRE = /^(-?[0-9.]+)(px|pt|pc|rem|em|%|vh|vw|in|cm|mm|ex|ch|vmin|vmax|rpx)?$/i;
 const numberRE = /^(-?[0-9.]+)$/i;
 const unitOnlyRE = /^(px)$/i;
 function round(n) {
@@ -348,4 +551,4 @@ const colorResolver = (property, varName) => ([, body], { theme }) => {
   }
 };
 
-export { cornerMap as a, directionSize as b, colorResolver as c, directionMap as d, positionMap as e, h as f, handler as h, insetMap as i, parseColor as p, valueHandlers as v, xyzMap as x };
+export { cornerMap as a, directionSize as b, colorResolver as c, directionMap as d, positionMap as e, hex2rgba as f, parseCssColor as g, handler as h, insetMap as i, h as j, parseColor as p, valueHandlers as v, xyzMap as x };

package/dist/utils.cjs

@@ -14,8 +14,10 @@ exports.directionMap = utilities.directionMap;
 exports.directionSize = utilities.directionSize;
 exports.h = utilities.h;
 exports.handler = utilities.handler;
+exports.hex2rgba = utilities.hex2rgba;
 exports.insetMap = utilities.insetMap;
 exports.parseColor = utilities.parseColor;
+exports.parseCssColor = utilities.parseCssColor;
 exports.positionMap = utilities.positionMap;
 exports.valueHandlers = utilities.valueHandlers;
 exports.xyzMap = utilities.xyzMap;

package/dist/utils.d.ts

@@ -1,8 +1,11 @@
 import * as _unocss_core from '@unocss/core';
-import { VariantHandler } from '@unocss/core';
+import { RGBAColorValue, CSSColorValue, VariantHandler } from '@unocss/core';
 export { c as colorResolver, d as directionSize, p as parseColor } from './utilities-8c324eff';
 import './types-154878eb';
 
+declare function hex2rgba(hex?: string): RGBAColorValue | undefined;
+declare function parseCssColor(str?: string): CSSColorValue | undefined;
+
 declare const directionMap: Record<string, string[]>;
 declare const insetMap: Record<string, string[]>;
 declare const cornerMap: Record<string, string[]>;
@@ -60,4 +63,4 @@ declare const h: _unocss_core.ValueHandler<"number" | "auto" | "numberWithUnit"
 declare const variantMatcher: (name: string, selector?: ((input: string) => string | undefined) | undefined) => (input: string) => VariantHandler | undefined;
 declare const variantParentMatcher: (name: string, parent: string) => (input: string) => VariantHandler | undefined;
 
-export { cornerMap, directionMap, h, handler, insetMap, positionMap, handlers as valueHandlers, variantMatcher, variantParentMatcher, xyzMap };
+export { cornerMap, directionMap, h, handler, hex2rgba, insetMap, parseCssColor, positionMap, handlers as valueHandlers, variantMatcher, variantParentMatcher, xyzMap };

package/dist/utils.mjs

@@ -1,3 +1,3 @@
-export { c as colorResolver, a as cornerMap, d as directionMap, b as directionSize, f as h, h as handler, i as insetMap, p as parseColor, e as positionMap, v as valueHandlers, x as xyzMap } from './chunks/utilities.mjs';
+export { c as colorResolver, a as cornerMap, d as directionMap, b as directionSize, j as h, h as handler, f as hex2rgba, i as insetMap, p as parseColor, g as parseCssColor, e as positionMap, v as valueHandlers, x as xyzMap } from './chunks/utilities.mjs';
 export { v as variantMatcher, a as variantParentMatcher } from './chunks/variants.mjs';
 import '@unocss/core';

package/dist/variants.cjs

@@ -14,6 +14,7 @@ exports.variantColorsMediaOrClass = _default.variantColorsMediaOrClass;
 exports.variantCombinators = _default.variantCombinators;
 exports.variantImportant = _default.variantImportant;
 exports.variantLanguageDirections = _default.variantLanguageDirections;
+exports.variantLayer = _default.variantLayer;
 exports.variantMotions = _default.variantMotions;
 exports.variantNegative = _default.variantNegative;
 exports.variantOrientations = _default.variantOrientations;

package/dist/variants.d.ts

@@ -19,6 +19,7 @@ declare const variants: (options: PresetMiniOptions) => Variant<Theme>[];
 
 declare const variantLanguageDirections: Variant[];
 
+declare const variantLayer: Variant;
 declare const variantImportant: Variant;
 declare const variantNegative: Variant;
 
@@ -28,4 +29,4 @@ declare const variantPseudoClassFunctions: VariantObject;
 declare const variantTaggedPseudoClasses: (options?: PresetMiniOptions) => VariantObject[];
 declare const partClasses: VariantObject;
 
-export { partClasses, variantBreakpoints, variantColorsMediaOrClass, variantCombinators, variantImportant, variantLanguageDirections, variantMotions, variantNegative, variantOrientations, variantPrint, variantPseudoClassFunctions, variantPseudoClasses, variantPseudoElements, variantTaggedPseudoClasses, variants };
+export { partClasses, variantBreakpoints, variantColorsMediaOrClass, variantCombinators, variantImportant, variantLanguageDirections, variantLayer, variantMotions, variantNegative, variantOrientations, variantPrint, variantPseudoClassFunctions, variantPseudoClasses, variantPseudoElements, variantTaggedPseudoClasses, variants };

package/dist/variants.mjs

@@ -1,3 +1,3 @@
-export { p as partClasses, a as variantBreakpoints, f as variantColorsMediaOrClass, b as variantCombinators, h as variantImportant, g as variantLanguageDirections, c as variantMotions, i as variantNegative, d as variantOrientations, e as variantPrint, l as variantPseudoClassFunctions, k as variantPseudoClasses, j as variantPseudoElements, m as variantTaggedPseudoClasses, v as variants } from './chunks/default3.mjs';
+export { p as partClasses, a as variantBreakpoints, f as variantColorsMediaOrClass, b as variantCombinators, i as variantImportant, g as variantLanguageDirections, h as variantLayer, c as variantMotions, j as variantNegative, d as variantOrientations, e as variantPrint, m as variantPseudoClassFunctions, l as variantPseudoClasses, k as variantPseudoElements, n as variantTaggedPseudoClasses, v as variants } from './chunks/default3.mjs';
 import './chunks/variants.mjs';
 import '@unocss/core';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unocss/preset-mini",
-  "version": "0.22.6",
+  "version": "0.22.7",
   "description": "The minimal preset for UnoCSS",
   "keywords": [
     "unocss",
@@ -61,7 +61,7 @@
     "*.css"
   ],
   "dependencies": {
-    "@unocss/core": "0.22.6"
+    "@unocss/core": "0.22.7"
   },
   "scripts": {
     "build": "unbuild",