@unocss/preset-mini 0.35.4 → 0.36.0

package/dist/chunks/default2.mjs

@@ -1,5 +1,7 @@
-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 { g as globalKeywords, h as handler, d as directionMap, c as cornerMap, i as insetMap } from './index.mjs';
+import { c as colorResolver, h as hasParseableColor, p as parseColor, a as colorToString, b as colorableShadows, r as resolveVerticalBreakpoints, d as resolveBreakpoints, e as directionSize } from './utilities.mjs';
 import { toArray, CONTROL_SHORTCUT_NO_MERGE } from '@unocss/core';
+import { a as transforms } from './transform.mjs';
 
 const verticalAlignAlias = {
   "mid": "middle",
@@ -721,153 +723,6 @@ const margins = [
   [/^m-?([bi][se])(?:-?(-?.+))?$/, directionSize("margin")]
 ];
 
-const transformGpu = {
-  "--un-transform": [
-    "translate3d(var(--un-translate-x), var(--un-translate-y), var(--un-translate-z))",
-    "rotate(var(--un-rotate))",
-    "rotateX(var(--un-rotate-x))",
-    "rotateY(var(--un-rotate-y))",
-    "rotateZ(var(--un-rotate-z))",
-    "skewX(var(--un-skew-x))",
-    "skewY(var(--un-skew-y))",
-    "scaleX(var(--un-scale-x))",
-    "scaleY(var(--un-scale-y))",
-    "scaleZ(var(--un-scale-z))"
-  ].join(" ")
-};
-const transformCpu = {
-  "--un-transform": [
-    "translateX(var(--un-translate-x))",
-    "translateY(var(--un-translate-y))",
-    "translateZ(var(--un-translate-z))",
-    "rotate(var(--un-rotate))",
-    "rotateX(var(--un-rotate-x))",
-    "rotateY(var(--un-rotate-y))",
-    "rotateZ(var(--un-rotate-z))",
-    "skewX(var(--un-skew-x))",
-    "skewY(var(--un-skew-y))",
-    "scaleX(var(--un-scale-x))",
-    "scaleY(var(--un-scale-y))",
-    "scaleZ(var(--un-scale-z))"
-  ].join(" ")
-};
-const transformBase = {
-  "--un-rotate": 0,
-  "--un-rotate-x": 0,
-  "--un-rotate-y": 0,
-  "--un-rotate-z": 0,
-  "--un-scale-x": 1,
-  "--un-scale-y": 1,
-  "--un-scale-z": 1,
-  "--un-skew-x": 0,
-  "--un-skew-y": 0,
-  "--un-translate-x": 0,
-  "--un-translate-y": 0,
-  "--un-translate-z": 0,
-  ...transformCpu,
-  [CONTROL_SHORTCUT_NO_MERGE]: "",
-  [CONTROL_MINI_NO_NEGATIVE]: ""
-};
-const transforms = [
-  [/^(?:transform-)?origin-(.+)$/, ([, s]) => ({ "transform-origin": positionMap[s] ?? handler.bracket.cssvar(s) }), { autocomplete: [`transform-origin-(${Object.keys(positionMap).join("|")})`, `origin-(${Object.keys(positionMap).join("|")})`] }],
-  [/^(?:transform-)?perspect(?:ive)?-(.+)$/, ([, s]) => {
-    const v = handler.bracket.cssvar.px.numberWithUnit(s);
-    if (v != null) {
-      return {
-        "-webkit-perspective": v,
-        "perspective": v
-      };
-    }
-  }],
-  [/^(?:transform-)?perspect(?:ive)?-origin-(.+)$/, ([, s]) => {
-    const v = handler.bracket.cssvar(s) ?? (s.length >= 3 ? positionMap[s] : void 0);
-    if (v != null) {
-      return {
-        "-webkit-perspective-origin": v,
-        "perspective-origin": v
-      };
-    }
-  }],
-  [/^(?:transform-)?translate-()(.+)$/, handleTranslate],
-  [/^(?:transform-)?translate-([xyz])-(.+)$/, handleTranslate],
-  [/^(?:transform-)?rotate-()(.+)$/, handleRotate],
-  [/^(?:transform-)?rotate-([xyz])-(.+)$/, handleRotate],
-  [/^(?:transform-)?skew-([xy])-(.+)$/, handleSkew],
-  [/^(?:transform-)?scale-()(.+)$/, handleScale],
-  [/^(?:transform-)?scale-([xyz])-(.+)$/, handleScale],
-  [/^(?:transform-)?preserve-3d$/, () => ({ "transform-style": "preserve-3d" })],
-  [/^(?:transform-)?preserve-flat$/, () => ({ "transform-style": "flat" })],
-  [/^transform$/, () => [
-    transformBase,
-    { transform: "var(--un-transform)" }
-  ]],
-  ["transform-gpu", transformGpu],
-  ["transform-cpu", transformCpu],
-  ["transform-none", { transform: "none" }]
-];
-function handleTranslate([, d, b], { theme }) {
-  const v = theme.spacing?.[b] ?? handler.bracket.cssvar.fraction.rem(b);
-  if (v != null) {
-    return [
-      transformBase,
-      [
-        ...xyzMap[d].map((i) => [`--un-translate${i}`, v]),
-        ["transform", "var(--un-transform)"]
-      ]
-    ];
-  }
-}
-function handleScale([, d, b]) {
-  const v = handler.bracket.cssvar.fraction.percent(b);
-  if (v != null) {
-    return [
-      transformBase,
-      [
-        ...xyzMap[d].map((i) => [`--un-scale${i}`, v]),
-        ["transform", "var(--un-transform)"]
-      ]
-    ];
-  }
-}
-function handleRotate([, d = "", b]) {
-  const v = handler.bracket.cssvar.degree(b);
-  if (v != null) {
-    if (d) {
-      return [
-        transformBase,
-        {
-          "--un-rotate": 0,
-          [`--un-rotate-${d}`]: v,
-          "transform": "var(--un-transform)"
-        }
-      ];
-    } else {
-      return [
-        transformBase,
-        {
-          "--un-rotate-x": 0,
-          "--un-rotate-y": 0,
-          "--un-rotate-z": 0,
-          "--un-rotate": v,
-          "transform": "var(--un-transform)"
-        }
-      ];
-    }
-  }
-}
-function handleSkew([, d, b]) {
-  const v = handler.bracket.cssvar.degree(b);
-  if (v != null) {
-    return [
-      transformBase,
-      {
-        [`--un-skew-${d}`]: v,
-        transform: "var(--un-transform)"
-      }
-    ];
-  }
-}
-
 const variablesAbbrMap = {
   backface: "backface-visibility",
   break: "word-break",
@@ -1003,4 +858,4 @@ const rules = [
   questionMark
 ].flat(1);
 
-export { cssProperty as $, sizes as A, aspectRatio as B, paddings as C, margins as D, varEmpty as E, displays as F, appearances as G, cursors as H, pointerEvents as I, resizes as J, userSelects as K, whitespaces as L, contents as M, breaks as N, textOverflows as O, textTransforms as P, fontStyles as Q, fontSmoothings as R, svgUtilities as S, transforms as T, transitions as U, fonts as V, tabSizes as W, textIndents as X, textStrokes as Y, textShadows as Z, cssVariables as _, appearance as a, textDecorations as a0, borders as b, opacity as c, textColors as d, bgColors as e, flex as f, gaps as g, grids as h, overflows as i, justifies as j, orders as k, alignments as l, placements as m, insets as n, outline as o, positions as p, floats as q, rules as r, boxSizing as s, textAligns as t, questionMark as u, verticalAligns as v, willChange as w, rings as x, boxShadows as y, zIndexes as z };
+export { textDecorations as $, sizes as A, aspectRatio as B, paddings as C, margins as D, varEmpty as E, displays as F, appearances as G, cursors as H, pointerEvents as I, resizes as J, userSelects as K, whitespaces as L, contents as M, breaks as N, textOverflows as O, textTransforms as P, fontStyles as Q, fontSmoothings as R, svgUtilities as S, transitions as T, fonts as U, tabSizes as V, textIndents as W, textStrokes as X, textShadows as Y, cssVariables as Z, cssProperty as _, appearance as a, borders as b, opacity as c, textColors as d, bgColors as e, flex as f, gaps as g, grids as h, overflows as i, justifies as j, orders as k, alignments as l, placements as m, insets as n, outline as o, positions as p, floats as q, rules as r, boxSizing as s, textAligns as t, questionMark as u, verticalAligns as v, willChange as w, rings as x, boxShadows as y, zIndexes as z };

package/dist/chunks/default3.cjs

@@ -123,10 +123,22 @@ const variantSelector = {
     }
   }
 };
