@unocss/preset-mini 0.55.7 → 0.56.0

package/dist/rules.mjs

@@ -1,7 +1,8 @@
-import { g as globalKeywords, h, c as colorResolver, l as directionMap, a as hasParseableColor, o as cornerMap, p as parseColor, k as colorToString, j as colorOpacityToString, z as numberWithUnitRE, m as makeGlobalStaticRules, s as splitShorthand, b as colorableShadows, n as insetMap, u as resolveVerticalBreakpoints, t as resolveBreakpoints, r as directionSize } from './shared/preset-mini.f1fe435e.mjs';
+import { g as globalKeywords, h, c as colorResolver, e as directionMap, a as hasParseableColor, f as cornerMap, p as parseColor, n as numberWithUnitRE, m as makeGlobalStaticRules, s as splitShorthand, b as colorableShadows, i as insetMap, r as resolveVerticalBreakpoints, j as resolveBreakpoints, k as directionSize } from './shared/preset-mini.8929b018.mjs';
+import { colorToString, colorOpacityToString } from '@unocss/rule-utils';
 import { warnOnce, toArray } from '@unocss/core';
-import { d as displays, c as contentVisibility, a as contents, e as textOverflows, f as textTransforms, g as fontStyles, h as fontSmoothings, i as boxShadows, j as rings, k as cursors, l as appearances, p as pointerEvents, m as resizes, u as userSelects, w as whitespaces, n as breaks, o as transforms, q as contains, s as textWraps } from './shared/preset-mini.0fac4963.mjs';
-export { b as boxShadowsBase, r as ringBase, t as transformBase, v as varEmpty } from './shared/preset-mini.0fac4963.mjs';
+import { d as displays, c as contentVisibility, a as contents, e as textOverflows, f as textTransforms, g as fontStyles, h as fontSmoothings, i as boxShadows, j as rings, k as cursors, l as appearances, p as pointerEvents, m as resizes, u as userSelects, w as whitespaces, n as breaks, o as transforms, q as contains, s as textWraps } from './shared/preset-mini.4fe01d46.mjs';
+export { b as boxShadowsBase, r as ringBase, t as transformBase, v as varEmpty } from './shared/preset-mini.4fe01d46.mjs';
 
 const verticalAlignAlias = {
   "mid": "middle",

package/dist/shared/{preset-mini.b4ad509c.cjs → preset-mini.3a376028.cjs}

@@ -1,5 +1,6 @@
 'use strict';
 
+const ruleUtils = require('@unocss/rule-utils');
 const core = require('@unocss/core');
 
 const directionMap = {
@@ -360,7 +361,7 @@ const valueHandlers = {
   time: time
 };
 
-const handler = core.createValueHandler(valueHandlers);
+const handler = ruleUtils.createValueHandler(valueHandlers);
 const h = handler;
 
 const CONTROL_MINI_NO_NEGATIVE = "$$mini-no-negative";
@@ -399,7 +400,7 @@ function splitShorthand(body, type) {
   }
   return split;
 }
-function parseColor$1(body, theme) {
+function parseColor(body, theme) {
   const [main, opacity] = splitShorthand(body, "color");
   const colors = main.replace(/([a-z])([0-9])/g, "$1-$2").split(/-/g);
   const [name] = colors;
@@ -450,26 +451,26 @@ function parseColor$1(body, theme) {
     name,
     no,
     color,
-    cssColor: parseCssColor(color),
+    cssColor: ruleUtils.parseCssColor(color),
     alpha: h.bracket.cssvar.percent(opacity ?? "")
   };
 }
 function colorResolver(property, varName, shouldPass) {
   return ([, body], { theme }) => {
-    const data = parseColor$1(body, theme);
+    const data = parseColor(body, theme);
     if (!data)
       return;
     const { alpha, color, cssColor } = data;
     const css = {};
     if (cssColor) {
       if (alpha != null) {
-        css[property] = colorToString(cssColor, alpha);
+        css[property] = ruleUtils.colorToString(cssColor, alpha);
       } else {
-        css[`--un-${varName}-opacity`] = colorOpacityToString(cssColor);
-        css[property] = colorToString(cssColor, `var(--un-${varName}-opacity)`);
+        css[`--un-${varName}-opacity`] = ruleUtils.colorOpacityToString(cssColor);
+        css[property] = ruleUtils.colorToString(cssColor, `var(--un-${varName}-opacity)`);
       }
     } else if (color) {
-      css[property] = colorToString(color, alpha);
+      css[property] = ruleUtils.colorToString(color, alpha);
     }
     if (shouldPass?.(css) !== false)
       return css;
@@ -479,18 +480,18 @@ function colorableShadows(shadows, colorVar) {
   const colored = [];
   shadows = core.toArray(shadows);
   for (let i = 0; i < shadows.length; i++) {
-    const components = getComponents(shadows[i], " ", 6);
+    const components = ruleUtils.getStringComponents(shadows[i], " ", 6);
     if (!components || components.length < 3)
       return shadows;
-    const color = parseCssColor(components.pop());
+    const color = ruleUtils.parseCssColor(components.pop());
     if (color == null)
       return shadows;
-    colored.push(`${components.join(" ")} var(${colorVar}, ${colorToString(color)})`);
+    colored.push(`${components.join(" ")} var(${colorVar}, ${ruleUtils.colorToString(color)})`);
   }
   return colored;
 }
 function hasParseableColor(color, theme) {
-  return color != null && !!parseColor$1(color, theme)?.color;
+  return color != null && !!parseColor(color, theme)?.color;
 }
 function resolveBreakpoints({ theme, generator }) {
   let breakpoints;
@@ -511,292 +512,21 @@ function resolveVerticalBreakpoints({ theme, generator }) {
 function makeGlobalStaticRules(prefix, property) {
   return globalKeywords.map((keyword) => [`${prefix}-${keyword}`, { [property ?? prefix]: keyword }]);
 }
-function getBracket(str, open, close) {
-  if (str === "")
-    return;
-  const l = str.length;
-  let parenthesis = 0;
-  let opened = false;
-  let openAt = 0;
-  for (let i = 0; i < l; i++) {
-    switch (str[i]) {
-      case open:
-        if (!opened) {
-          opened = true;
-          openAt = i;
-        }
-        parenthesis++;
-        break;
-      case close:
-        --parenthesis;
-        if (parenthesis < 0)
-          return;
-        if (parenthesis === 0) {
-          return [
-            str.slice(openAt, i + 1),
-            str.slice(i + 1),
-            str.slice(0, openAt)
-          ];
-        }
-        break;
-    }
-  }
-}
-function getComponent(str, open, close, separators) {
-  if (str === "")
-    return;
-  if (core.isString(separators))
-    separators = [separators];
-  if (separators.length === 0)
-    return;
-  const l = str.length;
-  let parenthesis = 0;
-  for (let i = 0; i < l; i++) {
-    switch (str[i]) {
-      case open:
-        parenthesis++;
-        break;
-      case close:
-        if (--parenthesis < 0)
-          return;
-        break;
-      default:
-        for (const separator of separators) {
-          const separatorLength = separator.length;
-          if (separatorLength && separator === str.slice(i, i + separatorLength) && parenthesis === 0) {
-            if (i === 0 || i === l - separatorLength)
-              return;
-            return [
-              str.slice(0, i),
-              str.slice(i + separatorLength)
-            ];
-          }
-        }
-    }
-  }
-  return [
-    str,
-    ""
-  ];
-}
-function getComponents(str, separators, limit) {
-  limit = limit ?? 10;
-  const components = [];
-  let i = 0;
-  while (str !== "") {
-    if (++i > limit)
-      return;
-    const componentPair = getComponent(str, "(", ")", separators);
-    if (!componentPair)
-      return;
-    const [component, rest] = componentPair;
-    components.push(component);
-    str = rest;
-  }
-  if (components.length > 0)
-    return components;
-}
-
-const cssColorFunctions = ["hsl", "hsla", "hwb", "lab", "lch", "oklab", "oklch", "rgb", "rgba"];
-const alphaPlaceholders = ["%alpha", "<alpha-value>"];
-const alphaPlaceholdersRE = new RegExp(alphaPlaceholders.map((v) => core.escapeRegExp(v)).join("|"));
-function hex2rgba(hex = "") {
-  const color = parseHexColor(hex);
-  if (color != null) {
-    const { components, alpha } = color;
-    if (alpha == null)
-      return components;
-    return [...components, alpha];
-  }
-}
-function parseCssColor(str = "") {
-  const color = parseColor(str);
-  if (color == null || color === false)
-    return;
-  const { type: casedType, components, alpha } = color;
-  const type = casedType.toLowerCase();
-  if (components.length === 0)
-    return;
-  if (["rgba", "hsla"].includes(type) && alpha == null)
-    return;
-  if (cssColorFunctions.includes(type) && ![1, 3].includes(components.length))
-    return;
-  return {
-    type,
-    components: components.map((c) => typeof c === "string" ? c.trim() : c),
-    alpha: typeof alpha === "string" ? alpha.trim() : alpha
-  };
-}
-function colorOpacityToString(color) {
-  const alpha = color.alpha ?? 1;
-  return typeof alpha === "string" && alphaPlaceholders.includes(alpha) ? 1 : alpha;
-}
-function colorToString(color, alphaOverride) {
-  if (typeof color === "string")
-    return color.replace(alphaPlaceholdersRE, `${alphaOverride ?? 1}`);
-  const { components } = color;
-  let { alpha, type } = color;
-  alpha = alphaOverride ?? alpha;
-  type = type.toLowerCase();
-  if (["hsla", "hsl", "rgba", "rgb"].includes(type))
-    return `${type.replace("a", "")}a(${components.join(",")}${alpha == null ? "" : `,${alpha}`})`;
-  alpha = alpha == null ? "" : ` / ${alpha}`;
-  if (cssColorFunctions.includes(type))
-    return `${type}(${components.join(" ")}${alpha})`;
-  return `color(${type} ${components.join(" ")}${alpha})`;
-}
-function parseColor(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 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 cssColorKeyword(str) {
-  const color = {
-    rebeccapurple: [102, 51, 153, 1]
-  }[str];
-  if (color != null) {
-    return {
-      type: "rgb",
-      components: color.slice(0, 3),
-      alpha: color[3]
-    };
-  }
-}
-function parseCssCommaColorFunction(color) {
-  const match = color.match(/^(rgb|rgba|hsl|hsla)\((.+)\)$/i);
-  if (!match)
-    return;
-  const [, type, componentString] = match;
-  const components = getComponents(componentString, ",", 5);
-  if (components) {
-    if ([3, 4].includes(components.length)) {
-      return {
-        type,
-        components: components.slice(0, 3),
-        alpha: components[3]
-      };
-    } else if (components.length !== 1) {
-      return false;
-    }
-  }
-}
-const cssColorFunctionsRe = new RegExp(`^(${cssColorFunctions.join("|")})\\((.+)\\)$`, "i");
-function parseCssSpaceColorFunction(color) {
-  const match = color.match(cssColorFunctionsRe);
-  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) {
-  const components = getComponents(componentString, " ");
-  if (!components)
-    return;
-  let totalComponents = components.length;
-  if (components[totalComponents - 2] === "/") {
-    return {
-      components: components.slice(0, totalComponents - 2),
-      alpha: components[totalComponents - 1]
-    };
-  }
-  if (components[totalComponents - 2] != null && (components[totalComponents - 2].endsWith("/") || components[totalComponents - 1].startsWith("/"))) {
-    const removed = components.splice(totalComponents - 2);
-    components.push(removed.join(" "));
-    --totalComponents;
-  }
-  const withAlpha = getComponents(components[totalComponents - 1], "/", 2);
-  if (!withAlpha)
-    return;
-  if (withAlpha.length === 1 || withAlpha[withAlpha.length - 1] === "")
-    return { components };
-  const alpha = withAlpha.pop();
-  components[totalComponents - 1] = withAlpha.join("/");
-  return {
-    components,
-    alpha
-  };
-}
 
 exports.CONTROL_MINI_NO_NEGATIVE = CONTROL_MINI_NO_NEGATIVE;
-exports.colorOpacityToString = colorOpacityToString;
 exports.colorResolver = colorResolver;
-exports.colorToString = colorToString;
 exports.colorableShadows = colorableShadows;
 exports.cornerMap = cornerMap;
 exports.directionMap = directionMap;
 exports.directionSize = directionSize;
-exports.getBracket = getBracket;
-exports.getComponent = getComponent;
-exports.getComponents = getComponents;
 exports.globalKeywords = globalKeywords;
 exports.h = h;
 exports.handler = handler;
 exports.hasParseableColor = hasParseableColor;
-exports.hex2rgba = hex2rgba;
 exports.insetMap = insetMap;
 exports.makeGlobalStaticRules = makeGlobalStaticRules;
 exports.numberWithUnitRE = numberWithUnitRE;
-exports.parseColor = parseColor$1;
-exports.parseCssColor = parseCssColor;
+exports.parseColor = parseColor;
 exports.positionMap = positionMap;
 exports.resolveBreakpoints = resolveBreakpoints;
 exports.resolveVerticalBreakpoints = resolveVerticalBreakpoints;

package/dist/shared/{preset-mini.0fac4963.mjs → preset-mini.4fe01d46.mjs}

@@ -1,4 +1,4 @@
-import { h, m as makeGlobalStaticRules, g as globalKeywords, c as colorResolver, a as hasParseableColor, b as colorableShadows, d as positionMap, x as xyzMap } from './preset-mini.f1fe435e.mjs';
+import { h, m as makeGlobalStaticRules, g as globalKeywords, c as colorResolver, a as hasParseableColor, b as colorableShadows, d as positionMap, x as xyzMap } from './preset-mini.8929b018.mjs';
 
 const cursorValues = ["auto", "default", "none", "context-menu", "help", "pointer", "progress", "wait", "cell", "crosshair", "text", "vertical-text", "alias", "copy", "move", "no-drop", "not-allowed", "grab", "grabbing", "all-scroll", "col-resize", "row-resize", "n-resize", "e-resize", "s-resize", "w-resize", "ne-resize", "nw-resize", "se-resize", "sw-resize", "ew-resize", "ns-resize", "nesw-resize", "nwse-resize", "zoom-in", "zoom-out"];
 const containValues = ["none", "strict", "content", "size", "inline-size", "layout", "style", "paint"];
@@ -110,13 +110,11 @@ const fontStyles = [
 const fontSmoothings = [
   ["antialiased", {
     "-webkit-font-smoothing": "antialiased",
-    "-moz-osx-font-smoothing": "grayscale",
-    "font-smoothing": "grayscale"
+    "-moz-osx-font-smoothing": "grayscale"
   }],
   ["subpixel-antialiased", {
     "-webkit-font-smoothing": "auto",
-    "-moz-osx-font-smoothing": "auto",
-    "font-smoothing": "auto"
+    "-moz-osx-font-smoothing": "auto"
   }]
 ];
 

package/dist/shared/{preset-mini.c0e4a0cc.d.ts → preset-mini.79297e15.d.ts}

@@ -51,8 +51,8 @@ declare function parseColor(body: string, theme: Theme): ParsedColorValue | unde
  *
  * @param {string} property - Property for the css value to be created.
  * @param {string} varName - Base name for the opacity variable.
- * @param {function} [shouldPass] - Function to decide whether to pass the css.
- * @return {@link DynamicMatcher} object.
+ * @param {Function} [shouldPass] - Function to decide whether to pass the css.
+ * @return {DynamicMatcher} object.
  */
 declare function colorResolver(property: string, varName: string, shouldPass?: (css: CSSObject) => boolean): DynamicMatcher;
 declare function colorableShadows(shadows: string | string[], colorVar: string): string[];
@@ -60,8 +60,5 @@ declare function hasParseableColor(color: string | undefined, theme: Theme): boo
 declare function resolveBreakpoints({ theme, generator }: Readonly<VariantContext<Theme>>): Record<string, string> | undefined;
 declare function resolveVerticalBreakpoints({ theme, generator }: Readonly<VariantContext<Theme>>): Record<string, string> | undefined;
 declare function makeGlobalStaticRules(prefix: string, property?: string): StaticRule[];
-declare function getBracket(str: string, open: string, close: string): string[] | undefined;
-declare function getComponent(str: string, open: string, close: string, separators: string | string[]): string[] | undefined;
-declare function getComponents(str: string, separators: string | string[], limit?: number): string[] | undefined;
 
-export { CONTROL_MINI_NO_NEGATIVE as C, colorableShadows as a, resolveVerticalBreakpoints as b, colorResolver as c, directionSize as d, getComponent as e, getComponents as f, getBracket as g, hasParseableColor as h, makeGlobalStaticRules as m, parseColor as p, resolveBreakpoints as r, splitShorthand as s };
+export { CONTROL_MINI_NO_NEGATIVE as C, colorableShadows as a, resolveVerticalBreakpoints as b, colorResolver as c, directionSize as d, hasParseableColor as h, makeGlobalStaticRules as m, parseColor as p, resolveBreakpoints as r, splitShorthand as s };