tw-mrg 1.0.0

package/dist/index.js

@@ -0,0 +1,2897 @@
+"use client";
+
+// src/groups/types.ts
+var SPECIFICITY = {
+  /** All sides (p-4, m-4, rounded) */
+  ALL: 1,
+  /** Axis (px-4, my-4, rounded-t) */
+  AXIS: 2,
+  /** Single side (pt-4, mr-4, rounded-tl) */
+  SIDE: 3,
+  /** Arbitrary values are highly specific */
+  ARBITRARY: 10
+};
+function prefix(groupId, specificity = 1) {
+  return { groupId, specificity };
+}
+function mergeConfigs(...configs) {
+  const merged = {
+    prefixes: {},
+    exactMatches: {},
+    patterns: [],
+    conflicts: {}
+  };
+  for (const config of configs) {
+    Object.assign(merged.prefixes, config.prefixes);
+    Object.assign(merged.exactMatches, config.exactMatches);
+    merged.patterns.push(...config.patterns);
+    for (const [key, values] of Object.entries(config.conflicts)) {
+      if (key in merged.conflicts) {
+        merged.conflicts[key] = [.../* @__PURE__ */ new Set([...merged.conflicts[key], ...values])];
+      } else {
+        merged.conflicts[key] = [...values];
+      }
+    }
+  }
+  return merged;
+}
+function generateConflicts(hierarchy, fullSideNames = false) {
+  const conflicts = {};
+  for (const [base, axes] of Object.entries(hierarchy)) {
+    const allGroups = [base];
+    const sideToAxis = /* @__PURE__ */ new Map();
+    for (const [axis, sides] of Object.entries(axes)) {
+      if (!sides || sides.length === 0) continue;
+      const axisGroup = `${base}-${axis}`;
+      allGroups.push(axisGroup);
+      for (const side of sides) {
+        const sideGroup = fullSideNames ? side : `${base}-${side}`;
+        allGroups.push(sideGroup);
+        sideToAxis.set(sideGroup, axisGroup);
+      }
+    }
+    conflicts[base] = [...allGroups];
+    for (const [axis, sides] of Object.entries(axes)) {
+      if (!sides || sides.length === 0) continue;
+      const axisGroup = `${base}-${axis}`;
+      const sideGroups = sides.map((s) => fullSideNames ? s : `${base}-${s}`);
+      conflicts[axisGroup] = [base, axisGroup, ...sideGroups];
+    }
+    for (const [axis, sides] of Object.entries(axes)) {
+      if (!sides || sides.length === 0) continue;
+      const axisGroup = `${base}-${axis}`;
+      for (const side of sides) {
+        const sideGroup = fullSideNames ? side : `${base}-${side}`;
+        conflicts[sideGroup] = [base, axisGroup, sideGroup];
+      }
+    }
+  }
+  return conflicts;
+}
+function simpleConflicts(...groupIds) {
+  const conflicts = {};
+  for (const id of groupIds) {
+    conflicts[id] = [id];
+  }
+  return conflicts;
+}
+
+// src/cache.ts
+var LRUCache = class {
+  constructor(maxSize = 500) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  /** Gets a value, moving it to most recently used position. */
+  get(key) {
+    const value = this.cache.get(key);
+    if (value === void 0) {
+      return void 0;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  /** Sets a value, evicting the oldest entry if at capacity. */
+  set(key, value) {
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    if (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.cache.delete(oldestKey);
+      }
+    }
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var parseCache = null;
+var mergeCache = null;
+function getParseCache() {
+  if (parseCache === null) {
+    parseCache = new LRUCache(1e3);
+  }
+  return parseCache;
+}
+function clearCaches() {
+  parseCache?.clear();
+  mergeCache?.clear();
+}
+function getCacheStats() {
+  return {
+    parseSize: parseCache?.size ?? 0,
+    mergeSize: mergeCache?.size ?? 0
+  };
+}
+
+// src/groups/layout.ts
+var LAYOUT_HIERARCHY = {
+  overflow: { x: [], y: [] },
+  overscroll: { x: [], y: [] }
+};
+var INSET_HIERARCHY = {
+  inset: { x: ["left", "right", "start", "end"], y: ["top", "bottom"] }
+};
+var layoutGroups = {
+  prefixes: {
+    // Aspect ratio
+    "aspect-": prefix("aspect-ratio"),
+    // Columns
+    "columns-": prefix("columns"),
+    // Container
+    "@container": prefix("container"),
+    // Position
+    "inset-": prefix("inset", SPECIFICITY.ALL),
+    "-inset-": prefix("inset", SPECIFICITY.ALL),
+    "inset-x-": prefix("inset-x", SPECIFICITY.AXIS),
+    "-inset-x-": prefix("inset-x", SPECIFICITY.AXIS),
+    "inset-y-": prefix("inset-y", SPECIFICITY.AXIS),
+    "-inset-y-": prefix("inset-y", SPECIFICITY.AXIS),
+    "top-": prefix("top", SPECIFICITY.SIDE),
+    "-top-": prefix("top", SPECIFICITY.SIDE),
+    "right-": prefix("right", SPECIFICITY.SIDE),
+    "-right-": prefix("right", SPECIFICITY.SIDE),
+    "bottom-": prefix("bottom", SPECIFICITY.SIDE),
+    "-bottom-": prefix("bottom", SPECIFICITY.SIDE),
+    "left-": prefix("left", SPECIFICITY.SIDE),
+    "-left-": prefix("left", SPECIFICITY.SIDE),
+    "start-": prefix("start", SPECIFICITY.SIDE),
+    "-start-": prefix("start", SPECIFICITY.SIDE),
+    "end-": prefix("end", SPECIFICITY.SIDE),
+    "-end-": prefix("end", SPECIFICITY.SIDE),
+    // Z-index
+    "z-": prefix("z-index"),
+    "-z-": prefix("z-index"),
+    // Float & Clear
+    "float-": prefix("float"),
+    "clear-": prefix("clear"),
+    // Object fit/position
+    "object-": prefix("object-fit"),
+    // Will be refined by exact matches
+    // Overflow
+    "overflow-": prefix("overflow", SPECIFICITY.ALL),
+    "overflow-x-": prefix("overflow-x", SPECIFICITY.AXIS),
+    "overflow-y-": prefix("overflow-y", SPECIFICITY.AXIS),
+    // Overscroll
+    "overscroll-": prefix("overscroll", SPECIFICITY.ALL),
+    "overscroll-x-": prefix("overscroll-x", SPECIFICITY.AXIS),
+    "overscroll-y-": prefix("overscroll-y", SPECIFICITY.AXIS)
+  },
+  exactMatches: {
+    // Aspect ratio
+    "aspect-auto": prefix("aspect-ratio"),
+    "aspect-square": prefix("aspect-ratio"),
+    "aspect-video": prefix("aspect-ratio"),
+    // Container
+    container: prefix("container"),
+    "@container": prefix("container"),
+    // Columns
+    "columns-auto": prefix("columns"),
+    // CSS Containment
+    "contain-none": prefix("contain"),
+    "contain-content": prefix("contain"),
+    "contain-strict": prefix("contain"),
+    "contain-size": prefix("contain"),
+    "contain-inline-size": prefix("contain"),
+    "contain-layout": prefix("contain"),
+    "contain-style": prefix("contain"),
+    "contain-paint": prefix("contain"),
+    // Field sizing (new in v4)
+    "field-sizing-content": prefix("field-sizing"),
+    "field-sizing-fixed": prefix("field-sizing"),
+    // Break before
+    "break-before-auto": prefix("break-before"),
+    "break-before-avoid": prefix("break-before"),
+    "break-before-all": prefix("break-before"),
+    "break-before-avoid-page": prefix("break-before"),
+    "break-before-page": prefix("break-before"),
+    "break-before-left": prefix("break-before"),
+    "break-before-right": prefix("break-before"),
+    "break-before-column": prefix("break-before"),
+    // Break after
+    "break-after-auto": prefix("break-after"),
+    "break-after-avoid": prefix("break-after"),
+    "break-after-all": prefix("break-after"),
+    "break-after-avoid-page": prefix("break-after"),
+    "break-after-page": prefix("break-after"),
+    "break-after-left": prefix("break-after"),
+    "break-after-right": prefix("break-after"),
+    "break-after-column": prefix("break-after"),
+    // Break inside
+    "break-inside-auto": prefix("break-inside"),
+    "break-inside-avoid": prefix("break-inside"),
+    "break-inside-avoid-page": prefix("break-inside"),
+    "break-inside-avoid-column": prefix("break-inside"),
+    // Color scheme
+    "scheme-normal": prefix("color-scheme"),
+    "scheme-dark": prefix("color-scheme"),
+    "scheme-light": prefix("color-scheme"),
+    "scheme-light-dark": prefix("color-scheme"),
+    "scheme-dark-light": prefix("color-scheme"),
+    "scheme-only-dark": prefix("color-scheme"),
+    "scheme-only-light": prefix("color-scheme"),
+    // Display
+    block: prefix("display"),
+    "inline-block": prefix("display"),
+    inline: prefix("display"),
+    flex: prefix("display"),
+    "inline-flex": prefix("display"),
+    table: prefix("display"),
+    "inline-table": prefix("display"),
+    "table-caption": prefix("display"),
+    "table-cell": prefix("display"),
+    "table-column": prefix("display"),
+    "table-column-group": prefix("display"),
+    "table-footer-group": prefix("display"),
+    "table-header-group": prefix("display"),
+    "table-row-group": prefix("display"),
+    "table-row": prefix("display"),
+    "flow-root": prefix("display"),
+    grid: prefix("display"),
+    "inline-grid": prefix("display"),
+    contents: prefix("display"),
+    "list-item": prefix("display"),
+    hidden: prefix("display"),
+    // Position
+    static: prefix("position"),
+    fixed: prefix("position"),
+    absolute: prefix("position"),
+    relative: prefix("position"),
+    sticky: prefix("position"),
+    // Visibility
+    visible: prefix("visibility"),
+    invisible: prefix("visibility"),
+    collapse: prefix("visibility"),
+    // Isolation
+    isolate: prefix("isolation"),
+    "isolation-auto": prefix("isolation"),
+    // Object fit
+    "object-contain": prefix("object-fit"),
+    "object-cover": prefix("object-fit"),
+    "object-fill": prefix("object-fit"),
+    "object-none": prefix("object-fit"),
+    "object-scale-down": prefix("object-fit"),
+    // Object position
+    "object-bottom": prefix("object-position"),
+    "object-center": prefix("object-position"),
+    "object-left": prefix("object-position"),
+    "object-left-bottom": prefix("object-position"),
+    "object-left-top": prefix("object-position"),
+    "object-right": prefix("object-position"),
+    "object-right-bottom": prefix("object-position"),
+    "object-right-top": prefix("object-position"),
+    "object-top": prefix("object-position"),
+    // Overflow exact
+    "overflow-auto": prefix("overflow", SPECIFICITY.ALL),
+    "overflow-hidden": prefix("overflow", SPECIFICITY.ALL),
+    "overflow-clip": prefix("overflow", SPECIFICITY.ALL),
+    "overflow-visible": prefix("overflow", SPECIFICITY.ALL),
+    "overflow-scroll": prefix("overflow", SPECIFICITY.ALL)
+  },
+  patterns: [],
+  conflicts: {
+    ...simpleConflicts(
+      "aspect-ratio",
+      "columns",
+      "container",
+      "display",
+      "position",
+      "visibility",
+      "isolation",
+      "float",
+      "clear",
+      "object-fit",
+      "object-position",
+      "z-index",
+      "contain",
+      "field-sizing",
+      "break-before",
+      "break-after",
+      "break-inside",
+      "color-scheme"
+    ),
+    ...generateConflicts(LAYOUT_HIERARCHY),
+    ...generateConflicts(INSET_HIERARCHY, true)
+    // Use full side names
+  }
+};
+
+// src/groups/spacing.ts
+var SPACING_HIERARCHY = {
+  padding: { x: ["l", "r", "s", "e"], y: ["t", "b"] },
+  margin: { x: ["l", "r", "s", "e"], y: ["t", "b"] },
+  gap: { x: [], y: [] }
+};
+var spacingGroups = {
+  prefixes: {
+    // Padding
+    "p-": prefix("padding", SPECIFICITY.ALL),
+    "px-": prefix("padding-x", SPECIFICITY.AXIS),
+    "py-": prefix("padding-y", SPECIFICITY.AXIS),
+    "pt-": prefix("padding-t", SPECIFICITY.SIDE),
+    "pr-": prefix("padding-r", SPECIFICITY.SIDE),
+    "pb-": prefix("padding-b", SPECIFICITY.SIDE),
+    "pl-": prefix("padding-l", SPECIFICITY.SIDE),
+    "ps-": prefix("padding-s", SPECIFICITY.SIDE),
+    "pe-": prefix("padding-e", SPECIFICITY.SIDE),
+    // Margin
+    "m-": prefix("margin", SPECIFICITY.ALL),
+    "-m-": prefix("margin", SPECIFICITY.ALL),
+    "mx-": prefix("margin-x", SPECIFICITY.AXIS),
+    "-mx-": prefix("margin-x", SPECIFICITY.AXIS),
+    "my-": prefix("margin-y", SPECIFICITY.AXIS),
+    "-my-": prefix("margin-y", SPECIFICITY.AXIS),
+    "mt-": prefix("margin-t", SPECIFICITY.SIDE),
+    "-mt-": prefix("margin-t", SPECIFICITY.SIDE),
+    "mr-": prefix("margin-r", SPECIFICITY.SIDE),
+    "-mr-": prefix("margin-r", SPECIFICITY.SIDE),
+    "mb-": prefix("margin-b", SPECIFICITY.SIDE),
+    "-mb-": prefix("margin-b", SPECIFICITY.SIDE),
+    "ml-": prefix("margin-l", SPECIFICITY.SIDE),
+    "-ml-": prefix("margin-l", SPECIFICITY.SIDE),
+    "ms-": prefix("margin-s", SPECIFICITY.SIDE),
+    "-ms-": prefix("margin-s", SPECIFICITY.SIDE),
+    "me-": prefix("margin-e", SPECIFICITY.SIDE),
+    "-me-": prefix("margin-e", SPECIFICITY.SIDE),
+    // Gap
+    "gap-": prefix("gap", SPECIFICITY.ALL),
+    "gap-x-": prefix("gap-x", SPECIFICITY.AXIS),
+    "gap-y-": prefix("gap-y", SPECIFICITY.AXIS),
+    // Space between
+    "space-x-": prefix("space-x"),
+    "-space-x-": prefix("space-x"),
+    "space-y-": prefix("space-y"),
+    "-space-y-": prefix("space-y")
+  },
+  exactMatches: {
+    "space-x-reverse": prefix("space-x-reverse"),
+    "space-y-reverse": prefix("space-y-reverse")
+  },
+  patterns: [],
+  conflicts: {
+    ...generateConflicts(SPACING_HIERARCHY),
+    ...simpleConflicts("space-x", "space-y", "space-x-reverse", "space-y-reverse")
+  }
+};
+
+// src/groups/sizing.ts
+var sizingGroups = {
+  prefixes: {
+    // Width
+    "w-": prefix("width"),
+    "min-w-": prefix("min-width"),
+    "max-w-": prefix("max-width"),
+    // Height
+    "h-": prefix("height"),
+    "min-h-": prefix("min-height"),
+    "max-h-": prefix("max-height"),
+    // Size (width + height shorthand)
+    "size-": prefix("size", SPECIFICITY.ALL)
+  },
+  exactMatches: {},
+  patterns: [],
+  conflicts: {
+    width: ["width"],
+    "min-width": ["min-width"],
+    "max-width": ["max-width"],
+    height: ["height"],
+    "min-height": ["min-height"],
+    "max-height": ["max-height"],
+    size: ["size", "width", "height"]
+  }
+};
+
+// src/groups/flexbox-grid.ts
+var flexboxGridGroups = {
+  prefixes: {
+    // Flex basis
+    "basis-": prefix("flex-basis"),
+    // Order
+    "order-": prefix("order"),
+    "-order-": prefix("order"),
+    // Grid template
+    "grid-cols-": prefix("grid-template-columns"),
+    "grid-rows-": prefix("grid-template-rows"),
+    // Grid column
+    "col-": prefix("grid-column"),
+    "col-start-": prefix("grid-column-start"),
+    "col-end-": prefix("grid-column-end"),
+    // Grid row
+    "row-": prefix("grid-row"),
+    "row-start-": prefix("grid-row-start"),
+    "row-end-": prefix("grid-row-end"),
+    // Grid auto
+    "auto-cols-": prefix("grid-auto-columns"),
+    "auto-rows-": prefix("grid-auto-rows")
+  },
+  exactMatches: {
+    // Flex direction
+    "flex-row": prefix("flex-direction"),
+    "flex-row-reverse": prefix("flex-direction"),
+    "flex-col": prefix("flex-direction"),
+    "flex-col-reverse": prefix("flex-direction"),
+    // Flex wrap
+    "flex-wrap": prefix("flex-wrap"),
+    "flex-wrap-reverse": prefix("flex-wrap"),
+    "flex-nowrap": prefix("flex-wrap"),
+    // Flex
+    "flex-1": prefix("flex"),
+    "flex-auto": prefix("flex"),
+    "flex-initial": prefix("flex"),
+    "flex-none": prefix("flex"),
+    // Grow / Shrink
+    grow: prefix("flex-grow"),
+    "grow-0": prefix("flex-grow"),
+    shrink: prefix("flex-shrink"),
+    "shrink-0": prefix("flex-shrink"),
+    // Order
+    "order-none": prefix("order"),
+    "order-first": prefix("order"),
+    "order-last": prefix("order"),
+    // Grid auto flow
+    "grid-flow-row": prefix("grid-auto-flow"),
+    "grid-flow-col": prefix("grid-auto-flow"),
+    "grid-flow-dense": prefix("grid-auto-flow"),
+    "grid-flow-row-dense": prefix("grid-auto-flow"),
+    "grid-flow-col-dense": prefix("grid-auto-flow"),
+    // Justify content
+    "justify-normal": prefix("justify-content"),
+    "justify-start": prefix("justify-content"),
+    "justify-end": prefix("justify-content"),
+    "justify-center": prefix("justify-content"),
+    "justify-between": prefix("justify-content"),
+    "justify-around": prefix("justify-content"),
+    "justify-evenly": prefix("justify-content"),
+    "justify-stretch": prefix("justify-content"),
+    "justify-baseline": prefix("justify-content"),
+    // Safe alignment
+    "justify-start-safe": prefix("justify-content"),
+    "justify-end-safe": prefix("justify-content"),
+    "justify-center-safe": prefix("justify-content"),
+    // Justify items
+    "justify-items-start": prefix("justify-items"),
+    "justify-items-end": prefix("justify-items"),
+    "justify-items-center": prefix("justify-items"),
+    "justify-items-stretch": prefix("justify-items"),
+    // Safe alignment
+    "justify-items-start-safe": prefix("justify-items"),
+    "justify-items-end-safe": prefix("justify-items"),
+    "justify-items-center-safe": prefix("justify-items"),
+    // Justify self
+    "justify-self-auto": prefix("justify-self"),
+    "justify-self-start": prefix("justify-self"),
+    "justify-self-end": prefix("justify-self"),
+    "justify-self-center": prefix("justify-self"),
+    "justify-self-stretch": prefix("justify-self"),
+    // Safe alignment
+    "justify-self-start-safe": prefix("justify-self"),
+    "justify-self-end-safe": prefix("justify-self"),
+    "justify-self-center-safe": prefix("justify-self"),
+    // Align content
+    "content-normal": prefix("align-content"),
+    "content-center": prefix("align-content"),
+    "content-start": prefix("align-content"),
+    "content-end": prefix("align-content"),
+    "content-between": prefix("align-content"),
+    "content-around": prefix("align-content"),
+    "content-evenly": prefix("align-content"),
+    "content-baseline": prefix("align-content"),
+    "content-stretch": prefix("align-content"),
+    // Safe alignment
+    "content-start-safe": prefix("align-content"),
+    "content-end-safe": prefix("align-content"),
+    "content-center-safe": prefix("align-content"),
+    // Align items
+    "items-start": prefix("align-items"),
+    "items-end": prefix("align-items"),
+    "items-center": prefix("align-items"),
+    "items-baseline": prefix("align-items"),
+    "items-baseline-last": prefix("align-items"),
+    "items-stretch": prefix("align-items"),
+    // Safe alignment
+    "items-start-safe": prefix("align-items"),
+    "items-end-safe": prefix("align-items"),
+    "items-center-safe": prefix("align-items"),
+    // Align self
+    "self-auto": prefix("align-self"),
+    "self-start": prefix("align-self"),
+    "self-end": prefix("align-self"),
+    "self-center": prefix("align-self"),
+    "self-stretch": prefix("align-self"),
+    "self-baseline": prefix("align-self"),
+    // Safe alignment
+    "self-start-safe": prefix("align-self"),
+    "self-end-safe": prefix("align-self"),
+    "self-center-safe": prefix("align-self"),
+    // Place content
+    "place-content-center": prefix("place-content"),
+    "place-content-start": prefix("place-content"),
+    "place-content-end": prefix("place-content"),
+    "place-content-between": prefix("place-content"),
+    "place-content-around": prefix("place-content"),
+    "place-content-evenly": prefix("place-content"),
+    "place-content-baseline": prefix("place-content"),
+    "place-content-stretch": prefix("place-content"),
+    // Safe alignment
+    "place-content-start-safe": prefix("place-content"),
+    "place-content-end-safe": prefix("place-content"),
+    "place-content-center-safe": prefix("place-content"),
+    // Place items
+    "place-items-start": prefix("place-items"),
+    "place-items-end": prefix("place-items"),
+    "place-items-center": prefix("place-items"),
+    "place-items-baseline": prefix("place-items"),
+    "place-items-stretch": prefix("place-items"),
+    // Safe alignment
+    "place-items-start-safe": prefix("place-items"),
+    "place-items-end-safe": prefix("place-items"),
+    "place-items-center-safe": prefix("place-items"),
+    // Place self
+    "place-self-auto": prefix("place-self"),
+    "place-self-start": prefix("place-self"),
+    "place-self-end": prefix("place-self"),
+    "place-self-center": prefix("place-self"),
+    "place-self-stretch": prefix("place-self"),
+    // Safe alignment
+    "place-self-start-safe": prefix("place-self"),
+    "place-self-end-safe": prefix("place-self"),
+    "place-self-center-safe": prefix("place-self")
+  },
+  patterns: [
+    // Arbitrary flex values
+    { pattern: /^flex-\[/, groupId: "flex", specificity: 1 },
+    { pattern: /^grow-\[/, groupId: "flex-grow", specificity: 1 },
+    { pattern: /^shrink-\[/, groupId: "flex-shrink", specificity: 1 }
+  ],
+  conflicts: {
+    // Grid column/row have hierarchical conflicts
+    "grid-column": ["grid-column", "grid-column-start", "grid-column-end"],
+    "grid-row": ["grid-row", "grid-row-start", "grid-row-end"],
+    ...simpleConflicts(
+      "flex-basis",
+      "flex-direction",
+      "flex-wrap",
+      "flex",
+      "flex-grow",
+      "flex-shrink",
+      "order",
+      "grid-template-columns",
+      "grid-template-rows",
+      "grid-column-start",
+      "grid-column-end",
+      "grid-row-start",
+      "grid-row-end",
+      "grid-auto-flow",
+      "grid-auto-columns",
+      "grid-auto-rows",
+      "justify-content",
+      "justify-items",
+      "justify-self",
+      "align-content",
+      "align-items",
+      "align-self",
+      "place-content",
+      "place-items",
+      "place-self"
+    )
+  }
+};
+
+// src/groups/typography.ts
+var typographyGroups = {
+  prefixes: {
+    // Letter spacing
+    "tracking-": prefix("letter-spacing"),
+    // Line height
+    "leading-": prefix("line-height"),
+    // Line clamp
+    "line-clamp-": prefix("line-clamp"),
+    // Text indent
+    "indent-": prefix("text-indent"),
+    // List image
+    "list-image-": prefix("list-image"),
+    // Text decoration
+    "decoration-": prefix("text-decoration-color"),
+    // Refined by exact matches
+    // Underline offset
+    "underline-offset-": prefix("text-underline-offset"),
+    // Content
+    "content-": prefix("content")
+  },
+  exactMatches: {
+    // Font family
+    "font-sans": prefix("font-family"),
+    "font-serif": prefix("font-family"),
+    "font-mono": prefix("font-family"),
+    // Font size
+    "text-xs": prefix("font-size"),
+    "text-sm": prefix("font-size"),
+    "text-base": prefix("font-size"),
+    "text-lg": prefix("font-size"),
+    "text-xl": prefix("font-size"),
+    "text-2xl": prefix("font-size"),
+    "text-3xl": prefix("font-size"),
+    "text-4xl": prefix("font-size"),
+    "text-5xl": prefix("font-size"),
+    "text-6xl": prefix("font-size"),
+    "text-7xl": prefix("font-size"),
+    "text-8xl": prefix("font-size"),
+    "text-9xl": prefix("font-size"),
+    // Font smoothing
+    antialiased: prefix("font-smoothing"),
+    "subpixel-antialiased": prefix("font-smoothing"),
+    // Font style
+    italic: prefix("font-style"),
+    "not-italic": prefix("font-style"),
+    // Font weight
+    "font-thin": prefix("font-weight"),
+    "font-extralight": prefix("font-weight"),
+    "font-light": prefix("font-weight"),
+    "font-normal": prefix("font-weight"),
+    "font-medium": prefix("font-weight"),
+    "font-semibold": prefix("font-weight"),
+    "font-bold": prefix("font-weight"),
+    "font-extrabold": prefix("font-weight"),
+    "font-black": prefix("font-weight"),
+    // Font variant numeric
+    "normal-nums": prefix("font-variant-numeric"),
+    ordinal: prefix("font-variant-numeric"),
+    "slashed-zero": prefix("font-variant-numeric"),
+    "lining-nums": prefix("font-variant-numeric"),
+    "oldstyle-nums": prefix("font-variant-numeric"),
+    "proportional-nums": prefix("font-variant-numeric"),
+    "tabular-nums": prefix("font-variant-numeric"),
+    "diagonal-fractions": prefix("font-variant-numeric"),
+    "stacked-fractions": prefix("font-variant-numeric"),
+    // Font stretch
+    "font-stretch-normal": prefix("font-stretch"),
+    "font-stretch-ultra-condensed": prefix("font-stretch"),
+    "font-stretch-extra-condensed": prefix("font-stretch"),
+    "font-stretch-condensed": prefix("font-stretch"),
+    "font-stretch-semi-condensed": prefix("font-stretch"),
+    "font-stretch-semi-expanded": prefix("font-stretch"),
+    "font-stretch-expanded": prefix("font-stretch"),
+    "font-stretch-extra-expanded": prefix("font-stretch"),
+    "font-stretch-ultra-expanded": prefix("font-stretch"),
+    // List style position
+    "list-inside": prefix("list-style-position"),
+    "list-outside": prefix("list-style-position"),
+    // List style type
+    "list-none": prefix("list-style-type"),
+    "list-disc": prefix("list-style-type"),
+    "list-decimal": prefix("list-style-type"),
+    // Text align
+    "text-left": prefix("text-align"),
+    "text-center": prefix("text-align"),
+    "text-right": prefix("text-align"),
+    "text-justify": prefix("text-align"),
+    "text-start": prefix("text-align"),
+    "text-end": prefix("text-align"),
+    // Text decoration
+    underline: prefix("text-decoration"),
+    overline: prefix("text-decoration"),
+    "line-through": prefix("text-decoration"),
+    "no-underline": prefix("text-decoration"),
+    // Text decoration style
+    "decoration-solid": prefix("text-decoration-style"),
+    "decoration-double": prefix("text-decoration-style"),
+    "decoration-dotted": prefix("text-decoration-style"),
+    "decoration-dashed": prefix("text-decoration-style"),
+    "decoration-wavy": prefix("text-decoration-style"),
+    // Text decoration thickness
+    "decoration-auto": prefix("text-decoration-thickness"),
+    "decoration-from-font": prefix("text-decoration-thickness"),
+    "decoration-0": prefix("text-decoration-thickness"),
+    "decoration-1": prefix("text-decoration-thickness"),
+    "decoration-2": prefix("text-decoration-thickness"),
+    "decoration-4": prefix("text-decoration-thickness"),
+    "decoration-8": prefix("text-decoration-thickness"),
+    // Text transform
+    uppercase: prefix("text-transform"),
+    lowercase: prefix("text-transform"),
+    capitalize: prefix("text-transform"),
+    "normal-case": prefix("text-transform"),
+    // Text overflow
+    truncate: prefix("text-overflow"),
+    "text-ellipsis": prefix("text-overflow"),
+    "text-clip": prefix("text-overflow"),
+    // Text wrap
+    "text-wrap": prefix("text-wrap"),
+    "text-nowrap": prefix("text-wrap"),
+    "text-balance": prefix("text-wrap"),
+    "text-pretty": prefix("text-wrap"),
+    // Vertical align
+    "align-baseline": prefix("vertical-align"),
+    "align-top": prefix("vertical-align"),
+    "align-middle": prefix("vertical-align"),
+    "align-bottom": prefix("vertical-align"),
+    "align-text-top": prefix("vertical-align"),
+    "align-text-bottom": prefix("vertical-align"),
+    "align-sub": prefix("vertical-align"),
+    "align-super": prefix("vertical-align"),
+    // Whitespace
+    "whitespace-normal": prefix("whitespace"),
+    "whitespace-nowrap": prefix("whitespace"),
+    "whitespace-pre": prefix("whitespace"),
+    "whitespace-pre-line": prefix("whitespace"),
+    "whitespace-pre-wrap": prefix("whitespace"),
+    "whitespace-break-spaces": prefix("whitespace"),
+    // Word break
+    "break-normal": prefix("word-break"),
+    "break-words": prefix("word-break"),
+    "break-all": prefix("word-break"),
+    "break-keep": prefix("word-break"),
+    // Hyphens
+    "hyphens-none": prefix("hyphens"),
+    "hyphens-manual": prefix("hyphens"),
+    "hyphens-auto": prefix("hyphens"),
+    // Overflow wrap
+    "wrap-normal": prefix("overflow-wrap"),
+    "wrap-break-word": prefix("overflow-wrap"),
+    "wrap-anywhere": prefix("overflow-wrap")
+  },
+  patterns: [
+    // Font family arbitrary
+    { pattern: /^font-\[/, groupId: "font-family", specificity: 1 },
+    // Font weight numeric
+    { pattern: /^font-\d+$/, groupId: "font-weight", specificity: 1 },
+    // Tracking arbitrary
+    { pattern: /^tracking-\[/, groupId: "letter-spacing", specificity: 1 },
+    // Leading arbitrary
+    { pattern: /^leading-\[/, groupId: "line-height", specificity: 1 },
+    // List style arbitrary
+    { pattern: /^list-\[/, groupId: "list-style-type", specificity: 1 },
+    // Decoration arbitrary
+    { pattern: /^decoration-\[/, groupId: "text-decoration-thickness", specificity: 1 }
+  ],
+  conflicts: {
+    "font-family": ["font-family"],
+    "font-size": ["font-size"],
+    "font-smoothing": ["font-smoothing"],
+    "font-style": ["font-style"],
+    "font-weight": ["font-weight"],
+    "font-variant-numeric": ["font-variant-numeric"],
+    "font-stretch": ["font-stretch"],
+    "letter-spacing": ["letter-spacing"],
+    "line-height": ["line-height"],
+    "line-clamp": ["line-clamp"],
+    "list-image": ["list-image"],
+    "list-style-position": ["list-style-position"],
+    "list-style-type": ["list-style-type"],
+    "text-align": ["text-align"],
+    "text-decoration": ["text-decoration"],
+    "text-decoration-color": ["text-decoration-color"],
+    "text-decoration-style": ["text-decoration-style"],
+    "text-decoration-thickness": ["text-decoration-thickness"],
+    "text-underline-offset": ["text-underline-offset"],
+    "text-transform": ["text-transform"],
+    "text-overflow": ["text-overflow"],
+    "text-wrap": ["text-wrap"],
+    "text-indent": ["text-indent"],
+    "vertical-align": ["vertical-align"],
+    whitespace: ["whitespace"],
+    "word-break": ["word-break"],
+    hyphens: ["hyphens"],
+    "overflow-wrap": ["overflow-wrap"],
+    content: ["content"]
+  }
+};
+
+// src/groups/colors.ts
+var COLOR_NAMES = [
+  "slate",
+  "gray",
+  "zinc",
+  "neutral",
+  "stone",
+  "red",
+  "orange",
+  "amber",
+  "yellow",
+  "lime",
+  "green",
+  "emerald",
+  "teal",
+  "cyan",
+  "sky",
+  "blue",
+  "indigo",
+  "violet",
+  "purple",
+  "fuchsia",
+  "pink",
+  "rose"
+];
+var SPECIAL_COLORS = ["inherit", "current", "transparent", "black", "white"];
+function createColorPrefixes(prefixStr, groupId) {
+  const prefixes = {};
+  for (const color of COLOR_NAMES) {
+    prefixes[`${prefixStr}${color}-`] = prefix(groupId);
+  }
+  prefixes[`${prefixStr}[`] = prefix(groupId);
+  return prefixes;
+}
+function createSpecialColorMatches(prefixStr, groupId) {
+  const matches = {};
+  for (const color of SPECIAL_COLORS) {
+    matches[`${prefixStr}${color}`] = prefix(groupId);
+  }
+  return matches;
+}
+var COLOR_UTILITIES = [
+  ["text-", "text-color"],
+  ["bg-", "bg-color"],
+  ["border-", "border-color"],
+  ["outline-", "outline-color"],
+  ["ring-", "ring-color"],
+  ["ring-offset-", "ring-offset-color"],
+  ["divide-", "divide-color"],
+  ["accent-", "accent-color"],
+  ["caret-", "caret-color"],
+  ["fill-", "fill"],
+  ["stroke-", "stroke"],
+  ["shadow-", "box-shadow-color"],
+  ["placeholder-", "placeholder-color"],
+  ["from-", "gradient-from"],
+  ["via-", "gradient-via"],
+  ["to-", "gradient-to"]
+];
+function generateAllColorPrefixes() {
+  const prefixes = {};
+  for (const [utilityPrefix, groupId] of COLOR_UTILITIES) {
+    Object.assign(prefixes, createColorPrefixes(utilityPrefix, groupId));
+  }
+  return prefixes;
+}
+var SPECIAL_COLOR_UTILITIES = [
+  ["text-", "text-color"],
+  ["bg-", "bg-color"],
+  ["border-", "border-color"],
+  ["outline-", "outline-color"],
+  ["ring-", "ring-color"]
+];
+function generateSpecialColorMatches() {
+  const matches = {};
+  for (const [utilityPrefix, groupId] of SPECIAL_COLOR_UTILITIES) {
+    Object.assign(matches, createSpecialColorMatches(utilityPrefix, groupId));
+  }
+  return matches;
+}
+var colorGroups = {
+  prefixes: generateAllColorPrefixes(),
+  exactMatches: {
+    ...generateSpecialColorMatches(),
+    // Gradient stop reset
+    "via-none": prefix("gradient-via")
+  },
+  // No patterns needed - all handled by prefixes now
+  patterns: [],
+  conflicts: simpleConflicts(
+    "text-color",
+    "bg-color",
+    "border-color",
+    "outline-color",
+    "ring-color",
+    "ring-offset-color",
+    "divide-color",
+    "accent-color",
+    "caret-color",
+    "fill",
+    "stroke",
+    "box-shadow-color",
+    "placeholder-color",
+    "gradient-from",
+    "gradient-via",
+    "gradient-to"
+  )
+};
+
+// src/groups/backgrounds.ts
+var backgroundGroups = {
+  prefixes: {
+    // Background image - gradient directions
+    "bg-gradient-to-": prefix("bg-image"),
+    // Background image - gradient types (v4)
+    "bg-linear-": prefix("bg-image"),
+    "-bg-linear-": prefix("bg-image"),
+    "bg-radial-": prefix("bg-image"),
+    "bg-conic-": prefix("bg-image"),
+    "-bg-conic-": prefix("bg-image")
+  },
+  exactMatches: {
+    // Background attachment
+    "bg-fixed": prefix("bg-attachment"),
+    "bg-local": prefix("bg-attachment"),
+    "bg-scroll": prefix("bg-attachment"),
+    // Background clip
+    "bg-clip-border": prefix("bg-clip"),
+    "bg-clip-padding": prefix("bg-clip"),
+    "bg-clip-content": prefix("bg-clip"),
+    "bg-clip-text": prefix("bg-clip"),
+    // Background origin
+    "bg-origin-border": prefix("bg-origin"),
+    "bg-origin-padding": prefix("bg-origin"),
+    "bg-origin-content": prefix("bg-origin"),
+    // Background position
+    "bg-bottom": prefix("bg-position"),
+    "bg-center": prefix("bg-position"),
+    "bg-left": prefix("bg-position"),
+    "bg-left-bottom": prefix("bg-position"),
+    "bg-left-top": prefix("bg-position"),
+    "bg-right": prefix("bg-position"),
+    "bg-right-bottom": prefix("bg-position"),
+    "bg-right-top": prefix("bg-position"),
+    "bg-top": prefix("bg-position"),
+    // Background repeat
+    "bg-repeat": prefix("bg-repeat"),
+    "bg-no-repeat": prefix("bg-repeat"),
+    "bg-repeat-x": prefix("bg-repeat"),
+    "bg-repeat-y": prefix("bg-repeat"),
+    "bg-repeat-round": prefix("bg-repeat"),
+    "bg-repeat-space": prefix("bg-repeat"),
+    // Background size
+    "bg-auto": prefix("bg-size"),
+    "bg-cover": prefix("bg-size"),
+    "bg-contain": prefix("bg-size"),
+    // Background image
+    "bg-none": prefix("bg-image")
+  },
+  patterns: [
+    // Background position arbitrary
+    { pattern: /^bg-\[position:/, groupId: "bg-position", specificity: 1 },
+    // Background size arbitrary
+    { pattern: /^bg-\[size:/, groupId: "bg-size", specificity: 1 },
+    // Background image url
+    { pattern: /^bg-\[url/, groupId: "bg-image", specificity: 1 }
+  ],
+  conflicts: {
+    "bg-attachment": ["bg-attachment"],
+    "bg-clip": ["bg-clip"],
+    "bg-origin": ["bg-origin"],
+    "bg-position": ["bg-position"],
+    "bg-repeat": ["bg-repeat"],
+    "bg-size": ["bg-size"],
+    "bg-image": ["bg-image"]
+  }
+};
+
+// src/groups/borders.ts
+var BORDER_WIDTH_HIERARCHY = {
+  "border-width": { x: ["l", "r", "s", "e"], y: ["t", "b"] },
+  "border-spacing": { x: [], y: [] }
+};
+function borderRadiusConflicts() {
+  const base = "border-radius";
+  const sides = ["t", "r", "b", "l", "s", "e"];
+  const corners = {
+    tl: ["t", "l"],
+    tr: ["t", "r"],
+    br: ["b", "r"],
+    bl: ["b", "l"],
+    ss: ["s"],
+    se: ["s", "e"],
+    es: ["e", "s"],
+    ee: ["e"]
+  };
+  const allGroups = [base, ...sides.map((s) => `${base}-${s}`), ...Object.keys(corners).map((c) => `${base}-${c}`)];
+  const conflicts = {};
+  conflicts[base] = allGroups;
+  for (const side of sides) {
+    const sideGroup = `${base}-${side}`;
+    const cornersOnSide = Object.entries(corners).filter(([_, adjSides]) => adjSides.includes(side)).map(([corner]) => `${base}-${corner}`);
+    conflicts[sideGroup] = [base, sideGroup, ...cornersOnSide];
+  }
+  for (const [corner, adjSides] of Object.entries(corners)) {
+    const cornerGroup = `${base}-${corner}`;
+    conflicts[cornerGroup] = [base, ...adjSides.map((s) => `${base}-${s}`), cornerGroup];
+  }
+  return conflicts;
+}
+var borderGroups = {
+  prefixes: {
+    // Border radius
+    "rounded-": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-t-": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-r-": prefix("border-radius-r", SPECIFICITY.AXIS),
+    "rounded-b-": prefix("border-radius-b", SPECIFICITY.AXIS),
+    "rounded-l-": prefix("border-radius-l", SPECIFICITY.AXIS),
+    "rounded-tl-": prefix("border-radius-tl", SPECIFICITY.SIDE),
+    "rounded-tr-": prefix("border-radius-tr", SPECIFICITY.SIDE),
+    "rounded-br-": prefix("border-radius-br", SPECIFICITY.SIDE),
+    "rounded-bl-": prefix("border-radius-bl", SPECIFICITY.SIDE),
+    "rounded-s-": prefix("border-radius-s", SPECIFICITY.AXIS),
+    "rounded-e-": prefix("border-radius-e", SPECIFICITY.AXIS),
+    "rounded-ss-": prefix("border-radius-ss", SPECIFICITY.SIDE),
+    "rounded-se-": prefix("border-radius-se", SPECIFICITY.SIDE),
+    "rounded-es-": prefix("border-radius-es", SPECIFICITY.SIDE),
+    "rounded-ee-": prefix("border-radius-ee", SPECIFICITY.SIDE),
+    // Border width (handled by exact matches mostly, but prefix for arbitrary)
+    "border-x-": prefix("border-width-x", SPECIFICITY.AXIS),
+    "border-y-": prefix("border-width-y", SPECIFICITY.AXIS),
+    "border-t-": prefix("border-width-t", SPECIFICITY.SIDE),
+    "border-r-": prefix("border-width-r", SPECIFICITY.SIDE),
+    "border-b-": prefix("border-width-b", SPECIFICITY.SIDE),
+    "border-l-": prefix("border-width-l", SPECIFICITY.SIDE),
+    "border-s-": prefix("border-width-s", SPECIFICITY.SIDE),
+    "border-e-": prefix("border-width-e", SPECIFICITY.SIDE),
+    // Border spacing
+    "border-spacing-": prefix("border-spacing", SPECIFICITY.ALL),
+    "border-spacing-x-": prefix("border-spacing-x", SPECIFICITY.AXIS),
+    "border-spacing-y-": prefix("border-spacing-y", SPECIFICITY.AXIS),
+    // Divide
+    "divide-x-": prefix("divide-x"),
+    "divide-y-": prefix("divide-y"),
+    // Outline
+    "outline-offset-": prefix("outline-offset"),
+    // Ring
+    "ring-offset-": prefix("ring-offset-width")
+  },
+  exactMatches: {
+    // Border radius exact
+    rounded: prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-none": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-sm": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-md": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-lg": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-xl": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-2xl": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-3xl": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-full": prefix("border-radius", SPECIFICITY.ALL),
+    "rounded-t": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-t-none": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-t-sm": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-t-md": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-t-lg": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-t-xl": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-t-2xl": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-t-3xl": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-t-full": prefix("border-radius-t", SPECIFICITY.AXIS),
+    "rounded-r": prefix("border-radius-r", SPECIFICITY.AXIS),
+    "rounded-b": prefix("border-radius-b", SPECIFICITY.AXIS),
+    "rounded-l": prefix("border-radius-l", SPECIFICITY.AXIS),
+    "rounded-s": prefix("border-radius-s", SPECIFICITY.AXIS),
+    "rounded-e": prefix("border-radius-e", SPECIFICITY.AXIS),
+    "rounded-tl": prefix("border-radius-tl", SPECIFICITY.SIDE),
+    "rounded-tr": prefix("border-radius-tr", SPECIFICITY.SIDE),
+    "rounded-br": prefix("border-radius-br", SPECIFICITY.SIDE),
+    "rounded-bl": prefix("border-radius-bl", SPECIFICITY.SIDE),
+    // Border width
+    border: prefix("border-width", SPECIFICITY.ALL),
+    "border-0": prefix("border-width", SPECIFICITY.ALL),
+    "border-2": prefix("border-width", SPECIFICITY.ALL),
+    "border-4": prefix("border-width", SPECIFICITY.ALL),
+    "border-8": prefix("border-width", SPECIFICITY.ALL),
+    "border-x": prefix("border-width-x", SPECIFICITY.AXIS),
+    "border-x-0": prefix("border-width-x", SPECIFICITY.AXIS),
+    "border-x-2": prefix("border-width-x", SPECIFICITY.AXIS),
+    "border-x-4": prefix("border-width-x", SPECIFICITY.AXIS),
+    "border-x-8": prefix("border-width-x", SPECIFICITY.AXIS),
+    "border-y": prefix("border-width-y", SPECIFICITY.AXIS),
+    "border-y-0": prefix("border-width-y", SPECIFICITY.AXIS),
+    "border-y-2": prefix("border-width-y", SPECIFICITY.AXIS),
+    "border-y-4": prefix("border-width-y", SPECIFICITY.AXIS),
+    "border-y-8": prefix("border-width-y", SPECIFICITY.AXIS),
+    "border-t": prefix("border-width-t", SPECIFICITY.SIDE),
+    "border-t-0": prefix("border-width-t", SPECIFICITY.SIDE),
+    "border-t-2": prefix("border-width-t", SPECIFICITY.SIDE),
+    "border-t-4": prefix("border-width-t", SPECIFICITY.SIDE),
+    "border-t-8": prefix("border-width-t", SPECIFICITY.SIDE),
+    "border-r": prefix("border-width-r", SPECIFICITY.SIDE),
+    "border-b": prefix("border-width-b", SPECIFICITY.SIDE),
+    "border-l": prefix("border-width-l", SPECIFICITY.SIDE),
+    "border-s": prefix("border-width-s", SPECIFICITY.SIDE),
+    "border-e": prefix("border-width-e", SPECIFICITY.SIDE),
+    // Border style
+    "border-solid": prefix("border-style"),
+    "border-dashed": prefix("border-style"),
+    "border-dotted": prefix("border-style"),
+    "border-double": prefix("border-style"),
+    "border-hidden": prefix("border-style"),
+    "border-none": prefix("border-style"),
+    // Border collapse
+    "border-collapse": prefix("border-collapse"),
+    "border-separate": prefix("border-collapse"),
+    // Divide style
+    "divide-solid": prefix("divide-style"),
+    "divide-dashed": prefix("divide-style"),
+    "divide-dotted": prefix("divide-style"),
+    "divide-double": prefix("divide-style"),
+    "divide-none": prefix("divide-style"),
+    // Divide reverse
+    "divide-x-reverse": prefix("divide-x-reverse"),
+    "divide-y-reverse": prefix("divide-y-reverse"),
+    // Outline style
+    outline: prefix("outline-style"),
+    "outline-none": prefix("outline-style"),
+    "outline-hidden": prefix("outline-style"),
+    "outline-dashed": prefix("outline-style"),
+    "outline-dotted": prefix("outline-style"),
+    "outline-double": prefix("outline-style"),
+    // Outline width (must be exact to avoid conflicting with outline-color)
+    "outline-0": prefix("outline-width"),
+    "outline-1": prefix("outline-width"),
+    "outline-2": prefix("outline-width"),
+    "outline-4": prefix("outline-width"),
+    "outline-8": prefix("outline-width"),
+    // Ring width
+    ring: prefix("ring-width"),
+    "ring-0": prefix("ring-width"),
+    "ring-1": prefix("ring-width"),
+    "ring-2": prefix("ring-width"),
+    "ring-4": prefix("ring-width"),
+    "ring-8": prefix("ring-width"),
+    "ring-inset": prefix("ring-width")
+  },
+  patterns: [
+    // Border width arbitrary
+    { pattern: /^border-\[\d/, groupId: "border-width", specificity: SPECIFICITY.ALL },
+    { pattern: /^border-\d+$/, groupId: "border-width", specificity: SPECIFICITY.ALL },
+    // Rounded arbitrary
+    { pattern: /^rounded-\[/, groupId: "border-radius", specificity: SPECIFICITY.ALL },
+    // Outline width
+    { pattern: /^outline-\d+$/, groupId: "outline-width", specificity: 1 },
+    { pattern: /^outline-\[.*px/, groupId: "outline-width", specificity: 1 },
+    // Ring arbitrary
+    { pattern: /^ring-\[/, groupId: "ring-width", specificity: 1 },
+    // Ring offset arbitrary
+    { pattern: /^ring-offset-\d+$/, groupId: "ring-offset-width", specificity: 1 },
+    { pattern: /^ring-offset-\[/, groupId: "ring-offset-width", specificity: 1 }
+  ],
+  conflicts: {
+    ...borderRadiusConflicts(),
+    ...generateConflicts(BORDER_WIDTH_HIERARCHY),
+    ...simpleConflicts(
+      "border-style",
+      "border-collapse",
+      "divide-x",
+      "divide-y",
+      "divide-style",
+      "divide-x-reverse",
+      "divide-y-reverse",
+      "outline-style",
+      "outline-width",
+      "outline-offset",
+      "ring-width",
+      "ring-offset-width"
+    )
+  }
+};
+
+// src/groups/effects.ts
+var effectsGroups = {
+  prefixes: {
+    // Opacity
+    "opacity-": prefix("opacity"),
+    // Inset shadow (arbitrary)
+    "inset-shadow-": prefix("inset-shadow"),
+    // Inset ring (arbitrary)
+    "inset-ring-": prefix("inset-ring"),
+    // Text shadow (arbitrary)
+    "text-shadow-": prefix("text-shadow"),
+    // Mix blend
+    "mix-blend-": prefix("mix-blend-mode"),
+    // Background blend
+    "bg-blend-": prefix("bg-blend-mode"),
+    // Filter values
+    "brightness-": prefix("brightness"),
+    "contrast-": prefix("contrast"),
+    "saturate-": prefix("saturate"),
+    "hue-rotate-": prefix("hue-rotate"),
+    "-hue-rotate-": prefix("hue-rotate"),
+    // Backdrop filter values
+    "backdrop-brightness-": prefix("backdrop-brightness"),
+    "backdrop-contrast-": prefix("backdrop-contrast"),
+    "backdrop-saturate-": prefix("backdrop-saturate"),
+    "backdrop-hue-rotate-": prefix("backdrop-hue-rotate"),
+    "-backdrop-hue-rotate-": prefix("backdrop-hue-rotate"),
+    "backdrop-opacity-": prefix("backdrop-opacity")
+  },
+  exactMatches: {
+    // Box shadow
+    shadow: prefix("box-shadow"),
+    "shadow-sm": prefix("box-shadow"),
+    "shadow-md": prefix("box-shadow"),
+    "shadow-lg": prefix("box-shadow"),
+    "shadow-xl": prefix("box-shadow"),
+    "shadow-2xl": prefix("box-shadow"),
+    "shadow-inner": prefix("box-shadow"),
+    "shadow-none": prefix("box-shadow"),
+    // Inset shadow
+    "inset-shadow": prefix("inset-shadow"),
+    "inset-shadow-xs": prefix("inset-shadow"),
+    "inset-shadow-sm": prefix("inset-shadow"),
+    "inset-shadow-md": prefix("inset-shadow"),
+    "inset-shadow-lg": prefix("inset-shadow"),
+    "inset-shadow-none": prefix("inset-shadow"),
+    // Inset ring
+    "inset-ring": prefix("inset-ring"),
+    "inset-ring-0": prefix("inset-ring"),
+    "inset-ring-1": prefix("inset-ring"),
+    "inset-ring-2": prefix("inset-ring"),
+    "inset-ring-4": prefix("inset-ring"),
+    "inset-ring-8": prefix("inset-ring"),
+    // Text shadow
+    "text-shadow": prefix("text-shadow"),
+    "text-shadow-sm": prefix("text-shadow"),
+    "text-shadow-md": prefix("text-shadow"),
+    "text-shadow-lg": prefix("text-shadow"),
+    "text-shadow-none": prefix("text-shadow"),
+    // Box decoration break
+    "box-decoration-clone": prefix("box-decoration-break"),
+    "box-decoration-slice": prefix("box-decoration-break"),
+    // Filter
+    filter: prefix("filter"),
+    "filter-none": prefix("filter"),
+    // Blur
+    blur: prefix("blur"),
+    "blur-none": prefix("blur"),
+    "blur-sm": prefix("blur"),
+    "blur-md": prefix("blur"),
+    "blur-lg": prefix("blur"),
+    "blur-xl": prefix("blur"),
+    "blur-2xl": prefix("blur"),
+    "blur-3xl": prefix("blur"),
+    // Drop shadow
+    "drop-shadow": prefix("drop-shadow"),
+    "drop-shadow-sm": prefix("drop-shadow"),
+    "drop-shadow-md": prefix("drop-shadow"),
+    "drop-shadow-lg": prefix("drop-shadow"),
+    "drop-shadow-xl": prefix("drop-shadow"),
+    "drop-shadow-2xl": prefix("drop-shadow"),
+    "drop-shadow-none": prefix("drop-shadow"),
+    // Grayscale
+    grayscale: prefix("grayscale"),
+    "grayscale-0": prefix("grayscale"),
+    // Invert
+    invert: prefix("invert"),
+    "invert-0": prefix("invert"),
+    // Sepia
+    sepia: prefix("sepia"),
+    "sepia-0": prefix("sepia"),
+    // Backdrop filter
+    "backdrop-filter": prefix("backdrop-filter"),
+    "backdrop-filter-none": prefix("backdrop-filter"),
+    // Backdrop blur
+    "backdrop-blur": prefix("backdrop-blur"),
+    "backdrop-blur-none": prefix("backdrop-blur"),
+    "backdrop-blur-sm": prefix("backdrop-blur"),
+    "backdrop-blur-md": prefix("backdrop-blur"),
+    "backdrop-blur-lg": prefix("backdrop-blur"),
+    "backdrop-blur-xl": prefix("backdrop-blur"),
+    "backdrop-blur-2xl": prefix("backdrop-blur"),
+    "backdrop-blur-3xl": prefix("backdrop-blur"),
+    // Backdrop grayscale
+    "backdrop-grayscale": prefix("backdrop-grayscale"),
+    "backdrop-grayscale-0": prefix("backdrop-grayscale"),
+    // Backdrop invert
+    "backdrop-invert": prefix("backdrop-invert"),
+    "backdrop-invert-0": prefix("backdrop-invert"),
+    // Backdrop sepia
+    "backdrop-sepia": prefix("backdrop-sepia"),
+    "backdrop-sepia-0": prefix("backdrop-sepia")
+  },
+  patterns: [
+    // Shadow arbitrary
+    { pattern: /^shadow-\[/, groupId: "box-shadow", specificity: 1 },
+    // Inset shadow arbitrary
+    { pattern: /^inset-shadow-\[/, groupId: "inset-shadow", specificity: 1 },
+    // Inset ring arbitrary
+    { pattern: /^inset-ring-\[/, groupId: "inset-ring", specificity: 1 },
+    // Text shadow arbitrary
+    { pattern: /^text-shadow-\[/, groupId: "text-shadow", specificity: 1 },
+    // Blur arbitrary
+    { pattern: /^blur-\[/, groupId: "blur", specificity: 1 },
+    // Drop shadow arbitrary
+    { pattern: /^drop-shadow-\[/, groupId: "drop-shadow", specificity: 1 },
+    // Backdrop blur arbitrary
+    { pattern: /^backdrop-blur-\[/, groupId: "backdrop-blur", specificity: 1 }
+  ],
+  conflicts: simpleConflicts(
+    "box-shadow",
+    "box-shadow-color",
+    "inset-shadow",
+    "inset-shadow-color",
+    "inset-ring",
+    "inset-ring-color",
+    "text-shadow",
+    "text-shadow-color",
+    "box-decoration-break",
+    "opacity",
+    "mix-blend-mode",
+    "bg-blend-mode",
+    "filter",
+    "blur",
+    "brightness",
+    "contrast",
+    "drop-shadow",
+    "grayscale",
+    "hue-rotate",
+    "invert",
+    "saturate",
+    "sepia",
+    "backdrop-filter",
+    "backdrop-blur",
+    "backdrop-brightness",
+    "backdrop-contrast",
+    "backdrop-grayscale",
+    "backdrop-hue-rotate",
+    "backdrop-invert",
+    "backdrop-opacity",
+    "backdrop-saturate",
+    "backdrop-sepia"
+  )
+};
+
+// src/groups/transforms.ts
+var transformGroups = {
+  prefixes: {
+    // Scale (2D)
+    "scale-": prefix("scale", SPECIFICITY.ALL),
+    "-scale-": prefix("scale", SPECIFICITY.ALL),
+    "scale-x-": prefix("scale-x", SPECIFICITY.AXIS),
+    "-scale-x-": prefix("scale-x", SPECIFICITY.AXIS),
+    "scale-y-": prefix("scale-y", SPECIFICITY.AXIS),
+    "-scale-y-": prefix("scale-y", SPECIFICITY.AXIS),
+    // Scale (3D)
+    "scale-z-": prefix("scale-z", SPECIFICITY.AXIS),
+    "-scale-z-": prefix("scale-z", SPECIFICITY.AXIS),
+    // Rotate (2D - default Z-axis)
+    "rotate-": prefix("rotate"),
+    "-rotate-": prefix("rotate"),
+    // Rotate (3D axes)
+    "rotate-x-": prefix("rotate-x"),
+    "-rotate-x-": prefix("rotate-x"),
+    "rotate-y-": prefix("rotate-y"),
+    "-rotate-y-": prefix("rotate-y"),
+    "rotate-z-": prefix("rotate-z"),
+    "-rotate-z-": prefix("rotate-z"),
+    // Translate (2D)
+    "translate-": prefix("translate", SPECIFICITY.ALL),
+    "-translate-": prefix("translate", SPECIFICITY.ALL),
+    "translate-x-": prefix("translate-x", SPECIFICITY.AXIS),
+    "-translate-x-": prefix("translate-x", SPECIFICITY.AXIS),
+    "translate-y-": prefix("translate-y", SPECIFICITY.AXIS),
+    "-translate-y-": prefix("translate-y", SPECIFICITY.AXIS),
+    // Translate (3D)
+    "translate-z-": prefix("translate-z", SPECIFICITY.AXIS),
+    "-translate-z-": prefix("translate-z", SPECIFICITY.AXIS),
+    // Skew
+    "skew-x-": prefix("skew-x"),
+    "-skew-x-": prefix("skew-x"),
+    "skew-y-": prefix("skew-y"),
+    "-skew-y-": prefix("skew-y"),
+    // Transform origin
+    "origin-": prefix("transform-origin"),
+    // Perspective
+    "perspective-": prefix("perspective"),
+    // Perspective origin
+    "perspective-origin-": prefix("perspective-origin")
+  },
+  exactMatches: {
+    // Transform
+    transform: prefix("transform"),
+    "transform-cpu": prefix("transform"),
+    "transform-gpu": prefix("transform"),
+    "transform-none": prefix("transform"),
+    // Transform style (3D)
+    "transform-3d": prefix("transform-style"),
+    "transform-flat": prefix("transform-style"),
+    // Backface visibility
+    "backface-visible": prefix("backface-visibility"),
+    "backface-hidden": prefix("backface-visibility"),
+    // Perspective none
+    "perspective-none": prefix("perspective"),
+    // Transform box
+    "transform-box-content": prefix("transform-box"),
+    "transform-box-border": prefix("transform-box"),
+    "transform-box-fill": prefix("transform-box"),
+    "transform-box-stroke": prefix("transform-box"),
+    "transform-box-view": prefix("transform-box"),
+    // Scale static
+    "scale-none": prefix("scale", SPECIFICITY.ALL),
+    "scale-3d": prefix("scale", SPECIFICITY.ALL),
+    // Rotate static
+    "rotate-none": prefix("rotate"),
+    // Translate static
+    "translate-none": prefix("translate", SPECIFICITY.ALL),
+    "translate-full": prefix("translate", SPECIFICITY.ALL),
+    "-translate-full": prefix("translate", SPECIFICITY.ALL),
+    // Perspective origin positions
+    "perspective-origin-center": prefix("perspective-origin"),
+    "perspective-origin-top": prefix("perspective-origin"),
+    "perspective-origin-top-right": prefix("perspective-origin"),
+    "perspective-origin-right": prefix("perspective-origin"),
+    "perspective-origin-bottom-right": prefix("perspective-origin"),
+    "perspective-origin-bottom": prefix("perspective-origin"),
+    "perspective-origin-bottom-left": prefix("perspective-origin"),
+    "perspective-origin-left": prefix("perspective-origin"),
+    "perspective-origin-top-left": prefix("perspective-origin")
+  },
+  patterns: [
+    // Perspective arbitrary
+    { pattern: /^perspective-\[/, groupId: "perspective", specificity: 1 }
+  ],
+  conflicts: {
+    transform: ["transform"],
+    "transform-style": ["transform-style"],
+    "backface-visibility": ["backface-visibility"],
+    perspective: ["perspective"],
+    "perspective-origin": ["perspective-origin"],
+    // Scale - 2D bidirectional (scale-z is independent 3D axis)
+    scale: ["scale", "scale-x", "scale-y"],
+    "scale-x": ["scale", "scale-x"],
+    "scale-y": ["scale", "scale-y"],
+    "scale-z": ["scale-z"],
+    // Rotate - each axis is independent
+    rotate: ["rotate"],
+    "rotate-x": ["rotate-x"],
+    "rotate-y": ["rotate-y"],
+    "rotate-z": ["rotate-z"],
+    // Translate - 2D bidirectional (translate-z is independent 3D axis)
+    translate: ["translate", "translate-x", "translate-y"],
+    "translate-x": ["translate", "translate-x"],
+    "translate-y": ["translate", "translate-y"],
+    "translate-z": ["translate-z"],
+    ...simpleConflicts("skew-x", "skew-y", "transform-origin", "transform-box")
+  }
+};
+
+// src/groups/transitions.ts
+var transitionGroups = {
+  prefixes: {
+    // Duration
+    "duration-": prefix("transition-duration"),
+    // Delay
+    "delay-": prefix("transition-delay")
+  },
+  exactMatches: {
+    // Transition
+    transition: prefix("transition"),
+    "transition-none": prefix("transition"),
+    "transition-all": prefix("transition"),
+    "transition-colors": prefix("transition"),
+    "transition-opacity": prefix("transition"),
+    "transition-shadow": prefix("transition"),
+    "transition-transform": prefix("transition"),
+    // Timing function
+    "ease-linear": prefix("transition-timing-function"),
+    "ease-in": prefix("transition-timing-function"),
+    "ease-out": prefix("transition-timing-function"),
+    "ease-in-out": prefix("transition-timing-function"),
+    // Transition behavior (new in v4)
+    "transition-normal": prefix("transition-behavior"),
+    "transition-discrete": prefix("transition-behavior"),
+    // Animation
+    "animate-none": prefix("animation"),
+    "animate-spin": prefix("animation"),
+    "animate-ping": prefix("animation"),
+    "animate-pulse": prefix("animation"),
+    "animate-bounce": prefix("animation")
+  },
+  patterns: [
+    // Animate arbitrary
+    { pattern: /^animate-\[/, groupId: "animation", specificity: 1 }
+  ],
+  conflicts: simpleConflicts(
+    "transition",
+    "transition-duration",
+    "transition-timing-function",
+    "transition-delay",
+    "transition-behavior",
+    "animation"
+  )
+};
+
+// src/groups/interactivity.ts
+var interactivityGroups = {
+  prefixes: {
+    // Cursor
+    "cursor-": prefix("cursor"),
+    // Scroll margin
+    "scroll-m-": prefix("scroll-margin", SPECIFICITY.ALL),
+    "scroll-mx-": prefix("scroll-margin-x", SPECIFICITY.AXIS),
+    "scroll-my-": prefix("scroll-margin-y", SPECIFICITY.AXIS),
+    "scroll-mt-": prefix("scroll-margin-t", SPECIFICITY.SIDE),
+    "scroll-mr-": prefix("scroll-margin-r", SPECIFICITY.SIDE),
+    "scroll-mb-": prefix("scroll-margin-b", SPECIFICITY.SIDE),
+    "scroll-ml-": prefix("scroll-margin-l", SPECIFICITY.SIDE),
+    "scroll-ms-": prefix("scroll-margin-s", SPECIFICITY.SIDE),
+    "scroll-me-": prefix("scroll-margin-e", SPECIFICITY.SIDE),
+    // Scroll padding
+    "scroll-p-": prefix("scroll-padding", SPECIFICITY.ALL),
+    "scroll-px-": prefix("scroll-padding-x", SPECIFICITY.AXIS),
+    "scroll-py-": prefix("scroll-padding-y", SPECIFICITY.AXIS),
+    "scroll-pt-": prefix("scroll-padding-t", SPECIFICITY.SIDE),
+    "scroll-pr-": prefix("scroll-padding-r", SPECIFICITY.SIDE),
+    "scroll-pb-": prefix("scroll-padding-b", SPECIFICITY.SIDE),
+    "scroll-pl-": prefix("scroll-padding-l", SPECIFICITY.SIDE),
+    "scroll-ps-": prefix("scroll-padding-s", SPECIFICITY.SIDE),
+    "scroll-pe-": prefix("scroll-padding-e", SPECIFICITY.SIDE),
+    // Will change
+    "will-change-": prefix("will-change")
+  },
+  exactMatches: {
+    // Appearance
+    "appearance-none": prefix("appearance"),
+    "appearance-auto": prefix("appearance"),
+    // Pointer events
+    "pointer-events-none": prefix("pointer-events"),
+    "pointer-events-auto": prefix("pointer-events"),
+    // Resize
+    resize: prefix("resize"),
+    "resize-none": prefix("resize"),
+    "resize-y": prefix("resize"),
+    "resize-x": prefix("resize"),
+    // Scroll behavior
+    "scroll-auto": prefix("scroll-behavior"),
+    "scroll-smooth": prefix("scroll-behavior"),
+    // Scroll snap align
+    "snap-start": prefix("scroll-snap-align"),
+    "snap-end": prefix("scroll-snap-align"),
+    "snap-center": prefix("scroll-snap-align"),
+    "snap-align-none": prefix("scroll-snap-align"),
+    // Scroll snap stop
+    "snap-normal": prefix("scroll-snap-stop"),
+    "snap-always": prefix("scroll-snap-stop"),
+    // Scroll snap type
+    "snap-none": prefix("scroll-snap-type"),
+    "snap-x": prefix("scroll-snap-type"),
+    "snap-y": prefix("scroll-snap-type"),
+    "snap-both": prefix("scroll-snap-type"),
+    "snap-mandatory": prefix("scroll-snap-type"),
+    "snap-proximity": prefix("scroll-snap-type"),
+    // Touch action
+    "touch-auto": prefix("touch-action"),
+    "touch-none": prefix("touch-action"),
+    "touch-pan-x": prefix("touch-action"),
+    "touch-pan-left": prefix("touch-action"),
+    "touch-pan-right": prefix("touch-action"),
+    "touch-pan-y": prefix("touch-action"),
+    "touch-pan-up": prefix("touch-action"),
+    "touch-pan-down": prefix("touch-action"),
+    "touch-pinch-zoom": prefix("touch-action"),
+    "touch-manipulation": prefix("touch-action"),
+    // User select
+    "select-none": prefix("user-select"),
+    "select-text": prefix("user-select"),
+    "select-all": prefix("user-select"),
+    "select-auto": prefix("user-select"),
+    // Will change
+    "will-change-auto": prefix("will-change"),
+    "will-change-scroll": prefix("will-change"),
+    "will-change-contents": prefix("will-change"),
+    "will-change-transform": prefix("will-change")
+  },
+  patterns: [
+    // Will change arbitrary
+    { pattern: /^will-change-\[/, groupId: "will-change", specificity: 1 }
+  ],
+  conflicts: {
+    appearance: ["appearance"],
+    cursor: ["cursor"],
+    "pointer-events": ["pointer-events"],
+    resize: ["resize"],
+    "scroll-behavior": ["scroll-behavior"],
+    "scroll-margin": [
+      "scroll-margin",
+      "scroll-margin-x",
+      "scroll-margin-y",
+      "scroll-margin-t",
+      "scroll-margin-r",
+      "scroll-margin-b",
+      "scroll-margin-l",
+      "scroll-margin-s",
+      "scroll-margin-e"
+    ],
+    "scroll-margin-x": ["scroll-margin-x", "scroll-margin-l", "scroll-margin-r", "scroll-margin-s", "scroll-margin-e"],
+    "scroll-margin-y": ["scroll-margin-y", "scroll-margin-t", "scroll-margin-b"],
+    "scroll-margin-t": ["scroll-margin-t"],
+    "scroll-margin-r": ["scroll-margin-r"],
+    "scroll-margin-b": ["scroll-margin-b"],
+    "scroll-margin-l": ["scroll-margin-l"],
+    "scroll-margin-s": ["scroll-margin-s"],
+    "scroll-margin-e": ["scroll-margin-e"],
+    "scroll-padding": [
+      "scroll-padding",
+      "scroll-padding-x",
+      "scroll-padding-y",
+      "scroll-padding-t",
+      "scroll-padding-r",
+      "scroll-padding-b",
+      "scroll-padding-l",
+      "scroll-padding-s",
+      "scroll-padding-e"
+    ],
+    "scroll-padding-x": ["scroll-padding-x", "scroll-padding-l", "scroll-padding-r", "scroll-padding-s", "scroll-padding-e"],
+    "scroll-padding-y": ["scroll-padding-y", "scroll-padding-t", "scroll-padding-b"],
+    "scroll-padding-t": ["scroll-padding-t"],
+    "scroll-padding-r": ["scroll-padding-r"],
+    "scroll-padding-b": ["scroll-padding-b"],
+    "scroll-padding-l": ["scroll-padding-l"],
+    "scroll-padding-s": ["scroll-padding-s"],
+    "scroll-padding-e": ["scroll-padding-e"],
+    "scroll-snap-align": ["scroll-snap-align"],
+    "scroll-snap-stop": ["scroll-snap-stop"],
+    "scroll-snap-type": ["scroll-snap-type"],
+    "touch-action": ["touch-action"],
+    "user-select": ["user-select"],
+    "will-change": ["will-change"]
+  }
+};
+
+// src/groups/svg.ts
+var svgGroups = {
+  prefixes: {
+    // Stroke width (numeric values like stroke-2)
+    // Note: stroke-<color> is handled by colors.ts
+    "stroke-": prefix("stroke-width"),
+    // Stroke linecap
+    "stroke-cap-": prefix("stroke-cap"),
+    // Stroke linejoin
+    "stroke-join-": prefix("stroke-join"),
+    // Stroke dasharray
+    "stroke-dash-": prefix("stroke-dash"),
+    // Stroke dashoffset
+    "stroke-offset-": prefix("stroke-offset"),
+    // Stroke miterlimit
+    "stroke-miter-": prefix("stroke-miter"),
+    // Stroke opacity
+    "stroke-opacity-": prefix("stroke-opacity"),
+    // Paint order
+    "paint-": prefix("paint-order"),
+    // Vector effect
+    "vector-": prefix("vector-effect")
+  },
+  exactMatches: {
+    // Stroke linecap exact matches
+    "stroke-cap-butt": prefix("stroke-cap"),
+    "stroke-cap-round": prefix("stroke-cap"),
+    "stroke-cap-square": prefix("stroke-cap"),
+    // Stroke linejoin exact matches
+    "stroke-join-miter": prefix("stroke-join"),
+    "stroke-join-round": prefix("stroke-join"),
+    "stroke-join-bevel": prefix("stroke-join"),
+    // Paint order exact matches
+    "paint-normal": prefix("paint-order"),
+    "paint-stroke": prefix("paint-order"),
+    "paint-fill": prefix("paint-order"),
+    "paint-markers": prefix("paint-order"),
+    "paint-stroke-fill": prefix("paint-order"),
+    "paint-stroke-markers": prefix("paint-order"),
+    "paint-fill-stroke": prefix("paint-order"),
+    "paint-fill-markers": prefix("paint-order"),
+    "paint-markers-stroke": prefix("paint-order"),
+    "paint-markers-fill": prefix("paint-order"),
+    "paint-stroke-fill-markers": prefix("paint-order"),
+    "paint-stroke-markers-fill": prefix("paint-order"),
+    "paint-fill-stroke-markers": prefix("paint-order"),
+    "paint-fill-markers-stroke": prefix("paint-order"),
+    "paint-markers-stroke-fill": prefix("paint-order"),
+    "paint-markers-fill-stroke": prefix("paint-order"),
+    // Vector effect exact matches
+    "vector-none": prefix("vector-effect"),
+    "vector-non-scaling-stroke": prefix("vector-effect"),
+    "vector-non-scaling-size": prefix("vector-effect"),
+    "vector-non-rotation": prefix("vector-effect"),
+    "vector-fixed-position": prefix("vector-effect")
+  },
+  patterns: [
+    // Stroke width numeric
+    { pattern: /^stroke-\d+$/, groupId: "stroke-width", specificity: 1 },
+    // Stroke width arbitrary
+    { pattern: /^stroke-\[/, groupId: "stroke-width", specificity: 1 },
+    // Stroke dasharray arbitrary
+    { pattern: /^stroke-dash-\[/, groupId: "stroke-dash", specificity: 1 },
+    // Stroke dashoffset arbitrary
+    { pattern: /^stroke-offset-\[/, groupId: "stroke-offset", specificity: 1 },
+    // Stroke miterlimit arbitrary
+    { pattern: /^stroke-miter-\[/, groupId: "stroke-miter", specificity: 1 },
+    // Stroke opacity arbitrary
+    { pattern: /^stroke-opacity-\[/, groupId: "stroke-opacity", specificity: 1 }
+  ],
+  conflicts: simpleConflicts(
+    "stroke-width",
+    "stroke-cap",
+    "stroke-join",
+    "stroke-dash",
+    "stroke-offset",
+    "stroke-miter",
+    "stroke-opacity",
+    "paint-order",
+    "vector-effect"
+  )
+};
+
+// src/groups/accessibility.ts
+var accessibilityGroups = {
+  prefixes: {},
+  exactMatches: {
+    // Screen reader
+    "sr-only": prefix("sr-only"),
+    "not-sr-only": prefix("sr-only"),
+    // Forced color adjust
+    "forced-color-adjust-auto": prefix("forced-color-adjust"),
+    "forced-color-adjust-none": prefix("forced-color-adjust")
+  },
+  patterns: [],
+  conflicts: {
+    "sr-only": ["sr-only"],
+    "forced-color-adjust": ["forced-color-adjust"]
+  }
+};
+
+// src/groups/tables.ts
+var tableGroups = {
+  prefixes: {},
+  exactMatches: {
+    // Table layout
+    "table-auto": prefix("table-layout"),
+    "table-fixed": prefix("table-layout"),
+    // Caption side
+    "caption-top": prefix("caption-side"),
+    "caption-bottom": prefix("caption-side")
+  },
+  patterns: [],
+  conflicts: {
+    "table-layout": ["table-layout"],
+    "caption-side": ["caption-side"]
+  }
+};
+
+// src/groups/masks.ts
+var maskGroups = {
+  prefixes: {
+    // Mask image (arbitrary)
+    "mask-": prefix("mask-image"),
+    // Mask size (arbitrary)
+    "mask-size-": prefix("mask-size"),
+    // Mask position (arbitrary)
+    "mask-position-": prefix("mask-position")
+  },
+  exactMatches: {
+    // Mask image
+    "mask-none": prefix("mask-image"),
+    // Mask shape functions
+    "mask-circle": prefix("mask-image"),
+    "mask-ellipse": prefix("mask-image"),
+    "mask-no-clip": prefix("mask-clip"),
+    // Mask radial positions
+    "mask-radial-at-center": prefix("mask-image"),
+    "mask-radial-at-top": prefix("mask-image"),
+    "mask-radial-at-top-left": prefix("mask-image"),
+    "mask-radial-at-top-right": prefix("mask-image"),
+    "mask-radial-at-bottom": prefix("mask-image"),
+    "mask-radial-at-bottom-left": prefix("mask-image"),
+    "mask-radial-at-bottom-right": prefix("mask-image"),
+    "mask-radial-at-left": prefix("mask-image"),
+    "mask-radial-at-right": prefix("mask-image"),
+    // Mask radial sizing
+    "mask-radial-closest-corner": prefix("mask-image"),
+    "mask-radial-closest-side": prefix("mask-image"),
+    "mask-radial-farthest-corner": prefix("mask-image"),
+    "mask-radial-farthest-side": prefix("mask-image"),
+    // Mask composite
+    "mask-add": prefix("mask-composite"),
+    "mask-subtract": prefix("mask-composite"),
+    "mask-intersect": prefix("mask-composite"),
+    "mask-exclude": prefix("mask-composite"),
+    // Mask mode
+    "mask-alpha": prefix("mask-mode"),
+    "mask-luminance": prefix("mask-mode"),
+    "mask-match": prefix("mask-mode"),
+    // Mask type
+    "mask-type-alpha": prefix("mask-type"),
+    "mask-type-luminance": prefix("mask-type"),
+    // Mask size
+    "mask-auto": prefix("mask-size"),
+    "mask-cover": prefix("mask-size"),
+    "mask-contain": prefix("mask-size"),
+    // Mask position
+    "mask-center": prefix("mask-position"),
+    "mask-top": prefix("mask-position"),
+    "mask-top-left": prefix("mask-position"),
+    "mask-top-right": prefix("mask-position"),
+    "mask-bottom": prefix("mask-position"),
+    "mask-bottom-left": prefix("mask-position"),
+    "mask-bottom-right": prefix("mask-position"),
+    "mask-left": prefix("mask-position"),
+    "mask-right": prefix("mask-position"),
+    // Mask repeat
+    "mask-repeat": prefix("mask-repeat"),
+    "mask-no-repeat": prefix("mask-repeat"),
+    "mask-repeat-x": prefix("mask-repeat"),
+    "mask-repeat-y": prefix("mask-repeat"),
+    "mask-repeat-round": prefix("mask-repeat"),
+    "mask-repeat-space": prefix("mask-repeat"),
+    // Mask clip
+    "mask-clip-border": prefix("mask-clip"),
+    "mask-clip-padding": prefix("mask-clip"),
+    "mask-clip-content": prefix("mask-clip"),
+    "mask-clip-fill": prefix("mask-clip"),
+    "mask-clip-stroke": prefix("mask-clip"),
+    "mask-clip-view": prefix("mask-clip"),
+    // Mask origin
+    "mask-origin-border": prefix("mask-origin"),
+    "mask-origin-padding": prefix("mask-origin"),
+    "mask-origin-content": prefix("mask-origin"),
+    "mask-origin-fill": prefix("mask-origin"),
+    "mask-origin-stroke": prefix("mask-origin"),
+    "mask-origin-view": prefix("mask-origin")
+  },
+  patterns: [
+    // Mask image arbitrary (gradients, urls, etc.)
+    { pattern: /^mask-\[/, groupId: "mask-image", specificity: 1 },
+    // Mask linear/radial/conic gradients
+    { pattern: /^mask-linear-/, groupId: "mask-image", specificity: 1 },
+    { pattern: /^mask-radial-/, groupId: "mask-image", specificity: 1 },
+    { pattern: /^mask-conic-/, groupId: "mask-image", specificity: 1 }
+  ],
+  conflicts: simpleConflicts(
+    "mask-image",
+    "mask-composite",
+    "mask-mode",
+    "mask-type",
+    "mask-size",
+    "mask-position",
+    "mask-repeat",
+    "mask-clip",
+    "mask-origin"
+  )
+};
+
+// src/groups/full.ts
+var _fullConfig = null;
+function getFullConfig() {
+  if (_fullConfig === null) {
+    _fullConfig = mergeConfigs(
+      layoutGroups,
+      spacingGroups,
+      sizingGroups,
+      flexboxGridGroups,
+      typographyGroups,
+      colorGroups,
+      backgroundGroups,
+      borderGroups,
+      effectsGroups,
+      transformGroups,
+      transitionGroups,
+      interactivityGroups,
+      svgGroups,
+      accessibilityGroups,
+      tableGroups,
+      maskGroups
+    );
+  }
+  return _fullConfig;
+}
+var fullConfig = new Proxy({}, {
+  get(_, prop) {
+    return getFullConfig()[prop];
+  },
+  ownKeys() {
+    return Reflect.ownKeys(getFullConfig());
+  },
+  getOwnPropertyDescriptor(_, prop) {
+    return Object.getOwnPropertyDescriptor(getFullConfig(), prop);
+  }
+});
+
+// src/groups/minimal.ts
+var minimalConfig = mergeConfigs(
+  layoutGroups,
+  spacingGroups,
+  sizingGroups,
+  flexboxGridGroups,
+  typographyGroups,
+  colorGroups,
+  borderGroups
+);
+
+// src/trie.ts
+function createTrieNode() {
+  return { children: /* @__PURE__ */ new Map(), entry: null };
+}
+var PrefixTrie = class {
+  constructor() {
+    this.root = createTrieNode();
+  }
+  insert(prefix2, entry) {
+    let node = this.root;
+    for (const char of prefix2) {
+      if (!node.children.has(char)) {
+        node.children.set(char, createTrieNode());
+      }
+      node = node.children.get(char);
+    }
+    node.entry = entry;
+  }
+  findLongestMatch(className) {
+    let node = this.root;
+    let lastMatch = null;
+    let matchLength = 0;
+    if (node.entry) {
+      lastMatch = { entry: node.entry, matchLength: 0 };
+    }
+    for (const char of className) {
+      const child = node.children.get(char);
+      if (!child) break;
+      node = child;
+      matchLength++;
+      if (node.entry) {
+        lastMatch = { entry: node.entry, matchLength };
+      }
+    }
+    return lastMatch;
+  }
+};
+
+// src/class-groups.ts
+var state = {
+  mode: "full",
+  config: fullConfig,
+  prefixTrie: new PrefixTrie(),
+  exactMatches: /* @__PURE__ */ new Map(),
+  conflicts: {},
+  conflictSets: /* @__PURE__ */ new Map(),
+  initialized: false
+};
+function initializeClassifier(config) {
+  state.prefixTrie = new PrefixTrie();
+  state.exactMatches = /* @__PURE__ */ new Map();
+  state.conflicts = config.conflicts;
+  state.conflictSets = /* @__PURE__ */ new Map();
+  for (const [prefix2, entry] of Object.entries(config.prefixes)) {
+    state.prefixTrie.insert(prefix2, entry);
+  }
+  for (const [className, entry] of Object.entries(config.exactMatches)) {
+    state.exactMatches.set(className, entry);
+  }
+  for (const [groupId, conflicts] of Object.entries(config.conflicts)) {
+    state.conflictSets.set(groupId, new Set(conflicts));
+  }
+  state.config = config;
+  state.initialized = true;
+}
+function setMergeMode(mode) {
+  if (mode === state.mode && state.initialized) {
+    return;
+  }
+  state.mode = mode;
+  if (mode === false) {
+    state.prefixTrie = new PrefixTrie();
+    state.exactMatches = /* @__PURE__ */ new Map();
+    state.conflicts = {};
+    state.conflictSets = /* @__PURE__ */ new Map();
+    state.initialized = true;
+    return;
+  }
+  const config = mode === "minimal" ? minimalConfig : fullConfig;
+  initializeClassifier(config);
+}
+function ensureInitialized() {
+  if (!state.initialized) {
+    setMergeMode(state.mode);
+  }
+}
+function classifyClass(utility) {
+  ensureInitialized();
+  if (state.mode === false) {
+    return { group: null, specificity: 1 };
+  }
+  const exactMatch = state.exactMatches.get(utility);
+  if (exactMatch) {
+    return { group: exactMatch.groupId, specificity: exactMatch.specificity };
+  }
+  const prefixMatch = state.prefixTrie.findLongestMatch(utility);
+  if (prefixMatch) {
+    return { group: prefixMatch.entry.groupId, specificity: prefixMatch.entry.specificity };
+  }
+  for (const { pattern, groupId, specificity } of state.config.patterns) {
+    if (pattern.test(utility)) {
+      return { group: groupId, specificity };
+    }
+  }
+  return { group: null, specificity: 1 };
+}
+function getConflictingGroups(groupId) {
+  ensureInitialized();
+  return state.conflicts[groupId] ?? [];
+}
+function getMergeMode() {
+  return state.mode;
+}
+function resetClassifier() {
+  state = {
+    mode: "full",
+    config: fullConfig,
+    prefixTrie: new PrefixTrie(),
+    exactMatches: /* @__PURE__ */ new Map(),
+    conflicts: {},
+    conflictSets: /* @__PURE__ */ new Map(),
+    initialized: false
+  };
+}
+
+// src/parser.ts
+function flattenClassValue(value) {
+  if (value === null || value === void 0 || value === false || value === "") {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 1) {
+      return flattenClassValue(value[0]);
+    }
+    let result = "";
+    for (const item of value) {
+      const flattened = flattenClassValue(item);
+      if (flattened) {
+        result = result ? result + " " + flattened : flattened;
+      }
+    }
+    return result;
+  }
+  if (typeof value === "object") {
+    let result = "";
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key) && value[key]) {
+        result = result ? result + " " + key : key;
+      }
+    }
+    return result;
+  }
+  return "";
+}
+function flattenClassValues(...inputs) {
+  if (inputs.length === 1) {
+    return flattenClassValue(inputs[0]);
+  }
+  let result = "";
+  for (const input of inputs) {
+    const flattened = flattenClassValue(input);
+    if (flattened) {
+      result = result ? result + " " + flattened : flattened;
+    }
+  }
+  return result;
+}
+var CLASS_SPLIT_REGEX = /\s+/;
+var ARBITRARY_VALUE_REGEX = /^\[([a-zA-Z-]+):(.+)\]$/;
+var ARBITRARY_CSS_VAR_REGEX = /^\[(--[a-zA-Z0-9-]+):(.+)\]$/;
+var POSTFIX_NUMBER_REGEX = /^[\d.]+$/;
+var POSTFIX_FRACTION_REGEX = /^\d+\/\d+$/;
+var POSTFIX_NAMED_REGEX = /^[a-z]+$/;
+function splitClasses(classString) {
+  return classString.split(CLASS_SPLIT_REGEX).filter(Boolean);
+}
+function extractModifiers(className) {
+  if (!className.includes("[")) {
+    const colonIndex = className.indexOf(":");
+    if (colonIndex === -1) {
+      if (className.startsWith("!")) {
+        return { modifiers: [], utility: className.slice(1), hasImportant: true };
+      }
+      return { modifiers: [], utility: className, hasImportant: false };
+    }
+    const parts2 = className.split(":");
+    let utility2 = parts2[parts2.length - 1];
+    const modifiers2 = parts2.slice(0, -1);
+    let hasImportant2 = false;
+    if (utility2.startsWith("!")) {
+      utility2 = utility2.slice(1);
+      hasImportant2 = true;
+    }
+    const importantIndex2 = modifiers2.indexOf("!");
+    if (importantIndex2 !== -1) {
+      modifiers2.splice(importantIndex2, 1);
+      hasImportant2 = true;
+    }
+    return { modifiers: modifiers2, utility: utility2, hasImportant: hasImportant2 };
+  }
+  const parts = [];
+  let current = "";
+  let bracketDepth = 0;
+  for (const char of className) {
+    if (char === "[") {
+      bracketDepth++;
+      current += char;
+    } else if (char === "]") {
+      bracketDepth--;
+      current += char;
+    } else if (char === ":" && bracketDepth === 0) {
+      if (current) {
+        parts.push(current);
+      }
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    parts.push(current);
+  }
+  if (parts.length === 0) {
+    return { modifiers: [], utility: "", hasImportant: false };
+  }
+  if (parts.length === 1) {
+    const single = parts[0];
+    if (single.startsWith("!")) {
+      return { modifiers: [], utility: single.slice(1), hasImportant: true };
+    }
+    return { modifiers: [], utility: single, hasImportant: false };
+  }
+  let utility = parts[parts.length - 1];
+  const modifiers = parts.slice(0, -1);
+  let hasImportant = false;
+  if (utility.startsWith("!")) {
+    utility = utility.slice(1);
+    hasImportant = true;
+  }
+  const importantIndex = modifiers.indexOf("!");
+  if (importantIndex !== -1) {
+    modifiers.splice(importantIndex, 1);
+    hasImportant = true;
+  }
+  return { modifiers, utility, hasImportant };
+}
+function stripPostfixModifier(utility) {
+  if (utility.includes("[")) {
+    return utility;
+  }
+  const slashIndex = utility.lastIndexOf("/");
+  if (slashIndex === -1) {
+    return utility;
+  }
+  const afterSlash = utility.slice(slashIndex + 1);
+  if (POSTFIX_NUMBER_REGEX.test(afterSlash) || POSTFIX_FRACTION_REGEX.test(afterSlash) || POSTFIX_NAMED_REGEX.test(afterSlash)) {
+    return utility.slice(0, slashIndex);
+  }
+  return utility;
+}
+function parseClassBase(className, position) {
+  const { modifiers, utility, hasImportant } = extractModifiers(className);
+  let modifierKey;
+  if (modifiers.length === 0) {
+    modifierKey = "";
+  } else if (modifiers.length === 1) {
+    modifierKey = modifiers[0];
+  } else {
+    modifierKey = [...modifiers].sort().join(":");
+  }
+  const utilityForClassification = stripPostfixModifier(utility);
+  const cssVarMatch = utilityForClassification.match(ARBITRARY_CSS_VAR_REGEX);
+  if (cssVarMatch) {
+    return {
+      raw: className,
+      modifiers,
+      modifierKey,
+      hasImportant,
+      utility,
+      utilityForClassification,
+      isArbitrary: true,
+      arbitraryProperty: cssVarMatch[1],
+      position
+    };
+  }
+  const arbitraryMatch = utilityForClassification.match(ARBITRARY_VALUE_REGEX);
+  if (arbitraryMatch) {
+    return {
+      raw: className,
+      modifiers,
+      modifierKey,
+      hasImportant,
+      utility,
+      utilityForClassification,
+      isArbitrary: true,
+      arbitraryProperty: arbitraryMatch[1],
+      position
+    };
+  }
+  return {
+    raw: className,
+    modifiers,
+    modifierKey,
+    hasImportant,
+    utility,
+    utilityForClassification,
+    isArbitrary: false,
+    position
+  };
+}
+function parseClass(className, position) {
+  const base = parseClassBase(className, position);
+  if (base.isArbitrary) {
+    const group2 = base.arbitraryProperty?.startsWith("--") ? "arbitrary-css-var" : `arbitrary-${base.arbitraryProperty}`;
+    return {
+      raw: base.raw,
+      modifiers: base.modifiers,
+      modifierKey: base.modifierKey,
+      hasImportant: base.hasImportant,
+      utility: base.utility,
+      group: group2,
+      isArbitrary: true,
+      arbitraryProperty: base.arbitraryProperty,
+      specificity: SPECIFICITY.ARBITRARY,
+      position: base.position
+    };
+  }
+  const { group, specificity } = classifyClass(base.utilityForClassification);
+  return {
+    raw: base.raw,
+    modifiers: base.modifiers,
+    modifierKey: base.modifierKey,
+    hasImportant: base.hasImportant,
+    utility: base.utility,
+    group,
+    isArbitrary: false,
+    specificity,
+    position: base.position
+  };
+}
+function parseClasses(classString) {
+  if (!classString) {
+    return [];
+  }
+  const cache = getParseCache();
+  const cached = cache.get(classString);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const classes = splitClasses(classString);
+  const tokens = new Array(classes.length);
+  for (let i = 0; i < classes.length; i++) {
+    tokens[i] = parseClass(classes[i], i);
+  }
+  cache.set(classString, tokens);
+  return tokens;
+}
+
+// src/resolver.ts
+function resolveCore(tokens, getConflicts, trackRemoved) {
+  const kept = /* @__PURE__ */ new Set();
+  if (tokens.length === 0) {
+    return { kept, removed: trackRemoved ? [] : null };
+  }
+  if (tokens.length === 1) {
+    kept.add(0);
+    return { kept, removed: trackRemoved ? [] : null };
+  }
+  const seen = trackRemoved ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map();
+  const removed = trackRemoved ? [] : null;
+  for (let i = tokens.length - 1; i >= 0; i--) {
+    const token = tokens[i];
+    if (token.group === null) {
+      kept.add(i);
+      continue;
+    }
+    const baseKey = `${token.hasImportant ? "!" : ""}${token.modifierKey}:`;
+    const ownKey = baseKey + token.group;
+    const existing = seen.get(ownKey);
+    if (existing !== void 0) {
+      if (trackRemoved) {
+        const existingWithToken = existing;
+        removed.push({
+          token,
+          overriddenBy: existingWithToken.token,
+          reason: `overridden by ${existingWithToken.token.raw}`
+        });
+      }
+      continue;
+    }
+    let overridden = false;
+    let overriddenByToken = null;
+    const conflictGroups = getConflicts(token.group);
+    for (const conflictGroup of conflictGroups) {
+      if (conflictGroup === token.group) continue;
+      const conflictKey = baseKey + conflictGroup;
+      const conflictExisting = seen.get(conflictKey);
+      if (conflictExisting !== void 0) {
+        if (conflictExisting.specificity > token.specificity) {
+          continue;
+        } else {
+          overridden = true;
+          if (trackRemoved && "token" in conflictExisting) {
+            overriddenByToken = conflictExisting.token;
+          }
+          break;
+        }
+      }
+    }
+    if (overridden) {
+      if (trackRemoved && overriddenByToken !== null) {
+        removed.push({
+          token,
+          overriddenBy: overriddenByToken,
+          reason: `overridden by ${overriddenByToken.raw}`
+        });
+      }
+    } else {
+      kept.add(i);
+      if (trackRemoved) {
+        ;
+        seen.set(ownKey, {
+          token,
+          specificity: token.specificity
+        });
+      } else {
+        ;
+        seen.set(ownKey, {
+          specificity: token.specificity
+        });
+      }
+    }
+  }
+  return { kept, removed };
+}
+function resolveConflicts(tokens) {
+  if (tokens.length === 0) return { kept: [], removed: [] };
+  if (tokens.length === 1) return { kept: [tokens[0]], removed: [] };
+  const { kept, removed } = resolveCore(tokens, getConflictingGroups, true);
+  return {
+    kept: tokens.filter((_, i) => kept.has(i)),
+    removed
+  };
+}
+function resolveConflictsSimple(tokens) {
+  if (tokens.length <= 1) return tokens;
+  const { kept } = resolveCore(tokens, getConflictingGroups, false);
+  return tokens.filter((_, i) => kept.has(i));
+}
+function resolveWithCustomConflicts(tokens, getConflicts) {
+  if (tokens.length === 0) return /* @__PURE__ */ new Set();
+  if (tokens.length === 1) return /* @__PURE__ */ new Set([0]);
+  const { kept } = resolveCore(tokens, getConflicts, false);
+  return kept;
+}
+function tokensToString(tokens) {
+  if (tokens.length === 0) return "";
+  if (tokens.length === 1) return tokens[0].raw;
+  let result = tokens[0].raw;
+  for (let i = 1; i < tokens.length; i++) {
+    result += " " + tokens[i].raw;
+  }
+  return result;
+}
+
+// src/create-tw.ts
+function createTw(config = {}) {
+  if (config.cacheSize !== void 0 && config.cacheSize < 0) {
+    throw new Error("tw-mrg: cacheSize must be non-negative");
+  }
+  const {
+    prefix: prefix2 = "",
+    cacheSize = 500,
+    mode = "full",
+    extend,
+    override
+  } = config;
+  if (mode === false) {
+    return function noMergeTw(...inputs) {
+      return flattenClassValues(...inputs);
+    };
+  }
+  const baseConfig = mode === "minimal" ? minimalConfig : fullConfig;
+  const groupConfig = buildGroupConfig(baseConfig, extend, override);
+  const trie = new PrefixTrie();
+  const exactMatches = /* @__PURE__ */ new Map();
+  for (const [pfx, entry] of Object.entries(groupConfig.prefixes)) {
+    trie.insert(pfx, entry);
+  }
+  for (const [className, entry] of Object.entries(groupConfig.exactMatches)) {
+    exactMatches.set(className, entry);
+  }
+  const cache = cacheSize > 0 ? new LRUCache(cacheSize) : null;
+  function classifyUtility(utility) {
+    const unprefixed = prefix2 && utility.startsWith(prefix2) ? utility.slice(prefix2.length) : utility;
+    const exact = exactMatches.get(unprefixed);
+    if (exact) {
+      return { group: exact.groupId, specificity: exact.specificity };
+    }
+    const prefixMatch = trie.findLongestMatch(unprefixed);
+    if (prefixMatch) {
+      return {
+        group: prefixMatch.entry.groupId,
+        specificity: prefixMatch.entry.specificity
+      };
+    }
+    for (const { pattern, groupId, specificity } of groupConfig.patterns) {
+      if (pattern.test(unprefixed)) {
+        return { group: groupId, specificity };
+      }
+    }
+    return { group: null, specificity: 1 };
+  }
+  function getConflicts(groupId) {
+    return groupConfig.conflicts[groupId] ?? [];
+  }
+  return function customTw(...inputs) {
+    if (inputs.length === 0) return "";
+    const classString = flattenClassValues(...inputs);
+    if (!classString) return "";
+    if (!classString.includes(" ")) return classString;
+    if (cache) {
+      const cached = cache.get(classString);
+      if (cached !== void 0) return cached;
+    }
+    const classes = splitClasses(classString);
+    const tokens = new Array(classes.length);
+    for (let i = 0; i < classes.length; i++) {
+      const parsed = parseClassBase(classes[i], i);
+      if (parsed.isArbitrary) {
+        const group = parsed.arbitraryProperty?.startsWith("--") ? "arbitrary-css-var" : `arbitrary-${parsed.arbitraryProperty}`;
+        tokens[i] = {
+          raw: parsed.raw,
+          modifiers: parsed.modifiers,
+          modifierKey: parsed.modifierKey,
+          hasImportant: parsed.hasImportant,
+          utility: parsed.utility,
+          group,
+          isArbitrary: true,
+          arbitraryProperty: parsed.arbitraryProperty,
+          specificity: SPECIFICITY.ARBITRARY,
+          position: parsed.position
+        };
+      } else {
+        const { group, specificity } = classifyUtility(
+          parsed.utilityForClassification
+        );
+        tokens[i] = {
+          raw: parsed.raw,
+          modifiers: parsed.modifiers,
+          modifierKey: parsed.modifierKey,
+          hasImportant: parsed.hasImportant,
+          utility: parsed.utility,
+          group,
+          isArbitrary: false,
+          specificity,
+          position: parsed.position
+        };
+      }
+    }
+    const kept = resolveWithCustomConflicts(tokens, getConflicts);
+    let result = "";
+    for (let i = 0; i < tokens.length; i++) {
+      if (kept.has(i)) {
+        result = result ? result + " " + tokens[i].raw : tokens[i].raw;
+      }
+    }
+    if (cache) {
+      cache.set(classString, result);
+    }
+    return result;
+  };
+}
+function addClassGroups(config, classGroups, addSelfConflict) {
+  for (const [id, patterns] of Object.entries(classGroups)) {
+    for (const p of patterns) {
+      if (p instanceof RegExp) {
+        config.patterns.push({
+          pattern: p,
+          groupId: id,
+          specificity: 1
+        });
+      } else {
+        config.exactMatches[p] = { groupId: id, specificity: 1 };
+      }
+    }
+    if (addSelfConflict && config.conflicts[id] === void 0) {
+      config.conflicts[id] = [id];
+    }
+  }
+}
+function buildGroupConfig(base, extend, override) {
+  const config = {
+    prefixes: { ...base.prefixes },
+    exactMatches: { ...base.exactMatches },
+    patterns: [...base.patterns],
+    conflicts: { ...base.conflicts }
+  };
+  if (override?.classGroups) {
+    addClassGroups(config, override.classGroups, false);
+  }
+  if (extend?.classGroups) {
+    addClassGroups(config, extend.classGroups, true);
+  }
+  if (extend?.conflictingClassGroups) {
+    for (const [id, conflicts] of Object.entries(
+      extend.conflictingClassGroups
+    )) {
+      const existing = config.conflicts[id];
+      config.conflicts[id] = existing !== void 0 ? [.../* @__PURE__ */ new Set([...existing, ...conflicts])] : conflicts;
+    }
+  }
+  if (override?.conflictingClassGroups) {
+    Object.assign(config.conflicts, override.conflictingClassGroups);
+  }
+  if (extend?.prefixes) {
+    for (const [pfx, entry] of Object.entries(extend.prefixes)) {
+      config.prefixes[pfx] = {
+        groupId: entry.groupId,
+        specificity: entry.specificity ?? 1
+      };
+    }
+  }
+  return config;
+}
+
+// src/tw.ts
+var twMerge = createTw({ mode: "full" });
+function tw(...inputs) {
+  if (getMergeMode() === false) {
+    return flattenClassValues(...inputs);
+  }
+  return twMerge(...inputs);
+}
+
+// src/tw-join.ts
+function twJoin(...inputs) {
+  return flattenClassValues(...inputs);
+}
+
+// src/css-generator.ts
+import { __unstable__loadDesignSystem } from "tailwindcss";
+var designSystem = null;
+var initPromise = null;
+async function initCSSGenerator(options = {}) {
+  if (designSystem) return;
+  if (initPromise) return initPromise;
+  const css = options.css ?? '@import "tailwindcss";';
+  initPromise = (async () => {
+    designSystem = await __unstable__loadDesignSystem(css);
+  })();
+  return initPromise;
+}
+function generateCSS(className) {
+  if (!designSystem) return null;
+  const [css] = designSystem.candidatesToCss([className]);
+  return css ?? null;
+}
+function generateCSSBatch(classNames) {
+  if (!designSystem) return classNames.map(() => null);
+  return designSystem.candidatesToCss(classNames);
+}
+function isInitialized() {
+  return designSystem !== null;
+}
+function getThemeValue(path) {
+  if (!designSystem) return void 0;
+  return designSystem.resolveThemeValue(path);
+}
+function isValidClass(className) {
+  if (!designSystem) return false;
+  const [css] = designSystem.candidatesToCss([className]);
+  return css !== null;
+}
+function validateClasses(classNames) {
+  if (!designSystem) return classNames.map(() => false);
+  return designSystem.candidatesToCss(classNames).map((css) => css !== null);
+}
+function getClassOrder(classNames) {
+  if (!designSystem) return classNames.map((c) => [c, null]);
+  return designSystem.getClassOrder(classNames);
+}
+function canonicalizeClasses(classNames) {
+  if (!designSystem) return classNames;
+  return designSystem.canonicalizeCandidates(classNames);
+}
+
+// src/style-injector.ts
+var styleElement = null;
+var injectedClasses = /* @__PURE__ */ new Set();
+var errorHandler = null;
+function setStyleInjectorErrorHandler(handler) {
+  errorHandler = handler;
+}
+function getStyleElement() {
+  if (typeof document === "undefined") return null;
+  if (!styleElement) {
+    styleElement = document.createElement("style");
+    styleElement.id = "tw-mrg-styles";
+    document.head.appendChild(styleElement);
+  }
+  return styleElement;
+}
+function injectCSS(className, cssRule) {
+  if (injectedClasses.has(className)) return;
+  const style = getStyleElement();
+  if (!style) return;
+  const sheet = style.sheet;
+  if (sheet) {
+    try {
+      sheet.insertRule(cssRule, sheet.cssRules.length);
+      injectedClasses.add(className);
+      return;
+    } catch (e) {
+      errorHandler?.(
+        e instanceof Error ? e : new Error(String(e)),
+        "injectCSS"
+      );
+    }
+  }
+  style.textContent += cssRule + "\n";
+  injectedClasses.add(className);
+}
+function injectCSSBatch(classNames, cssRules) {
+  const style = getStyleElement();
+  if (!style) return;
+  const sheet = style.sheet;
+  const useInsertRule = sheet !== null;
+  const rulesToInject = [];
+  for (let i = 0; i < classNames.length; i++) {
+    const className = classNames[i];
+    const css = cssRules[i];
+    if (css && className && !injectedClasses.has(className)) {
+      if (useInsertRule) {
+        try {
+          sheet.insertRule(css, sheet.cssRules.length);
+          injectedClasses.add(className);
+        } catch (e) {
+          errorHandler?.(
+            e instanceof Error ? e : new Error(String(e)),
+            "injectCSSBatch"
+          );
+          rulesToInject.push(css);
+          injectedClasses.add(className);
+        }
+      } else {
+        rulesToInject.push(css);
+        injectedClasses.add(className);
+      }
+    }
+  }
+  if (rulesToInject.length > 0) {
+    style.textContent += rulesToInject.join("\n") + "\n";
+  }
+}
+function hasInjectedClass(className) {
+  return injectedClasses.has(className);
+}
+function clearInjectedStyles() {
+  if (styleElement) {
+    const sheet = styleElement.sheet;
+    if (sheet) {
+      while (sheet.cssRules.length > 0) {
+        sheet.deleteRule(0);
+      }
+    }
+    styleElement.textContent = "";
+  }
+  injectedClasses.clear();
+}
+function getInjectedClasses() {
+  return Array.from(injectedClasses);
+}
+
+// src/tw-prefix.ts
+var CLASS_SPLIT_REGEX2 = /\s+/;
+function twPrefix(modifierOrMap, classes) {
+  let composed;
+  let prefixedClassNames = null;
+  if (typeof modifierOrMap === "object") {
+    const allPrefixed = [];
+    let result = "";
+    for (const modifier in modifierOrMap) {
+      if (Object.prototype.hasOwnProperty.call(modifierOrMap, modifier)) {
+        const classString = modifierOrMap[modifier];
+        if (classString) {
+          const { str, classNames } = prefixClassesWithNames(modifier, classString);
+          if (str) {
+            result = result ? result + " " + str : str;
+            for (const cls of classNames) {
+              allPrefixed.push(cls);
+            }
+          }
+        }
+      }
+    }
+    composed = result;
+    prefixedClassNames = allPrefixed;
+  } else {
+    const { str, classNames } = prefixClassesWithNames(modifierOrMap, classes ?? "");
+    composed = str;
+    prefixedClassNames = classNames;
+  }
+  if (typeof window !== "undefined" && isInitialized() && prefixedClassNames.length > 0) {
+    const newClassNames = prefixedClassNames.filter((cls) => !hasInjectedClass(cls));
+    if (newClassNames.length > 0) {
+      const cssRules = generateCSSBatch(newClassNames);
+      injectCSSBatch(newClassNames, cssRules);
+    }
+  }
+  return composed;
+}
+function prefixClassesWithNames(modifier, classes) {
+  const classList = classes.split(CLASS_SPLIT_REGEX2).filter(Boolean);
+  if (classList.length === 0) return { str: "", classNames: [] };
+  const classNames = new Array(classList.length);
+  let str = "";
+  for (let i = 0; i < classList.length; i++) {
+    const prefixed = modifier + classList[i];
+    classNames[i] = prefixed;
+    str = str ? str + " " + prefixed : prefixed;
+  }
+  return { str, classNames };
+}
+
+// src/tw-states.ts
+function twStates(config) {
+  const { base, variants, defaultVariants, compoundVariants } = config;
+  const variantKeys = variants ? Object.keys(variants) : [];
+  const compoundVariantKeys = compoundVariants ? compoundVariants.map((compound) => {
+    const keys = [];
+    for (const key in compound) {
+      if (Object.prototype.hasOwnProperty.call(compound, key) && key !== "class" && key !== "className") {
+        keys.push(key);
+      }
+    }
+    return keys;
+  }) : null;
+  return (props = {}) => {
+    const { class: classFromProps, className, ...variantProps } = props;
+    const classes = [];
+    if (base) {
+      classes.push(base);
+    }
+    if (variants) {
+      for (const variantKey of variantKeys) {
+        const value = variantProps[variantKey] ?? defaultVariants?.[variantKey];
+        if (value !== null && value !== void 0) {
+          const variantClasses = variants[variantKey][value];
+          if (variantClasses) {
+            classes.push(variantClasses);
+          }
+        }
+      }
+    }
+    if (compoundVariants && compoundVariantKeys) {
+      for (let i = 0; i < compoundVariants.length; i++) {
+        const compound = compoundVariants[i];
+        const keys = compoundVariantKeys[i];
+        if (matchesCompoundVariantFast(compound, keys, variantProps, defaultVariants)) {
+          const compoundClass = compound.class ?? compound.className;
+          if (compoundClass) {
+            classes.push(compoundClass);
+          }
+        }
+      }
+    }
+    if (classFromProps) {
+      classes.push(classFromProps);
+    }
+    if (className) {
+      classes.push(className);
+    }
+    return tw(...classes);
+  };
+}
+function matchesCompoundVariantFast(compound, keys, props, defaults) {
+  for (const key of keys) {
+    const value = compound[key];
+    const actualValue = props[key] ?? defaults?.[key];
+    if (normalizeValue(actualValue) !== normalizeValue(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+function normalizeValue(value) {
+  if (value === "true" || value === true) return true;
+  if (value === "false" || value === false) return false;
+  return value;
+}
+
+// src/tw-debug.ts
+function twDebug(...inputs) {
+  if (inputs.length === 0) {
+    return { output: "", removed: [], kept: [] };
+  }
+  const classString = flattenClassValues(...inputs);
+  if (!classString) {
+    return { output: "", removed: [], kept: [] };
+  }
+  if (!classString.includes(" ")) {
+    const tokens2 = parseClasses(classString);
+    return {
+      output: classString,
+      removed: [],
+      kept: tokens2.map((t) => ({
+        class: t.raw,
+        group: t.group
+      }))
+    };
+  }
+  const tokens = parseClasses(classString);
+  const { kept, removed } = resolveConflicts(tokens);
+  const removedClasses = removed.map((r) => ({
+    class: r.token.raw,
+    reason: r.reason,
+    conflictsWith: r.overriddenBy.raw
+  }));
+  const keptClasses = kept.map((k) => ({
+    class: k.raw,
+    group: k.group
+  }));
+  return {
+    output: tokensToString(kept),
+    removed: removedClasses,
+    kept: keptClasses
+  };
+}
+export {
+  LRUCache,
+  SPECIFICITY,
+  canonicalizeClasses,
+  classifyClass,
+  clearCaches,
+  clearInjectedStyles,
+  createTw,
+  extractModifiers,
+  flattenClassValue,
+  flattenClassValues,
+  fullConfig,
+  generateCSS,
+  generateCSSBatch,
+  getCacheStats,
+  getClassOrder,
+  getConflictingGroups,
+  getInjectedClasses,
+  getMergeMode,
+  getStyleElement,
+  getThemeValue,
+  hasInjectedClass,
+  initCSSGenerator,
+  injectCSS,
+  injectCSSBatch,
+  isInitialized,
+  isValidClass,
+  minimalConfig,
+  parseClass,
+  parseClassBase,
+  parseClasses,
+  resetClassifier,
+  resolveConflicts,
+  resolveConflictsSimple,
+  setMergeMode,
+  setStyleInjectorErrorHandler,
+  splitClasses,
+  tw,
+  twDebug,
+  twJoin,
+  twPrefix,
+  twStates,
+  validateClasses
+};
+//# sourceMappingURL=index.js.map