import { match as o, matchTheme as e, matchColor as n, asArray as W, arbitrary as V, mql as O, toColorValue as v, toCSS as b } from "../../../../@twind_core@1.1.3_typescript@5.8.3/node_modules/@twind/core/core.js";
let D = [
  /* arbitrary properties: [paint-order:markers] */
  o("\\[([-\\w]+):(.+)]", ({ 1: t, 2: r }, i) => ({
    "@layer overrides": {
      "&": {
        [t]: V(`[${r}]`, "", i)
      }
    }
  })),
  /* Styling based on parent and peer state */
  o("(group|peer)([~/][^-[]+)?", ({ input: t }, { h: r }) => [
    {
      c: r(t)
    }
  ]),
  /* LAYOUT */
  e("aspect-", "aspectRatio"),
  o("container", (t, { theme: r }) => {
    let { screens: i = r("screens"), center: a, padding: l } = r("container"), d = {
      width: "100%",
      marginRight: a && "auto",
      marginLeft: a && "auto",
      ...p("xs")
    };
    for (let u in i) {
      let w = i[u];
      typeof w == "string" && (d[O(w)] = {
        "&": {
          maxWidth: w,
          ...p(u)
        }
      });
    }
    return d;
    function p(u) {
      let w = l && (typeof l == "string" ? l : l[u] || l.DEFAULT);
      if (w) return {
        paddingRight: w,
        paddingLeft: w
      };
    }
  }),
  // Content
  e("content-", "content", ({ _: t }) => ({
    "--tw-content": t,
    content: "var(--tw-content)"
  })),
  // Box Decoration Break
  o("(?:box-)?decoration-(slice|clone)", "boxDecorationBreak"),
  // Box Sizing
  o("box-(border|content)", "boxSizing", ({ 1: t }) => t + "-box"),
  // Display
  o("hidden", {
    display: "none"
  }),
  // Table Layout
  o("table-(auto|fixed)", "tableLayout"),
  o([
    "(block|flex|table|grid|inline|contents|flow-root|list-item)",
    "(inline-(block|flex|table|grid))",
    "(table-(caption|cell|column|row|(column|row|footer|header)-group))"
  ], "display"),
  // Floats
  "(float)-(left|right|none)",
  // Clear
  "(clear)-(left|right|none|both)",
  // Overflow
  "(overflow(?:-[xy])?)-(auto|hidden|clip|visible|scroll)",
  // Isolation
  "(isolation)-(auto)",
  // Isolation
  o("isolate", "isolation"),
  // Object Fit
  o("object-(contain|cover|fill|none|scale-down)", "objectFit"),
  // Object Position
  e("object-", "objectPosition"),
  o("object-(top|bottom|center|(left|right)(-(top|bottom))?)", "objectPosition", y),
  // Overscroll Behavior
  o("overscroll(-[xy])?-(auto|contain|none)", ({ 1: t = "", 2: r }) => ({
    ["overscroll-behavior" + t]: r
  })),
  // Position
  o("(static|fixed|absolute|relative|sticky)", "position"),
  // Top / Right / Bottom / Left
  e("-?inset(-[xy])?(?:$|-)", "inset", ({ 1: t, _: r }) => ({
    top: t != "-x" && r,
    right: t != "-y" && r,
    bottom: t != "-x" && r,
    left: t != "-y" && r
  })),
  e("-?(top|bottom|left|right)(?:$|-)", "inset"),
  // Visibility
  o("(visible|collapse)", "visibility"),
  o("invisible", {
    visibility: "hidden"
  }),
  // Z-Index
  e("-?z-", "zIndex"),
  /* FLEXBOX */
  // Flex Direction
  o("flex-((row|col)(-reverse)?)", "flexDirection", x),
  o("flex-(wrap|wrap-reverse|nowrap)", "flexWrap"),
  e("(flex-(?:grow|shrink))(?:$|-)"),
  /*, 'flex-grow' | flex-shrink */
  e("(flex)-"),
  /*, 'flex' */
  e("grow(?:$|-)", "flexGrow"),
  e("shrink(?:$|-)", "flexShrink"),
  e("basis-", "flexBasis"),
  e("-?(order)-"),
  /*, 'order' */
  "-?(order)-(\\d+)",
  /* GRID */
  // Grid Template Columns
  e("grid-cols-", "gridTemplateColumns"),
  o("grid-cols-(\\d+)", "gridTemplateColumns", C),
  // Grid Column Start / End
  e("col-", "gridColumn"),
  o("col-(span)-(\\d+)", "gridColumn", $),
  e("col-start-", "gridColumnStart"),
  o("col-start-(auto|\\d+)", "gridColumnStart"),
  e("col-end-", "gridColumnEnd"),
  o("col-end-(auto|\\d+)", "gridColumnEnd"),
  // Grid Template Rows
  e("grid-rows-", "gridTemplateRows"),
  o("grid-rows-(\\d+)", "gridTemplateRows", C),
  // Grid Row Start / End
  e("row-", "gridRow"),
  o("row-(span)-(\\d+)", "gridRow", $),
  e("row-start-", "gridRowStart"),
  o("row-start-(auto|\\d+)", "gridRowStart"),
  e("row-end-", "gridRowEnd"),
  o("row-end-(auto|\\d+)", "gridRowEnd"),
  // Grid Auto Flow
  o("grid-flow-((row|col)(-dense)?)", "gridAutoFlow", (t) => y(x(t))),
  o("grid-flow-(dense)", "gridAutoFlow"),
  // Grid Auto Columns
  e("auto-cols-", "gridAutoColumns"),
  // Grid Auto Rows
  e("auto-rows-", "gridAutoRows"),
  // Gap
  e("gap-x(?:$|-)", "gap", "columnGap"),
  e("gap-y(?:$|-)", "gap", "rowGap"),
  e("gap(?:$|-)", "gap"),
  /* BOX ALIGNMENT */
  // Justify Items
  // Justify Self
  "(justify-(?:items|self))-",
  // Justify Content
  o("justify-", "justifyContent", k),
  // Align Content
  // Align Items
  // Align Self
  o("(content|items|self)-", (t) => ({
    ["align-" + t[1]]: k(t)
  })),
  // Place Content
  // Place Items
  // Place Self
  o("(place-(content|items|self))-", ({ 1: t, $$: r }) => ({
    [t]: ("wun".includes(r[3]) ? "space-" : "") + r
  })),
  /* SPACING */
  // Padding
  e("p([xytrbl])?(?:$|-)", "padding", f("padding")),
  // Margin
  e("-?m([xytrbl])?(?:$|-)", "margin", f("margin")),
  // Space Between
  e("-?space-(x|y)(?:$|-)", "space", ({ 1: t, _: r }) => ({
    "&>:not([hidden])~:not([hidden])": {
      [`--tw-space-${t}-reverse`]: "0",
      ["margin-" + {
        y: "top",
        x: "left"
      }[t]]: `calc(${r} * calc(1 - var(--tw-space-${t}-reverse)))`,
      ["margin-" + {
        y: "bottom",
        x: "right"
      }[t]]: `calc(${r} * var(--tw-space-${t}-reverse))`
    }
  })),
  o("space-(x|y)-reverse", ({ 1: t }) => ({
    "&>:not([hidden])~:not([hidden])": {
      [`--tw-space-${t}-reverse`]: "1"
    }
  })),
  /* SIZING */
  // Width
  e("w-", "width"),
  // Min-Width
  e("min-w-", "minWidth"),
  // Max-Width
  e("max-w-", "maxWidth"),
  // Height
  e("h-", "height"),
  // Min-Height
  e("min-h-", "minHeight"),
  // Max-Height
  e("max-h-", "maxHeight"),
  /* TYPOGRAPHY */
  // Font Weight
  e("font-", "fontWeight"),
  // Font Family
  e("font-", "fontFamily", ({ _: t }) => typeof (t = W(t))[1] == "string" ? {
    fontFamily: s(t)
  } : {
    fontFamily: s(t[0]),
    ...t[1]
  }),
  // Font Smoothing
  o("antialiased", {
    WebkitFontSmoothing: "antialiased",
    MozOsxFontSmoothing: "grayscale"
  }),
  o("subpixel-antialiased", {
    WebkitFontSmoothing: "auto",
    MozOsxFontSmoothing: "auto"
  }),
  // Font Style
  o("italic", "fontStyle"),
  o("not-italic", {
    fontStyle: "normal"
  }),
  // Font Variant Numeric
  o("(ordinal|slashed-zero|(normal|lining|oldstyle|proportional|tabular)-nums|(diagonal|stacked)-fractions)", ({ 1: t, 2: r = "", 3: i }) => (
    // normal-nums
    r == "normal" ? {
      fontVariantNumeric: "normal"
    } : {
      ["--tw-" + (i ? (
        // diagonal-fractions, stacked-fractions
        "numeric-fraction"
      ) : "pt".includes(r[0]) ? (
        // proportional-nums, tabular-nums
        "numeric-spacing"
      ) : r ? (
        // lining-nums, oldstyle-nums
        "numeric-figure"
      ) : (
        // ordinal, slashed-zero
        t
      ))]: t,
      fontVariantNumeric: "var(--tw-ordinal) var(--tw-slashed-zero) var(--tw-numeric-figure) var(--tw-numeric-spacing) var(--tw-numeric-fraction)",
      ...c({
        "--tw-ordinal": "var(--tw-empty,/*!*/ /*!*/)",
        "--tw-slashed-zero": "var(--tw-empty,/*!*/ /*!*/)",
        "--tw-numeric-figure": "var(--tw-empty,/*!*/ /*!*/)",
        "--tw-numeric-spacing": "var(--tw-empty,/*!*/ /*!*/)",
        "--tw-numeric-fraction": "var(--tw-empty,/*!*/ /*!*/)"
      })
    }
  )),
  // Letter Spacing
  e("tracking-", "letterSpacing"),
  // Line Height
  e("leading-", "lineHeight"),
  // List Style Position
  o("list-(inside|outside)", "listStylePosition"),
  // List Style Type
  e("list-", "listStyleType"),
  o("list-", "listStyleType"),
  // Placeholder Opacity
  e("placeholder-opacity-", "placeholderOpacity", ({ _: t }) => ({
    "&::placeholder": {
      "--tw-placeholder-opacity": t
    }
  })),
  // Placeholder Color
  n("placeholder-", {
    property: "color",
    selector: "&::placeholder"
  }),
  // Text Alignment
  o("text-(left|center|right|justify|start|end)", "textAlign"),
  o("text-(ellipsis|clip)", "textOverflow"),
  // Text Opacity
  e("text-opacity-", "textOpacity", "--tw-text-opacity"),
  // Text Color
  n("text-", {
    property: "color"
  }),
  // Font Size
  e("text-", "fontSize", ({ _: t }) => typeof t == "string" ? {
    fontSize: t
  } : {
    fontSize: t[0],
    ...typeof t[1] == "string" ? {
      lineHeight: t[1]
    } : t[1]
  }),
  // Text Indent
  e("indent-", "textIndent"),
  // Text Decoration
  o("(overline|underline|line-through)", "textDecorationLine"),
  o("no-underline", {
    textDecorationLine: "none"
  }),
  // Text Underline offset
  e("underline-offset-", "textUnderlineOffset"),
  // Text Decoration Color
  n("decoration-", {
    section: "textDecorationColor",
    opacityVariable: !1,
    opacitySection: "opacity"
  }),
  // Text Decoration Thickness
  e("decoration-", "textDecorationThickness"),
  // Text Decoration Style
  o("decoration-", "textDecorationStyle"),
  // Text Transform
  o("(uppercase|lowercase|capitalize)", "textTransform"),
  o("normal-case", {
    textTransform: "none"
  }),
  // Text Overflow
  o("truncate", {
    overflow: "hidden",
    whiteSpace: "nowrap",
    textOverflow: "ellipsis"
  }),
  // Vertical Alignment
  o("align-", "verticalAlign"),
  // Whitespace
  o("whitespace-", "whiteSpace"),
  // Word Break
  o("break-normal", {
    wordBreak: "normal",
    overflowWrap: "normal"
  }),
  o("break-words", {
    overflowWrap: "break-word"
  }),
  o("break-all", {
    wordBreak: "break-all"
  }),
  o("break-keep", {
    wordBreak: "keep-all"
  }),
  // Caret Color
  n("caret-", {
    // section: 'caretColor',
    opacityVariable: !1,
    opacitySection: "opacity"
  }),
  // Accent Color
  n("accent-", {
    // section: 'accentColor',
    opacityVariable: !1,
    opacitySection: "opacity"
  }),
  // Gradient Color Stops
  o("bg-gradient-to-([trbl]|[tb][rl])", "backgroundImage", ({ 1: t }) => `linear-gradient(to ${g(t, " ")},var(--tw-gradient-stops))`),
  n("from-", {
    section: "gradientColorStops",
    opacityVariable: !1,
    opacitySection: "opacity"
  }, ({ _: t }) => ({
    "--tw-gradient-from": t.value,
    "--tw-gradient-to": t.color({
      opacityValue: "0"
    }),
    "--tw-gradient-stops": "var(--tw-gradient-from),var(--tw-gradient-to)"
  })),
  n("via-", {
    section: "gradientColorStops",
    opacityVariable: !1,
    opacitySection: "opacity"
  }, ({ _: t }) => ({
    "--tw-gradient-to": t.color({
      opacityValue: "0"
    }),
    "--tw-gradient-stops": `var(--tw-gradient-from),${t.value},var(--tw-gradient-to)`
  })),
  n("to-", {
    section: "gradientColorStops",
    property: "--tw-gradient-to",
    opacityVariable: !1,
    opacitySection: "opacity"
  }),
  /* BACKGROUNDS */
  // Background Attachment
  o("bg-(fixed|local|scroll)", "backgroundAttachment"),
  // Background Origin
  o("bg-origin-(border|padding|content)", "backgroundOrigin", ({ 1: t }) => t + "-box"),
  // Background Repeat
  o([
    "bg-(no-repeat|repeat(-[xy])?)",
    "bg-repeat-(round|space)"
  ], "backgroundRepeat"),
  // Background Blend Mode
  o("bg-blend-", "backgroundBlendMode"),
  // Background Clip
  o("bg-clip-(border|padding|content|text)", "backgroundClip", ({ 1: t }) => t + (t == "text" ? "" : "-box")),
  // Background Opacity
  e("bg-opacity-", "backgroundOpacity", "--tw-bg-opacity"),
  // Background Color
  // bg-${backgroundColor}/${backgroundOpacity}
  n("bg-", {
    section: "backgroundColor"
  }),
  // Background Image
  // supported arbitrary types are: length, color, angle, list
  e("bg-", "backgroundImage"),
  // Background Position
  e("bg-", "backgroundPosition"),
  o("bg-(top|bottom|center|(left|right)(-(top|bottom))?)", "backgroundPosition", y),
  // Background Size
  e("bg-", "backgroundSize"),
  /* BORDERS */
  // Border Radius
  e("rounded(?:$|-)", "borderRadius"),
  e("rounded-([trbl]|[tb][rl])(?:$|-)", "borderRadius", ({ 1: t, _: r }) => {
    let i = {
      t: [
        "tl",
        "tr"
      ],
      r: [
        "tr",
        "br"
      ],
      b: [
        "bl",
        "br"
      ],
      l: [
        "bl",
        "tl"
      ]
    }[t] || [
      t,
      t
    ];
    return {
      [`border-${g(i[0])}-radius`]: r,
      [`border-${g(i[1])}-radius`]: r
    };
  }),
  // Border Collapse
  o("border-(collapse|separate)", "borderCollapse"),
  // Border Opacity
  e("border-opacity(?:$|-)", "borderOpacity", "--tw-border-opacity"),
  // Border Style
  o("border-(solid|dashed|dotted|double|none)", "borderStyle"),
  // Border Spacing
  e("border-spacing(-[xy])?(?:$|-)", "borderSpacing", ({ 1: t, _: r }) => ({
    ...c({
      "--tw-border-spacing-x": "0",
      "--tw-border-spacing-y": "0"
    }),
    ["--tw-border-spacing" + (t || "-x")]: r,
    ["--tw-border-spacing" + (t || "-y")]: r,
    "border-spacing": "var(--tw-border-spacing-x) var(--tw-border-spacing-y)"
  })),
  // Border Color
  n("border-([xytrbl])-", {
    section: "borderColor"
  }, f("border", "Color")),
  n("border-"),
  // Border Width
  e("border-([xytrbl])(?:$|-)", "borderWidth", f("border", "Width")),
  e("border(?:$|-)", "borderWidth"),
  // Divide Opacity
  e("divide-opacity(?:$|-)", "divideOpacity", ({ _: t }) => ({
    "&>:not([hidden])~:not([hidden])": {
      "--tw-divide-opacity": t
    }
  })),
  // Divide Style
  o("divide-(solid|dashed|dotted|double|none)", ({ 1: t }) => ({
    "&>:not([hidden])~:not([hidden])": {
      borderStyle: t
    }
  })),
  // Divide Width
  o("divide-([xy]-reverse)", ({ 1: t }) => ({
    "&>:not([hidden])~:not([hidden])": {
      ["--tw-divide-" + t]: "1"
    }
  })),
  e("divide-([xy])(?:$|-)", "divideWidth", ({ 1: t, _: r }) => {
    let i = {
      x: "lr",
      y: "tb"
    }[t];
    return {
      "&>:not([hidden])~:not([hidden])": {
        [`--tw-divide-${t}-reverse`]: "0",
        [`border-${g(i[0])}Width`]: `calc(${r} * calc(1 - var(--tw-divide-${t}-reverse)))`,
        [`border-${g(i[1])}Width`]: `calc(${r} * var(--tw-divide-${t}-reverse))`
      }
    };
  }),
  // Divide Color
  n("divide-", {
    // section: $0.replace('-', 'Color') -> 'divideColor'
    property: "borderColor",
    // opacityVariable: '--tw-border-opacity',
    // opacitySection: section.replace('Color', 'Opacity') -> 'divideOpacity'
    selector: "&>:not([hidden])~:not([hidden])"
  }),
  // Ring Offset Opacity
  e("ring-opacity(?:$|-)", "ringOpacity", "--tw-ring-opacity"),
  // Ring Offset Color
  n("ring-offset-", {
    // section: 'ringOffsetColor',
    property: "--tw-ring-offset-color",
    opacityVariable: !1
  }),
  // opacitySection: section.replace('Color', 'Opacity') -> 'ringOffsetOpacity'
  // Ring Offset Width
  e("ring-offset(?:$|-)", "ringOffsetWidth", "--tw-ring-offset-width"),
  // Ring Inset
  o("ring-inset", {
    "--tw-ring-inset": "inset"
  }),
  // Ring Color
  n("ring-", {
    // section: 'ringColor',
    property: "--tw-ring-color"
  }),
  // opacityVariable: '--tw-ring-opacity',
  // opacitySection: section.replace('Color', 'Opacity') -> 'ringOpacity'
  // Ring Width
  e("ring(?:$|-)", "ringWidth", ({ _: t }, { theme: r }) => ({
    ...c({
      "--tw-ring-offset-shadow": "0 0 #0000",
      "--tw-ring-shadow": "0 0 #0000",
      "--tw-shadow": "0 0 #0000",
      "--tw-shadow-colored": "0 0 #0000",
      // Within own declaration to have the defaults above to be merged with defaults from shadow
      "&": {
        "--tw-ring-inset": "var(--tw-empty,/*!*/ /*!*/)",
        "--tw-ring-offset-width": r("ringOffsetWidth", "", "0px"),
        "--tw-ring-offset-color": v(r("ringOffsetColor", "", "#fff")),
        "--tw-ring-color": v(r("ringColor", "", "#93c5fd"), {
          opacityVariable: "--tw-ring-opacity"
        }),
        "--tw-ring-opacity": r("ringOpacity", "", "0.5")
      }
    }),
    "--tw-ring-offset-shadow": "var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)",
    "--tw-ring-shadow": `var(--tw-ring-inset) 0 0 0 calc(${t} + var(--tw-ring-offset-width)) var(--tw-ring-color)`,
    boxShadow: "var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)"
  })),
  /* EFFECTS */
  // Box Shadow Color
  n("shadow-", {
    section: "boxShadowColor",
    opacityVariable: !1,
    opacitySection: "opacity"
  }, ({ _: t }) => ({
    "--tw-shadow-color": t.value,
    "--tw-shadow": "var(--tw-shadow-colored)"
  })),
  // Box Shadow
  e("shadow(?:$|-)", "boxShadow", ({ _: t }) => ({
    ...c({
      "--tw-ring-offset-shadow": "0 0 #0000",
      "--tw-ring-shadow": "0 0 #0000",
      "--tw-shadow": "0 0 #0000",
      "--tw-shadow-colored": "0 0 #0000"
    }),
    "--tw-shadow": s(t),
    // replace all colors with reference to --tw-shadow-colored
    // this matches colors after non-comma char (keyword, offset) before comma or the end
    "--tw-shadow-colored": s(t).replace(/([^,]\s+)(?:#[a-f\d]+|(?:(?:hsl|rgb)a?|hwb|lab|lch|color|var)\(.+?\)|[a-z]+)(,|$)/g, "$1var(--tw-shadow-color)$2"),
    boxShadow: "var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)"
  })),
  // Opacity
  e("(opacity)-"),
  /*, 'opacity' */
  // Mix Blend Mode
  o("mix-blend-", "mixBlendMode"),
  /* FILTERS */
  ...S(),
  ...S("backdrop-"),
  /* TRANSITIONS AND ANIMATION */
  // Transition Property
  e("transition(?:$|-)", "transitionProperty", (t, { theme: r }) => ({
    transitionProperty: s(t),
    transitionTimingFunction: t._ == "none" ? void 0 : s(r("transitionTimingFunction", "")),
    transitionDuration: t._ == "none" ? void 0 : s(r("transitionDuration", ""))
  })),
  // Transition Duration
  e("duration(?:$|-)", "transitionDuration", "transitionDuration", s),
  // Transition Timing Function
  e("ease(?:$|-)", "transitionTimingFunction", "transitionTimingFunction", s),
  // Transition Delay
  e("delay(?:$|-)", "transitionDelay", "transitionDelay", s),
  e("animate(?:$|-)", "animation", (t, { theme: r, h: i, e: a }) => {
    let l = s(t), d = l.split(" "), p = r("keyframes", d[0]);
    return p ? {
      ["@keyframes " + (d[0] = a(i(d[0])))]: p,
      animation: d.join(" ")
    } : {
      animation: l
    };
  }),
  /* TRANSFORMS */
  // Transform
  "(transform)-(none)",
  o("transform", m),
  o("transform-(cpu|gpu)", ({ 1: t }) => ({
    "--tw-transform": z(t == "gpu")
  })),
  // Scale
  e("scale(-[xy])?-", "scale", ({ 1: t, _: r }) => ({
    ["--tw-scale" + (t || "-x")]: r,
    ["--tw-scale" + (t || "-y")]: r,
    ...m()
  })),
  // Rotate
  e("-?(rotate)-", "rotate", h),
  // Translate
  e("-?(translate-[xy])-", "translate", h),
  // Skew
  e("-?(skew-[xy])-", "skew", h),
  // Transform Origin
  o("origin-(center|((top|bottom)(-(left|right))?)|left|right)", "transformOrigin", y),
  /* INTERACTIVITY */
  // Appearance
  "(appearance)-",
  // Columns
  e("(columns)-"),
  /*, 'columns' */
  "(columns)-(\\d+)",
  // Break Before, After and Inside
  "(break-(?:before|after|inside))-",
  // Cursor
  e("(cursor)-"),
  /*, 'cursor' */
  "(cursor)-",
  // Scroll Snap Type
  o("snap-(none)", "scroll-snap-type"),
  o("snap-(x|y|both)", ({ 1: t }) => ({
    ...c({
      "--tw-scroll-snap-strictness": "proximity"
    }),
    "scroll-snap-type": t + " var(--tw-scroll-snap-strictness)"
  })),
  o("snap-(mandatory|proximity)", "--tw-scroll-snap-strictness"),
  // Scroll Snap Align
  o("snap-(?:(start|end|center)|align-(none))", "scroll-snap-align"),
  // Scroll Snap Stop
  o("snap-(normal|always)", "scroll-snap-stop"),
  o("scroll-(auto|smooth)", "scroll-behavior"),
  // Scroll Margin
  // Padding
  e("scroll-p([xytrbl])?(?:$|-)", "padding", f("scroll-padding")),
  // Margin
  e("-?scroll-m([xytrbl])?(?:$|-)", "scroll-margin", f("scroll-margin")),
  // Touch Action
  o("touch-(auto|none|manipulation)", "touch-action"),
  o("touch-(pinch-zoom|pan-(?:(x|left|right)|(y|up|down)))", ({ 1: t, 2: r, 3: i }) => ({
    ...c({
      "--tw-pan-x": "var(--tw-empty,/*!*/ /*!*/)",
      "--tw-pan-y": "var(--tw-empty,/*!*/ /*!*/)",
      "--tw-pinch-zoom": "var(--tw-empty,/*!*/ /*!*/)",
      "--tw-touch-action": "var(--tw-pan-x) var(--tw-pan-y) var(--tw-pinch-zoom)"
    }),
    // x, left, right -> pan-x
    // y, up, down -> pan-y
    // -> pinch-zoom
    [`--tw-${r ? "pan-x" : i ? "pan-y" : t}`]: t,
    "touch-action": "var(--tw-touch-action)"
  })),
  // Outline Style
  o("outline-none", {
    outline: "2px solid transparent",
    "outline-offset": "2px"
  }),
  o("outline", {
    outlineStyle: "solid"
  }),
  o("outline-(dashed|dotted|double)", "outlineStyle"),
  // Outline Offset
  e("-?(outline-offset)-"),
  /*, 'outlineOffset'*/
  // Outline Color
  n("outline-", {
    opacityVariable: !1,
    opacitySection: "opacity"
  }),
  // Outline Width
  e("outline-", "outlineWidth"),
  // Pointer Events
  "(pointer-events)-",
  // Will Change
  e("(will-change)-"),
  /*, 'willChange' */
  "(will-change)-",
  // Resize
  [
    "resize(?:-(none|x|y))?",
    "resize",
    ({ 1: t }) => ({
      x: "horizontal",
      y: "vertical"
    })[t] || t || "both"
  ],
  // User Select
  o("select-(none|text|all|auto)", "userSelect"),
  /* SVG */
  // Fill, Stroke
  n("fill-", {
    section: "fill",
    opacityVariable: !1,
    opacitySection: "opacity"
  }),
  n("stroke-", {
    section: "stroke",
    opacityVariable: !1,
    opacitySection: "opacity"
  }),
  // Stroke Width
  e("stroke-", "strokeWidth"),
  /* ACCESSIBILITY */
  // Screen Readers
  o("sr-only", {
    position: "absolute",
    width: "1px",
    height: "1px",
    padding: "0",
    margin: "-1px",
    overflow: "hidden",
    whiteSpace: "nowrap",
    clip: "rect(0,0,0,0)",
    borderWidth: "0"
  }),
  o("not-sr-only", {
    position: "static",
    width: "auto",
    height: "auto",
    padding: "0",
    margin: "0",
    overflow: "visible",
    whiteSpace: "normal",
    clip: "auto"
  })
];
function y(t) {
  return (typeof t == "string" ? t : t[1]).replace(/-/g, " ").trim();
}
function x(t) {
  return (typeof t == "string" ? t : t[1]).replace("col", "column");
}
function g(t, r = "-") {
  let i = [];
  for (let a of t) i.push({
    t: "top",
    r: "right",
    b: "bottom",
    l: "left"
  }[a]);
  return i.join(r);
}
function s(t) {
  return t && "" + (t._ || t);
}
function k({ $$: t }) {
  return ({
    // /* aut*/ o: '',
    /* sta*/
    r: (
      /*t*/
      "flex-"
    ),
    /* end*/
    "": "flex-",
    // /* cen*/ t /*er*/: '',
    /* bet*/
    w: (
      /*een*/
      "space-"
    ),
    /* aro*/
    u: (
      /*nd*/
      "space-"
    ),
    /* eve*/
    n: (
      /*ly*/
      "space-"
    )
  }[t[3] || ""] || "") + t;
}
function f(t, r = "") {
  return ({ 1: i, _: a }) => {
    let l = {
      x: "lr",
      y: "tb"
    }[i] || i + i;
    return l ? {
      ...b(t + "-" + g(l[0]) + r, a),
      ...b(t + "-" + g(l[1]) + r, a)
    } : b(t + r, a);
  };
}
function S(t = "") {
  let r = [
    "blur",
    "brightness",
    "contrast",
    "grayscale",
    "hue-rotate",
    "invert",
    t && "opacity",
    "saturate",
    "sepia",
    !t && "drop-shadow"
  ].filter(Boolean), i = {};
  for (let a of r) i[`--tw-${t}${a}`] = "var(--tw-empty,/*!*/ /*!*/)";
  return i = {
    // move defaults
    ...c(i),
    // add default filter which allows standalone usage
    [`${t}filter`]: r.map((a) => `var(--tw-${t}${a})`).join(" ")
  }, [
    `(${t}filter)-(none)`,
    o(`${t}filter`, i),
    ...r.map((a) => e(
      // hue-rotate can be negated
      `${a[0] == "h" ? "-?" : ""}(${t}${a})(?:$|-)`,
      a,
      ({ 1: l, _: d }) => ({
        [`--tw-${l}`]: W(d).map((p) => `${a}(${p})`).join(" "),
        ...i
      })
    ))
  ];
}
function h({ 1: t, _: r }) {
  return {
    ["--tw-" + t]: r,
    ...m()
  };
}
function m() {
  return {
    ...c({
      "--tw-translate-x": "0",
      "--tw-translate-y": "0",
      "--tw-rotate": "0",
      "--tw-skew-x": "0",
      "--tw-skew-y": "0",
      "--tw-scale-x": "1",
      "--tw-scale-y": "1",
      "--tw-transform": z()
    }),
    transform: "var(--tw-transform)"
  };
}
function z(t) {
  return [
    t ? (
      // -gpu
      "translate3d(var(--tw-translate-x),var(--tw-translate-y),0)"
    ) : "translateX(var(--tw-translate-x)) translateY(var(--tw-translate-y))",
    "rotate(var(--tw-rotate))",
    "skewX(var(--tw-skew-x))",
    "skewY(var(--tw-skew-y))",
    "scaleX(var(--tw-scale-x))",
    "scaleY(var(--tw-scale-y))"
  ].join(" ");
}
function $({ 1: t, 2: r }) {
  return `${t} ${r} / ${t} ${r}`;
}
function C({ 1: t }) {
  return `repeat(${t},minmax(0,1fr))`;
}
function c(t) {
  return {
    "@layer defaults": {
      "*,::before,::after": t,
      "::backdrop": t
    }
  };
}
export {
  D as default
};
//# sourceMappingURL=rules.js.map
