domflax 0.1.0

package/dist/chunk-4HHISSMR.js

@@ -0,0 +1,2227 @@
+import {
+  BASE_CONDITION,
+  BASE_CONDITION_KEY,
+  and,
+  computed,
+  conditionKey,
+  createDocument,
+  createElement,
+  createExpr,
+  createFragment,
+  createText,
+  defaultMeta,
+  emptyClassList,
+  emptyStyleMap,
+  hasDynamicChildren,
+  hasDynamicClasses,
+  hasEventHandlers,
+  hasRef,
+  isElement,
+  normalizer,
+  not,
+  pattern,
+  targetedByCombinator
+} from "./chunk-77SLHRN6.js";
+import {
+  __filename,
+  init_esm_shims
+} from "./chunk-6WVVF6AD.js";
+
+// ../patterns/src/flatten/empty-style-div.pattern.ts
+init_esm_shims();
+function asEl(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+function metaFlag(flag) {
+  return (node) => Boolean(asEl(node)?.meta[flag]);
+}
+var establishesBox = metaFlag("establishesBox");
+var establishesFormattingContext = metaFlag("establishesFormattingContext");
+var establishesStackingContext = metaFlag("establishesStackingContext");
+var isContainingBlock = metaFlag("isContainingBlock");
+var declaresCustomProperties = metaFlag("declaresCustomProperties");
+var targetedByStructuralPseudo = (node, ctx) => {
+  const el = asEl(node);
+  if (!el) return false;
+  if (el.meta.targetedByStructuralPseudo) return true;
+  return ctx.selectors.targetedByStructuralPseudo(el.id);
+};
+var DISPLAY = "display";
+var hasNonBlockDisplay = (node, ctx) => {
+  const el = asEl(node);
+  if (!el) return false;
+  const sm = ctx.computedOf(el) ?? el.computed;
+  for (const block of sm.blocks.values()) {
+    const decl = block.decls.get(DISPLAY);
+    if (decl && String(decl.value) !== "block") return true;
+  }
+  return false;
+};
+var emptyStyleDiv = pattern({
+  name: "empty-style-div",
+  category: "flatten/empty-style-div",
+  safety: 1,
+  doc: {
+    title: "Flatten empty-style div wrapper",
+    summary: "A layout-neutral div (display:block default, no box/visual styles) that wraps a single child is removed; the child is hoisted into its place.",
+    before: "<div><Child/></div>",
+    after: "<Child/>",
+    safetyRationale: "Wrapper is a plain block box that paints nothing, establishes no box/formatting/stacking context, is no containing block, has no custom-property coupling, carries no ref/handlers/dynamic children/raw HTML, and is neither a combinator subject nor a structural-pseudo target; inheritable styles are folded onto the child before removal."
+  },
+  match: {
+    tag: "div",
+    onlyChild: "element",
+    paintsNothing: true,
+    where: [
+      not(hasNonBlockDisplay),
+      not(establishesBox),
+      not(establishesFormattingContext),
+      not(establishesStackingContext),
+      not(isContainingBlock),
+      not(declaresCustomProperties),
+      not(targetedByStructuralPseudo)
+    ]
+  },
+  rewrite: { flattenInto: "child" },
+  examples: [
+    {
+      before: '<div><span className="bg-red-200">Hi</span></div>',
+      after: '<span className="bg-red-200">Hi</span>'
+    },
+    {
+      // The wrapper paints its own background (own visual style) → not layout-neutral, kept.
+      noMatch: '<div className="bg-blue-500"><span className="bg-red-200">Hi</span></div>'
+    }
+  ]
+});
+
+// ../patterns/src/flatten/flex-center-wrapper.pattern.ts
+init_esm_shims();
+var flexCenterWrapper = pattern({
+  name: "flex-center-wrapper",
+  category: "flatten/flex-center-wrapper",
+  safety: 2,
+  doc: {
+    title: "Flatten flex-centering wrapper",
+    summary: "A div that only centers a single child (display:flex; align-items:center; justify-content:center) is removed; the child gains place-self:center.",
+    before: '<div style="display:flex;align-items:center;justify-content:center"><Child/></div>',
+    after: '<Child style="place-self:center"/>',
+    safetyRationale: "Wrapper paints nothing, carries no ref/handlers/dynamic children, and is not a combinator subject; inheritable styles are folded onto the child before removal."
+  },
+  match: {
+    tag: "div",
+    style: { display: "flex", alignItems: "center", justifyContent: "center" },
+    onlyChild: "element",
+    paintsNothing: true
+  },
+  rewrite: {
+    flattenInto: "child",
+    childGains: { placeSelf: "center" }
+  },
+  examples: [
+    {
+      // The wrapper is removed; the surviving child gains `place-self-center` (reverse-emitted
+      // from the folded computed style by the resolver).
+      before: '<div className="flex justify-center items-center"><div className="bg-red-200">Hello</div></div>',
+      after: '<div className="bg-red-200 place-self-center">Hello</div>'
+    },
+    {
+      // onClick is a hard opacity barrier → the wrapper is load-bearing, no flatten.
+      noMatch: '<div className="flex justify-center items-center" onClick={handleClick}><div className="bg-red-200">Hello</div></div>'
+    }
+  ]
+});
+
+// ../patterns/src/flatten/nested-flex-merge.pattern.ts
+init_esm_shims();
+function baseConditionStyleMap(decls) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [prop, value] of decls) {
+    for (const decl of normalizer.normalizeDeclaration(prop, value, false)) {
+      map.set(decl.property, decl);
+    }
+  }
+  const block = { condition: BASE_CONDITION, decls: map };
+  const blocks = /* @__PURE__ */ new Map([[conditionKey(BASE_CONDITION), block]]);
+  return { blocks };
+}
+var DISPLAY_FLEX = baseConditionStyleMap([["display", "flex"]]);
+var FLEX_CONTAINER_PROPERTIES = /* @__PURE__ */ new Set([
+  "display",
+  "flex-direction",
+  "flex-wrap",
+  "justify-content",
+  "align-items",
+  "align-content",
+  "place-content",
+  "place-items",
+  "row-gap",
+  "column-gap"
+]);
+function outerMergeSafe(sm) {
+  const norm = normalizer.normalizeStyleMap(sm);
+  for (const block of norm.blocks.values()) {
+    for (const decl of block.decls.values()) {
+      if (FLEX_CONTAINER_PROPERTIES.has(String(decl.property))) continue;
+      if (decl.inherited) continue;
+      return false;
+    }
+  }
+  return true;
+}
+function flexConflict(outer, inner) {
+  const a = normalizer.normalizeStyleMap(outer);
+  const b = normalizer.normalizeStyleMap(inner);
+  for (const [key, blockA] of a.blocks) {
+    const blockB = b.blocks.get(key);
+    if (!blockB) continue;
+    for (const [prop, declA] of blockA.decls) {
+      if (!FLEX_CONTAINER_PROPERTIES.has(String(prop))) continue;
+      const declB = blockB.decls.get(prop);
+      if (declB && declB.value !== declA.value) return true;
+    }
+  }
+  return false;
+}
+function extractFlexStyle(sm) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (FLEX_CONTAINER_PROPERTIES.has(String(prop))) decls.set(prop, decl);
+    }
+    if (decls.size > 0) blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var isInnerFlex = and(
+  isElement("div"),
+  computed(DISPLAY_FLEX),
+  not(targetedByCombinator)
+);
+var nestedFlexMerge = pattern({
+  name: "nested-flex-merge",
+  category: "flatten/nested-flex-merge",
+  safety: 2,
+  doc: {
+    title: "Merge nested flex containers",
+    summary: "A flex container whose only child is itself a flex container with non-conflicting flex properties is collapsed into one; the wrapper is removed and its flex declarations merge onto the surviving child.",
+    before: '<div style="display:flex;align-items:center;gap:8px"><div style="display:flex;flex-direction:column"/></div>',
+    after: '<div style="display:flex;flex-direction:column;align-items:center;gap:8px"/>',
+    safetyRationale: "The wrapper paints nothing, declares only flex-container/inheritable properties, carries no ref/handlers/dynamic children, and is not a combinator subject; the two containers do not conflict on any flex property, so the union is unambiguous and lossless."
+  },
+  match: {
+    tag: "div",
+    style: { display: "flex" },
+    onlyChild: "element",
+    paintsNothing: true
+  },
+  rewrite: (ctx, rw) => {
+    const outer = ctx.node;
+    const inner = ctx.onlyElementChild();
+    if (!inner) return null;
+    if (!isInnerFlex(inner, ctx)) return null;
+    const outerStyle = ctx.computed();
+    const innerStyle = ctx.computedOf(inner);
+    if (!outerMergeSafe(outerStyle)) return null;
+    if (flexConflict(outerStyle, innerStyle)) return null;
+    return [
+      // 1. Preserve inheritable values (color/font/…) by folding them onto the child first.
+      rw.foldInheritedStyles(outer, inner, { conditions: "all" }),
+      // 2. Transfer the wrapper's flex-container declarations onto the child (target-wins keeps the
+      //    child's value for any shared property — identical anyway, we proved non-conflict).
+      rw.mergeStyle(inner, null, extractFlexStyle(outerStyle), "target-wins"),
+      // 3. Remove the wrapper (structural-safe; hoists the child and preserves its IRNodeId).
+      rw.unwrap(outer)
+    ];
+  },
+  examples: [
+    {
+      // The wrapper's flex declarations (align-items / gap) merge onto the inner flex container,
+      // then the wrapper is removed (its own `data-x` here just blocks the more aggressive
+      // passthrough-wrapper so this merge is the one that fires).
+      before: '<div className="flex items-center gap-2" data-x="1"><div className="flex flex-col">X</div></div>',
+      after: '<div className="flex flex-col gap-2 items-center">X</div>'
+    },
+    {
+      // A non-flex wrapper does not match the flex-container signature → left unchanged.
+      noMatch: '<div className="block bg-blue-500"><div className="flex flex-col">X</div></div>'
+    }
+  ]
+});
+
+// ../patterns/src/flatten/passthrough-wrapper.pattern.ts
+init_esm_shims();
+function metaOf(node) {
+  const n = node;
+  return n.kind === "element" ? n.meta : null;
+}
+function elementOf(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+var establishesContext = (node) => {
+  const m = metaOf(node);
+  if (!m) return false;
+  return m.establishesBox || m.establishesFormattingContext || m.establishesStackingContext || m.isContainingBlock || m.declaresCustomProperties;
+};
+var hasSpreadAttrs = (node) => metaOf(node)?.hasSpreadAttrs ?? false;
+var isComponentNode = (node) => metaOf(node)?.isComponent ?? false;
+var hasOwnAttrs = (node) => {
+  const el = elementOf(node);
+  if (!el) return false;
+  return el.attrs.entries.size > 0 || el.attrs.spreads.length > 0;
+};
+var targetedByStructuralPseudo2 = (node, ctx) => {
+  const el = elementOf(node);
+  if (!el) return false;
+  if (el.meta.targetedByStructuralPseudo) return true;
+  return ctx.selectors.targetedByStructuralPseudo(el.id);
+};
+var passthroughWrapper = pattern({
+  name: "passthrough-wrapper",
+  category: "flatten/passthrough-wrapper",
+  safety: 2,
+  doc: {
+    title: "Flatten passthrough wrapper",
+    summary: "A div with no own visual/box style, no attributes beyond an inert class, exactly one element child, and no opacity barriers is removed; its sole child is hoisted in its place.",
+    before: "<div><Child/></div>",
+    after: "<Child/>",
+    safetyRationale: "Wrapper paints nothing and establishes no layout/paint/var context, carries no ref/handlers/dynamic-children/html/spread/component identity, owns no targetable attrs, and is not a combinator/structural-pseudo subject (reparenting changes no match-set); inheritable styles are folded onto the child before removal."
+  },
+  match: {
+    tag: "div",
+    onlyChild: "element",
+    paintsNothing: true,
+    where: [
+      not(establishesContext),
+      not(hasOwnAttrs),
+      not(hasDynamicClasses),
+      not(hasSpreadAttrs),
+      not(isComponentNode),
+      not(targetedByStructuralPseudo2)
+    ]
+  },
+  rewrite: { flattenInto: "child" },
+  examples: [
+    {
+      before: '<div className="flex"><a className="bg-red-200">Link</a></div>',
+      after: '<a className="bg-red-200">Link</a>'
+    },
+    {
+      // A ref pins the wrapper's element identity (a hard opacity barrier) → not a passthrough.
+      noMatch: '<div ref={rootRef}><a className="bg-red-200">Link</a></div>'
+    }
+  ]
+});
+
+// ../patterns/src/flatten/redundant-fragment.pattern.ts
+init_esm_shims();
+function parentIsRedundantFragment(node, ctx) {
+  const el = node;
+  if (el.kind !== "element") return false;
+  const parentId = el.parent;
+  if (parentId == null) return false;
+  const parent = ctx.doc.nodes.get(parentId);
+  if (!parent || parent.kind !== "fragment") return false;
+  if (parent.parent == null) return false;
+  if (parent.children.length !== 1) return false;
+  const m = parent.meta;
+  if (m.hasKey || m.hasRef || m.hasEventHandlers || m.hasDynamicChildren || m.hasDangerousHtml || m.hasSpreadAttrs || m.isComponent) {
+    return false;
+  }
+  if (m.targetedByCombinator || m.targetedByStructuralPseudo) return false;
+  const fid = parentId;
+  if (ctx.selectors.targetedByCombinator(fid) || ctx.selectors.targetedByStructuralPseudo(fid)) {
+    return false;
+  }
+  if (ctx.selectors.reparentImpact(fid).size > 0) return false;
+  return true;
+}
+var redundantFragment = pattern({
+  name: "redundant-fragment",
+  category: "flatten/redundant-fragment",
+  safety: 1,
+  doc: {
+    title: "Flatten redundant single-child fragment",
+    summary: "A fragment whose only child is a single node is removed; the child is spliced up into the fragment's slot, preserving its IRNodeId, siblings, attributes and the CSS cascade.",
+    before: "<><Child/></>",
+    after: "<Child/>",
+    safetyRationale: "A fragment paints nothing and renders no box; with exactly one child its removal changes no sibling/structural-pseudo match-set. Keyed fragments and fragments carrying ref/handlers/dynamic-children/raw-html/spread are excluded as opacity barriers."
+  },
+  match: parentIsRedundantFragment,
+  rewrite: (ctx, rw) => {
+    const parentId = ctx.node.parent;
+    if (parentId == null) return null;
+    const fragment = ctx.doc.nodes.get(parentId);
+    if (!fragment || fragment.kind !== "fragment") return null;
+    return [rw.unwrap(fragment)];
+  },
+  examples: [
+    {
+      before: '<><span className="bg-red-200">Hi</span></>',
+      after: '<span className="bg-red-200">Hi</span>'
+    },
+    {
+      // Two children ⇒ not a single-child fragment, so the fragment is load-bearing and stays.
+      noMatch: '<><span className="bg-red-200">A</span><span className="bg-green-200">B</span></>'
+    }
+  ]
+});
+
+// ../patterns/src/compress/dedupe-classes.pattern.ts
+init_esm_shims();
+function elementOf2(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+var hasDangerousHtml = (node) => elementOf2(node)?.meta.hasDangerousHtml ?? false;
+var isOpaque = (node, ctx) => ctx.isOpaque(node);
+function findRedundantClasses(computed2) {
+  const winners = /* @__PURE__ */ new Set();
+  const shadowed = /* @__PURE__ */ new Set();
+  for (const block of computed2.blocks.values()) {
+    for (const decl of block.decls.values()) {
+      if (decl.origin && decl.origin.kind === "class") winners.add(decl.origin.className);
+      for (const o of decl.shadowed ?? []) {
+        if (o.kind === "class") shadowed.add(o.className);
+      }
+    }
+  }
+  return { winners, shadowed };
+}
+var dedupeClasses = pattern({
+  name: "dedupe-classes",
+  category: "compress/dedupe-classes",
+  safety: 1,
+  doc: {
+    title: "Dedupe fully-overridden class tokens",
+    summary: "Drops class tokens whose every declaration is overridden by a later token resolving to the same property; the surviving token set produces a byte-for-byte identical computed style.",
+    before: '<p class="text-sm text-lg" />',
+    after: '<p class="text-lg" />',
+    safetyRationale: "A fully-overridden token contributes nothing to the computed style in any condition, so removing it changes no pixels. Dynamic/opaque class lists, ref/handler/dynamic-children/raw-html barriers, combinator subjects, and selector-bound (non-droppable) tokens are excluded."
+  },
+  match: {
+    where: [
+      not(hasRef),
+      not(hasEventHandlers),
+      not(hasDynamicChildren),
+      not(hasDangerousHtml),
+      not(hasDynamicClasses),
+      not(isOpaque),
+      not(targetedByCombinator)
+    ]
+  },
+  rewrite: {
+    dropClasses(computed2, ctx) {
+      const { winners, shadowed } = findRedundantClasses(computed2);
+      const drop = /* @__PURE__ */ new Set();
+      for (const cls of shadowed) {
+        if (winners.has(cls)) continue;
+        if (!ctx.resolver.selectorUsage(cls).droppable) continue;
+        drop.add(cls);
+      }
+      return drop;
+    }
+  },
+  examples: [
+    {
+      // `text-sm` is fully overridden by `text-lg` (both set font-size + line-height). The resolver
+      // records that shadowing in provenance and reports the Tailwind utility as droppable, so the
+      // pattern drops `text-sm`; the reverse-emit then re-derives the minimal set (`text-lg`).
+      before: '<p className="text-sm text-lg">Hi</p>',
+      after: '<p className="text-lg">Hi</p>'
+    },
+    {
+      // Both tokens win a distinct property (no full override) → nothing to dedupe.
+      noMatch: '<p className="text-lg font-bold">Hi</p>'
+    }
+  ]
+});
+
+// ../patterns/src/compress/inset-shorthand.pattern.ts
+init_esm_shims();
+var TOP = "top";
+var RIGHT = "right";
+var BOTTOM = "bottom";
+var LEFT = "left";
+var INSET = "inset";
+var INSET_BLOCK = "inset-block";
+var INSET_INLINE = "inset-inline";
+var hasRawHtml = (node) => {
+  const n = node;
+  return n.kind === "element" ? n.meta.hasDangerousHtml : false;
+};
+function sameSide(a, b) {
+  return a !== void 0 && b !== void 0 && a.value === b.value && a.important === b.important;
+}
+function asProperty(src, property) {
+  return { ...src, property, inherited: normalizer.inherited.isInherited(property) };
+}
+function withBaseDecls(src, baseDecls) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of src.blocks) {
+    const decls = key === BASE_CONDITION_KEY ? baseDecls : new Map(block.decls);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var insetShorthand = pattern({
+  name: "inset-shorthand",
+  category: "compress/inset-shorthand",
+  safety: 2,
+  doc: {
+    title: "Compress inset longhands into a shorthand",
+    summary: "top/right/bottom/left set to one value collapse to `inset`; a matching top/bottom or left/right pair collapses to `inset-block` / `inset-inline` (Tailwind inset-y / inset-x).",
+    before: '<div style="top:10px;right:10px;bottom:10px;left:10px"/>',
+    after: '<div style="inset:10px"/>',
+    safetyRationale: "Meaning-preserving shorthand compaction; the element is not a combinator subject and carries no ref/handlers/dynamic children/raw HTML, so neither selector matching nor behaviour changes."
+  },
+  match: {
+    where: [
+      not(hasRef),
+      not(hasEventHandlers),
+      not(hasDynamicChildren),
+      not(hasRawHtml),
+      not(hasDynamicClasses),
+      not(targetedByCombinator)
+    ]
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const base = computed2.blocks.get(BASE_CONDITION_KEY);
+      if (!base) return null;
+      const top = base.decls.get(TOP);
+      const right = base.decls.get(RIGHT);
+      const bottom = base.decls.get(BOTTOM);
+      const left = base.decls.get(LEFT);
+      const next = new Map(base.decls);
+      if (top && sameSide(top, right) && sameSide(top, bottom) && sameSide(top, left)) {
+        next.delete(TOP);
+        next.delete(RIGHT);
+        next.delete(BOTTOM);
+        next.delete(LEFT);
+        next.set(INSET, asProperty(top, INSET));
+      } else {
+        let collapsed = false;
+        if (sameSide(top, bottom)) {
+          next.delete(TOP);
+          next.delete(BOTTOM);
+          next.set(INSET_BLOCK, asProperty(top, INSET_BLOCK));
+          collapsed = true;
+        }
+        if (sameSide(left, right)) {
+          next.delete(LEFT);
+          next.delete(RIGHT);
+          next.set(INSET_INLINE, asProperty(left, INSET_INLINE));
+          collapsed = true;
+        }
+        if (!collapsed) return null;
+      }
+      return withBaseDecls(computed2, next);
+    }
+  },
+  examples: [
+    {
+      // The four equal inset longhands collapse to an `inset` shorthand at the IR level; the
+      // minimizing reverse-emit expands it back to top/right/bottom/left and picks the single utility
+      // covering all four (`inset-0`), replacing the four physical-side tokens. `bg-red-200` survives.
+      before: '<div className="top-0 right-0 bottom-0 left-0 bg-red-200">box</div>',
+      after: '<div className="bg-red-200 inset-0">box</div>'
+    },
+    {
+      // No matching inset pair (all four distinct) → nothing collapses.
+      noMatch: '<div className="top-0 right-1 bottom-2 left-3 bg-red-200">box</div>'
+    }
+  ]
+});
+
+// ../patterns/src/compress/margin-shorthand.pattern.ts
+init_esm_shims();
+var MARGIN_SIDES = [
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left"
+];
+var MARGIN_SIDE_SET = new Set(MARGIN_SIDES);
+var BASE_KEY = conditionKey(BASE_CONDITION);
+function asElement(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+var hasDangerousHtml2 = (node) => asElement(node)?.meta.hasDangerousHtml ?? false;
+function collapseMarginValue(top, right, bottom, left) {
+  if (right === left) {
+    if (top === bottom) {
+      return top === right ? top : `${top} ${right}`;
+    }
+    return `${top} ${right} ${bottom}`;
+  }
+  return `${top} ${right} ${bottom} ${left}`;
+}
+function withFoldedMargin(sm, marginDecl) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (!MARGIN_SIDE_SET.has(String(prop))) decls.set(prop, decl);
+    }
+    decls.set(marginDecl.property, marginDecl);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var marginShorthand = pattern({
+  name: "margin-shorthand",
+  category: "compress/margin-shorthand",
+  safety: 2,
+  doc: {
+    title: "Compress margin longhands into the `margin` shorthand",
+    summary: "An element with margin-top/right/bottom/left all set has them collapsed into the shortest legal `margin` shorthand (the m / mx / my forms); meaning is preserved, declaration count drops.",
+    before: '<div style="margin-top:8px;margin-right:8px;margin-bottom:8px;margin-left:8px"/>',
+    after: '<div style="margin:8px"/>',
+    safetyRationale: "Pure representation change (no pixels move); skips nodes with ref/handlers/dynamic children/raw html, dynamic class segments, or combinator-subject selectors."
+  },
+  match: {
+    where: [
+      not(hasRef),
+      not(hasEventHandlers),
+      not(hasDynamicChildren),
+      not(hasDynamicClasses),
+      not(hasDangerousHtml2),
+      not(targetedByCombinator)
+    ]
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const base = computed2.blocks.get(BASE_KEY);
+      if (!base) return null;
+      const sides = MARGIN_SIDES.map((p) => base.decls.get(p));
+      if (sides.some((d) => d === void 0)) return null;
+      const [mt, mr, mb, ml] = sides;
+      if (mt.important || mr.important || mb.important || ml.important) return null;
+      const value = collapseMarginValue(
+        String(mt.value),
+        String(mr.value),
+        String(mb.value),
+        String(ml.value)
+      );
+      const marginDecl = {
+        property: "margin",
+        value,
+        important: false,
+        relativeToParent: mt.relativeToParent || mr.relativeToParent || mb.relativeToParent || ml.relativeToParent,
+        inherited: false
+        // margin is not an inherited property
+      };
+      return withFoldedMargin(computed2, marginDecl);
+    }
+  },
+  examples: [
+    {
+      // The four equal margin longhands collapse to a `margin` shorthand at the IR level, and the
+      // minimizing reverse-emit picks the single shortest utility (`m-2`) reproducing it, replacing
+      // the four `m{t,r,b,l}-2` tokens. `bg-red-200` is preserved.
+      before: '<div className="mt-2 mr-2 mb-2 ml-2 bg-red-200">box</div>',
+      after: '<div className="bg-red-200 m-2">box</div>'
+    },
+    {
+      // Only two margin sides set → the four-longhand `margin` collapse does not apply.
+      noMatch: '<div className="mt-2 mb-2 bg-red-200">box</div>'
+    }
+  ]
+});
+
+// ../patterns/src/compress/padding-shorthand.pattern.ts
+init_esm_shims();
+var PADDING_SIDES = [
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left"
+];
+var PADDING_SIDE_SET = new Set(PADDING_SIDES);
+var BASE_KEY2 = conditionKey(BASE_CONDITION);
+function analyzePadding(sm) {
+  const block = sm.blocks.get(BASE_KEY2);
+  if (!block) return null;
+  const sides = [];
+  for (const side of PADDING_SIDES) {
+    const decl = block.decls.get(side);
+    if (!decl) return null;
+    sides.push(decl);
+  }
+  const [top, right, bottom, left] = sides;
+  if (!(top.important === right.important && right.important === bottom.important && bottom.important === left.important)) {
+    return null;
+  }
+  const tv = String(top.value);
+  const rv = String(right.value);
+  const bv = String(bottom.value);
+  const lv = String(left.value);
+  if (tv !== bv || lv !== rv) return null;
+  const value = tv === lv ? tv : `${tv} ${lv}`;
+  const relative = sides.some((d) => d.relativeToParent);
+  return { value, important: top.important, relative };
+}
+var isInert = (node) => {
+  const n = node;
+  if (n.kind !== "element") return false;
+  const el = n;
+  return !el.meta.hasDangerousHtml && !el.meta.hasSpreadAttrs && !el.isComponent;
+};
+function withFoldedPadding(sm, fold) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY2) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (PADDING_SIDE_SET.has(String(prop))) continue;
+      decls.set(prop, decl);
+    }
+    const shorthand = {
+      property: "padding",
+      value: fold.value,
+      important: fold.important,
+      relativeToParent: fold.relative,
+      inherited: false
+      // padding is never inherited
+    };
+    decls.set(shorthand.property, shorthand);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var paddingShorthand = pattern({
+  name: "padding-shorthand",
+  category: "compress/padding-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse padding longhands to shorthand",
+    summary: "Equal padding on all four sides (or matching x/y pairs) expressed as separate longhand declarations is collapsed to the shortest equivalent padding shorthand (p-* / px-* py-*).",
+    before: '<div class="pt-4 pr-4 pb-4 pl-4"/>',
+    after: '<div class="p-4"/>',
+    safetyRationale: "A value-preserving re-serialization of the same computed styles on the same node; it skips nodes with ref/handlers/dynamic children/dynamic classes/dangerous html and combinator subjects, so no JS identity, behaviour, or project selector is disturbed."
+  },
+  match: {
+    where: [
+      not(hasRef),
+      not(hasEventHandlers),
+      not(hasDynamicChildren),
+      not(hasDynamicClasses),
+      not(targetedByCombinator),
+      isInert
+    ]
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const fold = analyzePadding(computed2);
+      return fold ? withFoldedPadding(computed2, fold) : null;
+    }
+  },
+  examples: [
+    {
+      // The four equal padding longhands collapse to a `padding` shorthand at the IR level, and the
+      // minimizing reverse-emit picks the single shortest utility (`p-4`) that reproduces it,
+      // replacing the four `p{t,r,b,l}-4` tokens. `bg-red-200` is preserved (its order is stable).
+      before: '<div className="pt-4 pr-4 pb-4 pl-4 bg-red-200">box</div>',
+      after: '<div className="bg-red-200 p-4">box</div>'
+    },
+    {
+      // Asymmetric padding (top != bottom) cannot fold into a shorthand.
+      noMatch: '<div className="pt-2 pr-4 pb-8 pl-4 bg-red-200">box</div>'
+    }
+  ]
+});
+
+// ../patterns/src/compress/size-shorthand.pattern.ts
+init_esm_shims();
+var WIDTH = "width";
+var HEIGHT = "height";
+var SIZE = "size";
+var NON_COLLAPSIBLE_VALUES = /* @__PURE__ */ new Set(["auto", "initial", "unset"]);
+function asElement2(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+function baseBlock(sm) {
+  return sm.blocks.get(conditionKey(BASE_CONDITION));
+}
+var hasDangerousHtml3 = (node) => asElement2(node)?.meta.hasDangerousHtml ?? false;
+function withSizeShorthand(sm, value, important) {
+  const baseKey = conditionKey(BASE_CONDITION);
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== baseKey) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = new Map(block.decls);
+    decls.delete(WIDTH);
+    decls.delete(HEIGHT);
+    for (const decl of normalizer.normalizeDeclaration(String(SIZE), value, important)) {
+      decls.set(decl.property, decl);
+    }
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var sizeShorthand = pattern({
+  name: "size-shorthand",
+  category: "compress/size-shorthand",
+  safety: 2,
+  doc: {
+    title: "Collapse equal width/height into size-*",
+    summary: "An element whose computed width and height are equal is rewritten to the single Tailwind size-* utility (size-* === width + height at the same value).",
+    before: '<div style="width:1rem;height:1rem"/>',
+    after: '<div class="size-4"/>',
+    safetyRationale: "size-* is value-identical to equal width+height; the element carries no ref/handlers/dynamic children/dangerous HTML, no dynamic class segment, and is not a combinator subject."
+  },
+  match: {
+    where: [
+      not(hasRef),
+      not(hasEventHandlers),
+      not(hasDynamicChildren),
+      not(hasDangerousHtml3),
+      not(hasDynamicClasses),
+      not(targetedByCombinator)
+    ]
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const base = baseBlock(computed2);
+      const w = base?.decls.get(WIDTH);
+      const h = base?.decls.get(HEIGHT);
+      if (!w || !h) return null;
+      if (w.important !== h.important) return null;
+      if (NON_COLLAPSIBLE_VALUES.has(String(w.value))) return null;
+      if (w.value !== h.value) return null;
+      return withSizeShorthand(computed2, String(w.value), w.important);
+    }
+  },
+  examples: [
+    {
+      // Equal width/height collapse to a `size` decl at the IR level; the minimizing reverse-emit
+      // expands `size` back to width+height, finds the single utility covering both (`size-10`), and
+      // replaces the `h-10`+`w-10` pair with it. `bg-red-200` is preserved.
+      before: '<div className="h-10 w-10 bg-red-200">box</div>',
+      after: '<div className="bg-red-200 size-10">box</div>'
+    },
+    {
+      // Width and height differ → no equal-axis collapse.
+      noMatch: '<div className="h-10 w-20 bg-red-200">box</div>'
+    }
+  ]
+});
+
+// ../patterns/src/_registry.generated.ts
+init_esm_shims();
+var builtinPatterns = [
+  emptyStyleDiv,
+  flexCenterWrapper,
+  nestedFlexMerge,
+  passthroughWrapper,
+  redundantFragment,
+  dedupeClasses,
+  insetShorthand,
+  marginShorthand,
+  paddingShorthand,
+  sizeShorthand
+];
+
+// ../patterns/src/index.ts
+init_esm_shims();
+
+// ../frontend-jsx/src/frontend.ts
+init_esm_shims();
+import { parse as babelParse } from "@babel/parser";
+import babelTraverse from "@babel/traverse";
+var traverse = typeof babelTraverse === "function" ? babelTraverse : babelTraverse.default;
+var JSX_LANGS = ["jsx", "tsx"];
+var FILE_ID = 1;
+function jsxName(node) {
+  switch (node.type) {
+    case "JSXIdentifier":
+      return node.name;
+    case "JSXMemberExpression":
+      return `${jsxName(node.object)}.${node.property.name}`;
+    case "JSXNamespacedName":
+      return `${node.namespace.name}:${node.name.name}`;
+  }
+}
+function isComponentName(node) {
+  if (node.type === "JSXMemberExpression") return true;
+  if (node.type === "JSXNamespacedName") return false;
+  return /^[A-Z]/.test(node.name);
+}
+function attrName(name) {
+  return name.type === "JSXNamespacedName" ? `${name.namespace.name}:${name.name.name}` : name.name;
+}
+function exprKind(node) {
+  switch (node.type) {
+    case "CallExpression":
+    case "OptionalCallExpression":
+      return "call";
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return "member";
+    case "ConditionalExpression":
+    case "LogicalExpression":
+      return "conditional";
+    case "TemplateLiteral":
+    case "TaggedTemplateExpression":
+      return "template";
+    case "Identifier":
+      return "identifier";
+    case "SpreadElement":
+      return "spread";
+    default:
+      return "other";
+  }
+}
+function classFormOf(node) {
+  switch (node.type) {
+    case "TemplateLiteral":
+    case "TaggedTemplateExpression":
+      return "template-literal";
+    case "CallExpression":
+    case "OptionalCallExpression":
+      return "call";
+    case "ConditionalExpression":
+    case "LogicalExpression":
+      return "conditional";
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+    case "Identifier":
+      return "member";
+    default:
+      return "call";
+  }
+}
+function looksLikeJsx(id, code) {
+  if (/\.[jt]sx$/i.test(id)) return true;
+  return /<\/?[A-Za-z][\w.-]*|<>/.test(code);
+}
+function doParse(code, ctx) {
+  const diagnostics = [];
+  const doc = createDocument("jsx");
+  const backref = doc.backref;
+  const ast = babelParse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"]
+  });
+  const eol = code.includes("\r\n") ? "\r\n" : "\n";
+  const sourceFile = {
+    id: FILE_ID,
+    path: ctx.id,
+    text: code,
+    frontend: "jsx",
+    eol,
+    indentUnit: "  ",
+    native: ast
+  };
+  doc.sources.set(FILE_ID, sourceFile);
+  const spanOf = (node) => {
+    if (node.start == null || node.end == null) return null;
+    const span = {
+      file: FILE_ID,
+      start: node.start,
+      end: node.end,
+      startLoc: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0,
+      endLoc: node.loc ? { line: node.loc.end.line, column: node.loc.end.column } : void 0
+    };
+    return span;
+  };
+  const sliceOf = (node) => node.start == null || node.end == null ? "" : code.slice(node.start, node.end);
+  const internExpr = (node, spread) => {
+    const payload = { text: sliceOf(node), spread };
+    return doc.exprs.intern({
+      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },
+      kind: exprKind(node),
+      payload
+    });
+  };
+  const splitTokens = (raw) => raw.split(/\s+/).filter((t) => t.length > 0).map((value) => ({ value }));
+  const buildClassList = (attr) => {
+    const attrSpan = spanOf(attr) ?? void 0;
+    const v = attr.value;
+    const staticList = (tokens, valueSpan) => {
+      const seg = { kind: "static", span: valueSpan ?? void 0, tokens };
+      return {
+        form: "string-literal",
+        segments: [seg],
+        valueSpan,
+        attrSpan,
+        hasDynamic: false,
+        opaque: false,
+        rewritable: true
+      };
+    };
+    if (v == null) return staticList([], null);
+    if (v.type === "StringLiteral") {
+      return staticList(splitTokens(v.value), spanOf(v));
+    }
+    if (v.type === "JSXExpressionContainer") {
+      const expr = v.expression;
+      if (expr.type === "StringLiteral") {
+        return staticList(splitTokens(expr.value), spanOf(expr));
+      }
+      if (expr.type === "JSXEmptyExpression") return staticList([], null);
+      const ref = internExpr(expr, false);
+      const valueSpan = spanOf(expr);
+      const seg = { kind: "dynamic", span: valueSpan ?? void 0, expr: ref };
+      return {
+        form: classFormOf(expr),
+        segments: [seg],
+        valueSpan,
+        attrSpan,
+        hasDynamic: true,
+        opaque: true,
+        rewritable: false
+      };
+    }
+    return emptyClassList();
+  };
+  const staticTokensOf2 = (classes) => {
+    const out = [];
+    for (const seg of classes.segments) {
+      if (seg.kind === "static") for (const t of seg.tokens) out.push(t.value);
+    }
+    return out;
+  };
+  const buildAttrValue = (attr) => {
+    const v = attr.value;
+    if (v == null) return { kind: "static", value: true, span: spanOf(attr) ?? void 0 };
+    if (v.type === "StringLiteral") {
+      return { kind: "static", value: v.value, span: spanOf(v) ?? void 0 };
+    }
+    if (v.type === "JSXExpressionContainer") {
+      if (v.expression.type === "JSXEmptyExpression") {
+        return { kind: "static", value: true, span: spanOf(v) ?? void 0 };
+      }
+      return { kind: "dynamic", expr: internExpr(v.expression, false), span: spanOf(v) ?? void 0 };
+    }
+    return { kind: "dynamic", expr: internExpr(v, false), span: spanOf(v) ?? void 0 };
+  };
+  const buildChild = (node, parentId) => {
+    switch (node.type) {
+      case "JSXText": {
+        const id = doc.alloc.next();
+        doc.nodes.set(
+          id,
+          createText(id, node.value, {
+            parent: parentId,
+            span: spanOf(node),
+            collapsible: /^\s*$/.test(node.value)
+          })
+        );
+        return id;
+      }
+      case "JSXExpressionContainer": {
+        if (node.expression.type === "JSXEmptyExpression") return null;
+        const id = doc.alloc.next();
+        const ref = internExpr(node.expression, false);
+        doc.nodes.set(id, createExpr(id, ref, { parent: parentId, span: spanOf(node) }));
+        return id;
+      }
+      case "JSXSpreadChild": {
+        const id = doc.alloc.next();
+        const ref = internExpr(node.expression, true);
+        doc.nodes.set(id, createExpr(id, ref, { parent: parentId, span: spanOf(node) }));
+        return id;
+      }
+      case "JSXElement":
+        return buildElement(node, parentId);
+      case "JSXFragment":
+        return buildFragment(node, parentId);
+      default:
+        return null;
+    }
+  };
+  const buildFragment = (node, parentId) => {
+    const id = doc.alloc.next();
+    const children = [];
+    for (const c of node.children) {
+      const cid = buildChild(c, id);
+      if (cid != null) children.push(cid);
+    }
+    doc.nodes.set(id, createFragment(id, { children, parent: parentId, span: spanOf(node) }));
+    backref.set(id, {
+      nodeId: id,
+      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },
+      openTagSpan: spanOf(node.openingFragment),
+      closeTagSpan: spanOf(node.closingFragment),
+      innerSpan: null,
+      selfClosing: false
+    });
+    return id;
+  };
+  const buildElement = (node, parentId) => {
+    const id = doc.alloc.next();
+    const opening = node.openingElement;
+    const tag = jsxName(opening.name);
+    const component = isComponentName(opening.name);
+    const meta = defaultMeta();
+    meta.isComponent = component;
+    let classes = emptyClassList();
+    const entries = /* @__PURE__ */ new Map();
+    const order = [];
+    const spreads = [];
+    for (const attr of opening.attributes) {
+      if (attr.type === "JSXSpreadAttribute") {
+        spreads.push(internExpr(attr.argument, true));
+        meta.hasSpreadAttrs = true;
+        continue;
+      }
+      const name = attrName(attr.name);
+      if (name === "className" || name === "class") {
+        classes = buildClassList(attr);
+        continue;
+      }
+      if (name === "ref") meta.hasRef = true;
+      else if (name === "key") meta.hasKey = true;
+      else if (name === "dangerouslySetInnerHTML") meta.hasDangerousHtml = true;
+      else if (/^on[A-Z]/.test(name)) meta.hasEventHandlers = true;
+      entries.set(name, buildAttrValue(attr));
+      order.push(name);
+    }
+    const attrs = { entries, spreads, order };
+    const children = [];
+    for (const c of node.children) {
+      const cid = buildChild(c, id);
+      if (cid != null) children.push(cid);
+    }
+    for (const cid of children) {
+      const cn = doc.nodes.get(cid);
+      if (cn && cn.kind === "expr") {
+        meta.hasDynamicChildren = true;
+        break;
+      }
+    }
+    let computed2 = emptyStyleMap();
+    if (!classes.hasDynamic) {
+      const tokens = staticTokensOf2(classes);
+      if (tokens.length > 0) {
+        const res = ctx.resolver.resolve({
+          classes: tokens,
+          element: { tagName: tag, namespace: component ? void 0 : "html" }
+        });
+        computed2 = ctx.normalizer.normalizeStyleMap(res.styles);
+        for (const w of res.warnings) {
+          diagnostics.push({
+            code: "DF_STYLE_CONFLICT_UNRESOLVED",
+            severity: w.severity,
+            message: w.message,
+            nodeId: id
+          });
+        }
+      }
+    }
+    const namespace = component ? "component" : "html";
+    const el = createElement(id, {
+      tag,
+      namespace,
+      isComponent: component,
+      selfClosing: opening.selfClosing,
+      classes,
+      computed: computed2,
+      attrs,
+      children,
+      parent: parentId,
+      span: spanOf(node),
+      meta
+    });
+    doc.nodes.set(id, el);
+    const inner = children.length > 0 ? spanOf(node.children[0]) && spanOf(node.children.at(-1)) ? {
+      file: FILE_ID,
+      start: spanOf(node.children[0]).start,
+      end: spanOf(node.children.at(-1)).end
+    } : null : null;
+    backref.set(id, {
+      nodeId: id,
+      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },
+      openTagSpan: spanOf(opening),
+      closeTagSpan: node.closingElement ? spanOf(node.closingElement) : null,
+      innerSpan: inner,
+      selfClosing: opening.selfClosing
+    });
+    return id;
+  };
+  const roots = [];
+  traverse(ast, {
+    JSXElement(path3) {
+      roots.push(path3.node);
+      path3.skip();
+    },
+    JSXFragment(path3) {
+      roots.push(path3.node);
+      path3.skip();
+    }
+  });
+  const rootFrag = doc.nodes.get(doc.root);
+  for (const r of roots) {
+    const id = r.type === "JSXFragment" ? buildFragment(r, doc.root) : buildElement(r, doc.root);
+    rootFrag.children.push(id);
+  }
+  return { doc, diagnostics };
+}
+var jsxFrontend = {
+  name: "babel-jsx",
+  langs: JSX_LANGS,
+  canParse(id, code) {
+    return looksLikeJsx(id, code);
+  },
+  parse(code, ctx) {
+    return doParse(code, ctx);
+  }
+};
+function createJsxFrontend() {
+  return jsxFrontend;
+}
+
+// ../frontend-jsx/src/backend.ts
+init_esm_shims();
+import MagicString from "magic-string";
+var JSX_LANGS2 = ["jsx", "tsx"];
+function exprText(doc, ref) {
+  const rec = doc.exprs.get(ref);
+  const payload = rec?.payload;
+  if (payload && typeof payload.text === "string") {
+    return { text: payload.text, spread: payload.spread === true };
+  }
+  if (rec) {
+    const sf = doc.sources.get(rec.span.file);
+    if (sf) return { text: sf.text.slice(rec.span.start, rec.span.end), spread: false };
+  }
+  return { text: "", spread: false };
+}
+function staticTokensOf(classes) {
+  const out = [];
+  for (const seg of classes.segments) {
+    if (seg.kind === "static") for (const t of seg.tokens) out.push(t.value);
+  }
+  return out;
+}
+function primarySource(doc) {
+  for (const sf of doc.sources.values()) {
+    if (typeof sf.text === "string" && sf.text.length > 0) return sf;
+  }
+  return null;
+}
+function collectKept(doc) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const n = doc.nodes.get(id);
+    if (!n) return;
+    out.push(n);
+    if (n.kind === "element" || n.kind === "fragment") for (const c of n.children) visit(c);
+  };
+  visit(doc.root);
+  return out;
+}
+function strictlyContains(a, b) {
+  if (a.file !== b.file) return false;
+  if (a.start <= b.start && b.end <= a.end) return !(a.start === b.start && a.end === b.end);
+  return false;
+}
+function editClasses(ms, doc, sf, el) {
+  const classes = el.classes;
+  if (classes.hasDynamic || classes.opaque) return false;
+  const tokens = staticTokensOf(classes);
+  const valueSpan = classes.valueSpan;
+  if (valueSpan && valueSpan.file === sf.id) {
+    const current = sf.text.slice(valueSpan.start, valueSpan.end);
+    const quote = current.startsWith("'") ? "'" : '"';
+    const next = `${quote}${tokens.join(" ")}${quote}`;
+    if (current !== next) {
+      ms.overwrite(valueSpan.start, valueSpan.end, next);
+      return true;
+    }
+    return false;
+  }
+  if (tokens.length === 0) return false;
+  if (el.isComponent) return false;
+  const back = doc.backref.get(el.id);
+  const openTag = back?.openTagSpan;
+  if (!openTag || openTag.file !== sf.id) return false;
+  const insertAt = openTag.start + 1 + el.tag.length;
+  ms.appendLeft(insertAt, ` className="${tokens.join(" ")}"`);
+  return true;
+}
+function surgicalPrint(doc) {
+  const sf = primarySource(doc);
+  if (!sf) return null;
+  const ms = new MagicString(sf.text);
+  const kept = collectKept(doc);
+  const keptSpans = [];
+  for (const n of kept) if (n.span && n.span.file === sf.id) keptSpans.push(n.span);
+  const removed = [];
+  for (const id of backrefIds(doc)) {
+    if (doc.nodes.has(id)) continue;
+    const back = doc.backref.get(id);
+    if (!back || back.span.file !== sf.id) continue;
+    const unwrapped = keptSpans.some((k) => strictlyContains(back.span, k));
+    removed.push({ backref: back, unwrapped });
+  }
+  const fullRemovals = removed.filter((r) => !r.unwrapped).map((r) => r.backref.span);
+  for (const r of removed) {
+    const span = r.backref.span;
+    const coveredByFull = fullRemovals.some((f) => f !== span && strictlyContains(f, span));
+    if (coveredByFull) continue;
+    if (r.unwrapped) {
+      const open = r.backref.openTagSpan;
+      const close = r.backref.closeTagSpan;
+      if (open && open.file === sf.id && open.end > open.start) ms.remove(open.start, open.end);
+      if (close && close.file === sf.id && close.end > close.start) {
+        ms.remove(close.start, close.end);
+      }
+    } else {
+      ms.remove(span.start, span.end);
+    }
+  }
+  for (const n of kept) {
+    if (n.kind === "element") editClasses(ms, doc, sf, n);
+  }
+  return ms.toString();
+}
+function backrefIds(doc) {
+  const out = [];
+  const max = doc.alloc.peek;
+  for (let i = 1; i < max; i += 1) {
+    const id = i;
+    if (doc.backref.get(id)) out.push(id);
+  }
+  return out;
+}
+function classText(doc, classes) {
+  if (classes.form === "absent" || classes.segments.length === 0) return null;
+  const dynamic = classes.segments.find((s) => s.kind === "dynamic");
+  if (dynamic && dynamic.kind === "dynamic") {
+    return `className={${exprText(doc, dynamic.expr).text}}`;
+  }
+  const tokens = staticTokensOf(classes);
+  return `className="${tokens.join(" ")}"`;
+}
+function attrText(doc, name, value) {
+  if (value.kind === "static") {
+    if (value.value === true) return name;
+    if (value.value === false) return "";
+    return `${name}="${String(value.value)}"`;
+  }
+  return `${name}={${exprText(doc, value.expr).text}}`;
+}
+function printElement(doc, el) {
+  const parts = [];
+  const cls = classText(doc, el.classes);
+  if (cls !== null) parts.push(cls);
+  for (const name of el.attrs.order) {
+    const v = el.attrs.entries.get(name);
+    if (!v) continue;
+    const text = attrText(doc, name, v);
+    if (text.length > 0) parts.push(text);
+  }
+  for (const ref of el.attrs.spreads) parts.push(`{...${exprText(doc, ref).text}}`);
+  const attrStr = parts.length > 0 ? ` ${parts.join(" ")}` : "";
+  const tag = el.tag;
+  if (el.children.length === 0) {
+    return el.selfClosing ? `<${tag}${attrStr} />` : `<${tag}${attrStr}></${tag}>`;
+  }
+  const inner = el.children.map((c) => printNode(doc, c)).join("");
+  return `<${tag}${attrStr}>${inner}</${tag}>`;
+}
+function printNode(doc, id) {
+  const node = doc.nodes.get(id);
+  if (!node) return "";
+  switch (node.kind) {
+    case "text":
+      return node.value;
+    case "comment":
+      return `{/*${node.value}*/}`;
+    case "expr": {
+      const { text, spread } = exprText(doc, node.expr);
+      return spread ? `{...${text}}` : `{${text}}`;
+    }
+    case "fragment":
+      return `<>${node.children.map((c) => printNode(doc, c)).join("")}</>`;
+    case "element":
+      return printElement(doc, node);
+  }
+}
+function rePrint(doc) {
+  const root = doc.nodes.get(doc.root);
+  if (!root || root.kind !== "fragment") return printNode(doc, doc.root);
+  return root.children.map((c) => printNode(doc, c)).join("");
+}
+function doPrint(doc) {
+  const surgical = surgicalPrint(doc);
+  return surgical ?? rePrint(doc);
+}
+var jsxBackend = {
+  name: "babel-jsx",
+  langs: JSX_LANGS2,
+  print(doc, _plan, _ctx) {
+    const code = doPrint(doc);
+    return { code, map: null, edits: [], diagnostics: [] };
+  }
+};
+function createJsxBackend() {
+  return jsxBackend;
+}
+
+// ../frontend-jsx/src/index.ts
+init_esm_shims();
+
+// ../resolver-tailwind/src/index.ts
+init_esm_shims();
+import { createRequire } from "module";
+import * as path from "path";
+function moduleBase() {
+  return typeof __filename === "string" ? __filename : import.meta.url;
+}
+function projectRequire(projectRoot) {
+  const bases = [];
+  if (projectRoot) bases.push(path.join(projectRoot, "__domflax__.js"));
+  bases.push(path.join(process.cwd(), "__domflax__.js"));
+  bases.push(moduleBase());
+  for (const base of bases) {
+    try {
+      const candidate = createRequire(base);
+      candidate.resolve("tailwindcss/package.json");
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function loadEngine(options) {
+  const req = projectRequire(options.projectRoot);
+  if (!req) return null;
+  try {
+    const resolveConfig = req("tailwindcss/resolveConfig.js");
+    const { createContext } = req("tailwindcss/lib/lib/setupContextUtils.js");
+    const { generateRules } = req("tailwindcss/lib/lib/generateRules.js");
+    const pkg = req("tailwindcss/package.json");
+    let userConfig = options.config ?? { content: [{ raw: "" }] };
+    if (options.configPath !== void 0) {
+      const loadConfig = req("tailwindcss/loadConfig.js");
+      userConfig = loadConfig(options.configPath);
+    }
+    const resolved = resolveConfig(userConfig);
+    const context = createContext(resolved);
+    return {
+      version: pkg.version,
+      context,
+      generate(candidates) {
+        const rules = generateRules(new Set(candidates), context);
+        return rules.map(([, node]) => node);
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+var LEGACY_PSEUDO_ELEMENTS = /* @__PURE__ */ new Set([
+  ":before",
+  ":after",
+  ":first-line",
+  ":first-letter"
+]);
+function parseSelector(selector) {
+  const sel = selector.trim();
+  if (sel.length === 0 || sel[0] !== ".") return { kind: "complex" };
+  let i = 1;
+  for (; i < sel.length; i += 1) {
+    const c = sel[i];
+    if (c === "\\") {
+      i += 1;
+      continue;
+    }
+    if (c === ":" || c === "." || c === "[" || c === " " || c === ">" || c === "+" || c === "~" || c === ",") {
+      break;
+    }
+  }
+  const remainder = sel.slice(i);
+  if (remainder.length === 0) {
+    return { kind: "simple", states: [], pseudoElement: "" };
+  }
+  if (!/^(?:::?[-a-z]+(?:\([^()]*\))?)+$/i.test(remainder)) {
+    return { kind: "complex" };
+  }
+  const parts = remainder.match(/::?[-a-z]+(?:\([^()]*\))?/gi) ?? [];
+  const states = [];
+  let pseudoElement = "";
+  for (const part of parts) {
+    if (part.startsWith("::") || LEGACY_PSEUDO_ELEMENTS.has(part)) {
+      pseudoElement = part.startsWith("::") ? part : `:${part}`;
+    } else {
+      states.push(part);
+    }
+  }
+  return { kind: "simple", states, pseudoElement };
+}
+function makeCondition(media, states, pseudoElement) {
+  return {
+    media,
+    states: [...new Set(states)].sort(),
+    pseudoElement
+  };
+}
+function collectRules(node, mediaStack, inUnsupportedAtRule, out) {
+  if (node.type === "rule") {
+    out.push({ rule: node, media: mediaStack, unsupported: inUnsupportedAtRule });
+    return;
+  }
+  if (node.type === "atrule") {
+    const at = node;
+    const children = at.nodes ?? [];
+    if (at.name === "media") {
+      const nextStack = at.params ? [...mediaStack, at.params] : mediaStack;
+      for (const child of children) collectRules(child, nextStack, inUnsupportedAtRule, out);
+    } else {
+      for (const child of children) collectRules(child, mediaStack, true, out);
+    }
+  }
+}
+function extractToken(token, nodes) {
+  if (nodes.length === 0) return { blocks: [], produced: false };
+  const leaves = [];
+  for (const node of nodes) collectRules(node, [], false, leaves);
+  const blocks = [];
+  let sawComplex = false;
+  for (const { rule, media, unsupported } of leaves) {
+    const parsed = parseSelector(rule.selector);
+    if (parsed.kind === "complex" || unsupported) {
+      sawComplex = true;
+      continue;
+    }
+    const decls = [];
+    for (const child of rule.nodes ?? []) {
+      if (child.type !== "decl") continue;
+      const d = child;
+      if (typeof d.value !== "string") continue;
+      decls.push([d.prop, d.value, d.important === true]);
+    }
+    if (decls.length === 0) continue;
+    const mediaQuery = media.join(" and ");
+    blocks.push({ condition: makeCondition(mediaQuery, parsed.states, parsed.pseudoElement), decls });
+  }
+  const opaque = sawComplex && blocks.length === 0 ? { token, reason: "combinator-variant", detail: "utility targets descendants/siblings, not its own box" } : void 0;
+  return { blocks, produced: true, opaque };
+}
+function buildStyleMap(blockMaps) {
+  if (blockMaps.size === 0) return emptyStyleMap();
+  const blocks = /* @__PURE__ */ new Map();
+  for (const { condition, decls } of blockMaps.values()) {
+    if (decls.size === 0) continue;
+    blocks.set(conditionKey(condition), { condition, decls });
+  }
+  if (blocks.size === 0) return emptyStyleMap();
+  return normalizer.normalizeStyleMap({ blocks });
+}
+function shadowedBy(prev) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (o) => {
+    if (!o || o.kind !== "class" || seen.has(o.className)) return;
+    seen.add(o.className);
+    out.push(o);
+  };
+  for (const o of prev.shadowed ?? []) add(o);
+  add(prev.origin);
+  return out.length > 0 ? out : void 0;
+}
+var OPAQUE_USAGE = {
+  asSubject: true,
+  asAncestor: true,
+  asCompound: true,
+  asSibling: true,
+  asHasArgument: true,
+  asStructural: true,
+  droppable: false
+};
+var DROPPABLE_USAGE = {
+  asSubject: true,
+  asAncestor: false,
+  asCompound: false,
+  asSibling: false,
+  asHasArgument: false,
+  asStructural: false,
+  droppable: true
+};
+function fnv1a(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+var TailwindResolver = class {
+  id = "tailwind";
+  provider;
+  fingerprint;
+  #engine;
+  /** Per-token extraction cache (engine output is pure for a fixed config). */
+  #tokenCache = /* @__PURE__ */ new Map();
+  /** Per-class-set forward-resolution cache. */
+  #resolveCache = /* @__PURE__ */ new Map();
+  /** Lazily built reverse index for {@link emit}. */
+  #reverseIndex = null;
+  constructor(config = {}) {
+    this.#engine = loadEngine(config);
+    this.provider = config.provider ?? (this.#engine ? `tailwindcss@${this.#engine.version}` : "tailwindcss");
+    const seed = JSON.stringify(config.config ?? {}) + (config.configPath ?? "");
+    this.fingerprint = config.fingerprint ?? `${this.provider}/${fnv1a(seed)}`;
+  }
+  /** Engine-backed, cached single-token extraction. */
+  #extract(token) {
+    const cached = this.#tokenCache.get(token);
+    if (cached) return cached;
+    let result;
+    if (!this.#engine) {
+      result = { blocks: [], produced: false };
+    } else {
+      try {
+        result = extractToken(token, this.#engine.generate([token]));
+      } catch {
+        result = { blocks: [], produced: false };
+      }
+    }
+    this.#tokenCache.set(token, result);
+    return result;
+  }
+  owns(token) {
+    if (token.length === 0) return false;
+    return this.#extract(token).produced;
+  }
+  resolve(input) {
+    const key = JSON.stringify(input.classes);
+    const cached = this.#resolveCache.get(key);
+    if (cached) return cached;
+    const blockMaps = /* @__PURE__ */ new Map();
+    const resolved = [];
+    const unknown = [];
+    const opaque = [];
+    input.classes.forEach((token, tokenIndex) => {
+      const extracted = this.#extract(token);
+      if (!extracted.produced) {
+        unknown.push(token);
+        return;
+      }
+      if (extracted.opaque) opaque.push(extracted.opaque);
+      if (extracted.blocks.length === 0) return;
+      const origin = { kind: "class", tokenIndex, className: token };
+      let contributed = false;
+      for (const block of extracted.blocks) {
+        const ck = conditionKey(block.condition);
+        let bucket = blockMaps.get(ck);
+        if (!bucket) {
+          bucket = { condition: block.condition, decls: /* @__PURE__ */ new Map() };
+          blockMaps.set(ck, bucket);
+        }
+        for (const [prop, value, important] of block.decls) {
+          for (const decl of normalizer.normalizeDeclaration(prop, value, important)) {
+            const prev = bucket.decls.get(decl.property);
+            const shadowed = prev ? shadowedBy(prev) : void 0;
+            bucket.decls.set(decl.property, shadowed ? { ...decl, origin, shadowed } : { ...decl, origin });
+            contributed = true;
+          }
+        }
+      }
+      if (contributed) resolved.push(token);
+    });
+    const result = {
+      styles: buildStyleMap(blockMaps),
+      resolved,
+      unknown,
+      opaque,
+      warnings: []
+    };
+    this.#resolveCache.set(key, result);
+    return result;
+  }
+  /**
+   * Lazily build the reverse index from the engine's own enumerable class list. Each indexable
+   * utility maps to its NORMALIZED BASE longhand declarations (property → canonical value). Utilities
+   * with variant conditions, combinator selectors, or no BASE declarations are skipped. Sorted by
+   * declaration count (desc) so greedier (shorthand-like) utilities are tried first.
+   */
+  #buildReverseIndex() {
+    if (this.#reverseIndex) return this.#reverseIndex;
+    const index = [];
+    if (this.#engine) {
+      try {
+        const classes = this.#engine.context.getClassList().filter((c) => typeof c === "string");
+        const nodes = this.#engine.generate(classes);
+        for (const node of nodes) {
+          if (node.type !== "rule") continue;
+          const rule = node;
+          const parsed = parseSelector(rule.selector);
+          if (parsed.kind !== "simple" || parsed.states.length > 0 || parsed.pseudoElement !== "") {
+            continue;
+          }
+          const className = unescapeClass(rule.selector);
+          if (className === null) continue;
+          const decls = /* @__PURE__ */ new Map();
+          for (const child of rule.nodes ?? []) {
+            if (child.type !== "decl") continue;
+            const d = child;
+            if (typeof d.value !== "string") continue;
+            for (const decl of normalizer.normalizeDeclaration(d.prop, d.value, d.important === true)) {
+              decls.set(decl.property, String(decl.value));
+            }
+          }
+          if (decls.size > 0) index.push([className, decls]);
+        }
+      } catch {
+      }
+    }
+    index.sort((a, b) => b[1].size - a[1].size || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+    this.#reverseIndex = index;
+    return index;
+  }
+  emit(styles, ctx) {
+    const norm = ctx.normalizer ?? normalizer;
+    const normalized = norm.normalizeStyleMap(styles);
+    const base = normalized.blocks.get(conditionKey(BASE_CONDITION));
+    if (!base || base.decls.size === 0) return { classes: [], exact: true, warnings: [] };
+    const hasNonBase = normalized.blocks.size > 1;
+    const target = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of base.decls) {
+      for (const [lp, lv] of expandForEmit(norm, String(prop), String(decl.value), decl.important)) {
+        target.set(lp, lv);
+      }
+    }
+    const candidates = [];
+    for (const entry of this.#buildReverseIndex()) {
+      const [, declMap] = entry;
+      if (declMap.size === 0 || declMap.size > target.size) continue;
+      let fits = true;
+      for (const [prop, value] of declMap) {
+        if (target.get(prop) !== value) {
+          fits = false;
+          break;
+        }
+      }
+      if (fits) candidates.push(entry);
+    }
+    const remaining = new Map(target);
+    const classes = [];
+    while (remaining.size > 0) {
+      let best = null;
+      let bestCover = 0;
+      for (const entry of candidates) {
+        const [token, declMap] = entry;
+        let cover = 0;
+        for (const prop of declMap.keys()) if (remaining.has(prop)) cover += 1;
+        if (cover === 0) continue;
+        const better = best === null || cover > bestCover || cover === bestCover && declMap.size < best[1].size || cover === bestCover && declMap.size === best[1].size && token < best[0];
+        if (better) {
+          best = entry;
+          bestCover = cover;
+        }
+      }
+      if (!best) break;
+      classes.push(best[0]);
+      for (const prop of best[1].keys()) remaining.delete(prop);
+    }
+    const exact = remaining.size === 0 && !hasNonBase;
+    if (remaining.size === 0) return { classes, exact, warnings: [] };
+    const residual = synthesizeResidual(remaining, ctx);
+    return residual ? { classes, residual, exact, warnings: [] } : { classes, exact, warnings: [] };
+  }
+  selectorUsage(token) {
+    const ex = this.#extract(token);
+    if (!ex.produced || ex.opaque) return OPAQUE_USAGE;
+    const baseOnly = ex.blocks.length > 0 && ex.blocks.every((b) => conditionKey(b.condition) === conditionKey(BASE_CONDITION));
+    if (!baseOnly) return OPAQUE_USAGE;
+    return DROPPABLE_USAGE;
+  }
+};
+function expandForEmit(norm, prop, value, important) {
+  const pairsFor = (p, v) => norm.normalizeDeclaration(p, v, important).map((d) => [d.property, String(d.value)]);
+  if (prop === "size") {
+    return [...pairsFor("width", value), ...pairsFor("height", value)];
+  }
+  if (prop === "inset-block" || prop === "inset-inline") {
+    const parts = value.split(/\s+/).filter((s) => s.length > 0);
+    const a = parts[0] ?? value;
+    const b = parts[1] ?? a;
+    const sides = prop === "inset-block" ? ["top", "bottom"] : ["left", "right"];
+    return [...pairsFor(sides[0], a), ...pairsFor(sides[1], b)];
+  }
+  return pairsFor(prop, value);
+}
+function synthesizeResidual(remaining, ctx) {
+  if (remaining.size === 0) return void 0;
+  const norm = ctx.normalizer ?? normalizer;
+  const decls = /* @__PURE__ */ new Map();
+  for (const [prop, value] of remaining) {
+    for (const decl of norm.normalizeDeclaration(String(prop), value, false)) {
+      decls.set(decl.property, decl);
+    }
+  }
+  const block = { condition: BASE_CONDITION, decls };
+  const styleMap = { blocks: /* @__PURE__ */ new Map([[conditionKey(BASE_CONDITION), block]]) };
+  const css = [...remaining].map(([p, v]) => `${p}:${v}`).join(";");
+  const className = `df-${fnv1a(css)}`;
+  const synthetic = { className, decls: styleMap, css: `.${className}{${css}}` };
+  try {
+    ctx.sink.register(synthetic);
+  } catch {
+  }
+  return synthetic;
+}
+function unescapeClass(selector) {
+  const sel = selector.trim();
+  if (sel[0] !== ".") return null;
+  let out = "";
+  for (let i = 1; i < sel.length; i += 1) {
+    const c = sel[i];
+    if (c === "\\") {
+      i += 1;
+      if (i < sel.length) out += sel[i];
+      continue;
+    }
+    if (c === ":" || c === "." || c === "[" || c === " " || c === ">" || c === "+" || c === "~" || c === ",") {
+      return null;
+    }
+    out += c;
+  }
+  return out.length > 0 ? out : null;
+}
+function createTailwindResolver(config) {
+  return new TailwindResolver(config);
+}
+
+// ../resolver-css/src/index.ts
+init_esm_shims();
+import { readFileSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+import * as path2 from "path";
+function moduleBase2() {
+  return typeof __filename === "string" ? __filename : import.meta.url;
+}
+function loadPostcssEngine(projectRoot) {
+  const bases = [];
+  if (projectRoot) bases.push(path2.join(projectRoot, "__domflax__.js"));
+  bases.push(path2.join(process.cwd(), "__domflax__.js"));
+  bases.push(moduleBase2());
+  for (const base of bases) {
+    try {
+      const req = createRequire2(base);
+      req.resolve("postcss");
+      req.resolve("postcss-selector-parser");
+      const postcss = req("postcss");
+      const raw = req("postcss-selector-parser");
+      const selector = raw.default ?? raw;
+      return { parse: postcss.parse, selectorParser: selector };
+    } catch {
+    }
+  }
+  return null;
+}
+var pc = null;
+var sp = null;
+function ensurePostcss(projectRoot) {
+  if (pc && sp) return;
+  const engine = loadPostcssEngine(projectRoot);
+  if (!engine) {
+    throw new Error(
+      '@domflax/resolver-css requires "postcss" and "postcss-selector-parser" to be installed in your project (they are optional peer dependencies of domflax, loaded only when the custom-CSS provider is used). Install them with: npm install postcss postcss-selector-parser'
+    );
+  }
+  pc = engine.parse;
+  sp = engine.selectorParser;
+}
+var CSS_RESOLVER_ID = "css";
+var CSS_RESOLVER_PROVIDER = "custom-css";
+var ENGINE_VERSION = "css-index@1";
+var STRUCTURAL_PSEUDOS = /* @__PURE__ */ new Set([
+  ":nth-child",
+  ":nth-last-child",
+  ":first-child",
+  ":last-child",
+  ":only-child",
+  ":nth-of-type",
+  ":nth-last-of-type",
+  ":first-of-type",
+  ":last-of-type",
+  ":only-of-type"
+]);
+var FUNCTIONAL_PSEUDOS = /* @__PURE__ */ new Set([
+  ":not",
+  ":is",
+  ":where",
+  ":has",
+  ":matches"
+]);
+var LEGACY_PSEUDO_ELEMENTS2 = /* @__PURE__ */ new Set([
+  ":before",
+  ":after",
+  ":first-line",
+  ":first-letter"
+]);
+var CustomCSSResolver = class {
+  id = CSS_RESOLVER_ID;
+  provider = CSS_RESOLVER_PROVIDER;
+  fingerprint;
+  #files;
+  /** Forward map: class token → simple-`.class` rule contributions (source order). */
+  #classIndex = /* @__PURE__ */ new Map();
+  /** Selector-participation facts per class token. */
+  #usage = /* @__PURE__ */ new Map();
+  /** Every class referenced anywhere in the stylesheets (forward-resolvable or not). */
+  #known = /* @__PURE__ */ new Set();
+  /** Distinct COMPLEX selectors (combinator or structural pseudo), sorted. */
+  #complex;
+  #reverse = null;
+  constructor(cssFiles = [], options = {}) {
+    ensurePostcss(options.projectRoot);
+    const fromDisk = (options.files ?? []).map(readCssPath);
+    this.#files = [...cssFiles, ...fromDisk];
+    this.fingerprint = options.fingerprint ?? deriveFingerprint(this.provider, this.#files);
+    const complex = /* @__PURE__ */ new Set();
+    let order = 0;
+    for (const file of this.#files) {
+      order = this.#indexFile(file, order, complex);
+    }
+    this.#complex = [...complex].sort();
+  }
+  /** The stylesheets this resolver was constructed with (raw sources + any read from disk). */
+  get files() {
+    return this.#files;
+  }
+  /** Owns any plain class token referenced by one of {@link files}. */
+  owns(token) {
+    return isPlainClassToken(token) && this.#known.has(token);
+  }
+  resolve(input) {
+    const styles = this.#resolveTokens(input.classes, input.classes);
+    const resolved = [];
+    const unknown = [];
+    for (const token of input.classes) {
+      if (this.#classIndex.has(token)) resolved.push(token);
+      else unknown.push(token);
+    }
+    return { styles, resolved, unknown, opaque: [], warnings: [] };
+  }
+  emit(styles, ctx) {
+    const norm = ctx.normalizer ?? normalizer;
+    const remaining = /* @__PURE__ */ new Map();
+    for (const [ck, block] of norm.normalizeStyleMap(styles).blocks) {
+      for (const [prop, decl] of block.decls) {
+        remaining.set(`${ck}\0${prop}`, String(decl.value));
+      }
+    }
+    if (remaining.size === 0) return { classes: [], exact: true, warnings: [] };
+    const classes = [];
+    for (const { token, keyed } of this.#reverseIndex()) {
+      let matches = true;
+      for (const [key, value] of keyed) {
+        if (remaining.get(key) !== value) {
+          matches = false;
+          break;
+        }
+      }
+      if (!matches) continue;
+      classes.push(token);
+      for (const key of keyed.keys()) remaining.delete(key);
+      if (remaining.size === 0) break;
+    }
+    return { classes, exact: remaining.size === 0, warnings: [] };
+  }
+  selectorUsage(token) {
+    const u = this.#usage.get(token);
+    if (!u) {
+      return {
+        asSubject: false,
+        asAncestor: false,
+        asCompound: false,
+        asSibling: false,
+        asHasArgument: false,
+        asStructural: false,
+        droppable: true
+      };
+    }
+    return {
+      asSubject: u.asSubject,
+      asAncestor: u.asAncestor,
+      asCompound: u.asCompound,
+      asSibling: u.asSibling,
+      asHasArgument: u.asHasArgument,
+      asStructural: u.asStructural,
+      // Safe to drop/rename only when every reference is the lone subject of a bare `.x {}`.
+      droppable: u.referenced && !u.loadBearing
+    };
+  }
+  /**
+   * The distinct COMPLEX selectors found across all stylesheets — anything containing a combinator
+   * (descendant / `>` / `+` / `~`) or a structural pseudo (`:nth-child`, `:first-child`, …). Feeds
+   * domflax's CSS-selector-safety guard.
+   */
+  complexSelectors() {
+    return this.#complex;
+  }
+  /* ─────────────────────────── internals ─────────────────────────── */
+  /** Parse one stylesheet and fold its rules into the indexes. Returns the advanced order counter. */
+  #indexFile(file, startOrder, complex) {
+    let order = startOrder;
+    let root;
+    try {
+      root = pc(file.css, { from: file.id });
+    } catch {
+      return order;
+    }
+    root.walkRules((rule) => {
+      const media = mediaContext(rule);
+      if (media.skip) return;
+      const decls = collectDecls(rule);
+      let ast;
+      try {
+        ast = sp().astSync(rule.selector);
+      } catch {
+        return;
+      }
+      for (const sel of ast.nodes) {
+        const thisOrder = order;
+        this.#analyzeSelector(sel, media.media, decls, thisOrder, complex);
+      }
+      order += 1;
+    });
+    return order;
+  }
+  /** Analyze one comma-segment selector: forward indexing, usage facts, complex detection. */
+  #analyzeSelector(selector, media, decls, order, complex) {
+    const compounds = splitCompounds(selector);
+    let hasCombinator = false;
+    let hasStructural = false;
+    compounds.forEach((compound, index) => {
+      const isSubject = index === compounds.length - 1;
+      const rightCombinator = index < compounds.length - 1 ? compounds[index + 1].leftCombinator : null;
+      if (rightCombinator) hasCombinator = true;
+      const classes = compound.nodes.filter((n) => sp.isClassName(n));
+      const otherSimple = compound.nodes.some(
+        (n) => sp.isTag(n) || sp.isIdentifier(n) || sp.isAttribute(n) || sp.isUniversal(n) || sp.isNesting(n)
+      );
+      const pseudos = compound.nodes.filter((n) => sp.isPseudo(n));
+      const structuralPseudo = pseudos.some((p) => STRUCTURAL_PSEUDOS.has(pseudoName(p)));
+      const functionalPseudo = pseudos.some((p) => FUNCTIONAL_PSEUDOS.has(pseudoName(p)));
+      const statePseudos = pseudos.filter(
+        (p) => sp.isPseudoClass(p) && !STRUCTURAL_PSEUDOS.has(pseudoName(p)) && !FUNCTIONAL_PSEUDOS.has(pseudoName(p))
+      );
+      const elementPseudos = pseudos.filter((p) => isPseudoElement(p));
+      const qualified = classes.length > 1 || otherSimple || functionalPseudo || statePseudos.length > 0;
+      if (structuralPseudo) hasStructural = true;
+      for (const cls of classes) {
+        const token = cls.value;
+        this.#known.add(token);
+        const u = this.#getUsage(token);
+        u.referenced = true;
+        if (isSubject) u.asSubject = true;
+        if (rightCombinator === " " || rightCombinator === ">") u.asAncestor = true;
+        if (rightCombinator === "+" || rightCombinator === "~") u.asSibling = true;
+        if (qualified) u.asCompound = true;
+        if (structuralPseudo) u.asStructural = true;
+        if (rightCombinator !== null || qualified || structuralPseudo || elementPseudos.length > 0) {
+          u.loadBearing = true;
+        }
+        const forwardEligible = compounds.length === 1 && classes.length === 1 && !otherSimple && !structuralPseudo && !functionalPseudo && elementPseudos.length <= 1;
+        if (forwardEligible && decls.length > 0) {
+          const condition = {
+            media,
+            states: statePseudos.map(pseudoName).sort(),
+            pseudoElement: elementPseudos.length === 1 ? normalizePseudoElement(elementPseudos[0]) : ""
+          };
+          this.#addRuleEntry(token, { order, token, condition, decls });
+        }
+      }
+      for (const p of pseudos) {
+        const isHas = pseudoName(p) === ":has";
+        p.walkClasses((inner) => {
+          const token = inner.value;
+          this.#known.add(token);
+          const u = this.#getUsage(token);
+          u.referenced = true;
+          u.loadBearing = true;
+          if (isHas) u.asHasArgument = true;
+        });
+      }
+    });
+    if (hasCombinator || hasStructural) {
+      complex.add(selector.toString().trim());
+    }
+  }
+  #addRuleEntry(token, entry) {
+    const list = this.#classIndex.get(token);
+    if (list) list.push(entry);
+    else this.#classIndex.set(token, [entry]);
+  }
+  #getUsage(token) {
+    let u = this.#usage.get(token);
+    if (!u) {
+      u = {
+        referenced: false,
+        asSubject: false,
+        asAncestor: false,
+        asCompound: false,
+        asSibling: false,
+        asHasArgument: false,
+        asStructural: false,
+        loadBearing: false
+      };
+      this.#usage.set(token, u);
+    }
+    return u;
+  }
+  /**
+   * Resolve a set of tokens into a normalized condition-keyed StyleMap. `tokenList` is the original
+   * class list (for per-declaration `tokenIndex` provenance); `request` is the set being resolved.
+   */
+  #resolveTokens(request, tokenList) {
+    const entries = [];
+    for (const token of new Set(request)) {
+      const list = this.#classIndex.get(token);
+      if (list) entries.push(...list);
+    }
+    if (entries.length === 0) return emptyStyleMap();
+    entries.sort((a, b) => a.order - b.order);
+    const acc = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const key = conditionKey(entry.condition);
+      let block = acc.get(key);
+      if (!block) {
+        block = { condition: entry.condition, decls: /* @__PURE__ */ new Map() };
+        acc.set(key, block);
+      }
+      const tokenIndex = tokenList.indexOf(entry.token);
+      const origin = { kind: "class", tokenIndex, className: entry.token };
+      for (const [prop, value, important] of entry.decls) {
+        for (const decl of normalizer.normalizeDeclaration(prop, value, important)) {
+          block.decls.set(decl.property, { ...decl, origin });
+        }
+      }
+    }
+    const rawBlocks = /* @__PURE__ */ new Map();
+    for (const [key, block] of acc) {
+      if (block.decls.size === 0) continue;
+      rawBlocks.set(key, { condition: block.condition, decls: block.decls });
+    }
+    if (rawBlocks.size === 0) return emptyStyleMap();
+    return normalizer.normalizeStyleMap({ blocks: rawBlocks });
+  }
+  /** Build (once) the reverse index used by {@link emit}. */
+  #reverseIndex() {
+    if (this.#reverse) return this.#reverse;
+    const out = [];
+    for (const token of this.#classIndex.keys()) {
+      const styles = this.#resolveTokens([token], [token]);
+      const keyed = /* @__PURE__ */ new Map();
+      for (const [ck, block] of styles.blocks) {
+        for (const [prop, decl] of block.decls) keyed.set(`${ck}\0${prop}`, String(decl.value));
+      }
+      if (keyed.size > 0) out.push({ token, keyed });
+    }
+    out.sort((a, b) => b.keyed.size - a.keyed.size);
+    this.#reverse = out;
+    return out;
+  }
+};
+function createCssResolver(cssFiles = [], options) {
+  return new CustomCSSResolver(cssFiles, options);
+}
+function splitCompounds(selector) {
+  const compounds = [];
+  let current = [];
+  let leftCombinator = null;
+  for (const node of selector.nodes) {
+    if (sp.isCombinator(node)) {
+      compounds.push({ leftCombinator, nodes: current });
+      current = [];
+      leftCombinator = combinatorValue(node);
+    } else {
+      current.push(node);
+    }
+  }
+  compounds.push({ leftCombinator, nodes: current });
+  return compounds;
+}
+function combinatorValue(node) {
+  const v = node.value;
+  return v.trim() === "" ? " " : v.trim();
+}
+function pseudoName(node) {
+  return node.value.toLowerCase();
+}
+function isPseudoElement(node) {
+  return sp.isPseudoElement(node) || LEGACY_PSEUDO_ELEMENTS2.has(pseudoName(node));
+}
+function normalizePseudoElement(node) {
+  const name = pseudoName(node);
+  return name.startsWith("::") ? name : `::${name.replace(/^:/, "")}`;
+}
+function mediaContext(rule) {
+  const parts = [];
+  let skip = false;
+  let parent = rule.parent;
+  while (parent && parent.type === "atrule") {
+    const at = parent;
+    const name = at.name.toLowerCase();
+    if (name === "media") parts.unshift(at.params.trim().replace(/\s+/g, " "));
+    else if (name === "keyframes" || name.endsWith("keyframes") || name === "font-face") skip = true;
+    parent = parent.parent;
+  }
+  return { media: parts.join(" and "), skip };
+}
+function collectDecls(rule) {
+  const out = [];
+  for (const node of rule.nodes) {
+    if (node.type === "decl") out.push([node.prop, node.value, node.important === true]);
+  }
+  return out;
+}
+function isPlainClassToken(token) {
+  return token.length > 0 && !/[\s.#>+~:[\]()]/.test(token);
+}
+function readCssPath(path3) {
+  try {
+    return { id: path3, css: readFileSync(path3, "utf8") };
+  } catch (cause) {
+    throw new Error(`resolver-css: cannot read CSS file "${path3}"`, { cause });
+  }
+}
+function deriveFingerprint(provider, files) {
+  const parts = files.map((f) => `${f.id}:${f.css.length}`).sort();
+  return `${provider}/${ENGINE_VERSION}::${parts.join("|")}`;
+}
+
+export {
+  emptyStyleDiv,
+  flexCenterWrapper,
+  nestedFlexMerge,
+  passthroughWrapper,
+  redundantFragment,
+  dedupeClasses,
+  insetShorthand,
+  marginShorthand,
+  paddingShorthand,
+  sizeShorthand,
+  builtinPatterns,
+  createJsxFrontend,
+  createJsxBackend,
+  createTailwindResolver,
+  createCssResolver
+};
+//# sourceMappingURL=chunk-4HHISSMR.js.map