@duxweb/dvha-pro 0.0.8 → 1.0.14

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

@@ -1,2307 +0,0 @@
-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
-};