@unocss/preset-uno 0.1.0-beta.2 → 0.1.3

package/dist/chunk-S7XMIAO4.mjs

@@ -0,0 +1,742 @@
+import {
+  theme
+} from "./chunk-S5DFLDKC.mjs";
+import {
+  variants
+} from "./chunk-GZCILHEZ.mjs";
+import {
+  __export,
+  __reExport
+} from "./chunk-C52N6GD5.mjs";
+
+// 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)" }]
+];
+
+// src/rules/border.ts
+import { handler as h } from "@unocss/core";
+
+// 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"]
+};
+
+// 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]);
+}
+
+// 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.replace(/([a-z])([0-9])/g, "$1-$2").split(/-/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) })]
+];
+
+// 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%)" }]
+];
+
+// 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" }]
+];
+
+// 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 };
+  }]
+];
+
+// 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
+      };
+    }
+  }]
+];
+
+// 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, " ") })]
+];
+
+// 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]
+];
+
+// 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" }]
+];
+
+// 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) })]
+];
+
+// 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")]
+];
+
+// 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" }]
+];
+
+// ../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";
+
+// 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 elementRE = /<[\w:\.$-]+\s((?:'[\s\S]*?'|"[\s\S]*?"|`[\s\S]*?`|\{[\s\S]*?\}|[\s\S]*?)*?)>/g;
+var valuedAttributeRE = /([\w:-]+)(?:=(["'])([^\2]+?)\2)?/g;
+var extractorAttributify = (options) => (code) => {
+  const result = Array.from(code.matchAll(elementRE)).flatMap((match) => Array.from((match[1] || "").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/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` };
+}
+
+// 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);
+
+export {
+  rules,
+  preset,
+  src_default
+};