-const variantLayer = {
+const variantCssLayer = {
   name: "layer",
   match(matcher) {
     const match = matcher.match(/^layer-([_\d\w]+)[:-]/);
+    if (match) {
+      return {
+        matcher: matcher.slice(match[0].length),
+        parent: `@layer ${match[1]}`
+      };
+    }
+  }
+};
+const variantInternalLayer = {
+  name: "uno-layer",
+  match(matcher) {
+    const match = matcher.match(/^uno-layer-([_\d\w]+)[:-]/);
     if (match) {
       return {
         matcher: matcher.slice(match[0].length),
@@ -352,8 +364,9 @@ const partClasses = {
 };
 
 const variants = (options) => [
+  variantCssLayer,
   variantSelector,
-  variantLayer,
+  variantInternalLayer,
   variantNegative,
   variantImportant,
   variantPrint,
@@ -373,10 +386,11 @@ exports.partClasses = partClasses;
 exports.variantBreakpoints = variantBreakpoints;
 exports.variantColorsMediaOrClass = variantColorsMediaOrClass;
 exports.variantCombinators = variantCombinators;
+exports.variantCssLayer = variantCssLayer;
 exports.variantCustomMedia = variantCustomMedia;
 exports.variantImportant = variantImportant;
+exports.variantInternalLayer = variantInternalLayer;
 exports.variantLanguageDirections = variantLanguageDirections;
-exports.variantLayer = variantLayer;
 exports.variantNegative = variantNegative;
 exports.variantPrint = variantPrint;
 exports.variantPseudoClassFunctions = variantPseudoClassFunctions;

package/dist/chunks/default3.mjs

@@ -1,4 +1,4 @@
-import { j as resolveBreakpoints, C as CONTROL_MINI_NO_NEGATIVE } from './utilities.mjs';
+import { d 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';
 
@@ -121,10 +121,22 @@ const variantSelector = {
     }
   }
 };
-const variantLayer = {
+const variantCssLayer = {
   name: "layer",
   match(matcher) {
     const match = matcher.match(/^layer-([_\d\w]+)[:-]/);
+    if (match) {
+      return {
+        matcher: matcher.slice(match[0].length),
+        parent: `@layer ${match[1]}`
+      };
+    }
+  }
+};
+const variantInternalLayer = {
+  name: "uno-layer",
+  match(matcher) {
+    const match = matcher.match(/^uno-layer-([_\d\w]+)[:-]/);
     if (match) {
       return {
         matcher: matcher.slice(match[0].length),
@@ -350,8 +362,9 @@ const partClasses = {
 };
 
 const variants = (options) => [
+  variantCssLayer,
   variantSelector,
-  variantLayer,
+  variantInternalLayer,
   variantNegative,
   variantImportant,
   variantPrint,
@@ -367,4 +380,4 @@ const variants = (options) => [
   variantScope
 ];
 
-export { variantBreakpoints as a, variantCombinators as b, variantPrint as c, variantCustomMedia as d, variantColorsMediaOrClass as e, variantLanguageDirections as f, variantSelector as g, variantLayer as h, variantScope as i, variantImportant as j, variantNegative as k, variantPseudoClassesAndElements as l, variantPseudoClassFunctions as m, variantTaggedPseudoClasses as n, partClasses as p, variants as v };
+export { variantBreakpoints as a, variantCombinators as b, variantPrint as c, variantCustomMedia as d, variantColorsMediaOrClass as e, variantLanguageDirections as f, variantSelector as g, variantCssLayer as h, variantInternalLayer as i, variantScope as j, variantImportant as k, variantNegative as l, variantPseudoClassesAndElements as m, variantPseudoClassFunctions as n, variantTaggedPseudoClasses as o, partClasses as p, variants as v };

package/dist/chunks/index.cjs

@@ -0,0 +1,310 @@
+'use strict';
+
+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 cssProps = [
+  "color",
+  "border-color",
+  "background-color",
+  "flex-grow",
+  "flex",
+  "flex-shrink",
+  "caret-color",
+  "font",
+  "gap",
+  "opacity",
+  "visibility",
+  "z-index",
+  "font-weight",
+  "zoom",
+  "text-shadow",
+  "transform",
+  "box-shadow",
+  "backround-position",
+  "left",
+  "right",
+  "top",
+  "bottom",
+  "object-position",
+  "max-height",
+  "min-height",
+  "max-width",
+  "min-width",
+  "height",
+  "width",
+  "border-width",
+  "margin",
+  "padding",
+  "outline-width",
+  "outline-offset",
+  "font-size",
+  "line-height",
+  "text-indent",
+  "vertical-align",
+  "border-spacing",
+  "letter-spacing",
+  "word-spacing",
+  "stroke",
+  "filter",
+  "backdrop-filter",
+  "fill",
+  "mask",
+  "mask-size",
+  "mask-border",
+  "clip-path",
+  "clip",
+  "border-radius"
+];
+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) {
+  return n.toFixed(10).replace(/\.0+$/, "").replace(/(\.\d+?)0+$/, "$1");
+}
+function numberWithUnit(str) {
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (unit && !Number.isNaN(num))
+    return `${round(num)}${unit}`;
+}
+function auto(str) {
+  if (str === "auto" || str === "a")
+    return "auto";
+}
+function rem(str) {
+  if (str.match(unitOnlyRE))
+    return `1${str}`;
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num / 4)}rem`;
+}
+function px(str) {
+  if (str.match(unitOnlyRE))
+    return `1${str}`;
+  const match = str.match(numberWithUnitRE);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num)}px`;
+}
+function number(str) {
+  if (!numberRE.test(str))
+    return;
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return round(num);
+}
+function percent(str) {
+  if (str.endsWith("%"))
+    str = str.slice(0, -1);
+  const num = parseFloat(str);
+  if (!Number.isNaN(num))
+    return `${round(num / 100)}`;
+}
+function fraction(str) {
+  if (str === "full")
+    return "100%";
+  const [left, right] = str.split("/");
+  const num = parseFloat(left) / parseFloat(right);
+  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(bracketTypeRe);
+    if (!match)
+      base = str.slice(1, -1);
+    else if (type && match[1] === type)
+      base = str.slice(match[0].length, -1);
+    if (base !== void 0) {
+      return base.replace(/(url\(.*?\))/g, (v) => v.replace(/_/g, "\\_")).replace(/([^\\])_/g, "$1 ").replace(/calc\((.*)/g, (v) => {
+        return v.replace(/(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g, "$1 $2 ");
+      });
+    }
+  }
+}
+function bracket(str) {
+  return bracketWithType(str);
+}
+function bracketOfColor(str) {
+  return bracketWithType(str, "color");
+}
+function bracketOfLength(str) {
+  return bracketWithType(str, "length");
+}
+function bracketOfPosition(str) {
+  return bracketWithType(str, "position");
+}
+function cssvar(str) {
+  if (str.match(/^\$\S/))
+    return `var(--${core.escapeSelector(str.slice(1))})`;
+}
+function time(str) {
+  const match = str.match(/^(-?[0-9.]+)(s|ms)?$/i);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num)}ms`;
+}
+function degree(str) {
+  const match = str.match(/^(-?[0-9.]+)(deg|rad|grad|turn)?$/i);
+  if (!match)
+    return;
+  const [, n, unit] = match;
+  const num = parseFloat(n);
+  if (!Number.isNaN(num))
+    return unit ? `${round(num)}${unit}` : `${round(num)}deg`;
+}
+function global(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,
+  numberWithUnit: numberWithUnit,
+  auto: auto,
+  rem: rem,
+  px: px,
+  number: number,
+  percent: percent,
+  fraction: fraction,
+  bracket: bracket,
+  bracketOfColor: bracketOfColor,
+  bracketOfLength: bracketOfLength,
+  bracketOfPosition: bracketOfPosition,
+  cssvar: cssvar,
+  time: time,
+  degree: degree,
+  global: global,
+  properties: properties,
+  position: position
+};
+
+const handler = core.createValueHandler(valueHandlers);
+const h = handler;
+
+exports.cornerMap = cornerMap;
+exports.directionMap = directionMap;
+exports.globalKeywords = globalKeywords;
+exports.h = h;
+exports.handler = handler;
+exports.insetMap = insetMap;
+exports.positionMap = positionMap;
+exports.valueHandlers = valueHandlers;
+exports.xyzMap = xyzMap;