@unocss/preset-mini 0.15.0

package/dist/chunks/default2.cjs

@@ -0,0 +1,1077 @@
+'use strict';
+
+const core = require('@unocss/core');
+const index = require('./index.cjs');
+const pseudo = require('./pseudo.cjs');
+
+const verticalAlignAlias = {
+  mid: "middle",
+  base: "baseline",
+  btm: "bottom"
+};
+const verticalAligns = [
+  [/^(?:vertical|align|v)-(baseline|top|bottom|middle|text-top|text-bottom|mid|base|btm)$/, ([, v]) => ({ "vertical-align": verticalAlignAlias[v] || v })]
+];
+const textAligns = [
+  ["text-center", { "text-align": "center" }],
+  ["text-left", { "text-align": "left" }],
+  ["text-right", { "text-align": "right" }],
+  ["text-justify", { "text-align": "justify" }]
+];
+
+const parseColorUtil = (body, theme) => {
+  const [main, opacity2] = body.split(/(?:\/|:)/);
+  const [name, no = "DEFAULT"] = main.replace(/([a-z])([0-9])/g, "$1-$2").split(/-/g);
+  if (!name)
+    return;
+  let color;
+  const bracket = index.handler.bracket(main) || main;
+  if (bracket.startsWith("#"))
+    color = bracket.slice(1);
+  if (bracket.startsWith("hex-"))
+    color = bracket.slice(4);
+  if (!color) {
+    const colorData = theme.colors?.[name];
+    if (typeof colorData === "string")
+      color = colorData;
+    else if (no && colorData)
+      color = colorData[no];
+  }
+  return {
+    opacity: opacity2,
+    name,
+    no,
+    color,
+    rgba: core.hex2rgba(color)
+  };
+};
+const colorResolver$1 = (attribute, varName) => ([, body], { theme }) => {
+  const data = parseColorUtil(body, theme);
+  if (!data)
+    return;
+  const { opacity: opacity2, color, rgba } = data;
+  if (!color)
+    return;
+  const a = opacity2 ? opacity2[0] === "[" ? index.handler.bracket.percent(opacity2) : parseFloat(opacity2) / 100 : rgba?.[3];
+  if (rgba) {
+    if (a != null && !Number.isNaN(a)) {
+      rgba[3] = typeof a === "string" && !a.includes("%") ? parseFloat(a) : a;
+      return {
+        [attribute]: `rgba(${rgba.join(",")})`
+      };
+    } else {
+      return {
+        [`--un-${varName}-opacity`]: 1,
+        [attribute]: `rgba(${rgba.slice(0, 3).join(",")},var(--un-${varName}-opacity))`
+      };
+    }
+  } else {
+    return {
+      [attribute]: color.replace("%alpha", `${a || 1}`)
+    };
+  }
+};
+const opacity = [
+  [/^op(?:acity)?-?(.+)$/, ([, d]) => ({ opacity: index.handler.bracket.percent.cssvar(d) })]
+];
+const textColors = [
+  [/^(?:text|color|c)-(.+)$/, colorResolver$1("color", "text")],
+  [/^(?:text|color|c)-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-text-opacity": index.handler.bracket.percent.cssvar(opacity2) })]
+];
+const textDecorationColors = [
+  [/^underline-(.+)$/, (match, ctx) => {
+    const result = colorResolver$1("text-decoration-color", "line")(match, ctx);
+    if (result) {
+      return {
+        "-webkit-text-decoration-color": result["text-decoration-color"],
+        ...result
+      };
+    }
+  }],
+  [/^underline-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-line-opacity": index.handler.bracket.percent(opacity2) })]
+];
+const textStrokeColors = [
+  [/^text-stroke-(.+)$/, colorResolver$1("-webkit-text-stroke-color", "text-stroke")],
+  [/^text-stroke-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-text-stroke-opacity": index.handler.bracket.percent(opacity2) })]
+];
+const bgColors = [
+  [/^bg-(.+)$/, colorResolver$1("background-color", "bg")],
+  [/^bg-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-bg-opacity": index.handler.bracket.percent(opacity2) })]
+];
+const borderColors = [
+  [/^(?:border|b)-(.+)$/, colorResolver$1("border-color", "border")],
+  [/^(?:border|b)-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-border-opacity": index.handler.bracket.percent(opacity2) })]
+];
+const ringColors = [
+  [/^ring-(.+)$/, colorResolver$1("--un-ring-color", "ring")],
+  [/^ring-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-ring-opacity": index.handler.bracket.percent(opacity2) })]
+];
+const ringOffsetColors = [
+  [/^ring-offset-(.+)$/, colorResolver$1("--un-ring-offset-color", "ring-offset")],
+  [/^ring-offset-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-ring-offset-opacity": index.handler.bracket.percent(opacity2) })]
+];
+const fillColors = [
+  ["fill-none", { fill: "none" }],
+  [/^fill-(.+)$/, colorResolver$1("fill", "fill")],
+  [/^fill-op(?:acity)?-?(.+)$/m, ([, opacity2]) => ({ "--un-fill-opacity": index.handler.bracket.percent(opacity2) })]
+];
+
+const outlineStyle = ["none", "auto", "dotted", "dashed", "solid", "double", "groove", "ridge", "inset", "outset", "inherit", "initial", "revert", "unset"];
+const parseOutlineSize = (s) => {
+  const propName = ["width", "offset"].find((item) => s.startsWith(item)) || "width";
+  const size = index.handler.bracket.fraction.rem(s.replace(/^(offset\-|width\-)/, ""));
+  if (size) {
+    return {
+      [`outline-${propName}`]: size
+    };
+  }
+};
+const outline = [
+  ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }],
+  ["outline", { "outline-style": "solid" }],
+  [
+    /^outline-(.+)$/,
+    (match, config) => {
+      const [, d] = match;
+      if (d === "none") {
+        return {
+          "outline": "2px solid transparent",
+          "outline-offset": "2px"
+        };
+      }
+      if (outlineStyle.includes(d)) {
+        return {
+          "outline-style": d
+        };
+      }
+      const sizeSheet = parseOutlineSize(d);
+      if (sizeSheet)
+        return sizeSheet;
+      const colorSheet = colorResolver$1("outline-color", "outline-color")([
+        match[0],
+        match[1].replace(/^color-/, "")
+      ], config);
+      if (colorSheet)
+        return colorSheet;
+    }
+  ]
+];
+const appearance = [
+  ["appearance-none", {
+    "appearance": "none",
+    "-webkit-appearance": "none"
+  }]
+];
+const placeholder = [
+  [
+    /^placeholder-opacity-(\d+)$/,
+    ([, d]) => ({
+      "placeholder-opacity": index.handler.bracket.percent(d)
+    })
+  ],
+  [
+    /^placeholder-(?!opacity)(.+)$/,
+    (match, config) => {
+      match[1] = match[1].replace(/^color-/, "");
+      return colorResolver$1("placeholder-color", "placeholder-color")(match, config);
+    }
+  ]
+];
+
+const borderSizes = [
+  [/^border$/, handlerBorder],
+  [/^(?:border|b)(?:-([^-]+))?$/, handlerBorder],
+  [/^(?:border|b)(?:-([^-]+))?(?:-([^-]+))?$/, handlerBorder]
+];
+const borderRadius = [
+  [/^(?:border-)?(?:rounded|rd)$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-([^-]+))?$/, handlerRounded]
+];
+const borderStyles = [
+  ["border-solid", { "border-style": "solid" }],
+  ["border-dashed", { "border-style": "dashed" }],
+  ["border-dotted", { "border-style": "dotted" }],
+  ["border-double", { "border-style": "double" }],
+  ["border-none", { "border-style": "none" }]
+];
+const borders = [
+  borderSizes,
+  borderColors,
+  borderStyles,
+  borderRadius
+].flat(1);
+function handlerBorder([, a, b]) {
+  const [d, s = "1"] = index.directionMap[a] ? [a, b] : ["", a];
+  const v = index.handler.bracket.px(s);
+  if (v != null) {
+    return [
+      ...index.directionMap[d].map((i) => [`border${i}-width`, v]),
+      ["border-style", "solid"]
+    ];
+  }
+}
+function handlerRounded([, a, b], { theme }) {
+  const [d, s = "DEFAULT"] = index.cornerMap[a] ? [a, b] : ["", a];
+  const v = theme.borderRadius?.[s] || index.handler.bracket.fraction.rem(s);
+  if (v != null)
+    return index.cornerMap[d].map((i) => [`border${i}-radius`, v]);
+}
+
+const transitionBasicProps = [
+  "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"
+];
+const transitionPositionProps = [
+  "backround-position",
+  "left",
+  "right",
+  "top",
+  "bottom",
+  "object-position"
+];
+const transitionSizeProps = [
+  "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"
+];
+const transitionSwitchProps = ["all", "none"];
+const transitionEnhanceProps = ["stroke", "filter", "backdrop-filter", "fill", "mask", "mask-size", "mask-border", "clip-path", "clip"];
+const transitionProps = [
+  ...transitionBasicProps,
+  ...transitionPositionProps,
+  ...transitionSizeProps,
+  ...transitionEnhanceProps
+];
+const transitionPropsStr = transitionProps.join(", ");
+const validateProperty = (prop) => {
+  if (prop && ![...transitionProps, ...transitionSwitchProps].includes(prop))
+    return;
+  return prop || transitionPropsStr;
+};
+const transitions = [
+  [/^transition(?:-([a-z-]+))?(?:-(\d+))?$/, ([, prop, duration = "150"]) => {
+    const transitionProperty = validateProperty(prop);
+    if (!transitionProperty)
+      return;
+    return {
+      "transition-property": transitionProperty,
+      "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
+      "transition-duration": `${duration}ms`
+    };
+  }],
+  [/^duration-(\d+)$/, ([, duration = "150"]) => {
+    return {
+      "transition-duration": `${duration}ms`
+    };
+  }],
+  ["ease", { "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)" }],
+  ["ease-in", { "transition-timing-function": "cubic-bezier(0.4, 0, 1, 1)" }],
+  ["ease-out", { "transition-timing-function": "cubic-bezier(0, 0, 0.2, 1)" }],
+  ["ease-in-out", { "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)" }],
+  [/^transition-delay-(\d+)$/, ([, v]) => ({ "transition-delay": `${v}ms` })],
+  [/^transition-duration-(\d+)$/, ([, v]) => ({ "transition-duration": `${v}ms` })],
+  [/^(?:transition-)?property-([a-z-]+)$/, ([, v]) => {
+    const transitionProperty = validateProperty(v);
+    if (transitionProperty)
+      return { "transition-property": transitionProperty };
+  }]
+];
+
+const flex = [
+  ["flex-col", { "flex-direction": "column" }],
+  ["flex-col-reverse", { "flex-direction": "column-reverse" }],
+  ["flex-row", { "flex-direction": "row" }],
+  ["flex-row-reverse", { "flex-direction": "row-reverse" }],
+  ["flex-wrap", { "flex-wrap": "wrap" }],
+  ["flex-wrap-reverse", { "flex-wrap": "wrap-reverse" }],
+  ["flex-nowrap", { "flex-wrap": "nowrap" }],
+  ["flex-1", { flex: "1 1 0%" }],
+  ["flex-auto", { flex: "1 1 auto" }],
+  ["flex-initial", { flex: "0 1 auto" }],
+  ["flex-none", { flex: "none" }],
+  [/^flex-\[(.+)\]$/, ([, d]) => ({ flex: d })],
+  ["flex-grow", { "flex-grow": 1 }],
+  ["flex-grow-0", { "flex-grow": 0 }],
+  ["flex-shrink", { "flex-shrink": 1 }],
+  ["flex-shrink-0", { "flex-shrink": 0 }],
+  ["flex", { display: "flex" }],
+  ["inline-flex", { display: "inline-flex" }],
+  ["flex-inline", { display: "inline-flex" }]
+];
+
+const fontsFamilies = [
+  [/^font-(\w+)$/, ([, d], { theme }) => {
+    const font = theme.fontFamily?.[d];
+    if (font) {
+      return {
+        "font-family": font
+      };
+    }
+  }]
+];
+const weightMap = {
+  thin: "100",
+  extralight: "200",
+  light: "300",
+  normal: "400",
+  medium: "500",
+  semibold: "600",
+  bold: "700",
+  extrabold: "800",
+  black: "900"
+};
+const fontSizes = [
+  [/^text-([^-]+)$/, ([, s = "base"], { theme }) => {
+    const result = core.toArray(theme.fontSize?.[s] || index.handler.bracket.rem(s));
+    if (result?.[0]) {
+      const [size, height = "1"] = result;
+      return {
+        "font-size": size,
+        "line-height": height
+      };
+    }
+  }]
+];
+const fontWeights = [
+  [/^(?:font|fw)-?([^-]+)$/, ([, s]) => {
+    const v = weightMap[s] || index.handler.number(s);
+    if (v)
+      return { "font-weight": v };
+  }]
+];
+const leadings = [
+  [/^(?:leading|lh)-([^-]+)$/, ([, s], { theme }) => {
+    const v = theme.lineHeight?.[s] || index.handler.bracket.rem(s);
+    if (v !== null)
+      return { "line-height": v };
+  }]
+];
+const trackings = [
+  [/^tracking-([^-]+)$/, ([, s], { theme }) => {
+    const v = theme.letterSpacing?.[s] || index.handler.bracket.rem(s);
+    if (v !== null)
+      return { "letter-spacing": v };
+  }]
+];
+const wordSpacings = [
+  [/^word-spacing-([^-]+)$/, ([, s], { theme }) => {
+    const v = theme.wordSpacing?.[s] || index.handler.bracket.rem(s);
+    if (v !== null)
+      return { "word-spacing": v };
+  }]
+];
+const tabSizes = [
+  [/^tab-?([^-]*)$/, ([, s]) => {
+    s = s || "4";
+    const v = index.handler.bracket.global.number(s);
+    if (v !== null) {
+      return {
+        "-moz-tab-size": v,
+        "-o-tab-size": v,
+        "tab-size": v
+      };
+    }
+  }]
+];
+const textDecorationLengths = [
+  [/^underline-([^-]+)$/, ([, s]) => {
+    const v = s === "auto" ? s : index.handler.bracket.px(s);
+    if (v != null)
+      return { "text-decoration-thickness": v };
+  }]
+];
+const textDecorationOffsets = [
+  [/^underline-offset-([^-]+)$/, ([, s]) => {
+    const v = s === "auto" ? s : index.handler.bracket.px(s);
+    if (v != null)
+      return { "text-underline-offset": v };
+  }]
+];
+const textIndents = [
+  [/^indent(?:-(.+))?$/, ([, s], { theme }) => {
+    const v = theme.textIndent?.[s || "DEFAULT"] || index.handler.bracket.cssvar.fraction.rem(s);
+    if (v != null)
+      return { "text-indent": v };
+  }]
+];
+const textStrokeWidths = [
+  [/^text-stroke(?:-(.+))?$/, ([, s], { theme }) => {
+    const v = theme.textStrokeWidth?.[s || "DEFAULT"] || index.handler.bracket.cssvar.px(s);
+    if (v != null)
+      return { "-webkit-text-stroke-width": v };
+  }]
+];
+const textShadows = [
+  [/^text-shadow(?:-(.+))?$/, ([, s], { theme }) => {
+    const v = theme.textShadow?.[s || "DEFAULT"] || index.handler.bracket.cssvar(s);
+    if (v != null)
+      return { "text-shadow": v };
+  }]
+];
+const fonts = [
+  fontsFamilies,
+  fontSizes,
+  fontWeights
+].flat(1);
+
+const gaps = [
+  [/^(?:flex-|grid-)?gap-([^-]+)$/, ([, s]) => {
+    const v = index.handler.bracket.rem(s);
+    if (v != null) {
+      return {
+        "grid-gap": v,
+        "gap": v
+      };
+    }
+  }],
+  [/^(?:flex-|grid-)?gap-x-([^-]+)$/, ([, s]) => {
+    const v = index.handler.bracket.rem(s);
+    if (v != null) {
+      return {
+        "grid-column-gap": v,
+        "column-gap": v
+      };
+    }
+  }],
+  [/^(?:flex-|grid-)?gap-y-([^-]+)$/, ([, s]) => {
+    const v = index.handler.bracket.rem(s);
+    if (v != null) {
+      return {
+        "grid-row-gap": v,
+        "row-gap": v
+      };
+    }
+  }]
+];
+
+const calSize = (s, theme) => core.toArray(theme.fontSize?.[s] || index.handler.bracket.rem(s))[0];
+const autoDirection = (selector, theme) => {
+  if (selector === "min")
+    return "min-content";
+  else if (selector === "max")
+    return "max-content";
+  else if (selector === "fr")
+    return "minmax(0,1fr)";
+  return calSize(selector, theme);
+};
+const grids = [
+  ["grid", { display: "grid" }],
+  ["inline-grid", { display: "inline-grid" }],
+  [/^grid-cols-minmax-([\w.-]+)$/, ([, d]) => ({ "grid-template-columns": `repeat(auto-fill, minmax(${d}, 1fr))` })],
+  [/^grid-rows-minmax-([\w.-]+)$/, ([, d]) => ({ "grid-template-rows": `repeat(auto-fill, minmax(${d}, 1fr))` })],
+  [/^grid-cols-(\d+)$/, ([, d]) => ({ "grid-template-columns": `repeat(${d},minmax(0,1fr))` })],
+  [/^grid-rows-(\d+)$/, ([, d]) => ({ "grid-template-rows": `repeat(${d},minmax(0,1fr))` })],
+  [/^grid-cols-\[(.+)\]$/, ([, v]) => ({ "grid-template-columns": v.replace(/,/g, " ") })],
+  [/^grid-rows-\[(.+)\]$/, ([, v]) => ({ "grid-template-rows": v.replace(/,/g, " ") })],
+  [/^(?:grid-)?(row|col)-(.+)$/, ([, d, v]) => {
+    const key = d === "row" ? "grid-row" : "grid-column";
+    let raw = index.handler.bracket(v);
+    if (raw)
+      return { [key]: raw };
+    const parts = v.split("-");
+    if (parts.length === 1 && parts[0] === "auto")
+      return { [key]: parts[0] };
+    if (parts[0] === "span") {
+      if (parts[1] === "full")
+        return { [key]: "1/-1" };
+      raw = index.handler.number.bracket(parts[1])?.toString().replace(/_/g, " ");
+      if (raw)
+        return { [key]: `span ${raw}/span ${raw}` };
+    }
+  }],
+  [/^(?:grid-)?auto-flow-([\w.-]+)$/, ([, v]) => ({ "grid-auto-flow": `${v.replace("col", "column").split("-").join(" ")}` })],
+  [/^(?:grid-)?row-start-([\w.-]+)$/, ([, v]) => ({ "grid-row-start": `${v}` })],
+  [/^(?:grid-)?row-end-([\w.-]+)$/, ([, v]) => ({ "grid-row-end": `${v}` })],
+  [/^(?:grid-)?col-start-([\w.-]+)$/, ([, v]) => ({ "grid-column-start": `${v}` })],
+  [/^(?:grid-)?col-end-([\w.]+)$/, ([, v]) => ({ "grid-column-end": `${v}` })],
+  [/^(?:grid-)?auto-rows-([\w.-]+)$/, ([, v], { theme }) => ({ "grid-auto-rows": `${autoDirection(v, theme)}` })],
+  [/^(?:grid-)?auto-cols-([\w.-]+)$/, ([, v], { theme }) => ({ "grid-auto-columns": `${autoDirection(v, theme)}` })]
+];
+
+const overflowValues = [
+  "auto",
+  "hidden",
+  "visible",
+  "scroll"
+];
+const overflows = [
+  [/^(?:overflow|of)-(.+)$/, ([, v]) => overflowValues.includes(v) ? { overflow: v } : void 0],
+  [/^(?:overflow|of)-([xy])-(.+)$/, ([, d, v]) => overflowValues.includes(v) ? { [`overflow-${d}`]: v } : void 0]
+];
+
+const positions = [
+  ["relative", { position: "relative" }],
+  ["absolute", { position: "absolute" }],
+  ["fixed", { position: "fixed" }],
+  ["sticky", { position: "sticky" }],
+  ["static", { position: "static" }]
+];
+const justifies = [
+  ["justify-start", { "justify-content": "flex-start" }],
+  ["justify-end", { "justify-content": "flex-end" }],
+  ["justify-center", { "justify-content": "center" }],
+  ["justify-between", { "justify-content": "space-between" }],
+  ["justify-around", { "justify-content": "space-around" }],
+  ["justify-evenly", { "justify-content": "space-evenly" }]
+];
+const orders = [
+  [/^order-(.+)$/, ([, v]) => ({ order: { first: "-9999", last: "9999", none: "0" }[v] || index.handler.bracket.number(v) })]
+];
+const basicSet = ["auto", "start", "end", "center", "stretch"];
+const justifyItems = basicSet.map((i) => [`justify-items-${i}`, { "justify-items": i }]);
+const justifySelfs = basicSet.map((i) => [`justify-self-${i}`, { "justify-self": i }]);
+const alignContents = [
+  ["content-start", { "align-content": "flex-start" }],
+  ["content-end", { "align-content": "flex-end" }],
+  ["content-center", { "align-content": "center" }],
+  ["content-between", { "align-content": "space-between" }],
+  ["content-around", { "align-content": "space-around" }],
+  ["content-evenly", { "align-content": "space-evenly" }]
+];
+const alignItems = [
+  ["items-start", { "align-items": "flex-start" }],
+  ["items-end", { "align-items": "flex-end" }],
+  ["items-center", { "align-items": "center" }],
+  ["items-baseline", { "align-items": "baseline" }],
+  ["items-stretch", { "align-items": "stretch" }]
+];
+const alignSelfs = [
+  ["self-auto", { "align-self": "auto" }],
+  ["self-start", { "align-self": "flex-start" }],
+  ["self-end", { "align-self": "flex-end" }],
+  ["self-center", { "align-self": "center" }],
+  ["self-stretch", { "align-items": "stretch" }]
+];
+const placeContents = [
+  ["place-content-start", { "place-content": "start" }],
+  ["place-content-end", { "place-content": "end" }],
+  ["place-content-center", { "place-content": "center" }],
+  ["place-content-between", { "place-content": "space-between" }],
+  ["place-content-around", { "place-content": "space-around" }],
+  ["place-content-evenly", { "place-content": "space-evenly" }],
+  ["place-content-stretch", { "place-content": "stretch" }]
+];
+const placeItems = basicSet.map((i) => [`place-items-${i}`, { "place-items": i }]);
+const placeSelfs = basicSet.map((i) => [`place-self-${i}`, { "place-self": i }]);
+function handleInsetValue(v) {
+  return { auto: "auto", full: "100%" }[v] ?? index.handler.bracket.fraction.cssvar.rem(v);
+}
+const insets = [
+  [/^(top|left|right|bottom|inset)-(.+)$/, ([, d, v]) => ({ [d]: handleInsetValue(v) })],
+  [/^inset-([xy])-(.+)$/, ([, d, v]) => {
+    const r = handleInsetValue(v);
+    if (r != null && d in index.directionMap)
+      return index.directionMap[d].map((i) => [i.slice(1), r]);
+  }]
+];
+const floats = [
+  [/^float-(left|right|none)$/, ([, value]) => ({ float: value })],
+  [/^clear-(left|right|both|none)$/, ([, value]) => ({ clear: value })]
+];
+const zIndexes = [
+  ["z-auto", { "z-index": "auto" }],
+  [/^z-([^-]+)$/, ([, v]) => ({ "z-index": index.handler.number(v) })]
+];
+const boxSizing = [
+  [
+    /^box-(border|content)$/,
+    ([, value]) => ({
+      "box-sizing": `${value}-box`
+    })
+  ]
+];
+
+const rings = [
+  [/^ring-?(.*)$/, ([, d]) => {
+    const value = index.handler.px(d || "1");
+    if (value) {
+      return {
+        "--un-ring-inset": "var(--un-empty, )",
+        "--un-ring-offset-width": "0px",
+        "--un-ring-offset-color": "#fff",
+        "--un-ring-color": "rgba(59, 130, 246, .5)",
+        "--un-ring-offset-shadow": "var(--un-ring-inset) 0 0 0 var(--un-ring-offset-width) var(--un-ring-offset-color)",
+        "--un-ring-shadow": `var(--un-ring-inset) 0 0 0 calc(${value} + var(--un-ring-offset-width)) var(--un-ring-color)`,
+        "-webkit-box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000);",
+        "box-shadow": "var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow, 0 0 #0000);"
+      };
+    }
+  }],
+  [/^ring-offset-?(.*)$/, ([, d]) => {
+    const value = index.handler.px(d || "1");
+    if (value) {
+      return {
+        "--un-ring-offset-width": value
+      };
+    }
+  }],
+  ["ring-inset", { "--un-ring-inset": "inset" }],
+  ...ringColors,
+  ...ringOffsetColors
+];
+
+const colorResolver = (body, theme) => {
+  const data = parseColorUtil(body, theme);
+  if (!data)
+    return;
+  const { color, rgba } = data;
+  if (!color)
+    return;
+  if (rgba) {
+    return {
+      "--un-shadow-color": `${rgba.slice(0, 3).join(",")}`
+    };
+  } else {
+    return {
+      "--un-shadow-color": color
+    };
+  }
+};
+const boxShadows = [
+  [/^shadow-?(.*)$/, ([, d], { theme }) => {
+    const value = theme?.boxShadow?.[d || "DEFAULT"];
+    if (value) {
+      return {
+        "--un-shadow-color": "0,0,0",
+        "--un-shadow": value,
+        "box-shadow": "var(--un-ring-offset-shadow, 0 0 #0000), var(--un-ring-shadow, 0 0 #0000), var(--un-shadow)"
+      };
+    }
+    const color = colorResolver(d, theme);
+    if (color)
+      return color;
+  }]
+];
+
+function getPropName(minmax, hw) {
+  return `${minmax ? `${minmax}-` : ""}${hw === "h" ? "height" : "width"}`;
+}
+function getThemeValue(minmax, hw, theme, prop) {
+  let str = `${hw === "h" ? "height" : "width"}`;
+  if (minmax)
+    str = `${minmax}${index.capitalize(str)}`;
+  return theme[str]?.[prop];
+}
+const sizes = [
+  [/^(?:(min|max)-)?(w|h)-(.+)$/, ([, m, w, s], { theme }) => {
+    const v = getThemeValue(m, w, theme, s) || index.handler.bracket.cssvar.fraction.rem(s);
+    if (v != null)
+      return { [getPropName(m, w)]: v };
+  }],
+  [/^(?:(min|max)-)?(w)-screen-(.+)$/, ([, m, w, s], { theme }) => {
+    const v = theme.breakpoints?.[s];
+    if (v != null)
+      return { [getPropName(m, w)]: v };
+  }]
+];
+const aspectRatio = [
+  ["aspect-ratio-auto", { "aspect-ratio": "auto" }],
+  [/^aspect-ratio-(.+)$/, ([, d]) => {
+    const v = (/^\d+\/\d+$/.test(d) ? d : null) || index.handler.bracket.cssvar.number(d);
+    if (v != null)
+      return { "aspect-ratio": v };
+  }]
+];
+
+const directionSize = (prefix) => ([_, direction, size]) => {
+  const v = index.handler.bracket.rem.fraction.cssvar(size);
+  if (v)
+    return index.directionMap[direction].map((i) => [prefix + i, v]);
+};
+const paddings = [
+  [/^pa?()-?(-?.+)$/, directionSize("padding")],
+  [/^p-?([xy])-?(-?.+)$/, directionSize("padding")],
+  [/^p-?([rltbse])-?(-?.+)$/, directionSize("padding")]
+];
+const margins = [
+  [/^ma?()-?(-?.+)$/, directionSize("margin")],
+  [/^m-?([xy])-?(-?.+)$/, directionSize("margin")],
+  [/^m-?([rltbse])-?(-?.+)$/, directionSize("margin")]
+];
+
+const varEmpty = "var(--un-empty,/*!*/ /*!*/)";
+const displays = [
+  ["inline", { display: "inline" }],
+  ["block", { display: "block" }],
+  ["inline-block", { display: "inline-block" }],
+  ["contents", { display: "contents" }],
+  ["flow-root", { display: "flow-root" }],
+  ["list-item", { display: "list-item" }],
+  ["hidden", { display: "none" }]
+];
+const appearances = [
+  ["visible", { visibility: "visible" }],
+  ["invisible", { visibility: "hidden" }],
+  ["backface-visible", { "backface-visibility": "visible" }],
+  ["backface-hidden", { "backface-visibility": "hidden" }]
+];
+const cursors = [
+  [/^cursor-(.+)$/, ([, c]) => ({ cursor: c })]
+];
+const pointerEvents = [
+  ["pointer-events-none", { "pointer-events": "none" }],
+  ["pointer-events-auto", { "pointer-events": "auto" }]
+];
+const resizes = [
+  ["resize-none", { resize: "none" }],
+  ["resize-x", { resize: "horizontal" }],
+  ["resize-y", { resize: "vertical" }],
+  ["resize", { resize: "both" }]
+];
+const userSelects = [
+  [/^select-(none|text|all|auto)$/, ([, v]) => ({ "user-select": v })]
+];
+const whitespaces = [
+  [/^(?:whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap)$/, ([, v]) => ({ "white-space": v })]
+];
+const contents = [
+  ["content-empty", { content: '""' }]
+];
+const breaks = [
+  ["break-normal", { "overflow-wrap": "normal", "word-break": "normal" }],
+  ["break-word", { "overflow-wrap": "break-word" }],
+  ["break-all", { "word-break": "break-all" }]
+];
+const textOverflows = [
+  ["truncate", { "overflow": "hidden", "text-overflow": "ellipsis", "white-space": "nowrap" }],
+  ["text-ellipsis", { "text-overflow": "ellipsis" }],
+  ["text-clip", { "text-overflow": "clip" }]
+];
+const textTransforms = [
+  ["case-upper", { "text-transform": "uppercase" }],
+  ["case-lower", { "text-transform": "lowercase" }],
+  ["case-capital", { "text-transform": "capitalize" }],
+  ["case-normal", { "text-transform": "none" }]
+];
+const textDecorations = [
+  ["underline", { "text-decoration": "underline" }],
+  ["line-through", { "text-decoration": "line-through" }],
+  ["no-underline", { "text-decoration": "none" }]
+];
+const textDecorationStyles = [
+  ["underline-solid", { "text-decoration-style": "solid" }],
+  ["underline-double", { "text-decoration-style": "double" }],
+  ["underline-dotted", { "text-decoration-style": "dotted" }],
+  ["underline-dashed", { "text-decoration-style": "dashed" }]
+];
+const fontStyles = [
+  ["italic", { "font-style": "italic" }],
+  ["not-italic", { "font-style": "normal" }]
+];
+const fontSmoothings = [
+  ["antialiased", {
+    "-webkit-font-smoothing": "antialiased",
+    "-moz-osx-font-smoothing": "grayscale",
+    "font-smoothing": "grayscale"
+  }],
+  ["subpixel-antialiased", {
+    "-webkit-font-smoothing": "auto",
+    "-moz-osx-font-smoothing": "auto",
+    "font-smoothing": "auto"
+  }]
+];
+
+const transformBase = {
+  "--un-rotate": 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,
+  "transform": "rotate(var(--un-rotate)) scaleX(var(--un-scale-x)) scaleY(var(--un-scale-y)) scaleZ(var(--un-scale-z)) skewX(var(--un-skew-x)) skewY(var(--un-skew-y)) translateX(var(--un-translate-x)) translateY(var(--un-translate-y)) translateZ(var(--un-translate-z))",
+  [pseudo.CONTROL_BYPASS_PSEUDO]: ""
+};
+const transforms = [
+  ["transform", transformBase],
+  [/^preserve-(3d|flat)$/, ([, value]) => ({ "transform-style": value === "3d" ? `preserve-${value}` : value })],
+  [/^translate()-([^-]+)$/, handleTranslate],
+  [/^translate-([xyz])-([^-]+)$/, handleTranslate],
+  [/^scale()-([^-]+)$/, handleScale],
+  [/^scale-([xyz])-([^-]+)$/, handleScale],
+  [/^rotate-([^-]+)(?:deg)?$/, handleRotate],
+  ["origin-center", { "transform-origin": "center" }],
+  ["origin-top", { "transform-origin": "top" }],
+  ["origin-top-right", { "transform-origin": "top right" }],
+  ["origin-right", { "transform-origin": "right" }],
+  ["origin-bottom-right", { "transform-origin": "bottom right" }],
+  ["origin-bottom", { "transform-origin": "bottom" }],
+  ["origin-bottom-left", { "transform-origin": "bottom left" }],
+  ["origin-left", { "transform-origin": "left" }],
+  ["origin-top-left", { "transform-origin": "top left" }]
+];
+function handleTranslate([, d, b]) {
+  const v = index.handler.bracket.fraction.rem(b);
+  if (v != null) {
+    return [
+      transformBase,
+      [
+        ...index.xyzMap[d].map((i) => [`--un-translate${i}`, v])
+      ]
+    ];
+  }
+}
+function handleScale([, d, b]) {
+  const v = index.handler.bracket.fraction.percent(b);
+  if (v != null) {
+    return [
+      transformBase,
+      [
+        ...index.xyzMap[d].map((i) => [`--un-scale${i}`, v])
+      ]
+    ];
+  }
+}
+function handleRotate([, b]) {
+  const v = index.handler.bracket.number(b);
+  if (v != null) {
+    return [
+      transformBase,
+      { "--un-rotate": `${v}deg` }
+    ];
+  }
+}
+
+const variablesAbbrMap = {
+  "visible": "visibility",
+  "select": "user-select",
+  "vertical": "vertical-align",
+  "backface": "backface-visibility",
+  "whitespace": "white-space",
+  "break": "word-break",
+  "color": "color",
+  "case": "text-transform",
+  "write": "writing-mode",
+  "write-orient": "text-orientation",
+  "origin": "transform-origin",
+  "bg": "background-color",
+  "bg-blend": "background-blend-mode",
+  "bg-clip": "-webkit-background-clip",
+  "bg-gradient": "linear-gradient",
+  "bg-origin-border": "background-origin",
+  "bg-position": "background-position",
+  "bg-repeat": "background-repeat",
+  "bg-size": "background-size",
+  "bg-opacity": "background-opacity",
+  "tab": "tab-size",
+  "underline": "text-decoration-thickness",
+  "underline-offset": "text-underline-offset",
+  "text": "color",
+  "grid-cols": "grid-template-columns",
+  "grid-rows": "grid-template-rows",
+  "auto-flow": "grid-auto-flow",
+  "row-start": "grid-row-start",
+  "row-end": "grid-row-end",
+  "justify": "justify-content",
+  "content": "align-content",
+  "items": "align-items",
+  "self": "align-self",
+  "object": "object-fit",
+  "mix-blend": "mix-blend-mode",
+  "animate-speed": "animation-speed"
+};
+const cssVariables = [[
+  /^(.+)-\$(.+)$/,
+  ([, name, varname]) => {
+    const prop = variablesAbbrMap[name];
+    if (prop) {
+      return {
+        [prop]: `var(--${varname})`
+      };
+    }
+  }
+]];
+
+const questionMark = [
+  [
+    /^(where|\?)$/,
+    (_, { constructCSS, generator }) => {
+      if (generator.config.envMode === "dev")
+        return `@keyframes __un_qm{0%{box-shadow:inset 4px 4px #ff1e90, inset -4px -4px #ff1e90}100%{box-shadow:inset 8px 8px #3399ff, inset -8px -8px #3399ff}}
+${constructCSS({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
+    }
+  ]
+];
+
+const rules = [
+  cssVariables,
+  paddings,
+  margins,
+  displays,
+  opacity,
+  bgColors,
+  fillColors,
+  borders,
+  contents,
+  fonts,
+  tabSizes,
+  textIndents,
+  textOverflows,
+  textDecorations,
+  textDecorationStyles,
+  textDecorationColors,
+  textDecorationLengths,
+  textDecorationOffsets,
+  textStrokeWidths,
+  textStrokeColors,
+  textShadows,
+  textTransforms,
+  textAligns,
+  textColors,
+  fontStyles,
+  fontSmoothings,
+  boxShadows,
+  rings,
+  flex,
+  grids,
+  gaps,
+  positions,
+  sizes,
+  aspectRatio,
+  cursors,
+  appearances,
+  pointerEvents,
+  resizes,
+  verticalAligns,
+  userSelects,
+  whitespaces,
+  breaks,
+  trackings,
+  wordSpacings,
+  leadings,
+  overflows,
+  outline,
+  appearance,
+  placeholder,
+  positions,
+  orders,
+  justifies,
+  justifyItems,
+  justifySelfs,
+  alignContents,
+  alignItems,
+  alignSelfs,
+  placeContents,
+  placeItems,
+  placeSelfs,
+  insets,
+  floats,
+  zIndexes,
+  boxSizing,
+  transitions,
+  transforms,
+  questionMark
+].flat(1);
+
+exports.alignContents = alignContents;
+exports.alignItems = alignItems;
+exports.alignSelfs = alignSelfs;
+exports.appearance = appearance;
+exports.appearances = appearances;
+exports.aspectRatio = aspectRatio;
+exports.bgColors = bgColors;
+exports.borderColors = borderColors;
+exports.borderRadius = borderRadius;
+exports.borderSizes = borderSizes;
+exports.borderStyles = borderStyles;
+exports.borders = borders;
+exports.boxShadows = boxShadows;
+exports.boxSizing = boxSizing;
+exports.breaks = breaks;
+exports.colorResolver = colorResolver$1;
+exports.contents = contents;
+exports.cssVariables = cssVariables;
+exports.cursors = cursors;
+exports.displays = displays;
+exports.fillColors = fillColors;
+exports.flex = flex;
+exports.floats = floats;
+exports.fontSizes = fontSizes;
+exports.fontSmoothings = fontSmoothings;
+exports.fontStyles = fontStyles;
+exports.fontWeights = fontWeights;
+exports.fonts = fonts;
+exports.fontsFamilies = fontsFamilies;
+exports.gaps = gaps;
+exports.grids = grids;
+exports.insets = insets;
+exports.justifies = justifies;
+exports.justifyItems = justifyItems;
+exports.justifySelfs = justifySelfs;
+exports.leadings = leadings;
+exports.margins = margins;
+exports.opacity = opacity;
+exports.orders = orders;
+exports.outline = outline;
+exports.overflows = overflows;
+exports.paddings = paddings;
+exports.parseColorUtil = parseColorUtil;
+exports.placeContents = placeContents;
+exports.placeItems = placeItems;
+exports.placeSelfs = placeSelfs;
+exports.placeholder = placeholder;
+exports.pointerEvents = pointerEvents;
+exports.positions = positions;
+exports.questionMark = questionMark;
+exports.resizes = resizes;
+exports.ringColors = ringColors;
+exports.ringOffsetColors = ringOffsetColors;
+exports.rings = rings;
+exports.rules = rules;
+exports.sizes = sizes;
+exports.tabSizes = tabSizes;
+exports.textAligns = textAligns;
+exports.textColors = textColors;
+exports.textDecorationColors = textDecorationColors;
+exports.textDecorationLengths = textDecorationLengths;
+exports.textDecorationOffsets = textDecorationOffsets;
+exports.textDecorationStyles = textDecorationStyles;
+exports.textDecorations = textDecorations;
+exports.textIndents = textIndents;
+exports.textOverflows = textOverflows;
+exports.textShadows = textShadows;
+exports.textStrokeColors = textStrokeColors;
+exports.textStrokeWidths = textStrokeWidths;
+exports.textTransforms = textTransforms;
+exports.trackings = trackings;
+exports.transforms = transforms;
+exports.transitions = transitions;
+exports.userSelects = userSelects;
+exports.varEmpty = varEmpty;
+exports.verticalAligns = verticalAligns;
+exports.whitespaces = whitespaces;
+exports.wordSpacings = wordSpacings;
+exports.zIndexes = zIndexes;