@duxweb/dvha-pro 0.0.5 → 0.0.7

package/dist/esm/node_modules/.pnpm/@unocss_preset-wind4@66.2.3/node_modules/@unocss/preset-wind4/dist/shared/preset-wind4.BgkAsChl.js

@@ -0,0 +1,2307 @@
+import { B as b, g as f, b as r, s as d, H as s, G as l, p as v, k as u, l as p, q as $, I as E, D as Y, d as x, E as $e, c as B, J as Me, r as qe, L as De, C as Be, x as xe, i as oe, w as we, S as je, m as _e, O as Ge, A as Ie, N as Ne, e as He } from "./preset-wind4.BwwuP5Yw.js";
+import { symbols as Ke, notNull as Je } from "../../../../../../@unocss_core@66.2.3/node_modules/@unocss/core/dist/index.js";
+import { a as Ze, c as Xe } from "./preset-wind4.dDC8WtZ5.js";
+import { getStringComponent as Ye } from "../../../../../../@unocss_rule-utils@66.2.3/node_modules/@unocss/rule-utils/dist/index.js";
+const re = {
+  mid: "middle",
+  base: "baseline",
+  btm: "bottom",
+  baseline: "baseline",
+  top: "top",
+  start: "top",
+  middle: "middle",
+  bottom: "bottom",
+  end: "bottom",
+  "text-top": "text-top",
+  "text-bottom": "text-bottom",
+  sub: "sub",
+  super: "super",
+  ...Object.fromEntries(f.map((e) => [e, e]))
+}, Qe = [
+  [
+    /^(?:vertical|align|v)-(.+)$/,
+    ([, e]) => ({ "vertical-align": re[e] ?? r.bracket.cssvar.numberWithUnit(e) }),
+    {
+      autocomplete: [
+        `(vertical|align|v)-(${Object.keys(re).join("|")})`,
+        "(vertical|align|v)-<percentage>"
+      ]
+    }
+  ]
+], ae = ["center", "left", "right", "justify", "start", "end"], et = [
+  ...ae.map((e) => [`text-${e}`, { "text-align": e }]),
+  ...[
+    ...f,
+    ...ae
+  ].map((e) => [`text-align-${e}`, { "text-align": e }])
+], tt = [
+  [/^(?:animate-)?keyframes-(.+)$/, ([, e], { theme: t }) => {
+    var o, a;
+    const n = (a = (o = t.animation) == null ? void 0 : o.keyframes) == null ? void 0 : a[e];
+    if (n)
+      return [
+        `@keyframes ${e}${n}`,
+        { animation: e }
+      ];
+  }, { autocomplete: ["animate-keyframes-$animation.keyframes", "keyframes-$animation.keyframes"] }],
+  [/^animate-(.+)$/, ([, e], { theme: t }) => {
+    var o, a, i, c, m, g, z, T, L, ne;
+    const n = (a = (o = t.animation) == null ? void 0 : o.keyframes) == null ? void 0 : a[e];
+    if (n) {
+      const Te = ((c = (i = t.animation) == null ? void 0 : i.durations) == null ? void 0 : c[e]) ?? "1s", Le = ((g = (m = t.animation) == null ? void 0 : m.timingFns) == null ? void 0 : g[e]) ?? "linear", Pe = ((T = (z = t.animation) == null ? void 0 : z.counts) == null ? void 0 : T[e]) ?? 1, Fe = (ne = (L = t.animation) == null ? void 0 : L.properties) == null ? void 0 : ne[e];
+      return [
+        `@keyframes ${e}${n}`,
+        {
+          animation: `${e} ${Te} ${Le} ${Pe}`,
+          ...Fe
+        }
+      ];
+    }
+    return { animation: r.bracket.cssvar(e) };
+  }, { autocomplete: "animate-$animation.keyframes" }],
+  [/^animate-name-(.+)/, ([, e]) => ({ "animation-name": r.bracket.cssvar(e) ?? e })],
+  // timings
+  [/^animate-duration-(.+)$/, ([, e], { theme: t }) => {
+    var n;
+    return { "animation-duration": ((n = t.duration) == null ? void 0 : n[e || "DEFAULT"]) ?? r.bracket.cssvar.time(e) };
+  }, { autocomplete: ["animate-duration"] }],
+  [/^animate-delay-(.+)$/, ([, e], { theme: t }) => {
+    var n;
+    return { "animation-delay": ((n = t.duration) == null ? void 0 : n[e || "DEFAULT"]) ?? r.bracket.cssvar.time(e) };
+  }, { autocomplete: ["animate-delay"] }],
+  [/^animate-ease(?:-(.+))?$/, ([, e], { theme: t }) => {
+    var n;
+    return { "animation-timing-function": ((n = t.ease) == null ? void 0 : n[e || "DEFAULT"]) ?? r.bracket.cssvar(e) };
+  }, { autocomplete: ["animate-ease", "animate-ease-$ease"] }],
+  // fill mode
+  [/^animate-(fill-mode-|fill-|mode-)?(.+)$/, ([, e, t]) => ["none", "forwards", "backwards", "both", e ? f : []].includes(t) ? { "animation-fill-mode": t } : void 0, {
+    autocomplete: [
+      "animate-(fill|mode|fill-mode)",
+      "animate-(fill|mode|fill-mode)-(none|forwards|backwards|both|inherit|initial|revert|revert-layer|unset)",
+      "animate-(none|forwards|backwards|both|inherit|initial|revert|revert-layer|unset)"
+    ]
+  }],
+  // direction
+  [/^animate-(direction-)?(.+)$/, ([, e, t]) => ["normal", "reverse", "alternate", "alternate-reverse", e ? f : []].includes(t) ? { "animation-direction": t } : void 0, {
+    autocomplete: [
+      "animate-direction",
+      "animate-direction-(normal|reverse|alternate|alternate-reverse|inherit|initial|revert|revert-layer|unset)",
+      "animate-(normal|reverse|alternate|alternate-reverse|inherit|initial|revert|revert-layer|unset)"
+    ]
+  }],
+  // others
+  [/^animate-(?:iteration-count-|iteration-|count-)(.+)$/, ([, e]) => ({ "animation-iteration-count": r.bracket.cssvar(e) ?? e.replace(/-/g, ",") }), { autocomplete: ["animate-(iteration|count|iteration-count)", "animate-(iteration|count|iteration-count)-<num>"] }],
+  [/^animate-(play-state-|play-|state-)?(.+)$/, ([, e, t]) => ["paused", "running", e ? f : []].includes(t) ? { "animation-play-state": t } : void 0, {
+    autocomplete: [
+      "animate-(play|state|play-state)",
+      "animate-(play|state|play-state)-(paused|running|inherit|initial|revert|revert-layer|unset)",
+      "animate-(paused|running|inherit|initial|revert|revert-layer|unset)"
+    ]
+  }],
+  ["animate-none", { animation: "none" }],
+  ...l("animate", "animation")
+], ze = {
+  "gradient-position": s("--un-gradient-position"),
+  "gradient-from": s("--un-gradient-from", { syntax: "<color>", initialValue: "#0000" }),
+  "gradient-via": s("--un-gradient-via", { syntax: "<color>", initialValue: "#0000" }),
+  "gradient-to": s("--un-gradient-to", { syntax: "<color>", initialValue: "#0000" }),
+  "gradient-stops": s("--un-gradient-stops"),
+  "gradient-via-stops": s("--un-gradient-via-stops"),
+  "gradient-from-position": s("--un-gradient-from-position", { syntax: "<length-percentage>", initialValue: "0%" }),
+  "gradient-via-position": s("--un-gradient-via-position", { syntax: "<length-percentage>", initialValue: "50%" }),
+  "gradient-to-position": s("--un-gradient-to-position", { syntax: "<length-percentage>", initialValue: "100%" })
+};
+function ie(e) {
+  let t = "in oklab";
+  if (e)
+    if (e.startsWith("[") && e.endsWith("]"))
+      t = e.slice(1, -1);
+    else
+      switch (e) {
+        case "longer":
+        case "shorter":
+        case "increasing":
+        case "decreasing":
+          t = `in oklch ${e} hue`;
+          break;
+        default:
+          t = `in ${e}`;
+      }
+  return t;
+}
+function nt() {
+  return function* ([, e, t], { theme: n }) {
+    const o = {}, a = we(t, n);
+    if (a) {
+      const { color: i, keys: c, alpha: m } = a;
+      if (i) {
+        if (Object.values(je).includes(i))
+          o[`--un-gradient-${e}`] = i;
+        else {
+          o[`--un-${e}-opacity`] = m;
+          const g = c ? p("colors", c) : i;
+          o[`--un-gradient-${e}`] = `color-mix(in oklab, ${g} var(--un-${e}-opacity), transparent)`, yield s(`--un-${e}-opacity`, { syntax: "<percentage>", initialValue: "100%" });
+        }
+        c && u("colors", c), n && _e(i, n);
+      }
+    } else
+      o[`--un-gradient-${e}`] = r.bracket.cssvar(t);
+    if (o[`--un-gradient-${e}`]) {
+      switch (e) {
+        case "from":
+          yield {
+            ...o,
+            "--un-gradient-stops": "var(--un-gradient-via-stops, var(--un-gradient-position), var(--un-gradient-from) var(--un-gradient-from-position), var(--un-gradient-to) var(--un-gradient-to-position))"
+          };
+          break;
+        case "via":
+          yield {
+            ...o,
+            "--un-gradient-via-stops": "var(--un-gradient-position), var(--un-gradient-from) var(--un-gradient-from-position), var(--un-gradient-via) var(--un-gradient-via-position), var(--un-gradient-to) var(--un-gradient-to-position)",
+            "--un-gradient-stops": "var(--un-gradient-via-stops)"
+          };
+          break;
+        case "to":
+          yield {
+            ...o,
+            "--un-gradient-stops": "var(--un-gradient-via-stops, var(--un-gradient-position), var(--un-gradient-from) var(--un-gradient-from-position), var(--un-gradient-to) var(--un-gradient-to-position))"
+          };
+          break;
+        case "stops":
+          yield {
+            ...o
+          };
+          break;
+      }
+      for (const i of Object.values(ze))
+        yield i;
+    }
+  };
+}
+function ot() {
+  return function* ([, e, t]) {
+    yield {
+      [`--un-gradient-${e}-position`]: `${r.bracket.cssvar.percent(t)}`
+    };
+    for (const n of Object.values(ze))
+      yield n;
+  };
+}
+const rt = [
+  // gradients
+  [/^bg-(linear|radial|conic)-([^/]+)(?:\/(.+))?$/, ([, e, t, n]) => {
+    let o;
+    if (r.number(t) != null ? o = `${r.number(t)}deg ${ie(n)};` : o = r.bracket(t), o)
+      return {
+        "--un-gradient-position": o,
+        "background-image": `${e}-gradient(var(--un-gradient-stops))`
+      };
+  }, {
+    autocomplete: ["bg-(linear|radial|conic)", "(from|to|via)-$colors", "(from|to|via)-(op|opacity)", "(from|to|via)-(op|opacity)-<percent>"]
+  }],
+  [/^(from|via|to|stops)-(.+)$/, nt()],
+  [/^(from|via|to)-op(?:acity)?-?(.+)$/, ([, e, t]) => ({ [`--un-${e}-opacity`]: r.bracket.percent(t) })],
+  [/^(from|via|to)-([\d.]+%)$/, ot()],
+  // images
+  [/^bg-((?:repeating-)?(?:linear|radial|conic))$/, ([, e]) => ({
+    "background-image": `${e}-gradient(var(--un-gradient, var(--un-gradient-stops, rgb(255 255 255 / 0))))`
+  }), { autocomplete: ["bg-gradient-repeating", "bg-gradient-(linear|radial|conic)", "bg-gradient-repeating-(linear|radial|conic)"] }],
+  // ignore any center position
+  [/^bg-(linear|radial|conic)(?:-to-([rltb]{1,2}))?(?:\/(.+))?$/, ([, e, t, n]) => ({
+    "--un-gradient-position": `${t in v ? `to ${v[t]} ` : " "}${ie(n)}`,
+    "background-image": `${e}-gradient(var(--un-gradient-stops))`
+  }), { autocomplete: `bg-gradient-to-(${Object.keys(v).filter((e) => e.length <= 2 && Array.from(e).every((t) => "rltb".includes(t))).join("|")})` }],
+  ["bg-none", { "background-image": "none" }],
+  ["box-decoration-slice", { "box-decoration-break": "slice" }],
+  ["box-decoration-clone", { "box-decoration-break": "clone" }],
+  ...l("box-decoration", "box-decoration-break"),
+  // size
+  ["bg-auto", { "background-size": "auto" }],
+  ["bg-cover", { "background-size": "cover" }],
+  ["bg-contain", { "background-size": "contain" }],
+  // attachments
+  ["bg-fixed", { "background-attachment": "fixed" }],
+  ["bg-local", { "background-attachment": "local" }],
+  ["bg-scroll", { "background-attachment": "scroll" }],
+  // clips
+  ["bg-clip-border", { "-webkit-background-clip": "border-box", "background-clip": "border-box" }],
+  ["bg-clip-content", { "-webkit-background-clip": "content-box", "background-clip": "content-box" }],
+  ["bg-clip-padding", { "-webkit-background-clip": "padding-box", "background-clip": "padding-box" }],
+  ["bg-clip-text", { "-webkit-background-clip": "text", "background-clip": "text" }],
+  ...f.map((e) => [`bg-clip-${e}`, {
+    "-webkit-background-clip": e,
+    "background-clip": e
+  }]),
+  // positions
+  // skip 1 & 2 letters shortcut
+  [/^bg-([-\w]{3,})$/, ([, e]) => ({ "background-position": v[e] })],
+  // repeats
+  ["bg-repeat", { "background-repeat": "repeat" }],
+  ["bg-no-repeat", { "background-repeat": "no-repeat" }],
+  ["bg-repeat-x", { "background-repeat": "repeat-x" }],
+  ["bg-repeat-y", { "background-repeat": "repeat-y" }],
+  ["bg-repeat-round", { "background-repeat": "round" }],
+  ["bg-repeat-space", { "background-repeat": "space" }],
+  ...l("bg-repeat", "background-repeat"),
+  // origins
+  ["bg-origin-border", { "background-origin": "border-box" }],
+  ["bg-origin-padding", { "background-origin": "padding-box" }],
+  ["bg-origin-content", { "background-origin": "content-box" }],
+  ...l("bg-origin", "background-origin")
+], se = [
+  // size
+  [/^outline-(?:width-|size-)?(.+)$/, Se, { autocomplete: "outline-(width|size)-<num>" }],
+  // color
+  [/^outline-(?:color-)?(.+)$/, at, { autocomplete: "outline-$colors" }],
+  [/^outline-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-outline-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "outline-(op|opacity)-<percent>" }],
+  // offset
+  [/^outline-offset-(.+)$/, ([, e]) => ({ "outline-offset": r.bracket.cssvar.global.px(e) }), { autocomplete: "outline-(offset)-<num>" }],
+  ["outline-offset-none", { "outline-offset": "0" }],
+  // style
+  ["outline", [
+    {
+      "outline-style": "var(--un-outline-style)",
+      "outline-width": "1px"
+    },
+    s("--un-outline-style", { initialValue: "solid" })
+  ]],
+  ["outline-hidden", [
+    { "outline-style": "none" },
+    {
+      [Ke.parent]: "@media (forced-colors: active)",
+      outline: "2px solid transparent",
+      "outline-offset": "2px"
+    }
+  ]],
+  ["outline-none", { "--un-outline-style": "none", "outline-style": "none" }],
+  ...["auto", "dashed", "dotted", "double", "solid", "groove", "ridge", "inset", "outset", ...f].map((e) => [`outline-${e}`, { "--un-outline-style": e, "outline-style": e }])
+];
+function* Se([, e]) {
+  const t = r.bracket.cssvar.global.px(e);
+  t != null && (yield {
+    "outline-style": "var(--un-outline-style)",
+    "outline-width": t
+  }, yield s("--un-outline-style", { initialValue: "solid" }));
+}
+function* at(e, t) {
+  if (E(r.bracket(e[1])))
+    yield* Se(e);
+  else {
+    const n = b("outline-color", "outline")(e, t);
+    if (n)
+      for (const o of n)
+        yield o;
+  }
+}
+const it = [
+  ["appearance-auto", { "-webkit-appearance": "auto", appearance: "auto" }],
+  ["appearance-none", { "-webkit-appearance": "none", appearance: "none" }]
+];
+function st(e) {
+  const t = r.bracket(e);
+  return t && r.properties(t) ? t : r.properties.auto.cssvar.global(e) ?? {
+    contents: "contents",
+    scroll: "scroll-position"
+  }[e];
+}
+const le = [
+  [/^will-change-(.+)/, ([, e]) => ({ "will-change": st(e) })]
+], _ = {
+  disc: "disc",
+  circle: "circle",
+  square: "square",
+  decimal: "decimal",
+  "zero-decimal": "decimal-leading-zero",
+  greek: "lower-greek",
+  roman: "lower-roman",
+  "upper-roman": "upper-roman",
+  alpha: "lower-alpha",
+  "upper-alpha": "upper-alpha",
+  latin: "lower-latin",
+  "upper-latin": "upper-latin"
+}, lt = [
+  // base
+  [/^list-(.+?)(?:-(outside|inside))?$/, ([, e, t]) => {
+    const n = _[e];
+    if (n)
+      return t ? {
+        "list-style-position": t,
+        "list-style-type": n
+      } : { "list-style-type": n };
+  }, { autocomplete: [`list-(${Object.keys(_).join("|")})`, `list-(${Object.keys(_).join("|")})-(outside|inside)`] }],
+  // styles
+  ["list-outside", { "list-style-position": "outside" }],
+  ["list-inside", { "list-style-position": "inside" }],
+  ["list-none", { "list-style-type": "none" }],
+  // image
+  [/^list-image-(.+)$/, ([, e]) => {
+    if (/^\[url\(.+\)\]$/.test(e))
+      return { "list-style-image": r.bracket(e) };
+  }],
+  ["list-image-none", { "list-style-image": "none" }],
+  ...l("list", "list-style-type")
+], ct = [
+  [/^accent-(.+)$/, b("accent-color", "accent"), { autocomplete: "accent-$colors" }],
+  [/^accent-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-accent-opacity": r.bracket.percent(e) }), { autocomplete: ["accent-(op|opacity)", "accent-(op|opacity)-<percent>"] }]
+], ut = [
+  [/^caret-(.+)$/, b("caret-color", "caret"), { autocomplete: "caret-$colors" }],
+  [/^caret-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-caret-opacity": r.bracket.percent(e) }), { autocomplete: ["caret-(op|opacity)", "caret-(op|opacity)-<percent>"] }]
+], dt = [
+  ["image-render-auto", { "image-rendering": "auto" }],
+  ["image-render-edge", { "image-rendering": "crisp-edges" }],
+  ["image-render-pixel", [
+    ["-ms-interpolation-mode", "nearest-neighbor"],
+    ["image-rendering", "-webkit-optimize-contrast"],
+    ["image-rendering", "-moz-crisp-edges"],
+    ["image-rendering", "-o-pixelated"],
+    ["image-rendering", "pixelated"]
+  ]]
+], pt = [
+  ["overscroll-auto", { "overscroll-behavior": "auto" }],
+  ["overscroll-contain", { "overscroll-behavior": "contain" }],
+  ["overscroll-none", { "overscroll-behavior": "none" }],
+  ...l("overscroll", "overscroll-behavior"),
+  ["overscroll-x-auto", { "overscroll-behavior-x": "auto" }],
+  ["overscroll-x-contain", { "overscroll-behavior-x": "contain" }],
+  ["overscroll-x-none", { "overscroll-behavior-x": "none" }],
+  ...l("overscroll-x", "overscroll-behavior-x"),
+  ["overscroll-y-auto", { "overscroll-behavior-y": "auto" }],
+  ["overscroll-y-contain", { "overscroll-behavior-y": "contain" }],
+  ["overscroll-y-none", { "overscroll-behavior-y": "none" }],
+  ...l("overscroll-y", "overscroll-behavior-y")
+], bt = [
+  ["scroll-auto", { "scroll-behavior": "auto" }],
+  ["scroll-smooth", { "scroll-behavior": "smooth" }],
+  ...l("scroll", "scroll-behavior")
+], S = ["solid", "dashed", "dotted", "double", "hidden", "none", "groove", "ridge", "inset", "outset", ...f], ft = [
+  // compound
+  [/^(?:border|b)()(?:-(.+))?$/, h, { autocomplete: "(border|b)-<directions>" }],
+  [/^(?:border|b)-([xy])(?:-(.+))?$/, h],
+  [/^(?:border|b)-([rltbse])(?:-(.+))?$/, h],
+  [/^(?:border|b)-(block|inline)(?:-(.+))?$/, h],
+  [/^(?:border|b)-([bi][se])(?:-(.+))?$/, h],
+  // size
+  [/^(?:border|b)-()(?:width|size)-(.+)$/, h, { autocomplete: ["(border|b)-<num>", "(border|b)-<directions>-<num>"] }],
+  [/^(?:border|b)-([xy])-(?:width|size)-(.+)$/, h],
+  [/^(?:border|b)-([rltbse])-(?:width|size)-(.+)$/, h],
+  [/^(?:border|b)-(block|inline)-(?:width|size)-(.+)$/, h],
+  [/^(?:border|b)-([bi][se])-(?:width|size)-(.+)$/, h],
+  // colors
+  [/^(?:border|b)-()(?:color-)?(.+)$/, C, { autocomplete: ["(border|b)-$colors", "(border|b)-<directions>-$colors"] }],
+  [/^(?:border|b)-([xy])-(?:color-)?(.+)$/, C],
+  [/^(?:border|b)-([rltbse])-(?:color-)?(.+)$/, C],
+  [/^(?:border|b)-(block|inline)-(?:color-)?(.+)$/, C],
+  [/^(?:border|b)-([bi][se])-(?:color-)?(.+)$/, C],
+  // opacity
+  [/^(?:border|b)-()op(?:acity)?-?(.+)$/, W, { autocomplete: "(border|b)-(op|opacity)-<percent>" }],
+  [/^(?:border|b)-([xy])-op(?:acity)?-?(.+)$/, W],
+  [/^(?:border|b)-([rltbse])-op(?:acity)?-?(.+)$/, W],
+  [/^(?:border|b)-(block|inline)-op(?:acity)?-?(.+)$/, W],
+  [/^(?:border|b)-([bi][se])-op(?:acity)?-?(.+)$/, W],
+  // radius
+  [/^(?:border-|b-)?(?:rounded|rd)()(?:-(.+))?$/, A, { autocomplete: ["(border|b)-(rounded|rd)", "(border|b)-(rounded|rd)-$radius", "(rounded|rd)", "(rounded|rd)-$radius"] }],
+  [/^(?:border-|b-)?(?:rounded|rd)-([rltbse])(?:-(.+))?$/, A],
+  [/^(?:border-|b-)?(?:rounded|rd)-([rltb]{2})(?:-(.+))?$/, A],
+  [/^(?:border-|b-)?(?:rounded|rd)-([bise][se])(?:-(.+))?$/, A],
+  [/^(?:border-|b-)?(?:rounded|rd)-([bi][se]-[bi][se])(?:-(.+))?$/, A],
+  // style
+  [/^(?:border|b)-(?:style-)?()(.+)$/, R, { autocomplete: ["(border|b)-style", `(border|b)-(${S.join("|")})`, "(border|b)-<directions>-style", `(border|b)-<directions>-(${S.join("|")})`, `(border|b)-<directions>-style-(${S.join("|")})`, `(border|b)-style-(${S.join("|")})`] }],
+  [/^(?:border|b)-([xy])-(?:style-)?(.+)$/, R],
+  [/^(?:border|b)-([rltbse])-(?:style-)?(.+)$/, R],
+  [/^(?:border|b)-(block|inline)-(?:style-)?(.+)$/, R],
+  [/^(?:border|b)-([bi][se])-(?:style-)?(.+)$/, R]
+];
+function mt(e) {
+  return ([, t], n) => {
+    const o = we(t, n.theme), a = Ie(o, `border${e}-color`, `border${e}`, n);
+    if (a) {
+      const i = a[0];
+      return o != null && o.color && !Object.values(je).includes(o.color) && !o.alpha && e && e !== "" && (i[`--un-border${e}-opacity`] = "var(--un-border-opacity)"), a;
+    }
+  };
+}
+function h([, e = "", t = "1"]) {
+  const n = r.bracket.cssvar.global.px(t);
+  if (e in x && n != null)
+    return x[e].map((o) => [`border${o}-width`, n]);
+}
+function C([, e = "", t], n) {
+  if (e in x) {
+    if (E(r.bracket(t)))
+      return h(["", e, t]);
+    if ($e(t, n.theme)) {
+      const o = x[e].map((a) => mt(a)(["", t], n)).filter(Je);
+      return [
+        o.map((a) => a[0]).reduce((a, i) => (Object.assign(a, i), a), {}),
+        ...o.flatMap((a) => a.slice(1))
+      ];
+    }
+  }
+}
+function W([, e = "", t]) {
+  const n = r.bracket.percent.cssvar(t);
+  if (e in x && n != null)
+    return x[e].map((o) => [`--un-border${o}-opacity`, n]);
+}
+function A([, e = "", t = "DEFAULT"], { theme: n }) {
+  var o;
+  if (e in B) {
+    if (t === "full")
+      return B[e].map((i) => [`border${i}-radius`, "calc(infinity * 1px)"]);
+    const a = ((o = n.radius) == null ? void 0 : o[t]) ?? r.bracket.cssvar.global.fraction.rem(t);
+    if (a != null) {
+      const i = n.radius && t in n.radius;
+      return i && u("radius", t), B[e].map((c) => [
+        `border${c}-radius`,
+        i ? p("radius", t) : a
+      ]);
+    }
+  }
+}
+function R([, e = "", t]) {
+  if (S.includes(t) && e in x)
+    return [
+      ["--un-border-style", t],
+      ...x[e].map((n) => [`border${n}-style`, t])
+    ];
+}
+const gt = [
+  [/^op(?:acity)?-?(.+)$/, ([, e]) => ({ opacity: r.bracket.percent.cssvar(e) })]
+], ht = /^\[url\(.+\)\]$/, vt = /^\[(?:length|size):.+\]$/, yt = /^\[position:.+\]$/, kt = /^\[(?:linear|conic|radial)-gradient\(.+\)\]$/, $t = /^\[image:.+\]$/, xt = [
+  [/^bg-(.+)$/, (...e) => {
+    const t = e[0][1];
+    if (ht.test(t))
+      return { "--un-url": r.bracket(t), "background-image": "var(--un-url)" };
+    if (vt.test(t) && r.bracketOfLength(t) != null)
+      return { "background-size": r.bracketOfLength(t).split(" ").map((n) => r.fraction.auto.px.cssvar(n) ?? n).join(" ") };
+    if ((Me(t) || yt.test(t)) && r.bracketOfPosition(t) != null)
+      return { "background-position": r.bracketOfPosition(t).split(" ").map((n) => r.position.fraction.auto.px.cssvar(n) ?? n).join(" ") };
+    if (kt.test(t) || $t.test(t)) {
+      const n = r.bracket(t);
+      if (n)
+        return { "background-image": (n.startsWith("http") ? `url(${n})` : r.cssvar(n)) ?? n };
+    }
+    return b("background-color", "bg")(...e);
+  }, { autocomplete: "bg-$colors" }],
+  [/^bg-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-bg-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "bg-(op|opacity)-<percent>" }]
+], wt = [
+  [/^(?:color-)?scheme-(.+)$/, ([, e]) => ({ "color-scheme": e.split("-").join(" ") })]
+], jt = [
+  [/^columns-(.+)$/, ([, e]) => ({ columns: r.bracket.global.number.auto.numberWithUnit(e) }), { autocomplete: "columns-<num>" }],
+  // break before
+  ["break-before-auto", { "break-before": "auto" }],
+  ["break-before-avoid", { "break-before": "avoid" }],
+  ["break-before-all", { "break-before": "all" }],
+  ["break-before-avoid-page", { "break-before": "avoid-page" }],
+  ["break-before-page", { "break-before": "page" }],
+  ["break-before-left", { "break-before": "left" }],
+  ["break-before-right", { "break-before": "right" }],
+  ["break-before-column", { "break-before": "column" }],
+  ...l("break-before"),
+  // break inside
+  ["break-inside-auto", { "break-inside": "auto" }],
+  ["break-inside-avoid", { "break-inside": "avoid" }],
+  ["break-inside-avoid-page", { "break-inside": "avoid-page" }],
+  ["break-inside-avoid-column", { "break-inside": "avoid-column" }],
+  ...l("break-inside"),
+  // break after
+  ["break-after-auto", { "break-after": "auto" }],
+  ["break-after-avoid", { "break-after": "avoid" }],
+  ["break-after-all", { "break-after": "all" }],
+  ["break-after-avoid-page", { "break-after": "avoid-page" }],
+  ["break-after-page", { "break-after": "page" }],
+  ["break-after-left", { "break-after": "left" }],
+  ["break-after-right", { "break-after": "right" }],
+  ["break-after-column", { "break-after": "column" }],
+  ...l("break-after")
+], ce = ["solid", "double", "dotted", "dashed", "wavy", ...f], zt = [
+  [/^(?:decoration-)?(underline|overline|line-through)$/, ([, e]) => ({ "text-decoration-line": e }), { autocomplete: "decoration-(underline|overline|line-through)" }],
+  // size
+  [/^(?:underline|decoration)-(?:size-)?(.+)$/, Ve, { autocomplete: "(underline|decoration)-<num>" }],
+  [/^(?:underline|decoration)-(auto|from-font)$/, ([, e]) => ({ "text-decoration-thickness": e }), { autocomplete: "(underline|decoration)-(auto|from-font)" }],
+  // colors
+  [/^(?:underline|decoration)-(.+)$/, St, { autocomplete: "(underline|decoration)-$colors" }],
+  [/^(?:underline|decoration)-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-line-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "(underline|decoration)-(op|opacity)-<percent>" }],
+  // offset
+  [/^(?:underline|decoration)-offset-(.+)$/, ([, e]) => ({ "text-underline-offset": r.auto.bracket.cssvar.global.px(e) }), { autocomplete: "(underline|decoration)-(offset)-<num>" }],
+  // style
+  ...ce.map((e) => [`underline-${e}`, { "text-decoration-style": e }]),
+  ...ce.map((e) => [`decoration-${e}`, { "text-decoration-style": e }]),
+  ["no-underline", { "text-decoration": "none" }],
+  ["decoration-none", { "text-decoration": "none" }]
+];
+function Ve([, e]) {
+  return { "text-decoration-thickness": r.bracket.cssvar.global.px(e) };
+}
+function St(e, t) {
+  if (E(r.bracket(e[1])))
+    return Ve(e);
+  const n = b("text-decoration-color", "line")(e, t);
+  if (n) {
+    const o = n[0];
+    return o["-webkit-text-decoration-color"] = o["text-decoration-color"], n;
+  }
+}
+const Vt = [
+  [/^pa?()-?(.+)$/, d("padding"), { autocomplete: ["(m|p)<num>", "(m|p)-<num>"] }],
+  [/^p-?xy()()$/, d("padding"), { autocomplete: "(m|p)-(xy)" }],
+  [/^p-?([xy])(?:-?(.+))?$/, d("padding")],
+  [/^p-?([rltbse])(?:-?(.+))?$/, d("padding"), { autocomplete: "(m|p)<directions>-<num>" }],
+  [/^p-(block|inline)(?:-(.+))?$/, d("padding"), { autocomplete: "(m|p)-(block|inline)-<num>" }],
+  [/^p-?([bi][se])(?:-?(.+))?$/, d("padding"), { autocomplete: "(m|p)-(bs|be|is|ie)-<num>" }]
+], Ot = [
+  [/^ma?()-?(.+)$/, d("margin")],
+  [/^m-?xy()()$/, d("margin")],
+  [/^m-?([xy])(?:-?(.+))?$/, d("margin")],
+  [/^m-?([rltbse])(?:-?(.+))?$/, d("margin")],
+  [/^m-(block|inline)(?:-(.+))?$/, d("margin")],
+  [/^m-?([bi][se])(?:-?(.+))?$/, d("margin")]
+], Ct = [
+  [/^space-([xy])-(.+)$/, Wt, { autocomplete: ["space-(x|y)", "space-(x|y)-reverse", "space-(x|y)-$spacing"] }],
+  [/^space-([xy])-reverse$/, function* ([, e], { symbols: t }) {
+    yield {
+      [t.selector]: V,
+      [`--un-space-${e}-reverse`]: "1"
+    }, yield s(`--un-space-${e}-reverse`, { initialValue: 0 });
+  }]
+];
+function V(e) {
+  const t = ">:not(:last-child)";
+  return e.includes(t) ? e : `${e}${t}`;
+}
+function* Wt([, e, t], { theme: n, symbols: o }) {
+  var c;
+  let a;
+  const i = $(t);
+  if (i != null ? (u("spacing"), a = `calc(var(--spacing) * ${i})`) : a = ((c = n.spacing) == null ? void 0 : c[t]) ?? r.bracket.cssvar.auto.fraction.rem(t || "1"), a != null) {
+    const m = x[e === "x" ? "inline" : "block"].map((g, z) => {
+      const T = `margin${g}`, L = ` calc(${a} * ${z === 0 ? `var(--un-space-${e}-reverse)` : `calc(1 - var(--un-space-${e}-reverse))`})`;
+      return [T, L];
+    });
+    m && (yield {
+      [o.selector]: V,
+      [`--un-space-${e}-reverse`]: "0",
+      ...Object.fromEntries(m)
+    }, yield s(`--un-space-${e}-reverse`, { initialValue: 0 }));
+  }
+}
+const At = [
+  // color & opacity
+  [/^divide-(.+)$/, function* (e, t) {
+    const n = b("border-color", "divide")(e, t);
+    n && (yield {
+      [t.symbols.selector]: V,
+      ...n[0]
+    }, yield n[1]);
+  }, { autocomplete: "divide-$colors" }],
+  [/^divide-op(?:acity)?-?(.+)$/, function* ([, e], { symbols: t }) {
+    yield {
+      [t.selector]: V,
+      "--un-divide-opacity": r.bracket.percent(e)
+    };
+  }, { autocomplete: ["divide-(op|opacity)", "divide-(op|opacity)-<percent>"] }],
+  // divides
+  [/^divide-?([xy])$/, ue, { autocomplete: ["divide-(x|y)", "divide-(x|y)-reverse"] }],
+  [/^divide-?([xy])-?(.+)$/, ue],
+  [/^divide-?([xy])-reverse$/, function* ([, e], { symbols: t }) {
+    yield {
+      [t.selector]: V,
+      [`--un-divide-${e}-reverse`]: "1"
+    }, yield s(`--un-divide-${e}-reverse`, { initialValue: 0 });
+  }],
+  // styles
+  [new RegExp(`^divide-(${S.join("|")})$`), function* ([, e], { symbols: t }) {
+    yield {
+      [t.selector]: V,
+      "border-style": e
+    };
+  }, { autocomplete: S.map((e) => `divide-${e}`) }]
+];
+function* ue([, e, t], { symbols: n }) {
+  let o = r.bracket.cssvar.px(t || "1");
+  if (o != null) {
+    o === "0" && (o = "0px");
+    const i = {
+      x: ["-left", "-right"],
+      y: ["-top", "-bottom"]
+    }[e].map((c) => {
+      const m = c.endsWith("left") || c.endsWith("top") ? `calc(${o} * var(--un-divide-${e}-reverse))` : `calc(${o} * calc(1 - var(--un-divide-${e}-reverse)))`;
+      return [
+        [`border${c}-width`, m],
+        [`border${c}-style`, "var(--un-border-style)"]
+      ];
+    });
+    i && (yield {
+      [n.selector]: V,
+      [`--un-divide-${e}-reverse`]: 0,
+      ...Object.fromEntries(i.flat())
+    }, yield s(`--un-divide-${e}-reverse`, { initialValue: 0 }), yield s("--un-border-style", { initialValue: "solid" }));
+  }
+}
+const Oe = [
+  "blur",
+  "brightness",
+  "contrast",
+  "grayscale",
+  "hue-rotate",
+  "invert",
+  "saturate",
+  "sepia",
+  "drop-shadow"
+], J = Oe.map((e) => s(`--un-${e}`)), q = Oe.map((e) => `var(--un-${e},)`).join(" "), Ce = [
+  "backdrop-blur",
+  "backdrop-brightness",
+  "backdrop-contrast",
+  "backdrop-grayscale",
+  "backdrop-hue-rotate",
+  "backdrop-invert",
+  "backdrop-opacity",
+  "backdrop-saturate",
+  "backdrop-sepia"
+], Rt = Ce.map((e) => s(`--un-${e}`)), D = Ce.map((e) => `var(--un-${e},)`).join(" ");
+function G(e) {
+  let t = r.bracket.cssvar(e || "");
+  if (t != null || (t = e ? r.percent(e) : "100%", t != null && Number.parseFloat(t.slice(0, -1)) <= 100))
+    return t;
+}
+function k(e, t) {
+  return ([, n, o], { theme: a }) => {
+    const i = t(o, a) ?? (o === "none" ? "0" : "");
+    if (i !== "")
+      return n ? [
+        {
+          [`--un-${n}${e}`]: `${e}(${i})`,
+          "-webkit-backdrop-filter": D,
+          "backdrop-filter": D
+        },
+        ...Rt
+      ] : [
+        {
+          [`--un-${e}`]: `${e}(${i})`,
+          filter: q
+        },
+        ...J
+      ];
+  };
+}
+function Ut([, e], { theme: t }) {
+  var o;
+  let n = (o = t.dropShadow) == null ? void 0 : o[e || "DEFAULT"];
+  if (n != null)
+    return [
+      {
+        "--un-drop-shadow": `drop-shadow(${Y(n, "--un-drop-shadow-color").join(") drop-shadow(")})`,
+        filter: q
+      },
+      ...J
+    ];
+  if (n = r.bracket.cssvar(e) ?? (e === "none" ? "" : void 0), n != null)
+    return [
+      {
+        "--un-drop-shadow": n && `drop-shadow(${n})`,
+        filter: q
+      },
+      ...J
+    ];
+}
+const Et = [
+  // filters
+  [/^(?:(backdrop-)|filter-)?blur(?:-(.+))?$/, k("blur", (e, t) => {
+    var n;
+    return ((n = t.blur) == null ? void 0 : n[e || "DEFAULT"]) || r.bracket.cssvar.px(e);
+  }), { autocomplete: ["(backdrop|filter)-blur-$blur", "blur-$blur", "filter-blur"] }],
+  [/^(?:(backdrop-)|filter-)?brightness-(.+)$/, k("brightness", (e) => r.bracket.cssvar.percent(e)), { autocomplete: ["(backdrop|filter)-brightness-<percent>", "brightness-<percent>"] }],
+  [/^(?:(backdrop-)|filter-)?contrast-(.+)$/, k("contrast", (e) => r.bracket.cssvar.percent(e)), { autocomplete: ["(backdrop|filter)-contrast-<percent>", "contrast-<percent>"] }],
+  // drop-shadow only on filter
+  [/^(?:filter-)?drop-shadow(?:-(.+))?$/, Ut, {
+    autocomplete: [
+      "filter-drop",
+      "filter-drop-shadow",
+      "filter-drop-shadow-color",
+      "drop-shadow",
+      "drop-shadow-color",
+      "filter-drop-shadow-$dropShadow",
+      "drop-shadow-$dropShadow",
+      "filter-drop-shadow-color-$colors",
+      "drop-shadow-color-$colors",
+      "filter-drop-shadow-color-(op|opacity)",
+      "drop-shadow-color-(op|opacity)",
+      "filter-drop-shadow-color-(op|opacity)-<percent>",
+      "drop-shadow-color-(op|opacity)-<percent>"
+    ]
+  }],
+  [/^(?:filter-)?drop-shadow-color-(.+)$/, b("--un-drop-shadow-color", "drop-shadow")],
+  [/^(?:filter-)?drop-shadow-color-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-drop-shadow-opacity": r.bracket.percent(e) })],
+  [/^(?:(backdrop-)|filter-)?grayscale(?:-(.+))?$/, k("grayscale", G), { autocomplete: ["(backdrop|filter)-grayscale", "(backdrop|filter)-grayscale-<percent>", "grayscale-<percent>"] }],
+  [/^(?:(backdrop-)|filter-)?hue-rotate-(.+)$/, k("hue-rotate", (e) => r.bracket.cssvar.degree(e))],
+  [/^(?:(backdrop-)|filter-)?invert(?:-(.+))?$/, k("invert", G), { autocomplete: ["(backdrop|filter)-invert", "(backdrop|filter)-invert-<percent>", "invert-<percent>"] }],
+  // opacity only on backdrop-filter
+  [/^(backdrop-)op(?:acity)?-(.+)$/, k("opacity", (e) => r.bracket.cssvar.percent(e)), { autocomplete: ["backdrop-(op|opacity)", "backdrop-(op|opacity)-<percent>"] }],
+  [/^(?:(backdrop-)|filter-)?saturate-(.+)$/, k("saturate", (e) => r.bracket.cssvar.percent(e)), { autocomplete: ["(backdrop|filter)-saturate", "(backdrop|filter)-saturate-<percent>", "saturate-<percent>"] }],
+  [/^(?:(backdrop-)|filter-)?sepia(?:-(.+))?$/, k("sepia", G), { autocomplete: ["(backdrop|filter)-sepia", "(backdrop|filter)-sepia-<percent>", "sepia-<percent>"] }],
+  // base
+  ["filter", { filter: q }],
+  ["backdrop-filter", {
+    "-webkit-backdrop-filter": D,
+    "backdrop-filter": D
+  }],
+  // nones
+  ["filter-none", { filter: "none" }],
+  ["backdrop-filter-none", {
+    "-webkit-backdrop-filter": "none",
+    "backdrop-filter": "none"
+  }],
+  ...f.map((e) => [`filter-${e}`, { filter: e }]),
+  ...f.map((e) => [`backdrop-filter-${e}`, {
+    "-webkit-backdrop-filter": e,
+    "backdrop-filter": e
+  }])
+], Tt = [
+  // display
+  ["flex", { display: "flex" }],
+  ["inline-flex", { display: "inline-flex" }],
+  ["flex-inline", { display: "inline-flex" }],
+  // flex
+  [/^flex-(.*)$/, ([, e]) => ({ flex: r.bracket(e) != null ? r.bracket(e).split(" ").map((t) => r.cssvar.fraction(t) ?? t).join(" ") : r.cssvar.fraction(e) })],
+  ["flex-1", { flex: "1 1 0%" }],
+  ["flex-auto", { flex: "1 1 auto" }],
+  ["flex-initial", { flex: "0 1 auto" }],
+  ["flex-none", { flex: "none" }],
+  // shrink/grow/basis
+  [/^(?:flex-)?shrink(?:-(.*))?$/, ([, e = ""]) => ({ "flex-shrink": r.bracket.cssvar.number(e) ?? 1 }), { autocomplete: ["flex-shrink-<num>", "shrink-<num>"] }],
+  [/^(?:flex-)?grow(?:-(.*))?$/, ([, e = ""]) => ({ "flex-grow": r.bracket.cssvar.number(e) ?? 1 }), { autocomplete: ["flex-grow-<num>", "grow-<num>"] }],
+  [/^(?:flex-)?basis-(.+)$/, ([, e]) => {
+    const t = $(e);
+    return t != null ? (u("spacing"), { "flex-basis": `calc(var(--spacing) * ${t})` }) : { "flex-basis": r.bracket.cssvar.auto.fraction.rem(e) };
+  }, { autocomplete: ["flex-basis-$spacing", "basis-$spacing"] }],
+  // directions
+  ["flex-row", { "flex-direction": "row" }],
+  ["flex-row-reverse", { "flex-direction": "row-reverse" }],
+  ["flex-col", { "flex-direction": "column" }],
+  ["flex-col-reverse", { "flex-direction": "column-reverse" }],
+  // wraps
+  ["flex-wrap", { "flex-wrap": "wrap" }],
+  ["flex-wrap-reverse", { "flex-wrap": "wrap-reverse" }],
+  ["flex-nowrap", { "flex-wrap": "nowrap" }]
+], de = {
+  "": "",
+  x: "column-",
+  y: "row-",
+  col: "column-",
+  row: "row-"
+};
+function I([, e = "", t]) {
+  const n = $(t);
+  return n != null ? (u("spacing"), { [`${de[e]}gap`]: `calc(var(--spacing) * ${n})` }) : { [`${de[e]}gap`]: r.bracket.cssvar.global.rem(t) };
+}
+const Lt = [
+  [/^(?:flex-|grid-)?gap-?()(.+)$/, I, { autocomplete: ["gap-$spacing", "gap-<num>"] }],
+  [/^(?:flex-|grid-)?gap-([xy])-?(.+)$/, I, { autocomplete: ["gap-(x|y)-$spacing", "gap-(x|y)-<num>"] }],
+  [/^(?:flex-|grid-)?gap-(col|row)-?(.+)$/, I, { autocomplete: ["gap-(col|row)-$spacing", "gap-(col|row)-<num>"] }]
+];
+function y(e) {
+  return e.replace("col", "column");
+}
+function Pt(e) {
+  switch (e) {
+    case "min":
+      return "min-content";
+    case "max":
+      return "max-content";
+    case "fr":
+      return "minmax(0,1fr)";
+  }
+  return r.bracket.cssvar.auto.rem(e);
+}
+const Ft = [
+  // displays
+  ["grid", { display: "grid" }],
+  ["inline-grid", { display: "inline-grid" }],
+  // global
+  [/^(?:grid-)?(row|col)-(.+)$/, ([, e, t]) => ({
+    [`grid-${y(e)}`]: r.bracket.number.cssvar.auto(t)
+  })],
+  // span
+  [/^(?:grid-)?(row|col)-span-(.+)$/, ([, e, t]) => {
+    if (t === "full")
+      return { [`grid-${y(e)}`]: "1/-1" };
+    const n = r.bracket.number.cssvar(t);
+    if (n != null)
+      return { [`grid-${y(e)}`]: `span ${n}/span ${n}` };
+  }, { autocomplete: "(grid-row|grid-col|row|col)-span-<num>" }],
+  // starts & ends
+  [/^(?:grid-)?(row|col)-start-(.+)$/, ([, e, t]) => ({ [`grid-${y(e)}-start`]: r.bracket.cssvar(t) ?? t })],
+  [/^(?:grid-)?(row|col)-end-(.+)$/, ([, e, t]) => ({ [`grid-${y(e)}-end`]: r.bracket.cssvar(t) ?? t }), { autocomplete: "(grid-row|grid-col|row|col)-(start|end)-<num>" }],
+  // auto flows
+  [/^(?:grid-)?auto-(rows|cols)-(.+)$/, ([, e, t]) => ({ [`grid-auto-${y(e)}`]: Pt(t) }), { autocomplete: "(grid-auto|auto)-(rows|cols)-<num>" }],
+  // grid-auto-flow, auto-flow: uno
+  // grid-flow: wind
+  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(.+)$/, ([, e]) => ({ "grid-auto-flow": r.bracket.cssvar(e) })],
+  [/^(?:grid-auto-flow|auto-flow|grid-flow)-(row|col|dense|row-dense|col-dense)$/, ([, e]) => ({ "grid-auto-flow": y(e).replace("-", " ") }), { autocomplete: ["(grid-auto-flow|auto-flow|grid-flow)-(row|col|dense|row-dense|col-dense)"] }],
+  // templates
+  [/^(?:grid-)?(rows|cols)-(.+)$/, ([, e, t]) => ({
+    [`grid-template-${y(e)}`]: r.bracket.cssvar(t)
+  })],
+  [/^(?:grid-)?(rows|cols)-minmax-([\w.-]+)$/, ([, e, t]) => ({ [`grid-template-${y(e)}`]: `repeat(auto-fill,minmax(${t},1fr))` })],
+  [/^(?:grid-)?(rows|cols)-(\d+)$/, ([, e, t]) => ({ [`grid-template-${y(e)}`]: `repeat(${t},minmax(0,1fr))` }), { autocomplete: "(grid-rows|grid-cols|rows|cols)-<num>" }],
+  // areas
+  [/^grid-area(s)?-(.+)$/, ([, e, t]) => e != null ? { "grid-template-areas": r.cssvar(t) ?? t.split("-").map((n) => `"${r.bracket(n)}"`).join(" ") } : { "grid-area": r.bracket.cssvar(t) }],
+  // template none
+  ["grid-rows-none", { "grid-template-rows": "none" }],
+  ["grid-cols-none", { "grid-template-columns": "none" }],
+  // template subgrid
+  ["grid-rows-subgrid", { "grid-template-rows": "subgrid" }],
+  ["grid-cols-subgrid", { "grid-template-columns": "subgrid" }]
+], P = [
+  "auto",
+  "hidden",
+  "clip",
+  "visible",
+  "scroll",
+  "overlay",
+  ...f
+], Mt = [
+  [/^(?:overflow|of)-(.+)$/, ([, e]) => P.includes(e) ? { overflow: e } : void 0, { autocomplete: [`(overflow|of)-(${P.join("|")})`, `(overflow|of)-(x|y)-(${P.join("|")})`] }],
+  [/^(?:overflow|of)-([xy])-(.+)$/, ([, e, t]) => P.includes(t) ? { [`overflow-${e}`]: t } : void 0]
+], qt = [
+  [/^line-clamp-(\d+)$/, ([, e]) => ({
+    overflow: "hidden",
+    display: "-webkit-box",
+    "-webkit-box-orient": "vertical",
+    "-webkit-line-clamp": e
+  }), { autocomplete: ["line-clamp", "line-clamp-(1|2|3|4|5|6|none)"] }],
+  ["line-clamp-none", {
+    overflow: "visible",
+    display: "block",
+    "-webkit-box-orient": "horizontal",
+    "-webkit-line-clamp": "unset"
+  }]
+], Dt = [
+  // The prefix `$ ` is intentional. This rule is not to be matched directly from user-generated token.
+  // See variants/placeholder.
+  [/^\$ placeholder-(.+)$/, b("color", "placeholder"), { autocomplete: "placeholder-$colors" }],
+  [/^\$ placeholder-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-placeholder-opacity": r.bracket.percent(e) }), { autocomplete: ["placeholder-(op|opacity)", "placeholder-(op|opacity)-<percent>"] }]
+], Bt = [
+  [/^(?:position-|pos-)?(relative|absolute|fixed|sticky)$/, ([, e]) => ({ position: e }), {
+    autocomplete: [
+      "(position|pos)-<position>",
+      "(position|pos)-<globalKeyword>",
+      "<position>"
+    ]
+  }],
+  [/^(?:position-|pos-)([-\w]+)$/, ([, e]) => f.includes(e) ? { position: e } : void 0],
+  [/^(?:position-|pos-)?(static)$/, ([, e]) => ({ position: e })]
+], We = [
+  // contents
+  ["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" }],
+  ["justify-stretch", { "justify-content": "stretch" }],
+  ["justify-left", { "justify-content": "left" }],
+  ["justify-right", { "justify-content": "right" }],
+  ["justify-center-safe", { "justify-content": "safe center" }],
+  ["justify-end-safe", { "justify-content": "safe flex-end" }],
+  ["justify-normal", { "justify-content": "normal" }],
+  ...l("justify", "justify-content"),
+  // items
+  ["justify-items-start", { "justify-items": "start" }],
+  ["justify-items-end", { "justify-items": "end" }],
+  ["justify-items-center", { "justify-items": "center" }],
+  ["justify-items-stretch", { "justify-items": "stretch" }],
+  ["justify-items-center-safe", { "justify-items": "safe center" }],
+  ["justify-items-end-safe", { "justify-items": "safe flex-end" }],
+  ...l("justify-items"),
+  // selfs
+  ["justify-self-auto", { "justify-self": "auto" }],
+  ["justify-self-start", { "justify-self": "start" }],
+  ["justify-self-end", { "justify-self": "end" }],
+  ["justify-self-center", { "justify-self": "center" }],
+  ["justify-self-stretch", { "justify-self": "stretch" }],
+  ["justify-self-baseline", { "justify-self": "baseline" }],
+  ["justify-self-center-safe", { "justify-self": "safe center" }],
+  ["justify-self-end-safe", { "justify-self": "safe flex-end" }],
+  ...l("justify-self")
+], _t = [
+  [/^order-(.+)$/, ([, e]) => ({ order: r.bracket.cssvar.number(e) })],
+  ["order-first", { order: "calc(-infinity)" }],
+  ["order-last", { order: "calc(infinity)" }],
+  ["order-none", { order: "0" }]
+], Ae = [
+  // contents
+  ["content-center", { "align-content": "center" }],
+  ["content-start", { "align-content": "flex-start" }],
+  ["content-end", { "align-content": "flex-end" }],
+  ["content-between", { "align-content": "space-between" }],
+  ["content-around", { "align-content": "space-around" }],
+  ["content-evenly", { "align-content": "space-evenly" }],
+  ["content-baseline", { "align-content": "baseline" }],
+  ["content-center-safe", { "align-content": "safe center" }],
+  ["content-end-safe", { "align-content": "safe flex-end" }],
+  ["content-stretch", { "align-content": "stretch" }],
+  ["content-normal", { "align-content": "normal" }],
+  ...l("content", "align-content"),
+  // items
+  ["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" }],
+  ["items-baseline-last", { "align-items": "last baseline" }],
+  ["items-center-safe", { "align-items": "safe center" }],
+  ["items-end-safe", { "align-items": "safe flex-end" }],
+  ...l("items", "align-items"),
+  // selfs
+  ["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-self": "stretch" }],
+  ["self-baseline", { "align-self": "baseline" }],
+  ["self-baseline-last", { "align-self": "last baseline" }],
+  ["self-center-safe", { "align-self": "safe center" }],
+  ["self-end-safe", { "align-self": "safe flex-end" }],
+  ...l("self", "align-self")
+], Re = [
+  // contents
+  ["place-content-center", { "place-content": "center" }],
+  ["place-content-start", { "place-content": "start" }],
+  ["place-content-end", { "place-content": "end" }],
+  ["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" }],
+  ["place-content-baseline", { "place-content": "baseline" }],
+  ["place-content-center-safe", { "place-content": "safe center" }],
+  ["place-content-end-safe", { "place-content": "safe flex-end" }],
+  ...l("place-content"),
+  // items
+  ["place-items-start", { "place-items": "start" }],
+  ["place-items-end", { "place-items": "end" }],
+  ["place-items-center", { "place-items": "center" }],
+  ["place-items-stretch", { "place-items": "stretch" }],
+  ["place-items-baseline", { "place-items": "baseline" }],
+  ["place-items-center-safe", { "place-items": "safe center" }],
+  ["place-items-end-safe", { "place-items": "safe flex-end" }],
+  ...l("place-items"),
+  // selfs
+  ["place-self-auto", { "place-self": "auto" }],
+  ["place-self-start", { "place-self": "start" }],
+  ["place-self-end", { "place-self": "end" }],
+  ["place-self-center", { "place-self": "center" }],
+  ["place-self-stretch", { "place-self": "stretch" }],
+  ["place-self-center-safe", { "place-self": "safe center" }],
+  ["place-self-end-safe", { "place-self": "safe flex-end" }],
+  ...l("place-self")
+], Gt = [...We, ...Ae, ...Re].flatMap(([e, t]) => [
+  [`flex-${e}`, t],
+  [`grid-${e}`, t]
+]);
+function Z(e) {
+  const t = $(e);
+  return t != null ? (u("spacing"), `calc(var(--spacing) * ${t})`) : r.bracket.cssvar.global.auto.fraction.rem(e);
+}
+function U([, e, t]) {
+  const n = Z(t);
+  if (n != null && e in oe)
+    return oe[e].map((o) => [o.slice(1), n]);
+}
+const It = [
+  [
+    /^(?:position-|pos-)?inset-(.+)$/,
+    ([, e]) => ({ inset: Z(e) }),
+    {
+      autocomplete: [
+        "(position|pos)-inset-<directions>-$spacing",
+        "(position|pos)-inset-(block|inline)-$spacing",
+        "(position|pos)-inset-(bs|be|is|ie)-$spacing",
+        "(position|pos)-(top|left|right|bottom)-$spacing"
+      ]
+    }
+  ],
+  [/^(?:position-|pos-)?(start|end)-(.+)$/, U],
+  [/^(?:position-|pos-)?inset-([xy])-(.+)$/, U],
+  [/^(?:position-|pos-)?inset-([rltbse])-(.+)$/, U],
+  [/^(?:position-|pos-)?inset-(block|inline)-(.+)$/, U],
+  [/^(?:position-|pos-)?inset-([bi][se])-(.+)$/, U],
+  [/^(?:position-|pos-)?(top|left|right|bottom)-(.+)$/, ([, e, t]) => ({ [e]: Z(t) })]
+], Nt = [
+  // floats
+  ["float-left", { float: "left" }],
+  ["float-right", { float: "right" }],
+  ["float-start", { float: "inline-start" }],
+  ["float-end", { float: "inline-end" }],
+  ["float-none", { float: "none" }],
+  ...l("float"),
+  // clears
+  ["clear-left", { clear: "left" }],
+  ["clear-right", { clear: "right" }],
+  ["clear-both", { clear: "both" }],
+  ["clear-start", { clear: "inline-start" }],
+  ["clear-end", { clear: "inline-end" }],
+  ["clear-none", { clear: "none" }],
+  ...l("clear")
+], Ht = [
+  [/^(?:position-|pos-)?z([\d.]+)$/, ([, e]) => ({ "z-index": r.number(e) })],
+  [/^(?:position-|pos-)?z-(.+)$/, ([, e]) => ({ "z-index": r.bracket.cssvar.global.auto.number(e) }), { autocomplete: "z-<num>" }]
+], Kt = [
+  ["box-border", { "box-sizing": "border-box" }],
+  ["box-content", { "box-sizing": "content-box" }],
+  ...l("box", "box-sizing")
+], Jt = [
+  [
+    /^(where|\?)$/,
+    (e, { constructCSS: t, generator: n }) => {
+      if (n.userConfig.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}} ${t({ animation: "__un_qm 0.5s ease-in-out alternate infinite" })}`;
+    }
+  ]
+], X = {
+  shadow: s("--un-shadow", { initialValue: "0 0 #0000" }),
+  shadowColor: s("--un-shadow-color"),
+  insetShadow: s("--un-inset-shadow", { initialValue: "0 0 #0000" }),
+  insetShadowColor: s("--un-inset-shadow-color"),
+  ringColor: s("--un-ring-color"),
+  ringShadow: s("--un-ring-shadow", { initialValue: "0 0 #0000" }),
+  insetRingColor: s("--un-inset-ring-color"),
+  insetRingShadow: s("--un-inset-ring-shadow", { initialValue: "0 0 #0000" }),
+  ringInset: s("--un-ring-inset"),
+  ringOffsetWidth: s("--un-ring-offset-width", { syntax: "<length>", initialValue: "0px" }),
+  ringOffsetColor: s("--un-ring-offset-color"),
+  ringOffsetShadow: s("--un-ring-offset-shadow", { initialValue: "0 0 #0000" })
+}, Zt = [
+  // shadow
+  [/^shadow(?:-(.+))?$/, pe("shadow"), { autocomplete: ["shadow-$colors", "shadow-$shadow"] }],
+  [/^shadow-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-shadow-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "shadow-(op|opacity)-<percent>" }],
+  // inset shadow
+  [/^inset-shadow(?:-(.+))?$/, pe("insetShadow"), { autocomplete: ["inset-shadow-$colors", "inset-shadow-$insetShadow"] }],
+  [/^inset-shadow-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-inset-shadow-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "shadow-(op|opacity)-<percent>" }]
+];
+function pe(e) {
+  return (t, n) => {
+    var g;
+    const [, o] = t, { theme: a } = n, i = (g = a[e]) == null ? void 0 : g[o || "DEFAULT"], c = o ? r.bracket.cssvar(o) : void 0, m = De(e);
+    return (i != null || c != null) && !$e(c, a) ? [
+      {
+        [`--un-${m}`]: Y(i || c, `--un-${m}-color`).join(","),
+        "box-shadow": "var(--un-inset-shadow), var(--un-inset-ring-shadow), var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow)"
+      },
+      ...Object.values(X)
+    ] : b(`--un-${m}-color`, m)(t, n);
+  };
+}
+const Xt = [
+  // ring
+  [/^ring(?:-(.+))?$/, ([, e]) => {
+    const t = r.bracket.px(e || "1");
+    if (t != null)
+      return [
+        {
+          "--un-ring-shadow": `var(--un-ring-inset,) 0 0 0 calc(${t} + var(--un-ring-offset-width)) var(--un-ring-color, currentColor)`,
+          "box-shadow": "var(--un-inset-shadow), var(--un-inset-ring-shadow), var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow)"
+        },
+        ...Object.values(X)
+      ];
+  }],
+  [/^ring-(.+)$/, b("--un-ring-color", "ring"), { autocomplete: "ring-$colors" }],
+  [/^ring-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-ring-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "ring-(op|opacity)-<percent>" }],
+  // inset ring
+  [/^inset-ring(?:-(.+))?$/, ([, e]) => {
+    const t = r.bracket.px(e || "1");
+    if (t != null)
+      return [
+        {
+          "--un-inset-ring-shadow": `inset 0 0 0 ${t} var(--un-inset-ring-color, currentColor)`,
+          "box-shadow": "var(--un-inset-shadow), var(--un-inset-ring-shadow), var(--un-ring-offset-shadow), var(--un-ring-shadow), var(--un-shadow)"
+        },
+        ...Object.values(X)
+      ];
+  }],
+  [/^inset-ring-(.+)$/, b("--un-inset-ring-color", "inset-ring"), { autocomplete: "inset-ring-$colors" }],
+  [/^inset-ring-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-inset-ring-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "inset-ring-(op|opacity)-<percent>" }],
+  // offset
+  [/^ring-offset(?:-(?:width-|size-)?(.+))?$/, ([, e]) => {
+    const t = r.bracket.cssvar.px(e || "1");
+    if (t != null)
+      return {
+        "--un-ring-offset-width": t,
+        "--un-ring-offset-shadow": "var(--un-ring-inset,) 0 0 0 var(--un-ring-offset-width) var(--un-ring-offset-color)"
+      };
+  }, { autocomplete: "ring-offset-$colors" }],
+  [/^ring-offset-(.+)$/, b("--un-ring-offset-color", "ring-offset"), { autocomplete: "ring-offset-$colors" }],
+  [/^ring-offset-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-ring-offset-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "ring-offset-(op|opacity)-<percent>" }],
+  // style
+  ["ring-inset", { "--un-ring-inset": "inset" }]
+], Yt = [
+  ...["x", "y", "both"].map((e) => [
+    `snap-${e}`,
+    [
+      { "scroll-snap-type": `${e} var(--un-scroll-snap-strictness)` },
+      s("--un-scroll-snap-strictness", { initialValue: "proximity" })
+    ]
+  ]),
+  ...["mandatory", "proximity"].map((e) => [
+    `snap-${e}`,
+    [
+      { "--un-scroll-snap-strictness": e },
+      s("--un-scroll-snap-strictness", { initialValue: "proximity" })
+    ]
+  ]),
+  ["snap-none", { "scroll-snap-type": "none" }],
+  // snap align
+  ["snap-start", { "scroll-snap-align": "start" }],
+  ["snap-end", { "scroll-snap-align": "end" }],
+  ["snap-center", { "scroll-snap-align": "center" }],
+  ["snap-align-none", { "scroll-snap-align": "none" }],
+  // snap stop
+  ["snap-normal", { "scroll-snap-stop": "normal" }],
+  ["snap-always", { "scroll-snap-stop": "always" }],
+  // scroll margin
+  [/^scroll-ma?()-?(.+)$/, d("scroll-margin"), {
+    autocomplete: [
+      "scroll-(m|p|ma|pa|block|inline)",
+      "scroll-(m|p|ma|pa|block|inline)-$spacing",
+      "scroll-(m|p|ma|pa|block|inline)-(x|y|r|l|t|b|bs|be|is|ie)",
+      "scroll-(m|p|ma|pa|block|inline)-(x|y|r|l|t|b|bs|be|is|ie)-$spacing"
+    ]
+  }],
+  [/^scroll-m-?([xy])-?(.+)$/, d("scroll-margin")],
+  [/^scroll-m-?([rltb])-?(.+)$/, d("scroll-margin")],
+  [/^scroll-m-(block|inline)-(.+)$/, d("scroll-margin")],
+  [/^scroll-m-?([bi][se])-?(.+)$/, d("scroll-margin")],
+  // scroll padding
+  [/^scroll-pa?()-?(.+)$/, d("scroll-padding")],
+  [/^scroll-p-?([xy])-?(.+)$/, d("scroll-padding")],
+  [/^scroll-p-?([rltb])-?(.+)$/, d("scroll-padding")],
+  [/^scroll-p-(block|inline)-(.+)$/, d("scroll-padding")],
+  [/^scroll-p-?([bi][se])-?(.+)$/, d("scroll-padding")]
+], Qt = {
+  h: "height",
+  w: "width",
+  inline: "inline-size",
+  block: "block-size"
+};
+function O(e, t) {
+  return `${e || ""}${Qt[t]}`;
+}
+function F(e, t, n) {
+  var i;
+  let o;
+  const a = ["container", "spacing"];
+  for (const c of a)
+    if ((i = e[c]) != null && i[n]) {
+      u(c, n), o = p(c, n);
+      break;
+    }
+  if (!o)
+    switch (n) {
+      case "fit":
+      case "max":
+      case "min":
+        o = `${n}-content`;
+        break;
+      case "screen":
+        o = t === "w" ? "100vw" : "100vh";
+        break;
+    }
+  return !o && r.number(n) != null && (u("spacing"), o = `calc(var(--spacing) * ${r.number(n)})`), o ?? r.bracket.cssvar.global.auto.none.fraction.rem(n);
+}
+const en = [
+  [/^size-(min-|max-)?(.+)$/, ([, e, t], { theme: n }) => ({
+    [O(e, "w")]: F(n, "w", t),
+    [O(e, "h")]: F(n, "h", t)
+  })],
+  [/^(?:size-)?(min-|max-)?([wh])-?(.+)$/, ([, e, t, n], { theme: o }) => ({ [O(e, t)]: F(o, t, n) })],
+  [/^(?:size-)?(min-|max-)?(block|inline)-(.+)$/, ([, e, t, n], { theme: o }) => ({ [O(e, t)]: F(o, t, n) }), {
+    autocomplete: [
+      "(w|h)-<num>",
+      "(w|h)-(full|screen|fit|max|min)",
+      "(max|min)-(w|h)-<num>",
+      "(max|min)-(w|h)-(full|screen|fit|max|min)",
+      "(block|inline)-<num>",
+      "(block|inline)-(full|screen|fit|max|min)",
+      "(max|min)-(w|h|block|inline)",
+      "(max|min)-(w|h|block|inline)-<num>",
+      "(max|min)-(w|h|block|inline)-(full|screen|fit|max|min)"
+    ]
+  }],
+  [/^(?:size-)?(min-|max-)?(h)-screen-(.+)$/, ([, e, t, n], o) => ({ [O(e, t)]: be(o, n, "verticalBreakpoint") })],
+  [/^(?:size-)?(min-|max-)?(w)-screen-(.+)$/, ([, e, t, n], o) => ({ [O(e, t)]: be(o, n) }), {
+    autocomplete: [
+      "(w|h)-screen",
+      "(min|max)-(w|h)-screen",
+      "h-screen-$breakpoint",
+      "(min|max)-h-screen-$breakpoint",
+      "w-screen-$breakpoint",
+      "(min|max)-w-screen-$breakpoint"
+    ]
+  }]
+];
+function be(e, t, n = "breakpoint") {
+  var a;
+  const o = qe(e, n);
+  if (o)
+    return (a = o.find((i) => i.point === t)) == null ? void 0 : a.size;
+}
+function tn(e) {
+  if (/^\d+\/\d+$/.test(e))
+    return e;
+  switch (e) {
+    case "square":
+      return "1/1";
+    case "video":
+      return "16/9";
+  }
+  return r.bracket.cssvar.global.auto.number(e);
+}
+const nn = [
+  [/^(?:size-)?aspect-(?:ratio-)?(.+)$/, ([, e]) => ({ "aspect-ratio": tn(e) }), { autocomplete: ["aspect-(square|video|ratio)", "aspect-ratio-(square|video)"] }]
+], on = ["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"], N = ["size", "layout", "paint", "style"], rn = [
+  ["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" }],
+  [/^display-(.+)$/, ([, e]) => ({ display: r.bracket.cssvar.global(e) })]
+], an = [
+  ["visible", { visibility: "visible" }],
+  ["invisible", { visibility: "hidden" }],
+  ["collapse", { visibility: "collapse" }],
+  ["backface-visible", { "backface-visibility": "visible" }],
+  ["backface-hidden", { "backface-visibility": "hidden" }],
+  ...l("backface", "backface-visibility")
+], sn = [
+  [/^cursor-(.+)$/, ([, e]) => ({ cursor: r.bracket.cssvar.global(e) })],
+  ...on.map((e) => [`cursor-${e}`, { cursor: e }])
+], ln = [
+  [/^contain-(.*)$/, ([, e]) => r.bracket(e) != null ? {
+    contain: r.bracket(e).split(" ").map((t) => r.cssvar.fraction(t) ?? t).join(" ")
+  } : N.includes(e) ? [
+    {
+      "--un-contain-size": e,
+      contain: N.map((t) => `var(--un-contain-${t})`).join(" ")
+    },
+    ...N.map((t) => s(`--un-contain-${t}`))
+  ] : void 0],
+  ["contain-strict", { contain: "strict" }],
+  ["contain-content", { contain: "content" }],
+  ["contain-none", { contain: "none" }]
+], cn = [
+  ["pointer-events-auto", { "pointer-events": "auto" }],
+  ["pointer-events-none", { "pointer-events": "none" }],
+  ...l("pointer-events")
+], un = [
+  ["resize-x", { resize: "horizontal" }],
+  ["resize-y", { resize: "vertical" }],
+  ["resize", { resize: "both" }],
+  ["resize-none", { resize: "none" }],
+  ...l("resize")
+], dn = [
+  ["select-auto", { "-webkit-user-select": "auto", "user-select": "auto" }],
+  ["select-all", { "-webkit-user-select": "all", "user-select": "all" }],
+  ["select-text", { "-webkit-user-select": "text", "user-select": "text" }],
+  ["select-none", { "-webkit-user-select": "none", "user-select": "none" }],
+  ...l("select", "user-select")
+], pn = [
+  [
+    /^(?:whitespace-|ws-)([-\w]+)$/,
+    ([, e]) => ["normal", "nowrap", "pre", "pre-line", "pre-wrap", "break-spaces", ...f].includes(e) ? { "white-space": e } : void 0,
+    { autocomplete: "(whitespace|ws)-(normal|nowrap|pre|pre-line|pre-wrap|break-spaces)" }
+  ]
+], bn = [
+  [/^intrinsic-size-(.+)$/, ([, e]) => ({ "contain-intrinsic-size": r.bracket.cssvar.global.fraction.rem(e) }), { autocomplete: "intrinsic-size-<num>" }],
+  ["content-visibility-visible", { "content-visibility": "visible" }],
+  ["content-visibility-hidden", { "content-visibility": "hidden" }],
+  ["content-visibility-auto", { "content-visibility": "auto" }],
+  ...l("content-visibility")
+], fn = [
+  [/^content-(.+)$/, ([, e]) => {
+    if (r.bracket.cssvar(e) != null)
+      return [
+        {
+          "--un-content": r.bracket.cssvar(e),
+          content: "var(--un-content)"
+        },
+        s("--un-content", { initialValue: '""' })
+      ];
+  }],
+  ["content-empty", { content: '""' }],
+  ["content-none", { content: "none" }]
+], mn = [
+  ["break-normal", { "overflow-wrap": "normal", "word-break": "normal" }],
+  ["break-words", { "overflow-wrap": "break-word" }],
+  ["break-all", { "word-break": "break-all" }],
+  ["break-keep", { "word-break": "keep-all" }],
+  ["break-anywhere", { "overflow-wrap": "anywhere" }]
+], gn = [
+  ["text-wrap", { "text-wrap": "wrap" }],
+  ["text-nowrap", { "text-wrap": "nowrap" }],
+  ["text-balance", { "text-wrap": "balance" }],
+  ["text-pretty", { "text-wrap": "pretty" }]
+], hn = [
+  ["truncate", { overflow: "hidden", "text-overflow": "ellipsis", "white-space": "nowrap" }],
+  ["text-truncate", { overflow: "hidden", "text-overflow": "ellipsis", "white-space": "nowrap" }],
+  ["text-ellipsis", { "text-overflow": "ellipsis" }],
+  ["text-clip", { "text-overflow": "clip" }]
+], vn = [
+  ["case-upper", { "text-transform": "uppercase" }],
+  ["case-lower", { "text-transform": "lowercase" }],
+  ["case-capital", { "text-transform": "capitalize" }],
+  ["case-normal", { "text-transform": "none" }],
+  ["uppercase", { "text-transform": "uppercase" }],
+  ["lowercase", { "text-transform": "lowercase" }],
+  ["capitalize", { "text-transform": "capitalize" }],
+  ["normal-case", { "text-transform": "none" }],
+  ...l("case", "text-transform")
+], yn = [
+  ["italic", { "font-style": "italic" }],
+  ["not-italic", { "font-style": "normal" }],
+  ["font-italic", { "font-style": "italic" }],
+  ["font-not-italic", { "font-style": "normal" }],
+  ["oblique", { "font-style": "oblique" }],
+  ["not-oblique", { "font-style": "normal" }],
+  ["font-oblique", { "font-style": "oblique" }],
+  ["font-not-oblique", { "font-style": "normal" }]
+], kn = [
+  ["antialiased", {
+    "-webkit-font-smoothing": "antialiased",
+    "-moz-osx-font-smoothing": "grayscale"
+  }],
+  ["subpixel-antialiased", {
+    "-webkit-font-smoothing": "auto",
+    "-moz-osx-font-smoothing": "auto"
+  }]
+], $n = [
+  ...["manual", "auto", "none", ...f].map((e) => [`hyphens-${e}`, {
+    "-webkit-hyphens": e,
+    "-ms-hyphens": e,
+    hyphens: e
+  }])
+], xn = [
+  ["write-vertical-right", { "writing-mode": "vertical-rl" }],
+  ["write-vertical-left", { "writing-mode": "vertical-lr" }],
+  ["write-normal", { "writing-mode": "horizontal-tb" }],
+  ...l("write", "writing-mode")
+], wn = [
+  ["write-orient-mixed", { "text-orientation": "mixed" }],
+  ["write-orient-sideways", { "text-orientation": "sideways" }],
+  ["write-orient-upright", { "text-orientation": "upright" }],
+  ...l("write-orient", "text-orientation")
+], jn = [
+  [
+    "sr-only",
+    {
+      position: "absolute",
+      width: "1px",
+      height: "1px",
+      padding: "0",
+      margin: "-1px",
+      overflow: "hidden",
+      clip: "rect(0,0,0,0)",
+      "white-space": "nowrap",
+      "border-width": 0
+    }
+  ],
+  [
+    "not-sr-only",
+    {
+      position: "static",
+      width: "auto",
+      height: "auto",
+      padding: "0",
+      margin: "0",
+      overflow: "visible",
+      clip: "auto",
+      "white-space": "normal"
+    }
+  ]
+], zn = [
+  ["isolate", { isolation: "isolate" }],
+  ["isolate-auto", { isolation: "auto" }],
+  ["isolation-auto", { isolation: "auto" }]
+], Sn = [
+  // object fit
+  ["object-cover", { "object-fit": "cover" }],
+  ["object-contain", { "object-fit": "contain" }],
+  ["object-fill", { "object-fit": "fill" }],
+  ["object-scale-down", { "object-fit": "scale-down" }],
+  ["object-none", { "object-fit": "none" }],
+  // object position
+  [/^object-(.+)$/, ([, e]) => {
+    if (v[e])
+      return { "object-position": v[e] };
+    if (r.bracketOfPosition(e) != null)
+      return { "object-position": r.bracketOfPosition(e).split(" ").map((t) => r.position.fraction.auto.px.cssvar(t) ?? t).join(" ") };
+  }, { autocomplete: `object-(${Object.keys(v).join("|")})` }]
+], Vn = [
+  ["bg-blend-multiply", { "background-blend-mode": "multiply" }],
+  ["bg-blend-screen", { "background-blend-mode": "screen" }],
+  ["bg-blend-overlay", { "background-blend-mode": "overlay" }],
+  ["bg-blend-darken", { "background-blend-mode": "darken" }],
+  ["bg-blend-lighten", { "background-blend-mode": "lighten" }],
+  ["bg-blend-color-dodge", { "background-blend-mode": "color-dodge" }],
+  ["bg-blend-color-burn", { "background-blend-mode": "color-burn" }],
+  ["bg-blend-hard-light", { "background-blend-mode": "hard-light" }],
+  ["bg-blend-soft-light", { "background-blend-mode": "soft-light" }],
+  ["bg-blend-difference", { "background-blend-mode": "difference" }],
+  ["bg-blend-exclusion", { "background-blend-mode": "exclusion" }],
+  ["bg-blend-hue", { "background-blend-mode": "hue" }],
+  ["bg-blend-saturation", { "background-blend-mode": "saturation" }],
+  ["bg-blend-color", { "background-blend-mode": "color" }],
+  ["bg-blend-luminosity", { "background-blend-mode": "luminosity" }],
+  ["bg-blend-normal", { "background-blend-mode": "normal" }],
+  ...l("bg-blend", "background-blend")
+], On = [
+  ["mix-blend-multiply", { "mix-blend-mode": "multiply" }],
+  ["mix-blend-screen", { "mix-blend-mode": "screen" }],
+  ["mix-blend-overlay", { "mix-blend-mode": "overlay" }],
+  ["mix-blend-darken", { "mix-blend-mode": "darken" }],
+  ["mix-blend-lighten", { "mix-blend-mode": "lighten" }],
+  ["mix-blend-color-dodge", { "mix-blend-mode": "color-dodge" }],
+  ["mix-blend-color-burn", { "mix-blend-mode": "color-burn" }],
+  ["mix-blend-hard-light", { "mix-blend-mode": "hard-light" }],
+  ["mix-blend-soft-light", { "mix-blend-mode": "soft-light" }],
+  ["mix-blend-difference", { "mix-blend-mode": "difference" }],
+  ["mix-blend-exclusion", { "mix-blend-mode": "exclusion" }],
+  ["mix-blend-hue", { "mix-blend-mode": "hue" }],
+  ["mix-blend-saturation", { "mix-blend-mode": "saturation" }],
+  ["mix-blend-color", { "mix-blend-mode": "color" }],
+  ["mix-blend-luminosity", { "mix-blend-mode": "luminosity" }],
+  ["mix-blend-plus-lighter", { "mix-blend-mode": "plus-lighter" }],
+  ["mix-blend-normal", { "mix-blend-mode": "normal" }],
+  ...l("mix-blend")
+], Cn = [
+  ["min-h-dvh", { "min-height": "100dvh" }],
+  ["min-h-svh", { "min-height": "100svh" }],
+  ["min-h-lvh", { "min-height": "100lvh" }],
+  ["h-dvh", { height: "100dvh" }],
+  ["h-svh", { height: "100svh" }],
+  ["h-lvh", { height: "100lvh" }],
+  ["max-h-dvh", { "max-height": "100dvh" }],
+  ["max-h-svh", { "max-height": "100svh" }],
+  ["max-h-lvh", { "max-height": "100lvh" }]
+], Wn = [
+  ["forced-color-adjust-auto", { "forced-color-adjust": "auto" }],
+  ["forced-color-adjust-none", { "forced-color-adjust": "none" }]
+], An = [
+  ["field-sizing-fixed", { "field-sizing": "fixed" }],
+  ["field-sizing-content", { "field-sizing": "content" }]
+], Rn = [
+  // fills
+  [/^fill-(.+)$/, b("fill", "fill"), { autocomplete: "fill-$colors" }],
+  [/^fill-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-fill-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "fill-(op|opacity)-<percent>" }],
+  ["fill-none", { fill: "none" }],
+  // stroke size
+  [/^stroke-(?:width-|size-)?(.+)$/, Ue],
+  // stroke dash
+  [/^stroke-dash-(.+)$/, ([, e]) => ({ "stroke-dasharray": r.bracket.cssvar.number(e) }), { autocomplete: "stroke-dash-<num>" }],
+  [/^stroke-offset-(.+)$/, ([, e]) => ({ "stroke-dashoffset": r.bracket.cssvar.px.numberWithUnit(e) })],
+  // stroke colors
+  [/^stroke-(.+)$/, Un, { autocomplete: "stroke-$colors" }],
+  [/^stroke-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-stroke-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "stroke-(op|opacity)-<percent>" }],
+  // line cap
+  ["stroke-cap-square", { "stroke-linecap": "square" }],
+  ["stroke-cap-round", { "stroke-linecap": "round" }],
+  ["stroke-cap-auto", { "stroke-linecap": "butt" }],
+  // line join
+  ["stroke-join-arcs", { "stroke-linejoin": "arcs" }],
+  ["stroke-join-bevel", { "stroke-linejoin": "bevel" }],
+  ["stroke-join-clip", { "stroke-linejoin": "miter-clip" }],
+  ["stroke-join-round", { "stroke-linejoin": "round" }],
+  ["stroke-join-auto", { "stroke-linejoin": "miter" }],
+  // none
+  ["stroke-none", { stroke: "none" }]
+];
+function Ue([, e]) {
+  return { "stroke-width": r.bracket.cssvar.fraction.px.number(e) };
+}
+function Un(e, t) {
+  return E(r.bracket(e[1])) ? Ue(e) : b("stroke", "stroke")(e, t);
+}
+const En = [
+  // displays
+  ["inline-table", { display: "inline-table" }],
+  ["table", { display: "table" }],
+  ["table-caption", { display: "table-caption" }],
+  ["table-cell", { display: "table-cell" }],
+  ["table-column", { display: "table-column" }],
+  ["table-column-group", { display: "table-column-group" }],
+  ["table-footer-group", { display: "table-footer-group" }],
+  ["table-header-group", { display: "table-header-group" }],
+  ["table-row", { display: "table-row" }],
+  ["table-row-group", { display: "table-row-group" }],
+  // layouts
+  ["border-collapse", { "border-collapse": "collapse" }],
+  ["border-separate", { "border-collapse": "separate" }],
+  [/^border-spacing-(.+)$/, function* ([, e], { theme: t }) {
+    const n = fe(e, t);
+    if (n != null) {
+      yield {
+        "--un-border-spacing-x": n,
+        "--un-border-spacing-y": n,
+        "border-spacing": "var(--un-border-spacing-x) var(--un-border-spacing-y)"
+      };
+      for (const o of ["x", "y"])
+        yield s(`--un-border-spacing-${o}`, { syntax: "<length>", initialValue: "0" });
+    }
+  }, { autocomplete: ["border-spacing", "border-spacing-$spacing"] }],
+  [/^border-spacing-([xy])-(.+)$/, function* ([, e, t], { theme: n }) {
+    const o = fe(t, n);
+    if (o != null) {
+      yield {
+        [`--un-border-spacing-${e}`]: o,
+        "border-spacing": "var(--un-border-spacing-x) var(--un-border-spacing-y)"
+      };
+      for (const a of ["x", "y"])
+        yield s(`--un-border-spacing-${a}`, { syntax: "<length>", initialValue: "0" });
+    }
+  }, { autocomplete: ["border-spacing-(x|y)", "border-spacing-(x|y)-$spacing"] }],
+  ["caption-top", { "caption-side": "top" }],
+  ["caption-bottom", { "caption-side": "bottom" }],
+  ["table-auto", { "table-layout": "auto" }],
+  ["table-fixed", { "table-layout": "fixed" }],
+  ["table-empty-cells-visible", { "empty-cells": "show" }],
+  ["table-empty-cells-hidden", { "empty-cells": "hide" }]
+];
+function fe(e, t) {
+  var o;
+  let n = (o = t.spacing) == null ? void 0 : o[e];
+  if (!n) {
+    const a = $(e);
+    a != null ? (u("spacing"), n = `calc(var(--spacing) * ${a})`) : n = r.bracket.cssvar.global.auto.fraction.rem(e);
+  }
+  return n;
+}
+const H = "var(--un-pan-x) var(--un-pan-y) var(--un-pinch-zoom)", K = ["pan-x", "pan-y", "pinch-zoom"].map((e) => s(`--un-${e}`)), Tn = [
+  [/^touch-pan-(x|left|right)$/, function* ([, e]) {
+    yield {
+      "--un-pan-x": `pan-${e}`,
+      "touch-action": H
+    };
+    for (const t of K)
+      yield t;
+  }, { autocomplete: ["touch-pan", "touch-pan-(x|left|right|y|up|down)"] }],
+  [/^touch-pan-(y|up|down)$/, function* ([, e]) {
+    yield {
+      "--un-pan-y": `pan-${e}`,
+      "touch-action": H
+    };
+    for (const t of K)
+      yield t;
+  }],
+  [/^touch-pinch-zoom$/, function* () {
+    yield {
+      "--un-pinch-zoom": "pinch-zoom",
+      "touch-action": H
+    };
+    for (const e of K)
+      yield e;
+  }],
+  ["touch-auto", { "touch-action": "auto" }],
+  ["touch-manipulation", { "touch-action": "manipulation" }],
+  ["touch-none", { "touch-action": "none" }],
+  ...l("touch", "touch-action")
+], M = [
+  "translate",
+  "rotate",
+  "scale"
+], Q = [
+  "var(--un-rotate-x)",
+  "var(--un-rotate-y)",
+  "var(--un-rotate-z)",
+  "var(--un-skew-x)",
+  "var(--un-skew-y)"
+].join(" "), ee = Q, Ln = [
+  "translateZ(0)",
+  Q
+].join(" "), Pn = [
+  // origins
+  [
+    /^(?:transform-)?origin-(.+)$/,
+    ([, e]) => ({ "transform-origin": v[e] ?? r.bracket.cssvar(e) }),
+    { autocomplete: [`transform-origin-(${Object.keys(v).join("|")})`, `origin-(${Object.keys(v).join("|")})`] }
+  ],
+  // perspectives
+  [/^(?:transform-)?perspect(?:ive)?-(.+)$/, ([, e], { theme: t }) => {
+    var o;
+    let n;
+    if ((o = t.perspective) != null && o[e] ? (u("perspective", e), n = p("perspective", e)) : n = r.bracket.cssvar.px.numberWithUnit(e), n != null)
+      return {
+        perspective: n
+      };
+  }, { autocomplete: ["transform-perspective-<num>", "perspective-<num>", "perspective-$perspective"] }],
+  // skip 1 & 2 letters shortcut
+  [/^(?:transform-)?perspect(?:ive)?-origin-(.+)$/, ([, e]) => {
+    const t = r.bracket.cssvar(e) ?? (e.length >= 3 ? v[e] : void 0);
+    if (t != null)
+      return {
+        "perspective-origin": t
+      };
+  }],
+  // modifiers
+  [/^(?:transform-)?translate-()(.+)$/, me],
+  [/^(?:transform-)?translate-([xyz])-(.+)$/, me],
+  [/^(?:transform-)?rotate-()(.+)$/, he],
+  [/^(?:transform-)?rotate-([xyz])-(.+)$/, he],
+  [/^(?:transform-)?skew-()(.+)$/, ve],
+  [/^(?:transform-)?skew-([xy])-(.+)$/, ve, { autocomplete: ["transform-skew-(x|y)-<percent>", "skew-(x|y)-<percent>"] }],
+  [/^(?:transform-)?scale-()(.+)$/, ge],
+  [/^(?:transform-)?scale-([xyz])-(.+)$/, ge, { autocomplete: [`transform-(${M.join("|")})-<percent>`, `transform-(${M.join("|")})-(x|y|z)-<percent>`, `(${M.join("|")})-<percent>`, `(${M.join("|")})-(x|y|z)-<percent>`] }],
+  // style
+  ["transform-3d", { "transform-style": "preserve-3d" }],
+  ["transform-flat", { "transform-style": "flat" }],
+  // transform-box
+  [/^transform-(border|content|fill|stroke|view)$/, ([, e]) => ({ "transform-box": `${e}-box` })],
+  // base
+  ["transform", { transform: ee }],
+  ["transform-cpu", { transform: Q }],
+  ["transform-gpu", { transform: Ln }],
+  ["transform-none", { transform: "none" }],
+  ...l("transform")
+];
+function me([, e, t]) {
+  const n = $(t) ?? r.bracket.cssvar.none.fraction.rem(t);
+  if (n != null)
+    return n === "none" ? {
+      translate: "none"
+    } : (u("spacing"), [
+      [
+        ...te(e, typeof n == "number" ? `calc(var(--spacing) * ${n})` : n, "translate"),
+        ["translate", `var(--un-translate-x) var(--un-translate-y)${e === "z" ? " var(--un-translate-z)" : ""}`, Be]
+      ],
+      ...["x", "y", "z"].map((o) => s(`--un-translate-${o}`, { initialValue: 0 }))
+    ]);
+}
+function ge([, e, t]) {
+  const n = r.bracket.cssvar.none.fraction.percent(t);
+  if (n != null)
+    return n === "none" ? {
+      scale: "none"
+    } : [
+      [
+        ...te(e, n, "scale"),
+        ["scale", `var(--un-scale-x) var(--un-scale-y)${e === "z" ? " var(--un-scale-z)" : ""}`]
+      ],
+      ...["x", "y", "z"].map((o) => s(`--un-scale-${o}`, { initialValue: 1 }))
+    ];
+}
+function he([, e = "", t]) {
+  const n = r.bracket.cssvar.none.degree(t);
+  if (n != null)
+    return n === "none" ? {
+      rotate: "none"
+    } : e ? [
+      [
+        ...te(e, n.endsWith("deg") ? `rotate${e.toUpperCase()}(${n})` : n, "rotate"),
+        ["transform", ee]
+      ],
+      ...["x", "y", "z"].map((o) => s(`--un-rotate-${o}`, { initialValue: `rotate${o.toUpperCase()}(0)` })),
+      ...["x", "y"].map((o) => s(`--un-skew-${o}`, { initialValue: `skew${o.toUpperCase()}(0)` }))
+    ] : {
+      rotate: r.bracket.cssvar.degree(t)
+    };
+}
+function ve([, e, t]) {
+  const n = r.bracket.cssvar.degree(t), o = xe[e];
+  if (n != null && o)
+    return [
+      [
+        ...o.map((a) => [`--un-skew${a}`, n.endsWith("deg") ? `skew${a.slice(1).toUpperCase()}(${n})` : n]),
+        ["transform", ee]
+      ],
+      ...["x", "y", "z"].map((a) => s(`--un-rotate-${a}`, { initialValue: `rotate${a.toUpperCase()}(0)` })),
+      ...["x", "y"].map((a) => s(`--un-skew-${a}`, { initialValue: `skew${a.toUpperCase()}(0)` }))
+    ];
+}
+function te(e, t, n) {
+  const o = t.split(Ne);
+  return e || !e && o.length === 1 ? xe[e].map((a) => [`--un-${n}${a}`, t]) : o.map((a, i) => [`--un-${n}-${He[i]}`, a]);
+}
+function ye(e, t) {
+  let n;
+  if (r.cssvar(e) != null)
+    n = r.cssvar(e);
+  else {
+    e.startsWith("[") && e.endsWith("]") && (e = e.slice(1, -1));
+    const o = e.split(",").map((a) => {
+      var i;
+      return ((i = t.property) == null ? void 0 : i[a]) ?? r.properties(a);
+    });
+    o.every(Boolean) && (n = o.join(","));
+  }
+  return n;
+}
+const Fn = [
+  // transition
+  [
+    /^transition(?:-(\D+?))?(?:-(\d+))?$/,
+    ([, e, t], { theme: n }) => {
+      var a;
+      u("default", ["transition", "timingFunction"]), u("default", ["transition", "duration"]);
+      const o = {
+        "transition-property": (a = n.property) == null ? void 0 : a.DEFAULT,
+        "transition-timing-function": `var(--un-ease, ${p("default", ["transition", "timingFunction"])})`,
+        "transition-duration": `var(--un-duration, ${p("default", ["transition", "duration"])})`
+      };
+      if (!e && !t)
+        return {
+          ...o
+        };
+      if (e != null) {
+        const i = ye(e, n);
+        if (i)
+          return {
+            "--un-duration": t && r.time(t),
+            ...o,
+            "transition-property": i
+          };
+      } else if (t != null)
+        return {
+          "--un-duration": r.time(t),
+          ...o
+        };
+    }
+  ],
+  // timings
+  [
+    /^(?:transition-)?duration-(.+)$/,
+    ([, e]) => ({
+      "--un-duration": r.bracket.cssvar.time(e),
+      "transition-duration": r.bracket.cssvar.time(e)
+    })
+  ],
+  [
+    /^(?:transition-)?delay-(.+)$/,
+    ([, e]) => ({ "transition-delay": r.bracket.cssvar.time(e) })
+  ],
+  [
+    /^(?:transition-)?ease(?:-(.+))?$/,
+    ([, e = "DEFAULT"], { theme: t }) => {
+      var o;
+      let n;
+      return (o = t.ease) != null && o[e] ? (u("ease", e), n = p("ease", e)) : n = r.bracket.cssvar(e), [
+        {
+          "--un-ease": n,
+          "transition-timing-function": n
+        },
+        s("--un-ease")
+      ];
+    },
+    { autocomplete: ["transition-ease-(linear|in|out|in-out)", "ease-(linear|in|out|in-out)"] }
+  ],
+  // props
+  [
+    /^(?:transition-)?property-(.+)$/,
+    ([, e], { theme: t }) => {
+      const n = r.global(e) || ye(e, t);
+      if (n)
+        return { "transition-property": n };
+    },
+    { autocomplete: [
+      `transition-property-(${[...f].join("|")})`
+    ] }
+  ],
+  // none
+  ["transition-none", { transition: "none" }],
+  ...l("transition"),
+  // behavior
+  ["transition-discrete", { "transition-behavior": "allow-discrete" }],
+  ["transition-normal", { "transition-behavior": "normal" }]
+], Mn = [
+  // text
+  [/^text-(.+)$/, In, { autocomplete: "text-$text" }],
+  // // text size
+  [/^(?:text|font)-size-(.+)$/, Ee, { autocomplete: "text-size-$text" }],
+  // text colors
+  [/^text-(?:color-)?(.+)$/, Nn, { autocomplete: "text-$colors" }],
+  // colors
+  [/^(?:color|c)-(.+)$/, b("color", "text")],
+  // style
+  [/^(?:text|color|c)-(.+)$/, ([, e]) => f.includes(e) ? { color: e } : void 0, { autocomplete: `(text|color|c)-(${f.join("|")})` }],
+  // opacity
+  [/^(?:text|color|c)-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-text-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "(text|color|c)-(op|opacity)-<percent>" }],
+  // weights
+  [
+    /^fw-?([^-]+)$/,
+    ([, e], { theme: t }) => {
+      var o;
+      let n;
+      return (o = t.fontWeight) != null && o[e] ? (u("fontWeight", e), n = p("fontWeight", e)) : n = r.bracket.cssvar.global.number(e), {
+        "--un-font-weight": n,
+        "font-weight": n
+      };
+    },
+    {
+      autocomplete: [
+        "(font|fw)-(100|200|300|400|500|600|700|800|900)",
+        "(font|fw)-$fontWeight"
+      ]
+    }
+  ],
+  // leadings
+  [
+    /^(?:font-)?(?:leading|lh|line-height)-(.+)$/,
+    ([, e], { theme: t }) => {
+      var o;
+      let n;
+      if ((o = t.leading) != null && o[e] ? (u("leading", e), n = p("leading", e)) : $(e) ? (u("spacing"), n = `calc(var(--spacing) * ${$(e)})`) : n = r.bracket.cssvar.global.rem(e), n != null)
+        return [
+          {
+            "--un-leading": n,
+            "line-height": n
+          },
+          s("--un-leading")
+        ];
+    },
+    { autocomplete: "(leading|lh|line-height)-$leading" }
+  ],
+  // synthesis
+  ["font-synthesis-weight", { "font-synthesis": "weight" }],
+  ["font-synthesis-style", { "font-synthesis": "style" }],
+  ["font-synthesis-small-caps", { "font-synthesis": "small-caps" }],
+  ["font-synthesis-none", { "font-synthesis": "none" }],
+  [/^font-synthesis-(.+)$/, ([, e]) => ({ "font-synthesis": r.bracket.cssvar.global(e) })],
+  // tracking
+  [
+    /^(?:font-)?tracking-(.+)$/,
+    ([, e], { theme: t }) => {
+      var o;
+      let n;
+      return (o = t.tracking) != null && o[e] ? (u("tracking", e), n = p("tracking", e)) : n = r.bracket.cssvar.global.rem(e), {
+        "--un-tracking": n,
+        "letter-spacing": n
+      };
+    },
+    { autocomplete: "tracking-$tracking" }
+  ],
+  // word-spacing
+  [
+    /^(?:font-)?word-spacing-(.+)$/,
+    ([, e], { theme: t }) => {
+      var o;
+      const n = (o = t.tracking) != null && o[e] ? p("tracking", e) : r.bracket.cssvar.global.rem(e);
+      return {
+        "--un-word-spacing": n,
+        "word-spacing": n
+      };
+    },
+    { autocomplete: "word-spacing-$spacing" }
+  ],
+  // stretch
+  ["font-stretch-normal", { "font-stretch": "normal" }],
+  ["font-stretch-ultra-condensed", { "font-stretch": "ultra-condensed" }],
+  ["font-stretch-extra-condensed", { "font-stretch": "extra-condensed" }],
+  ["font-stretch-condensed", { "font-stretch": "condensed" }],
+  ["font-stretch-semi-condensed", { "font-stretch": "semi-condensed" }],
+  ["font-stretch-semi-expanded", { "font-stretch": "semi-expanded" }],
+  ["font-stretch-expanded", { "font-stretch": "expanded" }],
+  ["font-stretch-extra-expanded", { "font-stretch": "extra-expanded" }],
+  ["font-stretch-ultra-expanded", { "font-stretch": "ultra-expanded" }],
+  [
+    /^font-stretch-(.+)$/,
+    ([, e]) => ({ "font-stretch": r.bracket.cssvar.fraction.global(e) }),
+    { autocomplete: "font-stretch-<percentage>" }
+  ],
+  // family & weight
+  [
+    /^font-(.+)$/,
+    ([, e], { theme: t }) => {
+      var o, a;
+      let n;
+      if ((o = t.font) != null && o[e])
+        return u("font", e), n = p("font", e), { "font-family": n };
+      if ((a = t.fontWeight) != null && a[e])
+        return u("fontWeight", e), n = p("fontWeight", e), { "--un-font-weight": n, "font-weight": n };
+      if (n = r.number(e), n != null)
+        return { "--un-font-weight": n, "font-weight": n };
+      if (n = r.bracketOfFamily(e), n != null && r.number(n) == null)
+        return n = r.cssvar(n) ?? n, { "font-family": n };
+      if (n = r.bracketOfNumber(e), n != null)
+        return n = r.cssvar.number(n), { "--un-font-weight": n, "font-weight": n };
+      if (n = r.bracket(e), n != null && r.number(n) != null) {
+        const i = r.number(n);
+        return { "--un-font-weight": i, "font-weight": i };
+      }
+      if (n = r.bracket.cssvar.global(e), n != null)
+        return { "font-family": n };
+    },
+    { autocomplete: ["font-$font", "font-$fontWeight"] }
+  ]
+], qn = [
+  [/^tab(?:-(.+))?$/, ([, e]) => {
+    const t = r.bracket.cssvar.global.number(e || "4");
+    if (t != null)
+      return {
+        "-moz-tab-size": t,
+        "-o-tab-size": t,
+        "tab-size": t
+      };
+  }]
+], Dn = [
+  [/^indent-(.+)$/, ([, e]) => {
+    let t = $(e);
+    if (t != null)
+      return u("spacing"), { "text-indent": `calc(var(--spacing) * ${t})` };
+    if (t = r.bracket.cssvar.auto.global.rem(e), t != null)
+      return { "text-indent": t };
+  }]
+], Bn = [
+  // widths
+  [/^text-stroke(?:-(.+))?$/, ([, e = "DEFAULT"], { theme: t }) => {
+    var n, o;
+    return (n = t.textStrokeWidth) != null && n[e] && u("textStrokeWidth", e), {
+      "-webkit-text-stroke-width": (o = t.textStrokeWidth) != null && o[e] ? p("textStrokeWidth", e) : r.bracket.cssvar.px(e)
+    };
+  }, { autocomplete: "text-stroke-$textStrokeWidth" }],
+  // colors
+  [/^text-stroke-(.+)$/, b("-webkit-text-stroke-color", "text-stroke"), { autocomplete: "text-stroke-$colors" }],
+  [/^text-stroke-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-text-stroke-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "text-stroke-(op|opacity)-<percent>" }]
+], ke = /op(?:acity)?-/, _n = [
+  [/^text-shadow(?:-(.+))?$/, (e, t) => {
+    var i;
+    const [n, o = "DEFAULT"] = e, a = (i = t.theme.textShadow) == null ? void 0 : i[o];
+    return a != null ? {
+      "--un-text-shadow": Y(a, "--un-text-shadow-color").join(","),
+      "text-shadow": "var(--un-text-shadow)"
+    } : ke.test(o) ? { "--un-text-shadow-opacity": r.bracket.percent.cssvar(o.replace(ke, "")) } : b("--un-text-shadow-color", "text-shadow")(e, t) ?? { "text-shadow": r.bracket.cssvar.global(o) };
+  }, {
+    autocomplete: [
+      "text-shadow-$textShadow",
+      "text-shadow(-color)?-$colors",
+      "text-shadow(-color)?-(op|opacity)-<percent>"
+    ]
+  }],
+  // colors
+  [/^text-shadow-color-(.+)$/, b("--un-text-shadow-color", "text-shadow"), { autocomplete: "text-shadow-color-$colors" }],
+  [/^text-shadow-color-op(?:acity)?-?(.+)$/, ([, e]) => ({ "--un-text-shadow-opacity": r.bracket.percent.cssvar(e) }), { autocomplete: "text-shadow-color-(op|opacity)-<percent>" }]
+], w = [
+  s("--un-ordinal"),
+  s("--un-slashed-zero"),
+  s("--un-numeric-figure"),
+  s("--un-numeric-spacing"),
+  s("--un-numeric-fraction")
+], j = {
+  "font-variant-numeric": "var(--un-ordinal) var(--un-slashed-zero) var(--un-numeric-figure) var(--un-numeric-spacing) var(--un-numeric-fraction)"
+}, Gn = [
+  ["ordinal", [{ "--un-ordinal": "ordinal", ...j }, ...w]],
+  ["slashed-zero", [{ "--un-slashed-zero": "slashed-zero", ...j }, ...w]],
+  ["lining-nums", [{ "--un-numeric-figure": "lining-nums", ...j }, ...w]],
+  ["oldstyle-nums", [{ "--un-numeric-figure": "oldstyle-nums", ...j }, ...w]],
+  ["proportional-nums", [{ "--un-numeric-spacing": "proportional-nums", ...j }, ...w]],
+  ["tabular-nums", [{ "--un-numeric-spacing": "tabular-nums", ...j }, ...w]],
+  ["diagonal-fractions", [{ "--un-numeric-fraction": "diagonal-fractions", ...j }, ...w]],
+  ["stacked-fractions", [{ "--un-numeric-fraction": "stacked-fractions", ...j }, ...w]],
+  ["normal-nums", [{ "font-variant-numeric": "normal" }]]
+];
+function In([, e = "base"], { theme: t }) {
+  var g, z;
+  const n = Hn(e, "length");
+  if (!n)
+    return;
+  const [o, a] = n, i = (g = t.text) == null ? void 0 : g[o];
+  let c;
+  if (a && ((z = t.leading) != null && z[a] ? (u("leading", a), c = p("leading", a)) : c = r.bracket.cssvar.global.rem(a)), i)
+    return u("text", [o, "fontSize"]), u("text", [o, "lineHeight"]), i.letterSpacing && u("text", [o, "letterSpacing"]), {
+      "font-size": p("text", [o, "fontSize"]),
+      "line-height": c ?? `var(--un-leading, ${p("text", [o, "lineHeight"])})`,
+      "letter-spacing": i.letterSpacing ? p("text", [o, "letterSpacing"]) : void 0
+    };
+  const m = r.bracketOfLength.rem(o);
+  return c && m ? {
+    "font-size": m,
+    "line-height": c
+  } : { "font-size": r.bracketOfLength.rem(e) };
+}
+function Ee([, e], { theme: t }) {
+  var n;
+  if (((n = t.text) == null ? void 0 : n[e]) != null)
+    return u("text", [e, "fontSize"]), u("text", [e, "lineHeight"]), {
+      "font-size": p("text", [e, "fontSize"]),
+      "line-height": `var(--un-leading, ${p("text", [e, "lineHeight"])})`
+    };
+  {
+    const o = r.bracket.cssvar.global.rem(e);
+    if (o)
+      return { "font-size": o };
+  }
+}
+function Nn(e, t) {
+  return E(r.bracket(e[1])) ? Ee(e, t) : b("color", "text")(e, t);
+}
+function Hn(e, t) {
+  const [n, o] = Ye(e, "[", "]", ["/", ":"]) ?? [];
+  if (n != null) {
+    const a = (n.match(Ge) ?? [])[1];
+    if (a == null || a === t)
+      return [n, o];
+  }
+}
+const Kn = {
+  backface: "backface-visibility",
+  break: "word-break",
+  case: "text-transform",
+  content: "align-content",
+  fw: "font-weight",
+  items: "align-items",
+  justify: "justify-content",
+  select: "user-select",
+  self: "align-self",
+  vertical: "vertical-align",
+  visible: "visibility",
+  whitespace: "white-space",
+  ws: "white-space",
+  "bg-blend": "background-blend-mode",
+  "bg-clip": "-webkit-background-clip",
+  "bg-image": "background-image",
+  "bg-origin": "background-origin",
+  "bg-position": "background-position",
+  "bg-repeat": "background-repeat",
+  "bg-size": "background-size",
+  "mix-blend": "mix-blend-mode",
+  object: "object-fit",
+  "object-position": "object-position",
+  write: "writing-mode",
+  "write-orient": "text-orientation"
+}, Jn = [
+  [/^(.+?)-(\$.+)$/, ([, e, t]) => {
+    const n = Kn[e];
+    if (n)
+      return { [n]: r.cssvar(t) };
+  }]
+], Zn = [
+  [/^\[(.*)\]$/, ([e, t]) => {
+    if (!t.includes(":"))
+      return;
+    const [n, ...o] = t.split(":"), a = o.join(":");
+    if (!Yn(t) && /^[\w-]+$/.test(n) && Xn(a)) {
+      const i = r.bracket(`[${a}]`);
+      if (i)
+        return { [n]: i };
+    }
+  }]
+];
+function Xn(e) {
+  let t = 0;
+  function n(o) {
+    for (; t < e.length; )
+      if (t += 1, e[t] === o)
+        return !0;
+    return !1;
+  }
+  for (t = 0; t < e.length; t++) {
+    const o = e[t];
+    if ("\"`'".includes(o)) {
+      if (!n(o))
+        return !1;
+    } else if (o === "(") {
+      if (!n(")"))
+        return !1;
+    } else if ("[]{}:".includes(o))
+      return !1;
+  }
+  return !0;
+}
+function Yn(e) {
+  if (!e.includes("://"))
+    return !1;
+  try {
+    return new URL(e).host !== "";
+  } catch {
+    return !1;
+  }
+}
+const Qn = [
+  [/^view-transition-([\w-]+)$/, ([, e]) => ({ "view-transition-name": e })]
+], ro = [
+  Mn,
+  qn,
+  Dn,
+  Bn,
+  _n,
+  Ot,
+  Vt,
+  et,
+  Qe,
+  it,
+  se,
+  le,
+  lt,
+  ct,
+  ut,
+  dt,
+  pt,
+  se,
+  bt,
+  le,
+  ft,
+  xt,
+  gt,
+  wt,
+  Ze,
+  Xe,
+  zt,
+  Tt,
+  Lt,
+  Ft,
+  en,
+  nn,
+  rn,
+  an,
+  sn,
+  ln,
+  cn,
+  un,
+  dn,
+  pn,
+  bn,
+  fn,
+  mn,
+  gn,
+  hn,
+  vn,
+  yn,
+  kn,
+  Xt,
+  Zt,
+  Pn,
+  Fn,
+  Jn,
+  Zn,
+  Ae,
+  Kt,
+  Gt,
+  Nt,
+  It,
+  We,
+  _t,
+  Re,
+  Bt,
+  Ht,
+  Mt,
+  Rn,
+  tt,
+  rt,
+  $n,
+  xn,
+  wn,
+  Wn,
+  jn,
+  zn,
+  Sn,
+  Vn,
+  On,
+  Cn,
+  jt,
+  Et,
+  qt,
+  Dt,
+  Yt,
+  En,
+  Tn,
+  Gn,
+  Qn,
+  Ct,
+  At,
+  An,
+  // should be the last
+  Jt
+].flat();
+export {
+  sn as $,
+  Ft as A,
+  Mt as B,
+  qt as C,
+  Dt as D,
+  Bt as E,
+  We as F,
+  _t as G,
+  Ae as H,
+  Re as I,
+  Gt as J,
+  It as K,
+  Nt as L,
+  Ht as M,
+  Kt as N,
+  Jt as O,
+  Xt as P,
+  Yt as Q,
+  X as R,
+  Zt as S,
+  en as T,
+  nn as U,
+  Vt as V,
+  Ot as W,
+  Ct as X,
+  V as Y,
+  rn as Z,
+  an as _,
+  tt as a,
+  ln as a0,
+  cn as a1,
+  un as a2,
+  dn as a3,
+  pn as a4,
+  bn as a5,
+  fn as a6,
+  mn as a7,
+  gn as a8,
+  hn as a9,
+  Hn as aA,
+  Jn as aB,
+  Zn as aC,
+  Qn as aD,
+  vn as aa,
+  yn as ab,
+  kn as ac,
+  $n as ad,
+  xn as ae,
+  wn as af,
+  jn as ag,
+  zn as ah,
+  Sn as ai,
+  Vn as aj,
+  On as ak,
+  Cn as al,
+  Wn as am,
+  An as an,
+  Rn as ao,
+  En as ap,
+  Tn as aq,
+  Pn as as,
+  Fn as at,
+  Mn as au,
+  qn as av,
+  Dn as aw,
+  Bn as ax,
+  _n as ay,
+  Gn as az,
+  rt as b,
+  it as c,
+  ct as d,
+  ut as e,
+  pt as f,
+  S as g,
+  ft as h,
+  dt as i,
+  R as j,
+  gt as k,
+  lt as l,
+  xt as m,
+  wt as n,
+  se as o,
+  jt as p,
+  zt as q,
+  ro as r,
+  bt as s,
+  et as t,
+  At as u,
+  Qe as v,
+  le as w,
+  Et as x,
+  Tt as y,
+  Lt as z
+};