@unocss/vite 0.1.0-beta.2

package/dist/index.mjs

@@ -0,0 +1,1710 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module, desc) => {
+  if (module && typeof module === "object" || typeof module === "function") {
+    for (let key of __getOwnPropNames(module))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+  }
+  return target;
+};
+
+// ../unocss/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  presetAttributify: () => src_default2,
+  presetUno: () => src_default
+});
+__reExport(src_exports, core_star);
+import * as core_star from "@unocss/core";
+
+// ../preset-uno/src/rules/animations.ts
+var transitionProps = ["background-color", "border-color", "color", "fill", "stroke", "opacity", "box-shadow", "transform", "filter", "backdrop-filter"];
+var transitionPropsStr = transitionProps.join(", ");
+var transitions = [
+  [/^transition(?:-([a-z-]+))?(?:-(\d+))?$/, ([, prop, duration = "150"]) => {
+    if (prop && !transitionProps.includes(prop))
+      return;
+    return {
+      "transition-property": prop || transitionPropsStr,
+      "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)",
+      "transition-duration": `${duration}ms`
+    };
+  }],
+  [/^duration-(\d+)$/, ([, duration = "150"]) => {
+    return {
+      "transition-duration": `${duration}ms`
+    };
+  }],
+  ["ease", { "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)" }],
+  ["ease-in", { "transition-timing-function": "cubic-bezier(0.4, 0, 1, 1)" }],
+  ["ease-out", { "transition-timing-function": "cubic-bezier(0, 0, 0.2, 1)" }],
+  ["ease-in-out", { "transition-timing-function": "cubic-bezier(0.4, 0, 0.2, 1)" }]
+];
+
+// ../preset-uno/src/rules/border.ts
+import { handler as h } from "@unocss/core";
+
+// ../preset-uno/src/utils/mappings.ts
+var directionMap = {
+  "l": ["-left"],
+  "r": ["-right"],
+  "t": ["-top"],
+  "b": ["-bottom"],
+  "s": ["-inline-start"],
+  "e": ["-inline-end"],
+  "x": ["-left", "-right"],
+  "y": ["-top", "-bottom"],
+  "": [""],
+  "a": [""]
+};
+var cornerMap = {
+  "t": ["-top-left", "-top-right"],
+  "r": ["-top-right", "-bottom-right"],
+  "b": ["-bottom-left", "-bottom-right"],
+  "l": ["-bottom-left", "-top-left"],
+  "tl": ["-top-left"],
+  "lt": ["-top-left"],
+  "tr": ["-top-right"],
+  "rt": ["-top-right"],
+  "bl": ["-bottom-left"],
+  "lb": ["-bottom-left"],
+  "br": ["-bottom-right"],
+  "rb": ["-bottom-right"],
+  "": [""]
+};
+var xyzMap = {
+  "x": ["-x"],
+  "y": ["-y"],
+  "z": ["-z"],
+  "": ["-x", "-y"]
+};
+
+// ../preset-uno/src/rules/border.ts
+var borders = [
+  [/^border$/, handlerBorder],
+  [/^border(?:-([^-]+))?$/, handlerBorder],
+  [/^border(?:-([^-]+))?(?:-([^-]+))?$/, handlerBorder]
+];
+var borderRadius = [
+  [/^(?:border-)?(?:rounded|rd)$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?$/, handlerRounded],
+  [/^(?:border-)?(?:rounded|rd)(?:-([^-]+))?(?:-([^-]+))?$/, handlerRounded]
+];
+var borderStyles = [
+  ["border-solid", { "border-style": "solid" }],
+  ["border-dashed", { "border-style": "dashed" }],
+  ["border-dotted", { "border-style": "dotted" }],
+  ["border-double", { "border-style": "double" }],
+  ["border-none", { "border-style": "none" }]
+];
+function handlerBorder([, a, b]) {
+  const [d, s = "1"] = directionMap[a] ? [a, b] : ["", a];
+  const v = h.bracket.border(s);
+  if (v != null) {
+    return [
+      ...directionMap[d].map((i) => [`border${i}-width`, v]),
+      ["border-style", "solid"]
+    ];
+  }
+}
+function handlerRounded([, a, b], theme2) {
+  var _a;
+  const [d, s = "DEFAULT"] = cornerMap[a] ? [a, b] : ["", a];
+  const v = ((_a = theme2.borderRadius) == null ? void 0 : _a[s]) || h.bracket.fraction.size(s);
+  if (v != null)
+    return cornerMap[d].map((i) => [`border${i}-radius`, v]);
+}
+
+// ../preset-uno/src/rules/colors.ts
+import { handler as h2, hex2rgba } from "@unocss/core";
+var colorResolver = (attribute, varName) => ([, body], theme2) => {
+  var _a;
+  const [main, opacity2] = body.split("/");
+  const [name, no = "DEFAULT"] = main.split(/(?<=[a-z])-?(?=[0-9])/g);
+  if (!name)
+    return;
+  let color;
+  const bracket = h2.bracket(main) || main;
+  if (bracket.startsWith("#"))
+    color = bracket.slice(1);
+  if (bracket.startsWith("hex-"))
+    color = bracket.slice(4);
+  if (!color) {
+    if (name === "transparent") {
+      return {
+        [attribute]: "transparent"
+      };
+    } else if (name === "inherit") {
+      return {
+        [attribute]: "inherit"
+      };
+    } else if (name === "current") {
+      return {
+        [attribute]: "currentColor"
+      };
+    }
+    color = (_a = theme2.colors) == null ? void 0 : _a[name];
+    if (no && color && typeof color !== "string")
+      color = color[no];
+  }
+  if (typeof color !== "string")
+    return;
+  const rgba = hex2rgba(color);
+  if (rgba) {
+    const a = opacity2 ? parseFloat(opacity2) / 100 : rgba[3];
+    if (a != null && !Number.isNaN(a)) {
+      rgba[3] = a;
+      return {
+        [attribute]: `rgba(${rgba.join(",")})`
+      };
+    } else {
+      return {
+        [`--un-${varName}-opacity`]: 1,
+        [attribute]: `rgba(${rgba.slice(0, 3).join(",")},var(--un-${varName}-opacity))`
+      };
+    }
+  }
+};
+var opacity = [
+  [/^op(?:acity)?-?(\d+)$/, ([, d]) => ({ opacity: h2.percent(d) })]
+];
+var textColors = [
+  [/^(?:text|color|c)-(.+)$/, colorResolver("color", "text")],
+  [/^(?:text|color|c)-op(?:acity)?-?(\d+)$/m, ([, opacity2]) => ({ "--un-text-opacity": h2.percent(opacity2) })]
+];
+var bgColors = [
+  [/^bg-(.+)$/, colorResolver("background-color", "bg")],
+  [/^bg-op(?:acity)?-?(\d+)$/m, ([, opacity2]) => ({ "--un-bg-opacity": h2.percent(opacity2) })]
+];
+var borderColors = [
+  [/^border-(.+)$/, colorResolver("border-color", "border")],
+  [/^border-op(?:acity)?-?(\d+)$/m, ([, opacity2]) => ({ "--un-border-opacity": h2.percent(opacity2) })]
+];
+
+// ../preset-uno/src/rules/filters.ts
+var filterContnet = "var(--un-blur) var(--un-brightness) var(--un-contrast) var(--un-grayscale) var(--un-hue-rotate) var(--un-invert) var(--un-saturate) var(--un-sepia) var(--un-drop-shadow)";
+var init = {
+  "--un-blur": "var(--un-empty,/*!*/ /*!*/)",
+  "--un-brightness": "var(--un-empty,/*!*/ /*!*/)",
+  "--un-contrast": "var(--un-empty,/*!*/ /*!*/)",
+  "--un-grayscale": "var(--un-empty,/*!*/ /*!*/)",
+  "--un-hue-rotate": "var(--un-empty,/*!*/ /*!*/)",
+  "--un-invert": "var(--un-empty,/*!*/ /*!*/)",
+  "--un-saturate": "var(--un-empty,/*!*/ /*!*/)",
+  "--un-sepia": "var(--un-empty,/*!*/ /*!*/)",
+  "--un-drop-shadow": "var(--un-empty,/*!*/ /*!*/)",
+  "filter": filterContnet
+};
+var filters = [
+  ["filter", init],
+  ["filter-none", { filter: "none" }],
+  [/^blur(?:-(\d+))?$/, ([, d]) => ({ "--un-blur": `blur(${d}px)`, "filter": filterContnet })],
+  ["invert", { "--un-invert": "invert(100%)" }]
+];
+
+// ../preset-uno/src/rules/flex.ts
+var flex = [
+  ["flex-col", { "flex-direction": "column" }],
+  ["flex-col-reverse", { "flex-direction": "column-reverse" }],
+  ["flex-row", { "flex-direction": "row" }],
+  ["flex-row-reverse", { "flex-direction": "row-reverse" }],
+  ["flex-wrap", { "flex-wrap": "wrap" }],
+  ["flex-wrap-reverse", { "flex-wrap": "wrap-reverse" }],
+  ["flex-nowrap", { "flex-wrap": "nowrap" }],
+  ["flex-1", { flex: "1 1 0%" }],
+  ["flex-auto", { flex: "1 1 auto" }],
+  ["flex-initial", { flex: "0 1 auto" }],
+  ["flex-none", { flex: "none" }],
+  [/^flex-\[(.+)\]$/, ([, d]) => ({ flex: d })],
+  ["flex-grow", { "flex-grow": 1 }],
+  ["flex-grow-0", { "flex-grow": 0 }],
+  ["flex-shrink", { "flex-shrink": 1 }],
+  ["flex-shrink-0", { "flex-shrink": 0 }],
+  ["flex", { display: "flex" }],
+  ["inline-flex", { display: "inline-flex" }]
+];
+
+// ../preset-uno/src/rules/font.ts
+import { handler as h3, toArray } from "@unocss/core";
+var fonts = [
+  [/^font-(\w+)$/, ([, d], theme2) => {
+    var _a;
+    const font = (_a = theme2.fontFamily) == null ? void 0 : _a[d];
+    if (font) {
+      return {
+        "font-family": font
+      };
+    }
+  }]
+];
+var weightMap = {
+  thin: "100",
+  extralight: "200",
+  light: "300",
+  normal: "400",
+  medium: "500",
+  semibold: "600",
+  bold: "700",
+  extrabold: "800",
+  black: "900"
+};
+var fontSizes = [
+  [/^text-([^-]+)$/, ([, s = "base"], theme2) => {
+    var _a;
+    const result = toArray(((_a = theme2.fontSize) == null ? void 0 : _a[s]) || h3.bracket.size(s));
+    if (result == null ? void 0 : result[0]) {
+      const [size, height = "1"] = result;
+      return {
+        "font-size": size,
+        "line-height": height
+      };
+    }
+  }]
+];
+var fontWeights = [
+  [/^(?:font|fw)-?([^-]+)$/, ([, s]) => {
+    const v = weightMap[s] || h3.number(s);
+    if (v)
+      return { "font-weight": v };
+  }]
+];
+var leadings = [
+  [/^(?:leading|lh)-([^-]+)$/, ([, s], theme2) => {
+    var _a;
+    const v = ((_a = theme2.lineHeight) == null ? void 0 : _a[s]) || h3.bracket.size(s);
+    if (v !== null)
+      return { "line-height": v };
+  }]
+];
+var trackings = [
+  [/^tracking-([^-]+)$/, ([, s], theme2) => {
+    var _a;
+    const v = ((_a = theme2.letterSpacing) == null ? void 0 : _a[s]) || h3.bracket.size(s);
+    if (v !== null)
+      return { "letter-spacing": v };
+  }]
+];
+
+// ../preset-uno/src/rules/gap.ts
+import { handler as h4 } from "@unocss/core";
+var gaps = [
+  [/^(?:flex-|grid-)?gap-([^-]+)$/, ([, s]) => {
+    const v = h4.bracket.size(s);
+    if (v != null) {
+      return {
+        "grid-gap": v,
+        "gap": v
+      };
+    }
+  }],
+  [/^(?:flex-|grid-)?gap-x-([^-]+)$/, ([, s]) => {
+    const v = h4.bracket.size(s);
+    if (v != null) {
+      return {
+        "grid-column-gap": v,
+        "column-gap": v
+      };
+    }
+  }],
+  [/^(?:flex-|grid-)?gap-y-([^-]+)$/, ([, s]) => {
+    const v = h4.bracket.size(s);
+    if (v != null) {
+      return {
+        "grid-row-gap": v,
+        "row-gap": v
+      };
+    }
+  }]
+];
+
+// ../preset-uno/src/rules/grid.ts
+var grids = [
+  ["grid", { display: "grid" }],
+  ["inline-grid", { display: "inline-grid" }],
+  [/^grid-cols-(\d+)$/, ([, d]) => ({ "grid-template-columns": `repeat(${d}, minmax(0, 1fr))` })],
+  [/^grid-rows-(\d+)$/, ([, d]) => ({ "grid-template-rows": `repeat(${d}, minmax(0, 1fr))` })],
+  [/^grid-cols-\[(.+)\]$/, ([, v]) => ({ "grid-template-columns": v.replace(/,/g, " ") })],
+  [/^grid-rows-\[(.+)\]$/, ([, v]) => ({ "grid-template-rows": v.replace(/,/g, " ") })]
+];
+
+// ../preset-uno/src/rules/layouts.ts
+var overflowValues = [
+  "auto",
+  "hidden",
+  "visible",
+  "scroll"
+];
+var overflows = [
+  [/^overflow-(.+)$/, ([, v]) => overflowValues.includes(v) ? { overflow: v } : void 0],
+  [/^overflow-([xy])-(.+)$/, ([, d, v]) => overflowValues.includes(v) ? { [`overflow-${d}`]: v } : void 0]
+];
+
+// ../preset-uno/src/rules/positions.ts
+import { handler as h5 } from "@unocss/core";
+var positions = [
+  ["relative", { position: "relative" }],
+  ["absolute", { position: "absolute" }],
+  ["fixed", { position: "fixed" }]
+];
+var justifies = [
+  ["justify-start", { "justify-content": "flex-start" }],
+  ["justify-end", { "justify-content": "flex-end" }],
+  ["justify-center", { "justify-content": "center" }],
+  ["justify-between", { "justify-content": "space-between" }],
+  ["justify-around", { "justify-content": "space-around" }],
+  ["justify-evenly", { "justify-content": "space-evenly" }]
+];
+var orders = [
+  [/^order-(.+)$/, ([, v]) => ({ order: { first: "-9999", last: "9999", none: "0" }[v] || h5.bracket.number(v) })]
+];
+var basicSet = ["auto", "start", "end", "center", "stretch"];
+var justifyItems = basicSet.map((i) => [`justify-items-${i}`, { "justify-items": i }]);
+var justifySelfs = basicSet.map((i) => [`justify-self-${i}`, { "justify-self": i }]);
+var alignContents = [
+  ["content-start", { "align-content": "flex-start" }],
+  ["content-end", { "align-content": "flex-end" }],
+  ["content-center", { "align-content": "center" }],
+  ["content-between", { "align-content": "space-between" }],
+  ["content-around", { "align-content": "space-around" }],
+  ["content-evenly", { "align-content": "space-evenly" }]
+];
+var alignItems = [
+  ["items-start", { "align-items": "flex-start" }],
+  ["items-end", { "align-items": "flex-end" }],
+  ["items-center", { "align-items": "center" }],
+  ["items-baseline", { "align-items": "baseline" }],
+  ["items-stretch", { "align-items": "stretch" }]
+];
+var alignSelfs = [
+  ["self-auto", { "align-self": "auto" }],
+  ["self-start", { "align-self": "flex-start" }],
+  ["self-end", { "align-self": "flex-end" }],
+  ["self-center", { "align-self": "center" }],
+  ["self-stretch", { "align-items": "stretch" }]
+];
+var placeContents = [
+  ["place-content-start", { "place-content": "start" }],
+  ["place-content-end", { "place-content": "end" }],
+  ["place-content-center", { "place-content": "center" }],
+  ["place-content-between", { "place-content": "space-between" }],
+  ["place-content-around", { "place-content": "space-around" }],
+  ["place-content-evenly", { "place-content": "space-evenly" }],
+  ["place-content-stretch", { "place-content": "stretch" }]
+];
+var placeItems = basicSet.map((i) => [`place-items-${i}`, { "place-items": i }]);
+var placeSelfs = basicSet.map((i) => [`place-self-${i}`, { "place-self": i }]);
+function handleInsetValue(v) {
+  var _a;
+  return (_a = { auto: "auto", full: "100%" }[v]) != null ? _a : h5.bracket.fraction.size(v);
+}
+var insets = [
+  [/^inset-(x|y)-(.+)$/, ([, d, v]) => {
+    const r = handleInsetValue(v);
+    if (r != null)
+      return directionMap[d].map((i) => [i.slice(1), r]);
+  }],
+  [/^(top|left|right|bottom|inset)-(.+)$/, ([, d, v]) => ({ [d]: handleInsetValue(v) })]
+];
+var floats = [
+  [/^float-(left|right|none)$/, ([, value]) => ({ float: value })],
+  [/^clear-(left|right|both|none)$/, ([, value]) => ({ clear: value })]
+];
+var zIndexes = [
+  ["z-auto", { "z-index": "auto" }],
+  [/^z-([^-]+)$/, ([, v]) => ({ "z-index": h5.number(v) })]
+];
+var objectPositions = [
+  ["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-bottom", { "object-position": "bottom" }],
+  ["object-top", { "object-position": "top" }],
+  ["object-right", { "object-position": "right" }],
+  ["object-left", { "object-position": "left" }],
+  ["object-lb", { "object-position": "left bottom" }],
+  ["object-lt", { "object-position": "left top" }],
+  ["object-rb", { "object-position": "right bottom" }],
+  ["object-rt", { "object-position": "right top" }]
+];
+
+// ../preset-uno/src/rules/size.ts
+import { handler as h6 } from "@unocss/core";
+var sizes = [
+  ["w-full", { width: "100%" }],
+  ["h-full", { height: "100%" }],
+  ["w-screen", { width: "100vw" }],
+  ["h-screen", { height: "100vh" }],
+  [/^w-([^-]+)$/, ([, s]) => ({ width: h6.bracket.fraction.size(s) })],
+  [/^h-([^-]+)$/, ([, s]) => ({ height: h6.bracket.fraction.size(s) })],
+  [/^max-w-([^-]+)$/, ([, s]) => ({ "max-width": h6.bracket.fraction.size(s) })],
+  [/^max-h-([^-]+)$/, ([, s]) => ({ "max-height": h6.bracket.fraction.size(s) })]
+];
+
+// ../preset-uno/src/rules/spacing.ts
+import { handler as h7 } from "@unocss/core";
+var directionSize = (prefix) => ([_, direction, size]) => {
+  const v = h7.bracket.size.fraction(size);
+  if (v)
+    return directionMap[direction].map((i) => [prefix + i, v]);
+};
+var paddings = [
+  [/^pa?()-?(-?[^-]+)$/, directionSize("padding")],
+  [/^p-?([xy])-?(-?[^-]+)$/, directionSize("padding")],
+  [/^p-?([rltbse])-?(-?[^-]+)$/, directionSize("padding")]
+];
+var margins = [
+  [/^ma?()-?(-?[^-]+)$/, directionSize("margin")],
+  [/^m-?([xy])-?(-?[^-]+)$/, directionSize("margin")],
+  [/^m-?([rltbse])-?(-?[^-]+)$/, directionSize("margin")]
+];
+
+// ../preset-uno/src/rules/static.ts
+var displays = [
+  ["inline", { display: "inline" }],
+  ["block", { display: "block" }],
+  ["inline-block", { display: "inline-block" }],
+  ["table", { display: "table" }],
+  ["contents", { display: "contents" }],
+  ["flow-root", { display: "flow-root" }],
+  ["list-item", { display: "list-item" }],
+  ["hidden", { display: "none" }]
+];
+var appearances = [
+  ["outline-none", { "outline": "2px solid transparent", "outline-offset": "2px" }],
+  ["appearance-none", { appearance: "none" }],
+  ["visible", { visibility: "visible" }],
+  ["invisible", { visibility: "hidden" }],
+  ["backface-visible", { "backface-visibility": "visible" }],
+  ["backface-hidden", { "backface-visibility": "hidden" }]
+];
+var cursors = [
+  [/^cursor-(.+)$/, ([, c]) => ({ cursor: c })]
+];
+var pointerEvents = [
+  ["pointer-events-none", { "pointer-events": "none" }],
+  ["pointer-events-auto", { "pointer-events": "auto" }]
+];
+var resizes = [
+  ["resize-none", { resize: "none" }],
+  ["resize-x", { resize: "horizontal" }],
+  ["resize-y", { resize: "vertical" }],
+  ["resize", { resize: "both" }]
+];
+var userSelects = [
+  ["select-none", { "user-select": "none" }],
+  ["select-text", { "user-select": "text" }],
+  ["select-all", { "user-select": "all" }],
+  ["select-auto", { "user-select": "auto" }]
+];
+var verticalAligns = [
+  ["vertical-baseline", { "vertical-align": "baseline" }],
+  ["vertical-top", { "vertical-align": "top" }],
+  ["vertical-middle", { "vertical-align": "middle" }],
+  ["vertical-text-top", { "vertical-align": "text-top" }],
+  ["vertical-text-bottom", { "vertical-align": "text-bottom" }]
+];
+var whitespaces = [
+  ["whitespace-normal", { "white-space": "normal" }],
+  ["whitespace-nowrap", { "white-space": "nowrap" }],
+  ["whitespace-pre", { "white-space": "pre" }],
+  ["whitespace-pre-line", { "white-space": "pre-line" }],
+  ["whitespace-pre-wrap", { "white-space": "pre-wrap" }]
+];
+var breaks = [
+  ["break-normal", { "overflow-wrap": "normal", "word-break": "normal" }],
+  ["break-works", { "overflow-wrap": "break-word" }],
+  ["break-all", { "word-break": "break-all" }]
+];
+var textOverflows = [
+  ["truncate", { "overflow": "hidden", "text-overflow": "ellipsis", "white-space": "nowrap" }],
+  ["text-ellipsis", { "text-overflow": "ellipsis" }],
+  ["text-clip", { "text-overflow": "clip" }]
+];
+var textTransforms = [
+  ["case-upper", { "text-transform": "uppercase" }],
+  ["case-lower", { "text-transform": "lowercase" }],
+  ["case-capital", { "text-transform": "capitalize" }],
+  ["case-normal", { "text-transform": "none" }]
+];
+var textDecorations = [
+  ["underline", { "text-decoration": "underline" }],
+  ["line-through", { "text-decoration": "line-through" }],
+  ["no-underline", { "text-decoration": "none" }]
+];
+var textAligns = [
+  ["text-center", { "text-align": "center" }],
+  ["text-left", { "text-align": "left" }],
+  ["text-right", { "text-align": "right" }],
+  ["text-justify", { "text-align": "justify" }]
+];
+
+// ../preset-uno/src/rules/transform.ts
+var transforms = [
+  [
+    "transform",
+    {
+      "--un-rotate": 0,
+      "--un-scale-x": 1,
+      "--un-scale-y": 1,
+      "--un-scale-z": 1,
+      "--un-skew-x": 0,
+      "--un-skew-y": 0,
+      "--un-translate-x": 0,
+      "--un-translate-y": 0,
+      "--un-translate-z": 0,
+      "transform": "rotate(var(--un-rotate)) scaleX(var(--un-scale-x)) scaleY(var(--un-scale-y)) scaleZ(var(--un-scale-z)) skewX(var(--un-skew-x)) skewY(var(--un-skew-y)) translateX(var(--un-translate-x)) translateY(var(--un-translate-y)) translateZ(var(--un-translate-z))"
+    }
+  ],
+  [/^translate()-([^-]+)$/, handleTranslate],
+  [/^translate-([xyz])-([^-]+)$/, handleTranslate],
+  [/^scale()-([^-]+)$/, handleScale],
+  [/^scale-([xyz])-([^-]+)$/, handleScale],
+  [/^rotate-([^-]+)(?:deg)?$/, handleRotate],
+  ["origin-center", { "transform-origin": "center" }],
+  ["origin-top", { "transform-origin": "top" }],
+  ["origin-top-right", { "transform-origin": "top right" }],
+  ["origin-right", { "transform-origin": "right" }],
+  ["origin-bottom-right", { "transform-origin": "bottom right" }],
+  ["origin-bottom", { "transform-origin": "bottom" }],
+  ["origin-bottom-left", { "transform-origin": "bottom left" }],
+  ["origin-left", { "transform-origin": "left" }],
+  ["origin-top-left", { "transform-origin": "top left" }]
+];
+function handleTranslate([, d, b]) {
+  const v = src_exports.handler.bracket.size(b);
+  if (v != null) {
+    return [
+      ...xyzMap[d].map((i) => [`--un-translate${i}`, v])
+    ];
+  }
+}
+function handleScale([, d, b]) {
+  const v = src_exports.handler.bracket.fraction.percent(b);
+  if (v != null) {
+    return [
+      ...xyzMap[d].map((i) => [`--un-scale${i}`, v])
+    ];
+  }
+}
+function handleRotate([, b]) {
+  const v = src_exports.handler.bracket.number(b);
+  if (v != null)
+    return { "--un-rotate": `${v}deg` };
+}
+
+// ../preset-uno/src/rules/index.ts
+var rules = [
+  paddings,
+  margins,
+  displays,
+  opacity,
+  bgColors,
+  borders,
+  borderColors,
+  borderStyles,
+  borderRadius,
+  fonts,
+  fontSizes,
+  fontWeights,
+  textOverflows,
+  textDecorations,
+  textTransforms,
+  textAligns,
+  textColors,
+  flex,
+  grids,
+  gaps,
+  positions,
+  sizes,
+  cursors,
+  appearances,
+  pointerEvents,
+  resizes,
+  verticalAligns,
+  userSelects,
+  whitespaces,
+  breaks,
+  trackings,
+  leadings,
+  overflows,
+  positions,
+  orders,
+  justifies,
+  justifyItems,
+  justifySelfs,
+  alignContents,
+  alignItems,
+  alignSelfs,
+  placeContents,
+  placeItems,
+  placeSelfs,
+  insets,
+  floats,
+  zIndexes,
+  objectPositions,
+  transitions,
+  filters,
+  transforms
+].flat(1);
+
+// ../preset-uno/src/theme/colors.ts
+var colors = {
+  black: "#000",
+  white: "#fff",
+  rose: {
+    50: "#fff1f2",
+    100: "#ffe4e6",
+    200: "#fecdd3",
+    300: "#fda4af",
+    400: "#fb7185",
+    500: "#f43f5e",
+    600: "#e11d48",
+    700: "#be123c",
+    800: "#9f1239",
+    900: "#881337"
+  },
+  pink: {
+    50: "#fdf2f8",
+    100: "#fce7f3",
+    200: "#fbcfe8",
+    300: "#f9a8d4",
+    400: "#f472b6",
+    500: "#ec4899",
+    600: "#db2777",
+    700: "#be185d",
+    800: "#9d174d",
+    900: "#831843"
+  },
+  fuchsia: {
+    50: "#fdf4ff",
+    100: "#fae8ff",
+    200: "#f5d0fe",
+    300: "#f0abfc",
+    400: "#e879f9",
+    500: "#d946ef",
+    600: "#c026d3",
+    700: "#a21caf",
+    800: "#86198f",
+    900: "#701a75"
+  },
+  purple: {
+    50: "#faf5ff",
+    100: "#f3e8ff",
+    200: "#e9d5ff",
+    300: "#d8b4fe",
+    400: "#c084fc",
+    500: "#a855f7",
+    600: "#9333ea",
+    700: "#7e22ce",
+    800: "#6b21a8",
+    900: "#581c87"
+  },
+  violet: {
+    50: "#f5f3ff",
+    100: "#ede9fe",
+    200: "#ddd6fe",
+    300: "#c4b5fd",
+    400: "#a78bfa",
+    500: "#8b5cf6",
+    600: "#7c3aed",
+    700: "#6d28d9",
+    800: "#5b21b6",
+    900: "#4c1d95"
+  },
+  indigo: {
+    50: "#eef2ff",
+    100: "#e0e7ff",
+    200: "#c7d2fe",
+    300: "#a5b4fc",
+    400: "#818cf8",
+    500: "#6366f1",
+    600: "#4f46e5",
+    700: "#4338ca",
+    800: "#3730a3",
+    900: "#312e81"
+  },
+  blue: {
+    50: "#eff6ff",
+    100: "#dbeafe",
+    200: "#bfdbfe",
+    300: "#93c5fd",
+    400: "#60a5fa",
+    500: "#3b82f6",
+    600: "#2563eb",
+    700: "#1d4ed8",
+    800: "#1e40af",
+    900: "#1e3a8a"
+  },
+  sky: {
+    50: "#f0f9ff",
+    100: "#e0f2fe",
+    200: "#bae6fd",
+    300: "#7dd3fc",
+    400: "#38bdf8",
+    500: "#0ea5e9",
+    600: "#0284c7",
+    700: "#0369a1",
+    800: "#075985",
+    900: "#0c4a6e"
+  },
+  cyan: {
+    50: "#ecfeff",
+    100: "#cffafe",
+    200: "#a5f3fc",
+    300: "#67e8f9",
+    400: "#22d3ee",
+    500: "#06b6d4",
+    600: "#0891b2",
+    700: "#0e7490",
+    800: "#155e75",
+    900: "#164e63"
+  },
+  teal: {
+    50: "#f0fdfa",
+    100: "#ccfbf1",
+    200: "#99f6e4",
+    300: "#5eead4",
+    400: "#2dd4bf",
+    500: "#14b8a6",
+    600: "#0d9488",
+    700: "#0f766e",
+    800: "#115e59",
+    900: "#134e4a"
+  },
+  emerald: {
+    50: "#ecfdf5",
+    100: "#d1fae5",
+    200: "#a7f3d0",
+    300: "#6ee7b7",
+    400: "#34d399",
+    500: "#10b981",
+    600: "#059669",
+    700: "#047857",
+    800: "#065f46",
+    900: "#064e3b"
+  },
+  green: {
+    50: "#f0fdf4",
+    100: "#dcfce7",
+    200: "#bbf7d0",
+    300: "#86efac",
+    400: "#4ade80",
+    500: "#22c55e",
+    600: "#16a34a",
+    700: "#15803d",
+    800: "#166534",
+    900: "#14532d"
+  },
+  lime: {
+    50: "#f7fee7",
+    100: "#ecfccb",
+    200: "#d9f99d",
+    300: "#bef264",
+    400: "#a3e635",
+    500: "#84cc16",
+    600: "#65a30d",
+    700: "#4d7c0f",
+    800: "#3f6212",
+    900: "#365314"
+  },
+  yellow: {
+    50: "#fefce8",
+    100: "#fef9c3",
+    200: "#fef08a",
+    300: "#fde047",
+    400: "#facc15",
+    500: "#eab308",
+    600: "#ca8a04",
+    700: "#a16207",
+    800: "#854d0e",
+    900: "#713f12"
+  },
+  amber: {
+    50: "#fffbeb",
+    100: "#fef3c7",
+    200: "#fde68a",
+    300: "#fcd34d",
+    400: "#fbbf24",
+    500: "#f59e0b",
+    600: "#d97706",
+    700: "#b45309",
+    800: "#92400e",
+    900: "#78350f"
+  },
+  orange: {
+    50: "#fff7ed",
+    100: "#ffedd5",
+    200: "#fed7aa",
+    300: "#fdba74",
+    400: "#fb923c",
+    500: "#f97316",
+    600: "#ea580c",
+    700: "#c2410c",
+    800: "#9a3412",
+    900: "#7c2d12"
+  },
+  red: {
+    50: "#fef2f2",
+    100: "#fee2e2",
+    200: "#fecaca",
+    300: "#fca5a5",
+    400: "#f87171",
+    500: "#ef4444",
+    600: "#dc2626",
+    700: "#b91c1c",
+    800: "#991b1b",
+    900: "#7f1d1d"
+  },
+  warmgray: {
+    50: "#fafaf9",
+    100: "#f5f5f4",
+    200: "#e7e5e4",
+    300: "#d6d3d1",
+    400: "#a8a29e",
+    500: "#78716c",
+    600: "#57534e",
+    700: "#44403c",
+    800: "#292524",
+    900: "#1c1917"
+  },
+  truegray: {
+    50: "#fafafa",
+    100: "#f5f5f5",
+    200: "#e5e5e5",
+    300: "#d4d4d4",
+    400: "#a3a3a3",
+    500: "#737373",
+    600: "#525252",
+    700: "#404040",
+    800: "#262626",
+    900: "#171717"
+  },
+  gray: {
+    50: "#fafafa",
+    100: "#f4f4f5",
+    200: "#e4e4e7",
+    300: "#d4d4d8",
+    400: "#a1a1aa",
+    500: "#71717a",
+    600: "#52525b",
+    700: "#3f3f46",
+    800: "#27272a",
+    900: "#18181b"
+  },
+  coolgray: {
+    50: "#f9fafb",
+    100: "#f3f4f6",
+    200: "#e5e7eb",
+    300: "#d1d5db",
+    400: "#9ca3af",
+    500: "#6b7280",
+    600: "#4b5563",
+    700: "#374151",
+    800: "#1f2937",
+    900: "#111827"
+  },
+  bluegray: {
+    50: "#f8fafc",
+    100: "#f1f5f9",
+    200: "#e2e8f0",
+    300: "#cbd5e1",
+    400: "#94a3b8",
+    500: "#64748b",
+    600: "#475569",
+    700: "#334155",
+    800: "#1e293b",
+    900: "#0f172a"
+  },
+  light: {
+    50: "#fdfdfd",
+    100: "#fcfcfc",
+    200: "#fafafa",
+    300: "#f8f9fa",
+    400: "#f6f6f6",
+    500: "#f2f2f2",
+    600: "#f1f3f5",
+    700: "#e9ecef",
+    800: "#dee2e6",
+    900: "#dde1e3"
+  },
+  dark: {
+    50: "#4a4a4a",
+    100: "#3c3c3c",
+    200: "#323232",
+    300: "#2d2d2d",
+    400: "#222222",
+    500: "#1f1f1f",
+    600: "#1c1c1e",
+    700: "#1b1b1b",
+    800: "#181818",
+    900: "#0f0f0f"
+  }
+};
+Object.values(colors).forEach((color) => {
+  if (typeof color !== "string") {
+    color.DEFAULT = color.DEFAULT || color[400];
+    Object.keys(color).forEach((key) => {
+      const short = +key / 100;
+      if (short === Math.round(short))
+        color[short] = color[key];
+    });
+  }
+});
+
+// ../preset-uno/src/theme/font.ts
+var fontFamily = {
+  sans: [
+    "ui-sans-serif",
+    "system-ui",
+    "-apple-system",
+    "BlinkMacSystemFont",
+    '"Segoe UI"',
+    "Roboto",
+    '"Helvetica Neue"',
+    "Arial",
+    '"Noto Sans"',
+    "sans-serif",
+    '"Apple Color Emoji"',
+    '"Segoe UI Emoji"',
+    '"Segoe UI Symbol"',
+    '"Noto Color Emoji"'
+  ].join(","),
+  serif: [
+    "ui-serif",
+    "Georgia",
+    "Cambria",
+    '"Times New Roman"',
+    "Times",
+    "serif"
+  ].join(","),
+  mono: [
+    "ui-monospace",
+    "SFMono-Regular",
+    "Menlo",
+    "Monaco",
+    "Consolas",
+    '"Liberation Mono"',
+    '"Courier New"',
+    "monospace"
+  ].join(",")
+};
+var fontSize = {
+  "xs": ["0.75rem", "1rem"],
+  "sm": ["0.875rem", "1.25rem"],
+  "base": ["1rem", "1.5rem"],
+  "lg": ["1.125rem", "1.75rem"],
+  "xl": ["1.25rem", "1.75rem"],
+  "2xl": ["1.5rem", "2rem"],
+  "3xl": ["1.875rem", "2.25rem"],
+  "4xl": ["2.25rem", "2.5rem"],
+  "5xl": ["3rem", "1"],
+  "6xl": ["3.75rem", "1"],
+  "7xl": ["4.5rem", "1"],
+  "8xl": ["6rem", "1"],
+  "9xl": ["8rem", "1"]
+};
+var lineHeight = {
+  none: "1",
+  tight: "1.25",
+  snug: "1.375",
+  normal: "1.5",
+  relaxed: "1.625",
+  loose: "2"
+};
+var letterSpacing = {
+  tighter: "-0.05em",
+  tight: "-0.025em",
+  normal: "0em",
+  wide: "0.025em",
+  wider: "0.05em",
+  widest: "0.1em"
+};
+
+// ../preset-uno/src/theme/index.ts
+var breakpoints = {
+  "sm": "640px",
+  "md": "768px",
+  "lg": "1024px",
+  "xl": "1280px",
+  "2xl": "1536px"
+};
+var borderRadius2 = {
+  "DEFAULT": "0.25rem",
+  "none": "0px",
+  "sm": "0.125rem",
+  "md": "0.375rem",
+  "lg": "0.5rem",
+  "xl": "0.75rem",
+  "2xl": "1rem",
+  "3xl": "1.5rem",
+  "full": "9999px"
+};
+var theme = {
+  colors,
+  fontFamily,
+  fontSize,
+  breakpoints,
+  borderRadius: borderRadius2,
+  lineHeight,
+  letterSpacing
+};
+
+// ../preset-uno/src/variants/breakpoints.ts
+var regexCache = {};
+var variantBreakpoints = {
+  match(input, theme2) {
+    for (const point of Object.keys(theme2.breakpoints || {})) {
+      if (!regexCache[point])
+        regexCache[point] = new RegExp(`^((?:lt-)?${point}[:-])`);
+      const match = input.match(regexCache[point]);
+      if (match)
+        return input.slice(match[1].length);
+    }
+  },
+  mediaQuery(input, theme2) {
+    var _a;
+    const [, d, s] = input.match(/^(lt-)?(\w+)[:-]/) || [];
+    if (!s)
+      return;
+    let direction = "min";
+    if (d === "lt-")
+      direction = "max";
+    const point = (_a = theme2.breakpoints) == null ? void 0 : _a[s];
+    if (point)
+      return `@media (${direction}-width: ${point})`;
+  }
+};
+
+// ../core/src/utils/basic.ts
+function toArray2(value = []) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// ../core/src/utils/variant.ts
+var variantMatcher = (name) => {
+  const length = name.length + 1;
+  const re = new RegExp(`^${name}[:-]`);
+  return (input) => input.match(re) ? input.slice(length) : void 0;
+};
+
+// ../preset-uno/src/variants/children.ts
+var variantChildren = [
+  {
+    match: variantMatcher("children"),
+    selector: (input) => `${input} > *`
+  },
+  {
+    match: variantMatcher("all"),
+    selector: (input) => `${input} *`
+  }
+];
+
+// ../preset-uno/src/variants/dark.ts
+var variantColorsClass = [
+  {
+    match: variantMatcher("dark"),
+    selector: (input) => `.dark $$ ${input}`
+  },
+  {
+    match: variantMatcher("light"),
+    selector: (input) => `.light $$ ${input}`
+  }
+];
+var variantColorsMedia = [
+  {
+    match: variantMatcher("dark"),
+    mediaQuery: () => "@media (prefers-color-scheme: dark)"
+  },
+  {
+    match: variantMatcher("light"),
+    mediaQuery: () => "@media (prefers-color-scheme: light)"
+  }
+];
+
+// ../preset-uno/src/variants/pseudo.ts
+function createPseudoClassVariant(name, pseudo = name) {
+  return [
+    {
+      match: variantMatcher(name),
+      selector: (input) => `${input}:${pseudo}`
+    },
+    {
+      match: variantMatcher(`not-${name}`),
+      selector: (input) => `${input}:not(:${pseudo})`
+    },
+    {
+      match: variantMatcher(`group-${name}`),
+      selector: (input) => `.group:${pseudo} ${input}`
+    }
+  ];
+}
+function createPseudoElementVariant(name) {
+  return {
+    match: variantMatcher(name),
+    selector: (input) => `${input}::${name}`
+  };
+}
+var variantPseudoClasses = [
+  "active",
+  "checked",
+  "default",
+  "empty",
+  "enabled",
+  "first-of-type",
+  "first",
+  "focus-visible",
+  "focus-within",
+  "focus",
+  "hover",
+  "indeterminate",
+  "invalid",
+  "last-of-type",
+  "last",
+  "link",
+  "only-child",
+  "only-of-type",
+  "optional",
+  "placeholder-shown",
+  "read-only",
+  "read-write",
+  "required",
+  "root",
+  "target",
+  "valid",
+  "visited",
+  ["even-of-type", "nth-of-type(even)"],
+  ["even", "nth-child(even)"],
+  ["odd-of-type", "nth-of-type(odd)"],
+  ["odd", "nth-child(odd)"]
+].flatMap((i) => createPseudoClassVariant(...toArray2(i)));
+var variantPseudoElements = [
+  "before",
+  "after",
+  "first-letter",
+  "first-line",
+  "selection"
+].map(createPseudoElementVariant);
+
+// ../preset-uno/src/variants/index.ts
+var variantImportant = {
+  match: (input) => input.startsWith("!") ? input.slice(1) : void 0,
+  rewrite: (input) => {
+    input.forEach((v) => {
+      if (v[1])
+        v[1] += " !important";
+    });
+    return input;
+  }
+};
+var variantNegative = {
+  match: (input) => input.startsWith("-") ? input.slice(1) : void 0,
+  rewrite: (input) => {
+    input.forEach((v) => {
+      var _a;
+      if ((_a = v[1]) == null ? void 0 : _a.toString().match(/^\d/))
+        v[1] = `-${v[1]}`;
+    });
+    return input;
+  }
+};
+var variants = [
+  variantNegative,
+  variantImportant,
+  variantBreakpoints,
+  ...variantChildren,
+  ...variantColorsClass,
+  ...variantPseudoClasses,
+  ...variantPseudoElements
+];
+
+// ../preset-uno/src/index.ts
+var preset = () => ({
+  theme,
+  rules,
+  variants
+});
+var src_default = preset;
+
+// ../preset-attributify/src/index.ts
+import { extractorSplit } from "@unocss/core";
+
+// ../preset-attributify/src/extractor.ts
+import { isValidSelector } from "@unocss/core";
+var strippedPrefixes = [
+  "v-bind:",
+  ":"
+];
+var splitterRE = /[\s'"`;]/g;
+var valuedAttributeRE = /([\w:-]+)(?:=(["'])([^\2]+?)\2)?/g;
+var extractorAttributify = (options) => (code) => {
+  const result = Array.from(code.matchAll(valuedAttributeRE)).flatMap(([, name, _, content]) => {
+    for (const prefix of strippedPrefixes) {
+      if (name.startsWith(prefix)) {
+        name = name.slice(prefix.length);
+        break;
+      }
+    }
+    if (!content) {
+      if (isValidSelector(name) && (options == null ? void 0 : options.nonValuedAttribute) !== false)
+        return [`[${name}=""]`];
+      return [];
+    }
+    if (["class", "className"].includes(name)) {
+      return content.split(splitterRE).filter(isValidSelector);
+    } else {
+      return content.split(splitterRE).filter(Boolean).map((v) => `[${name}~="${v}"]`);
+    }
+  });
+  return new Set(result);
+};
+
+// ../preset-attributify/src/variant.ts
+import { isAttributifySelector } from "@unocss/core";
+var variantsRE = /^(.+\:\!?)?(.*?)$/;
+var variantAttributify = (options = {}) => {
+  var _a;
+  const prefix = (_a = options.prefix) != null ? _a : "un-";
+  return {
+    match(input) {
+      const match = isAttributifySelector(input);
+      if (!match)
+        return;
+      let name = match[1];
+      if (name.startsWith(prefix))
+        name = name.slice(prefix.length);
+      else if (options.prefixedOnly)
+        return;
+      const content = match[2];
+      const [, variants2 = "", body = content] = content.match(variantsRE) || [];
+      if (body === "~" || !body)
+        return `${variants2}${name}`;
+      else
+        return `${variants2}${name}-${body}`;
+    }
+  };
+};
+
+// ../preset-attributify/src/index.ts
+var preset2 = (options) => {
+  const variants2 = [
+    variantAttributify(options)
+  ];
+  const extractors = [
+    extractorAttributify(options)
+  ];
+  if (!(options == null ? void 0 : options.strict))
+    extractors.unshift(extractorSplit);
+  return {
+    variants: variants2,
+    extractors
+  };
+};
+var src_default2 = preset2;
+
+// src/index.ts
+import { loadConfig as loadConfig2 } from "@unocss/config";
+
+// src/context.ts
+function createContext(uno, config, configFilepath) {
+  const invalidations = [];
+  const modules = new src_exports.BetterMap();
+  const tokens = new Set();
+  function invalidate() {
+    invalidations.forEach((cb) => cb());
+  }
+  async function scan(code, id) {
+    if (id)
+      modules.set(id, code);
+    await uno.applyExtractors(code, id, tokens);
+    invalidate();
+  }
+  return {
+    tokens,
+    modules,
+    invalidate,
+    onInvalidate(fn) {
+      invalidations.push(fn);
+    },
+    uno,
+    scan,
+    config,
+    configFilepath
+  };
+}
+
+// src/chunk-build.ts
+import { createFilter } from "@rollup/pluginutils";
+
+// src/utils.ts
+import { createHash } from "crypto";
+var defaultExclude = [/[\/\\]node_modules[\/\\]/, /[\/\\]dist[\/\\]/, /\.(css|postcss|sass|scss|less|stylus|styl)$/];
+var defaultInclude = [/\.vue$/, /\.vue\?vue/, /\.svelte$/, /\.[jt]sx$/, /\.mdx?$/];
+function getHash(input, length = 8) {
+  return createHash("sha256").update(input).digest("hex").substr(0, length);
+}
+
+// src/chunk-build.ts
+function ChunkModeBuildPlugin({ uno, config }) {
+  let cssPlugin;
+  const filter = createFilter(config.include || defaultInclude, config.exclude || defaultExclude);
+  const files = {};
+  return {
+    name: "unocss:chunk",
+    apply: "build",
+    enforce: "pre",
+    configResolved(config2) {
+      cssPlugin = config2.plugins.find((i) => i.name === "vite:css-post");
+    },
+    transform(code, id) {
+      if (!filter(id))
+        return;
+      files[id] = code;
+      return null;
+    },
+    async renderChunk(_, chunk) {
+      const chunks = Object.keys(chunk.modules).map((i) => files[i]).filter(Boolean);
+      if (!chunks.length)
+        return null;
+      const tokens = new Set();
+      await Promise.all(chunks.map((c) => uno.applyExtractors(c, void 0, tokens)));
+      const { css } = await uno.generate(tokens);
+      const fakeCssId = `${chunk.fileName}.css`;
+      await cssPlugin.transform(css, fakeCssId);
+      chunk.modules[fakeCssId] = {
+        code: null,
+        originalLength: 0,
+        removedExports: [],
+        renderedExports: [],
+        renderedLength: 0
+      };
+      return null;
+    },
+    async transformIndexHtml(code) {
+      const { css } = await uno.generate(code);
+      if (css)
+        return `${code}<style>${css}</style>`;
+    }
+  };
+}
+
+// src/global-dev.ts
+import { createFilter as createFilter2 } from "@rollup/pluginutils";
+var VIRTUAL_ENTRY = "/@unocss-entry";
+var READY_CALLBACK = "/__unocss_ready";
+function GlobalModeDevPlugin({ config, uno, tokens, onInvalidate, scan }) {
+  let server;
+  const filter = createFilter2(config.include || defaultInclude, config.exclude || defaultExclude);
+  const tasks = [];
+  let timer;
+  let lastUpdate = +new Date();
+  function invalidate() {
+    if (!server)
+      return;
+    const mod = server.moduleGraph.getModuleById(VIRTUAL_ENTRY);
+    if (!mod)
+      return;
+    lastUpdate = +new Date();
+    server.moduleGraph.invalidateModule(mod);
+    clearTimeout(timer);
+    timer = setTimeout(sendUpdate, 10);
+  }
+  function sendUpdate() {
+    server.ws.send({
+      type: "update",
+      updates: [{
+        acceptedPath: VIRTUAL_ENTRY,
+        path: VIRTUAL_ENTRY,
+        timestamp: lastUpdate,
+        type: "js-update"
+      }]
+    });
+  }
+  onInvalidate(invalidate);
+  return {
+    name: "unocss:global",
+    apply: "serve",
+    enforce: "pre",
+    configureServer(_server) {
+      server = _server;
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url === READY_CALLBACK) {
+          let body = "";
+          await new Promise((resolve) => {
+            req.on("data", (chunk) => {
+              body += chunk;
+            });
+            req.on("end", resolve);
+          });
+          if (+body !== lastUpdate)
+            sendUpdate();
+          res.statusCode = 200;
+          res.end();
+        } else {
+          return next();
+        }
+      });
+    },
+    transform(code, id) {
+      if (!filter(id))
+        return;
+      scan(code, id);
+      return null;
+    },
+    resolveId(id) {
+      return id === VIRTUAL_ENTRY ? id : null;
+    },
+    async load(id) {
+      if (id !== VIRTUAL_ENTRY)
+        return null;
+      await Promise.all(tasks);
+      const { css } = await uno.generate(tokens);
+      return `
+import { updateStyle, removeStyle } from "/@vite/client";
+const id = "${VIRTUAL_ENTRY}"
+import.meta.hot.accept()
+import.meta.hot.prune(() => removeStyle(id))
+const css = ${JSON.stringify(`/* unocss */
+${css}`)}
+updateStyle(id, css)
+export default css
+fetch('${READY_CALLBACK}', { method: 'POST', body: '${lastUpdate}' })
+`;
+    },
+    transformIndexHtml: {
+      enforce: "pre",
+      async transform(code, { path }) {
+        tasks.push(scan(code, path));
+        return `${code}<script src="${VIRTUAL_ENTRY}" type="module"><\/script>`;
+      }
+    }
+  };
+}
+
+// src/per-module.ts
+import { createFilter as createFilter3 } from "@rollup/pluginutils";
+var VIRTUAL_PREFIX = "/@unocss/";
+var SCOPE_IMPORT_RE = / from (['"])(@unocss\/scope)\1/;
+function PerModuleModePlugin({ uno, config }) {
+  const moduleMap = new Map();
+  let server;
+  const filter = createFilter3(config.include || defaultInclude, config.exclude || defaultExclude);
+  const invalidate = (hash) => {
+    if (!server)
+      return;
+    const id = `${VIRTUAL_PREFIX}${hash}.css`;
+    const mod = server.moduleGraph.getModuleById(id);
+    if (!mod)
+      return;
+    server.moduleGraph.invalidateModule(mod);
+    server.ws.send({
+      type: "update",
+      updates: [{
+        acceptedPath: id,
+        path: id,
+        timestamp: +Date.now(),
+        type: "js-update"
+      }]
+    });
+  };
+  return {
+    name: "unocss:module-scope",
+    enforce: "post",
+    configureServer(_server) {
+      server = _server;
+    },
+    async transform(code, id) {
+      if (!filter(id))
+        return;
+      const hash = getHash(id);
+      const hasScope = code.match(SCOPE_IMPORT_RE);
+      const { css } = await uno.generate(code, id, hasScope ? `.${hash}` : void 0);
+      if (!css && !hasScope)
+        return null;
+      if (hasScope)
+        code = code.replace(SCOPE_IMPORT_RE, ` from 'data:text/javascript;base64,${Buffer.from(`export default () => "${hash}"`).toString("base64")}'`);
+      moduleMap.set(hash, [id, css]);
+      invalidate(hash);
+      return {
+        code: `import "${VIRTUAL_PREFIX}${hash}.css";${code}`,
+        map: null
+      };
+    },
+    resolveId(id) {
+      return id.startsWith(VIRTUAL_PREFIX) ? id : null;
+    },
+    load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX))
+        return null;
+      const hash = id.slice(VIRTUAL_PREFIX.length, -".css".length);
+      const [source, css] = moduleMap.get(hash) || [];
+      if (source)
+        this.addWatchFile(source);
+      return `
+/* unocss ${source} */
+${css}`;
+    }
+  };
+}
+
+// src/vue-scoped.ts
+import { createFilter as createFilter4 } from "@rollup/pluginutils";
+function VueScopedPlugin({ uno, config }) {
+  const filter = createFilter4(config.include || [/\.vue$/], config.exclude || defaultExclude);
+  async function transformSFC(code) {
+    const { css } = await uno.generate(code);
+    if (!css)
+      return null;
+    return `${code}
+<style scoped>${css}</style>`;
+  }
+  return {
+    name: "unocss:vue-scoped",
+    enforce: "pre",
+    transform(code, id) {
+      if (!filter(id))
+        return;
+      return transformSFC(code);
+    },
+    handleHotUpdate(ctx) {
+      const read = ctx.read;
+      if (filter(ctx.file)) {
+        ctx.read = async () => {
+          const code = await read();
+          return await transformSFC(code) || code;
+        };
+      }
+    }
+  };
+}
+
+// src/global-build.ts
+import { createFilter as createFilter5 } from "@rollup/pluginutils";
+var VIRTUAL_ENTRY2 = "/@unocss/entry.css";
+var PLACEHOLDER = "#--unocss--{--unocss:true}";
+var PLACEHOLDER_RE = /#--unocss--\s*{\s*--unocss:\s*true;?\s*}/;
+function GlobalModeBuildPlugin({ uno, config, scan, tokens }) {
+  const filter = createFilter5(config.include || defaultInclude, config.exclude || defaultExclude);
+  const tasks = [];
+  return [
+    {
+      name: "unocss:global:build:scan",
+      apply: "build",
+      enforce: "pre",
+      transform(code, id) {
+        if (!filter(id))
+          return;
+        tasks.push(scan(code, id));
+        return null;
+      },
+      resolveId(id) {
+        return id === VIRTUAL_ENTRY2 ? id : null;
+      },
+      async load(id) {
+        if (id !== VIRTUAL_ENTRY2)
+          return null;
+        return PLACEHOLDER;
+      },
+      transformIndexHtml: {
+        enforce: "pre",
+        transform(code, { path }) {
+          tasks.push(scan(code, path));
+          return `${code}<script src="${VIRTUAL_ENTRY2}" type="module"><\/script>`;
+        }
+      }
+    },
+    {
+      name: "unocss:global:build:generate",
+      apply(options, { command }) {
+        var _a;
+        return command === "build" && !((_a = options.build) == null ? void 0 : _a.ssr);
+      },
+      enforce: "post",
+      async generateBundle(options, bundle) {
+        const keys = Object.keys(bundle).filter((i) => i.endsWith(".css"));
+        await Promise.all(tasks);
+        const { css } = await uno.generate(tokens);
+        let replaced = false;
+        if (!css)
+          return;
+        for (const key of keys) {
+          const chunk = bundle[key];
+          if (chunk.type === "asset" && typeof chunk.source === "string") {
+            if (PLACEHOLDER_RE.test(chunk.source)) {
+              chunk.source = chunk.source.replace(PLACEHOLDER_RE, css);
+              replaced = true;
+            }
+          }
+        }
+        if (!replaced)
+          this.error(new Error("[unocss] does not found CSS placeholder in the generated chunks,\nthis is likely an internal bug of unocss vite plugin"));
+      }
+    }
+  ];
+}
+
+// src/config-hmr.ts
+import { loadConfig } from "@unocss/config";
+function ConfigHMRPlugin({ uno, configFilepath: filepath, invalidate, tokens, modules }) {
+  if (!filepath)
+    return;
+  return {
+    name: "unocss:config",
+    configureServer(server) {
+      server.watcher.add(filepath);
+      server.watcher.on("change", async (p) => {
+        if (p !== filepath)
+          return;
+        uno.setConfig(loadConfig(filepath).config);
+        tokens.clear();
+        await Promise.all(modules.map((code, id) => uno.applyExtractors(code, id, tokens)));
+        invalidate();
+      });
+    }
+  };
+}
+
+// src/index.ts
+function UnocssPlugin(configOrPath, defaults = {
+  presets: [
+    src_default()
+  ]
+}) {
+  var _a;
+  const { config = {}, filepath } = loadConfig2(configOrPath);
+  const mode = (_a = config.mode) != null ? _a : "global";
+  const uno = (0, src_exports.createGenerator)(config, defaults);
+  const ctx = createContext(uno, config, filepath);
+  const plugins = [
+    ConfigHMRPlugin(ctx)
+  ];
+  if (mode === "per-module") {
+    plugins.push(PerModuleModePlugin(ctx));
+  } else if (mode === "vue-scoped") {
+    plugins.push(VueScopedPlugin(ctx));
+  } else if (mode === "global") {
+    plugins.push(...GlobalModeBuildPlugin(ctx), GlobalModeDevPlugin(ctx));
+  } else if (mode === "dist-chunk") {
+    plugins.push(ChunkModeBuildPlugin(ctx), GlobalModeDevPlugin(ctx));
+  } else {
+    throw new Error(`[unocss] unknown mode "${mode}"`);
+  }
+  return plugins.filter(Boolean);
+}
+export {
+  ChunkModeBuildPlugin,
+  GlobalModeDevPlugin,
+  PerModuleModePlugin,
+  VueScopedPlugin,
+  UnocssPlugin as default
+};