domflax 0.1.0

package/dist/index.cjs

@@ -0,0 +1,4383 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BASE_CONDITION: () => BASE_CONDITION,
+  BASE_CONDITION_KEY: () => BASE_CONDITION_KEY,
+  DEFAULT_FIXPOINT: () => DEFAULT_FIXPOINT,
+  applyGroups: () => applyGroups,
+  applyOps: () => applyOps,
+  buildSelectorIndex: () => buildSelectorIndex,
+  builtinPatterns: () => builtinPatterns,
+  childIds: () => childIds,
+  cloneDocument: () => cloneDocument,
+  conditionKey: () => conditionKey,
+  createBackrefTable: () => createBackrefTable,
+  createComment: () => createComment,
+  createDocument: () => createDocument,
+  createDomflax: () => createDomflax,
+  createElement: () => createElement,
+  createExpr: () => createExpr,
+  createExprRegistry: () => createExprRegistry,
+  createFragment: () => createFragment,
+  createIdAllocator: () => createIdAllocator,
+  createNullResolver: () => createNullResolver,
+  createNullSelectorIndex: () => createNullSelectorIndex,
+  createPassManager: () => createPassManager,
+  createPipeline: () => createPipeline,
+  createRewriteFactory: () => createRewriteFactory,
+  createSyntheticSink: () => createSyntheticSink,
+  createText: () => createText,
+  dedupeClasses: () => dedupeClasses,
+  default: () => src_default,
+  defaultMeta: () => defaultMeta,
+  elementIds: () => elementIds,
+  emptyAttrMap: () => emptyAttrMap,
+  emptyClassList: () => emptyClassList,
+  emptyInlineStyle: () => emptyInlineStyle,
+  emptyStyleDiv: () => emptyStyleDiv,
+  emptyStyleMap: () => emptyStyleMap,
+  flexCenterWrapper: () => flexCenterWrapper,
+  getElement: () => getElement,
+  getNode: () => getNode,
+  insetShorthand: () => insetShorthand,
+  marginShorthand: () => marginShorthand,
+  nestedFlexMerge: () => nestedFlexMerge,
+  paddingShorthand: () => paddingShorthand,
+  passthroughWrapper: () => passthroughWrapper,
+  redundantFragment: () => redundantFragment,
+  runPasses: () => runPasses,
+  sizeShorthand: () => sizeShorthand,
+  syncClassesFromComputed: () => syncClassesFromComputed,
+  vite: () => vite,
+  walk: () => walk,
+  webpack: () => webpack
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// ../core/src/builders.ts
+function createIdAllocator(start = 1) {
+  let n = start;
+  return {
+    next() {
+      const id = n;
+      n += 1;
+      return id;
+    },
+    get peek() {
+      return n;
+    }
+  };
+}
+function createExprRegistry(start = 1) {
+  const map = /* @__PURE__ */ new Map();
+  let n = start;
+  return {
+    get(r) {
+      return map.get(r);
+    },
+    intern(rec) {
+      const ref = n;
+      n += 1;
+      map.set(ref, { ...rec, ref });
+      return ref;
+    },
+    releasePayloads() {
+      for (const [k, v] of map) map.set(k, { ...v, payload: void 0 });
+    }
+  };
+}
+function createBackrefTable() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    get(id) {
+      return map.get(id);
+    },
+    span(id) {
+      return map.get(id)?.span ?? null;
+    },
+    childrenSpan(id) {
+      return map.get(id)?.innerSpan ?? null;
+    },
+    set(id, backref) {
+      map.set(id, backref);
+    }
+  };
+}
+function defaultMeta(safetyFloor = 0) {
+  return {
+    hasRef: false,
+    hasEventHandlers: false,
+    hasKey: false,
+    hasSpreadAttrs: false,
+    hasDynamicChildren: false,
+    isComponent: false,
+    hasDangerousHtml: false,
+    targetedByCombinator: false,
+    targetedByStructuralPseudo: false,
+    selectorDependents: 0,
+    hasOwnVisualStyle: false,
+    establishesBox: false,
+    establishesStackingContext: false,
+    isContainingBlock: false,
+    establishesFormattingContext: false,
+    declaresCustomProperties: false,
+    whitespaceSensitive: false,
+    touched: false,
+    synthetic: false,
+    safetyFloor
+  };
+}
+var BASE_CONDITION = { media: "", states: [], pseudoElement: "" };
+function conditionKey(c) {
+  const states = [...c.states].sort().join(",");
+  return `${c.media}|${states}|${c.pseudoElement}`;
+}
+var BASE_CONDITION_KEY = conditionKey(BASE_CONDITION);
+function emptyStyleMap() {
+  return { blocks: /* @__PURE__ */ new Map() };
+}
+function emptyClassList() {
+  return {
+    form: "absent",
+    segments: [],
+    valueSpan: null,
+    hasDynamic: false,
+    opaque: false,
+    rewritable: false
+  };
+}
+function emptyAttrMap() {
+  return { entries: /* @__PURE__ */ new Map(), spreads: [], order: [] };
+}
+function emptyInlineStyle() {
+  return { decls: /* @__PURE__ */ new Map(), dynamic: null };
+}
+function createElement(id, init) {
+  return {
+    id,
+    kind: "element",
+    parent: init.parent ?? null,
+    span: init.span ?? null,
+    meta: init.meta ?? defaultMeta(),
+    tag: init.tag,
+    namespace: init.namespace ?? "html",
+    isComponent: init.isComponent ?? false,
+    selfClosing: init.selfClosing ?? false,
+    classes: init.classes ?? emptyClassList(),
+    inlineStyle: init.inlineStyle ?? emptyInlineStyle(),
+    computed: init.computed ?? emptyStyleMap(),
+    attrs: init.attrs ?? emptyAttrMap(),
+    children: init.children ?? []
+  };
+}
+function createText(id, value, opts) {
+  return {
+    id,
+    kind: "text",
+    parent: opts?.parent ?? null,
+    span: opts?.span ?? null,
+    meta: defaultMeta(),
+    value,
+    collapsible: opts?.collapsible ?? true
+  };
+}
+function createExpr(id, expr, opts) {
+  return {
+    id,
+    kind: "expr",
+    parent: opts?.parent ?? null,
+    span: opts?.span ?? null,
+    meta: defaultMeta(),
+    expr
+  };
+}
+function createFragment(id, opts) {
+  return {
+    id,
+    kind: "fragment",
+    parent: opts?.parent ?? null,
+    span: opts?.span ?? null,
+    meta: defaultMeta(),
+    children: opts?.children ?? []
+  };
+}
+function createComment(id, value, opts) {
+  return {
+    id,
+    kind: "comment",
+    parent: opts?.parent ?? null,
+    span: opts?.span ?? null,
+    meta: defaultMeta(),
+    value
+  };
+}
+function createDocument(frontend) {
+  const alloc = createIdAllocator();
+  const rootId = alloc.next();
+  const root = createFragment(rootId);
+  const nodes = /* @__PURE__ */ new Map([[rootId, root]]);
+  return {
+    root: rootId,
+    nodes,
+    exprs: createExprRegistry(),
+    sources: /* @__PURE__ */ new Map(),
+    backref: createBackrefTable(),
+    frontend,
+    alloc
+  };
+}
+function childIds(node) {
+  return node.kind === "element" || node.kind === "fragment" ? node.children : [];
+}
+function getNode(doc, id) {
+  return doc.nodes.get(id);
+}
+function getElement(doc, id) {
+  const n = doc.nodes.get(id);
+  return n && n.kind === "element" ? n : void 0;
+}
+function elementIds(doc) {
+  const out = [];
+  const visit = (id) => {
+    const n = doc.nodes.get(id);
+    if (!n) return;
+    if (n.kind === "element") out.push(id);
+    for (const c of childIds(n)) visit(c);
+  };
+  visit(doc.root);
+  return out;
+}
+function walk(doc, visitor) {
+  const roDoc = doc;
+  let stopped = false;
+  const visit = (id, depth) => {
+    if (stopped) return;
+    const node = doc.nodes.get(id);
+    if (!node) return;
+    const ctx = {
+      doc: roDoc,
+      depth,
+      parent() {
+        return node.parent == null ? null : doc.nodes.get(node.parent) ?? null;
+      }
+    };
+    const entered = visitor.enter ? visitor.enter(node, ctx) : void 0;
+    if (entered === "stop") {
+      stopped = true;
+      return;
+    }
+    if (entered !== "skip") {
+      for (const child of childIds(node)) {
+        visit(child, depth + 1);
+        if (stopped) return;
+      }
+    }
+    const exited = visitor.exit ? visitor.exit(node, ctx) : void 0;
+    if (exited === "stop") stopped = true;
+  };
+  visit(doc.root, 0);
+}
+
+// ../core/src/ops.ts
+function cloneStyleMap(sm) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    blocks.set(key, {
+      condition: block.condition,
+      decls: new Map(block.decls)
+    });
+  }
+  return { blocks };
+}
+function cloneNode(node) {
+  const meta = { ...node.meta };
+  switch (node.kind) {
+    case "element":
+      return {
+        ...node,
+        meta,
+        children: [...node.children],
+        computed: cloneStyleMap(node.computed)
+      };
+    case "fragment":
+      return { ...node, meta, children: [...node.children] };
+    default:
+      return { ...node, meta };
+  }
+}
+function cloneDocument(doc) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const [id, n] of doc.nodes) nodes.set(id, cloneNode(n));
+  return {
+    root: doc.root,
+    nodes,
+    exprs: doc.exprs,
+    sources: doc.sources,
+    backref: doc.backref,
+    frontend: doc.frontend,
+    alloc: doc.alloc
+  };
+}
+function diag(code, message, extra) {
+  return { code, severity: "warn", message, ...extra };
+}
+function getParentChildren(doc, id) {
+  const node = doc.nodes.get(id);
+  if (!node || node.parent == null) return null;
+  const parent = doc.nodes.get(node.parent);
+  if (!parent) return null;
+  if (parent.kind === "element" || parent.kind === "fragment") return parent.children;
+  return null;
+}
+function markTouched(state, id) {
+  const n = state.doc.nodes.get(id);
+  if (n) {
+    n.meta.touched = true;
+    state.touched.add(id);
+  }
+}
+function removeSubtree(state, id) {
+  const node = state.doc.nodes.get(id);
+  if (!node) return;
+  if (node.kind === "element" || node.kind === "fragment") {
+    for (const child of [...node.children]) removeSubtree(state, child);
+  }
+  state.doc.nodes.delete(id);
+  state.removed.add(id);
+}
+function specToAttrs(map) {
+  if (!map || map.size === 0) return { entries: /* @__PURE__ */ new Map(), spreads: [], order: [] };
+  const entries = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const [k, v] of map) {
+    entries.set(k, { kind: "static", value: v });
+    order.push(k);
+  }
+  return { entries, spreads: [], order };
+}
+function materialize(state, spec, parent) {
+  const { doc } = state;
+  if (spec.kind === "ref") {
+    const existing = doc.nodes.get(spec.ref);
+    if (existing) existing.parent = parent;
+    return spec.ref;
+  }
+  const id = doc.alloc.next();
+  state.created.add(id);
+  switch (spec.kind) {
+    case "element": {
+      const childIds2 = [];
+      const el = createElement(id, {
+        tag: spec.tag,
+        namespace: spec.namespace,
+        selfClosing: spec.selfClosing,
+        attrs: specToAttrs(spec.attrs),
+        parent,
+        meta: { ...defaultMeta(), synthetic: true }
+      });
+      if (spec.classes) el.computed = cloneStyleMap(spec.classes);
+      doc.nodes.set(id, el);
+      for (const child of spec.children ?? []) {
+        childIds2.push(materialize(state, child, id));
+      }
+      el.children = childIds2;
+      return id;
+    }
+    case "text": {
+      const t = createText(id, spec.value, { parent });
+      t.meta.synthetic = true;
+      doc.nodes.set(id, t);
+      return id;
+    }
+    case "expr": {
+      const e = createExpr(id, spec.expr, { parent });
+      e.meta.synthetic = true;
+      doc.nodes.set(id, e);
+      return id;
+    }
+    case "comment": {
+      const c = createComment(id, spec.value, { parent });
+      c.meta.synthetic = true;
+      doc.nodes.set(id, c);
+      return id;
+    }
+    case "fragment": {
+      const frag = createFragment(id, { parent });
+      frag.meta.synthetic = true;
+      doc.nodes.set(id, frag);
+      const childIds2 = [];
+      for (const child of spec.children) childIds2.push(materialize(state, child, id));
+      frag.children = childIds2;
+      return id;
+    }
+  }
+}
+function elementSpecToNode(state, spec, parent) {
+  return materialize(state, spec, parent);
+}
+function isInherited(state, decl) {
+  if (decl.inherited) return true;
+  const table = state.ctx.normalizer?.inherited;
+  if (table) {
+    try {
+      return table.isInherited(decl.property);
+    } catch {
+      return decl.inherited;
+    }
+  }
+  return decl.inherited;
+}
+function mergeStyleMaps(target, source, policy) {
+  const blocks = new Map(cloneStyleMap(target).blocks);
+  let conflict = false;
+  for (const [key, srcBlock] of source.blocks) {
+    const existing = blocks.get(key);
+    if (!existing) {
+      blocks.set(key, {
+        condition: srcBlock.condition,
+        decls: new Map(srcBlock.decls)
+      });
+      continue;
+    }
+    const decls = new Map(existing.decls);
+    for (const [prop, srcDecl] of srcBlock.decls) {
+      const had = decls.get(prop);
+      if (had && had.value !== srcDecl.value) {
+        conflict = true;
+        if (policy === "target-wins") continue;
+      }
+      if (policy === "target-wins" && had) continue;
+      decls.set(prop, srcDecl);
+    }
+    blocks.set(key, { condition: existing.condition, decls });
+  }
+  return { map: { blocks }, conflict };
+}
+function safetyOk(state, op, targetId) {
+  const opSafety = op.origin.safety;
+  if (opSafety > state.ceiling) {
+    return diag(
+      "DF_SAFETY_CEILING_EXCEEDED",
+      `op '${op.op}' safety ${opSafety} exceeds ceiling ${state.ceiling}`,
+      { nodeId: targetId, pattern: op.origin.pattern, severity: "error" }
+    );
+  }
+  const node = state.doc.nodes.get(targetId);
+  if (node && opSafety > node.meta.safetyFloor) {
+    return diag(
+      "DF_SAFETY_CEILING_EXCEEDED",
+      `op '${op.op}' safety ${opSafety} exceeds node ${targetId} floor ${node.meta.safetyFloor}`,
+      { nodeId: targetId, pattern: op.origin.pattern, severity: "error" }
+    );
+  }
+  return null;
+}
+function applyOne(state, op) {
+  const { doc } = state;
+  const primary = primaryTarget(op);
+  if (primary != null) {
+    if (!doc.nodes.get(primary)) {
+      return [
+        diag("DF_OP_PRECONDITION_FAILED", `target node ${primary} not found`, {
+          nodeId: primary,
+          pattern: op.origin.pattern,
+          severity: "error"
+        })
+      ];
+    }
+    const safety = safetyOk(state, op, primary);
+    if (safety) return [safety];
+  }
+  switch (op.op) {
+    case "removeNode": {
+      const siblings = getParentChildren(doc, op.target);
+      if (siblings) {
+        const i = siblings.indexOf(op.target);
+        if (i >= 0) siblings.splice(i, 1);
+      }
+      removeSubtree(state, op.target);
+      return [];
+    }
+    case "unwrap": {
+      const node = doc.nodes.get(op.target);
+      if (!node || node.kind !== "element" && node.kind !== "fragment") {
+        return [precond(op, op.target, "unwrap target is not a container")];
+      }
+      const siblings = getParentChildren(doc, op.target);
+      if (!siblings) return [precond(op, op.target, "unwrap target has no parent")];
+      const at = siblings.indexOf(op.target);
+      const kids = node.children;
+      for (const k of kids) {
+        const kn = doc.nodes.get(k);
+        if (kn) kn.parent = node.parent;
+      }
+      siblings.splice(at, 1, ...kids);
+      doc.nodes.delete(op.target);
+      state.removed.add(op.target);
+      if (node.parent != null) markTouched(state, node.parent);
+      return [];
+    }
+    case "replaceWith": {
+      const siblings = getParentChildren(doc, op.target);
+      if (!siblings) return [precond(op, op.target, "replaceWith target has no parent")];
+      const at = siblings.indexOf(op.target);
+      const parentId = doc.nodes.get(op.target)?.parent ?? null;
+      const newId = materialize(state, op.replacement, parentId);
+      siblings.splice(at, 1, newId);
+      removeSubtree(state, op.target);
+      if (parentId != null) markTouched(state, parentId);
+      return [];
+    }
+    case "wrap": {
+      const siblings = getParentChildren(doc, op.target);
+      if (!siblings) return [precond(op, op.target, "wrap target has no parent")];
+      const at = siblings.indexOf(op.target);
+      const parentId = doc.nodes.get(op.target)?.parent ?? null;
+      const wrapperId = elementSpecToNode(state, op.wrapper, parentId);
+      const wrapper = doc.nodes.get(wrapperId);
+      const targetNode = doc.nodes.get(op.target);
+      if (wrapper && (wrapper.kind === "element" || wrapper.kind === "fragment")) {
+        wrapper.children.push(op.target);
+      }
+      if (targetNode) targetNode.parent = wrapperId;
+      siblings.splice(at, 1, wrapperId);
+      return [];
+    }
+    case "insertBefore":
+    case "insertAfter": {
+      const siblings = getParentChildren(doc, op.anchor);
+      if (!siblings) return [precond(op, op.anchor, "insert anchor has no parent")];
+      const at = siblings.indexOf(op.anchor);
+      const parentId = doc.nodes.get(op.anchor)?.parent ?? null;
+      const newId = materialize(state, op.node, parentId);
+      siblings.splice(op.op === "insertBefore" ? at : at + 1, 0, newId);
+      if (parentId != null) markTouched(state, parentId);
+      return [];
+    }
+    case "moveNode": {
+      const newParent = doc.nodes.get(op.newParent);
+      if (!newParent || newParent.kind !== "element" && newParent.kind !== "fragment") {
+        return [precond(op, op.newParent, "moveNode newParent is not a container")];
+      }
+      const siblings = getParentChildren(doc, op.target);
+      if (siblings) {
+        const i = siblings.indexOf(op.target);
+        if (i >= 0) siblings.splice(i, 1);
+      }
+      const target = doc.nodes.get(op.target);
+      if (target) target.parent = op.newParent;
+      const idx = Math.max(0, Math.min(op.index, newParent.children.length));
+      newParent.children.splice(idx, 0, op.target);
+      markTouched(state, op.newParent);
+      return [];
+    }
+    case "mergeSiblings": {
+      const first = doc.nodes.get(op.first);
+      const second = doc.nodes.get(op.second);
+      if (!first || !second) return [precond(op, op.first, "mergeSiblings node missing")];
+      if ((first.kind === "element" || first.kind === "fragment") && (second.kind === "element" || second.kind === "fragment")) {
+        for (const c of second.children) {
+          const cn = doc.nodes.get(c);
+          if (cn) cn.parent = op.first;
+          first.children.push(c);
+        }
+        second.children = [];
+      }
+      const siblings = getParentChildren(doc, op.second);
+      if (siblings) {
+        const i = siblings.indexOf(op.second);
+        if (i >= 0) siblings.splice(i, 1);
+      }
+      doc.nodes.delete(op.second);
+      state.removed.add(op.second);
+      markTouched(state, op.first);
+      return [];
+    }
+    case "setClassList": {
+      const el = doc.nodes.get(op.target);
+      if (!el || el.kind !== "element") {
+        return [precond(op, op.target, "setClassList target is not an element")];
+      }
+      el.computed = cloneStyleMap(op.style);
+      markTouched(state, op.target);
+      return [];
+    }
+    case "mergeStyle": {
+      const el = doc.nodes.get(op.target);
+      if (!el || el.kind !== "element") {
+        return [precond(op, op.target, "mergeStyle target is not an element")];
+      }
+      const report = mergeStyleMaps(el.computed, op.style, op.onConflict);
+      if (report.conflict && op.onConflict === "abort") {
+        return [
+          diag("DF_STYLE_CONFLICT_UNRESOLVED", `mergeStyle aborted on conflict at ${op.target}`, {
+            nodeId: op.target,
+            pattern: op.origin.pattern,
+            severity: "error"
+          })
+        ];
+      }
+      el.computed = report.map;
+      if (op.source != null) {
+        const src = doc.nodes.get(op.source);
+        if (src) markTouched(state, op.source);
+      }
+      markTouched(state, op.target);
+      return [];
+    }
+    case "foldInheritedStyles":
+      return applyFold(state, op);
+  }
+}
+function applyFold(state, op) {
+  const { doc } = state;
+  const from = doc.nodes.get(op.from);
+  if (!from || from.kind !== "element") {
+    return [precond(op, op.from, "fold source is not an element")];
+  }
+  const issues = [];
+  const onlyProps = op.properties === "all-inherited" ? null : new Set(op.properties);
+  const conditionKeys = op.conditions === "all" ? [...from.computed.blocks.keys()] : [BASE_CONDITION_KEY];
+  for (const intoId of op.into) {
+    const into = doc.nodes.get(intoId);
+    if (!into || into.kind !== "element") {
+      issues.push(precond(op, intoId, "fold target is not an element"));
+      continue;
+    }
+    const nextBlocks = new Map(cloneStyleMap(into.computed).blocks);
+    let folded = false;
+    for (const key of conditionKeys) {
+      const srcBlock = from.computed.blocks.get(key);
+      if (!srcBlock) continue;
+      const dstBlock = nextBlocks.get(key);
+      const decls = dstBlock ? new Map(dstBlock.decls) : /* @__PURE__ */ new Map();
+      for (const [prop, decl] of srcBlock.decls) {
+        if (onlyProps && !onlyProps.has(prop)) continue;
+        if (!isInherited(state, decl)) continue;
+        if (decl.relativeToParent) {
+          issues.push(
+            diag(
+              "DF_RELATIVE_UNIT_FOLD",
+              `refused to fold relative-unit declaration '${decl.property}' onto ${intoId}`,
+              { nodeId: intoId, pattern: op.origin.pattern, severity: "warn" }
+            )
+          );
+          continue;
+        }
+        if (!decls.has(prop)) {
+          decls.set(prop, decl);
+          folded = true;
+        }
+      }
+      nextBlocks.set(key, { condition: srcBlock.condition, decls });
+    }
+    if (folded) {
+      into.computed = { blocks: nextBlocks };
+      markTouched(state, intoId);
+    }
+  }
+  for (const d of issues) state.diagnostics.push(d);
+  return [];
+}
+function precond(op, nodeId, message) {
+  return diag("DF_OP_PRECONDITION_FAILED", message, {
+    nodeId,
+    pattern: op.origin.pattern,
+    severity: "error"
+  });
+}
+function primaryTarget(op) {
+  switch (op.op) {
+    case "removeNode":
+    case "unwrap":
+    case "replaceWith":
+    case "wrap":
+    case "moveNode":
+    case "setClassList":
+    case "mergeStyle":
+      return op.target;
+    case "insertBefore":
+    case "insertAfter":
+      return op.anchor;
+    case "mergeSiblings":
+      return op.first;
+    case "foldInheritedStyles":
+      return op.from;
+  }
+}
+function applyOps(doc, ops, ctx) {
+  const cloned = cloneDocument(doc);
+  const state = {
+    doc: cloned,
+    touched: /* @__PURE__ */ new Set(),
+    removed: /* @__PURE__ */ new Set(),
+    created: /* @__PURE__ */ new Set(),
+    diagnostics: [],
+    skipped: [],
+    appliedGroups: 0,
+    ceiling: ctx?.safetyCeiling ?? 3,
+    ctx: { doc: cloned, safetyCeiling: ctx?.safetyCeiling ?? 3, ...ctx }
+  };
+  for (const op of ops) {
+    const issues = applyOne(state, op);
+    if (issues.length > 0) {
+      state.skipped.push({
+        group: { pattern: op.origin.pattern, anchor: primaryTarget(op) ?? doc.root, ops: [op] },
+        issues: issues.map((d) => ({ op, code: d.code, message: d.message }))
+      });
+      for (const d of issues) state.diagnostics.push(d);
+    } else {
+      state.appliedGroups += 1;
+    }
+  }
+  return { doc: cloned, result: finalize(state) };
+}
+function applyGroups(doc, groups, ctx) {
+  let current = cloneDocument(doc);
+  const touched = /* @__PURE__ */ new Set();
+  const removed = /* @__PURE__ */ new Set();
+  const created = /* @__PURE__ */ new Set();
+  const diagnostics = [];
+  const skipped = [];
+  let appliedGroups = 0;
+  for (const group of groups) {
+    const attempt = applyOps(current, group.ops, ctx);
+    if (attempt.result.skipped.length > 0) {
+      skipped.push({
+        group,
+        issues: attempt.result.skipped.flatMap((s) => s.issues)
+      });
+      for (const s of attempt.result.skipped) for (const i of s.issues) {
+        diagnostics.push(diag(i.code, i.message, { pattern: group.pattern }));
+      }
+      continue;
+    }
+    current = attempt.doc;
+    appliedGroups += 1;
+    for (const id of attempt.result.touched) touched.add(id);
+    for (const id of attempt.result.removed) removed.add(id);
+    for (const id of attempt.result.created) created.add(id);
+    for (const d of attempt.result.diagnostics) diagnostics.push(d);
+  }
+  const result = {
+    touched,
+    removed,
+    created,
+    appliedGroups,
+    skipped,
+    journal: [],
+    diagnostics
+  };
+  return { doc: current, result };
+}
+function finalize(state) {
+  return {
+    touched: state.touched,
+    removed: state.removed,
+    created: state.created,
+    appliedGroups: state.appliedGroups,
+    skipped: state.skipped,
+    journal: [],
+    diagnostics: state.diagnostics
+  };
+}
+
+// ../core/src/pass-manager.ts
+var DEFAULT_FIXPOINT = {
+  maxIterations: 16,
+  phases: { flatten: 16, compress: 8, extract: 4 },
+  onBudgetExhausted: "warn",
+  detectOscillation: true
+};
+var PHASE_ORDER = ["flatten", "compress", "extract"];
+function createNullResolver() {
+  const empty = {
+    styles: emptyStyleMap(),
+    resolved: [],
+    unknown: [],
+    opaque: [],
+    warnings: []
+  };
+  const usage = {
+    asSubject: false,
+    asAncestor: false,
+    asCompound: false,
+    asSibling: false,
+    asHasArgument: false,
+    asStructural: false,
+    droppable: true
+  };
+  return {
+    id: "null",
+    provider: "null@0.0.0",
+    fingerprint: "null",
+    owns() {
+      return false;
+    },
+    resolve(_input) {
+      return empty;
+    },
+    emit(_styles, _ctx) {
+      return { classes: [], exact: true, warnings: [] };
+    },
+    selectorUsage() {
+      return usage;
+    }
+  };
+}
+function createNullSelectorIndex() {
+  const none = /* @__PURE__ */ new Set();
+  return {
+    targetedByCombinator() {
+      return false;
+    },
+    targetedByStructuralPseudo() {
+      return false;
+    },
+    reparentImpact() {
+      return none;
+    }
+  };
+}
+function hasComplexSelectors(r) {
+  return typeof r.complexSelectors === "function";
+}
+function buildSelectorIndex(doc, resolver) {
+  if (!hasComplexSelectors(resolver) || resolver.complexSelectors().length === 0) {
+    return createNullSelectorIndex();
+  }
+  const combinator = /* @__PURE__ */ new Set();
+  const structural = /* @__PURE__ */ new Set();
+  for (const id of elementIds(doc)) {
+    const el = getElement(doc, id);
+    if (!el) continue;
+    for (const seg of el.classes.segments) {
+      if (seg.kind !== "static") continue;
+      for (const t of seg.tokens) {
+        const u = resolver.selectorUsage(t.value);
+        if (u.asAncestor || u.asSibling || u.asHasArgument) combinator.add(id);
+        if (u.asStructural) structural.add(id);
+      }
+    }
+  }
+  const impact = /* @__PURE__ */ new Map();
+  for (const id of elementIds(doc)) {
+    const el = getElement(doc, id);
+    if (!el) continue;
+    if (!combinator.has(id) && !structural.has(id)) continue;
+    const set = /* @__PURE__ */ new Set([id]);
+    for (const c of el.children) {
+      const cn = doc.nodes.get(c);
+      if (cn && cn.kind === "element") set.add(c);
+    }
+    impact.set(id, set);
+  }
+  const empty = /* @__PURE__ */ new Set();
+  return {
+    targetedByCombinator: (id) => combinator.has(id),
+    targetedByStructuralPseudo: (id) => structural.has(id),
+    reparentImpact: (id) => impact.get(id) ?? empty
+  };
+}
+function idOf(n) {
+  return n.id;
+}
+function createRewriteFactory() {
+  return {
+    unwrap(target) {
+      return { op: "unwrap", target: idOf(target) };
+    },
+    removeNode(target) {
+      return { op: "removeNode", target: idOf(target) };
+    },
+    replaceWith(target, replacement) {
+      return { op: "replaceWith", target: idOf(target), replacement };
+    },
+    wrap(target, wrapper) {
+      return { op: "wrap", target: idOf(target), wrapper };
+    },
+    insertBefore(anchor, node) {
+      return { op: "insertBefore", anchor: idOf(anchor), node };
+    },
+    insertAfter(anchor, node) {
+      return { op: "insertAfter", anchor: idOf(anchor), node };
+    },
+    moveNode(target, newParent, index) {
+      return { op: "moveNode", target: idOf(target), newParent: idOf(newParent), index };
+    },
+    mergeSiblings(first, second) {
+      return { op: "mergeSiblings", first: idOf(first), second: idOf(second) };
+    },
+    setClassList(target, style, preserveOpaque = true) {
+      return { op: "setClassList", target: idOf(target), style, preserveOpaque };
+    },
+    mergeStyle(target, source, style, onConflict = "abort") {
+      return {
+        op: "mergeStyle",
+        target: idOf(target),
+        source: source ? idOf(source) : null,
+        style,
+        onConflict
+      };
+    },
+    foldInheritedStyles(from, into, opts) {
+      const list = Array.isArray(into) ? into : [into];
+      return {
+        op: "foldInheritedStyles",
+        from: idOf(from),
+        into: list.map((t) => idOf(t)),
+        properties: opts?.only ?? "all-inherited",
+        conditions: opts?.conditions ?? "base"
+      };
+    },
+    element(spec) {
+      return spec;
+    },
+    text(value) {
+      return { kind: "text", value };
+    },
+    keep(node) {
+      return { kind: "ref", ref: idOf(node) };
+    }
+  };
+}
+function ro(v) {
+  return v;
+}
+function buildMatchContext(doc, elementId, resolver, selectors, safety, phase, iteration) {
+  const self = getElement(doc, elementId);
+  const parentEl = () => {
+    if (self.parent == null) return null;
+    const p = doc.nodes.get(self.parent);
+    return p && p.kind === "element" ? ro(p) : null;
+  };
+  const elementChildren = () => {
+    const out = [];
+    for (const c of self.children) {
+      const cn = doc.nodes.get(c);
+      if (cn && cn.kind === "element") out.push(ro(cn));
+    }
+    return out;
+  };
+  const ancestors = () => {
+    const out = [];
+    let cur = self.parent;
+    while (cur != null) {
+      const n = doc.nodes.get(cur);
+      if (!n) break;
+      if (n.kind === "element") out.push(ro(n));
+      cur = n.parent;
+    }
+    return out;
+  };
+  const siblingAt = (delta) => {
+    if (self.parent == null) return null;
+    const p = doc.nodes.get(self.parent);
+    if (!p || p.kind !== "element" && p.kind !== "fragment") return null;
+    const i = p.children.indexOf(elementId);
+    const sib = p.children[i + delta];
+    if (sib == null) return null;
+    const sn = doc.nodes.get(sib);
+    return sn ? ro(sn) : null;
+  };
+  const computedOf = (n) => {
+    const node = doc.nodes.get(n.id);
+    return node && node.kind === "element" ? node.computed : emptyStyleMap();
+  };
+  return {
+    node: ro(self),
+    doc: ro(doc),
+    resolver,
+    selectors,
+    safety,
+    phase,
+    iteration,
+    parent: parentEl,
+    elementChildren,
+    onlyElementChild() {
+      const els = elementChildren();
+      return els.length === 1 ? els[0] : null;
+    },
+    computed() {
+      return self.computed;
+    },
+    computedOf,
+    isOpaque(n) {
+      const target = n ? doc.nodes.get(n.id) : self;
+      if (!target || target.kind !== "element") return true;
+      return target.classes.opaque || target.meta.hasSpreadAttrs;
+    },
+    ancestors,
+    closest(pred) {
+      for (const a of ancestors()) if (pred(a)) return a;
+      return null;
+    },
+    prevSibling() {
+      return siblingAt(-1);
+    },
+    nextSibling() {
+      return siblingAt(1);
+    },
+    nthChildIndex() {
+      if (self.parent == null) return 1;
+      const p = doc.nodes.get(self.parent);
+      if (!p || p.kind !== "element" && p.kind !== "fragment") return 1;
+      let idx = 0;
+      for (const c of p.children) {
+        const cn = doc.nodes.get(c);
+        if (cn && cn.kind === "element") {
+          idx += 1;
+          if (c === elementId) return idx;
+        }
+      }
+      return idx;
+    }
+  };
+}
+function stampOrigin(draft, pattern2) {
+  return {
+    ...draft,
+    origin: { pattern: pattern2.name, category: pattern2.category, safety: pattern2.safety }
+  };
+}
+function patternsForPhase(passes, phase) {
+  const out = [];
+  for (const pass of passes) {
+    if (pass.phase !== phase) continue;
+    for (const p of pass.patterns) out.push(p);
+  }
+  out.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  return out;
+}
+function probeSink() {
+  return {
+    register(s) {
+      return s.className;
+    },
+    drain() {
+      return [];
+    }
+  };
+}
+function styleWriteTargets(ops) {
+  const ids = [];
+  for (const op of ops) {
+    if (op.op === "mergeStyle" || op.op === "setClassList") ids.push(op.target);
+    else if (op.op === "foldInheritedStyles") ids.push(...op.into);
+  }
+  return ids;
+}
+function emitIsExact(resolver, normalizer2, sm) {
+  if (sm.blocks.size === 0) return true;
+  try {
+    const ctx = { normalizer: normalizer2, sink: probeSink() };
+    const r = resolver.emit(sm, ctx);
+    return r.exact && r.residual == null;
+  } catch {
+    return true;
+  }
+}
+function flattenWouldDropStyle(before, after, ops, resolver, normalizer2) {
+  for (const id of styleWriteTargets(ops)) {
+    const newEl = getElement(after, id);
+    if (!newEl) continue;
+    if (newEl.classes.opaque || newEl.classes.hasDynamic) continue;
+    if (emitIsExact(resolver, normalizer2, newEl.computed)) continue;
+    const oldEl = getElement(before, id);
+    const wasExact = !oldEl || emitIsExact(resolver, normalizer2, oldEl.computed);
+    if (wasExact) return true;
+  }
+  return false;
+}
+function runSweep(state, patterns, ctx, factory, phase, iteration, touched, diagnostics, flattenBarred) {
+  let appliedOps = 0;
+  const resolver = ctx.resolver;
+  const selectors = ctx.selectors;
+  for (const elId of elementIds(state.doc)) {
+    const el = getElement(state.doc, elId);
+    if (!el) continue;
+    if (phase === "flatten" && flattenBarred.has(elId)) continue;
+    for (const pattern2 of patterns) {
+      if (pattern2.safety > ctx.safetyCeiling) continue;
+      let drafts = [];
+      try {
+        const mctx = buildMatchContext(
+          state.doc,
+          elId,
+          resolver,
+          selectors,
+          ctx.safetyCeiling,
+          phase,
+          iteration
+        );
+        const result = pattern2.evaluate(mctx, factory);
+        if (!result) continue;
+        drafts = result.ops;
+        if (result.diagnostics) for (const d of result.diagnostics) diagnostics.push(d);
+      } catch (err) {
+        diagnostics.push({
+          code: "DF_PATTERN_THREW",
+          severity: "error",
+          message: `pattern '${pattern2.name}' threw: ${String(err?.message ?? err)}`,
+          nodeId: elId,
+          pattern: pattern2.name,
+          phase,
+          iteration,
+          cause: err
+        });
+        continue;
+      }
+      if (drafts.length === 0) continue;
+      const ops = drafts.map((d) => stampOrigin(d, pattern2));
+      const outcome = applyOps(state.doc, ops, ctx);
+      for (const d of outcome.result.diagnostics) diagnostics.push(d);
+      if (outcome.result.appliedGroups > 0) {
+        if (phase === "flatten" && flattenWouldDropStyle(state.doc, outcome.doc, ops, resolver, ctx.normalizer)) {
+          diagnostics.push({
+            code: "DF_VERIFY_REVERTED",
+            severity: "warn",
+            message: `flatten '${pattern2.name}' reverted on node ${elId}: residual style is not reproducible by resolver '${resolver.id}', so flattening would drop it`,
+            nodeId: elId,
+            pattern: pattern2.name,
+            phase,
+            iteration
+          });
+          flattenBarred.add(elId);
+          break;
+        }
+        state.doc = outcome.doc;
+        appliedOps += outcome.result.appliedGroups;
+        for (const id of outcome.result.touched) touched.add(id);
+        for (const id of outcome.result.created) touched.add(id);
+        break;
+      }
+    }
+  }
+  return appliedOps;
+}
+function docFingerprint(doc) {
+  const parts = [];
+  const visit = (id) => {
+    const n = doc.nodes.get(id);
+    if (!n) return;
+    parts.push(`${id}:${n.kind}`);
+    for (const c of childIds(n)) visit(c);
+  };
+  visit(doc.root);
+  return parts.join("|");
+}
+function runPasses(doc, passes, ctx, config) {
+  const cfg = { ...DEFAULT_FIXPOINT, ...config };
+  const factory = createRewriteFactory();
+  const state = { doc };
+  const results = [];
+  const flattenBarred = /* @__PURE__ */ new Set();
+  for (const phase of PHASE_ORDER) {
+    const patterns = patternsForPhase(passes, phase);
+    const phaseTouched = /* @__PURE__ */ new Set();
+    const diagnostics = [];
+    const budget = cfg.phases[phase] ?? cfg.maxIterations;
+    let iterations = 0;
+    let converged = false;
+    let haltReason = "converged";
+    const seen = /* @__PURE__ */ new Set();
+    if (patterns.length === 0) {
+      results.push({
+        phase,
+        iterations: 0,
+        converged: true,
+        haltReason: "converged",
+        touched: phaseTouched,
+        diagnostics
+      });
+      continue;
+    }
+    while (iterations < budget) {
+      iterations += 1;
+      const applied = runSweep(
+        state,
+        patterns,
+        ctx,
+        factory,
+        phase,
+        iterations,
+        phaseTouched,
+        diagnostics,
+        flattenBarred
+      );
+      if (applied === 0) {
+        converged = true;
+        haltReason = "converged";
+        break;
+      }
+      if (cfg.detectOscillation) {
+        const fp = docFingerprint(state.doc);
+        if (seen.has(fp)) {
+          haltReason = "oscillation";
+          diagnostics.push({
+            code: "DF_FIXPOINT_OSCILLATION",
+            severity: "warn",
+            message: `phase '${phase}' oscillated; halting`,
+            phase,
+            iteration: iterations
+          });
+          break;
+        }
+        seen.add(fp);
+      }
+    }
+    if (!converged && haltReason !== "oscillation") {
+      haltReason = "budget";
+      diagnostics.push({
+        code: "DF_FIXPOINT_BUDGET",
+        severity: cfg.onBudgetExhausted === "error" ? "error" : "warn",
+        message: `phase '${phase}' exhausted ${budget}-iteration budget`,
+        phase,
+        iteration: iterations
+      });
+    }
+    results.push({
+      phase,
+      iterations,
+      converged,
+      haltReason,
+      touched: phaseTouched,
+      diagnostics
+    });
+  }
+  return { doc: state.doc, results };
+}
+function createPassManager(passes) {
+  return {
+    run(doc, ctx, config) {
+      return runPasses(doc, passes, ctx, config).results;
+    }
+  };
+}
+
+// ../core/src/pipeline.ts
+function createSyntheticSink() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    register(s) {
+      if (!map.has(s.className)) map.set(s.className, s);
+      return s.className;
+    },
+    drain() {
+      return [...map.values()];
+    }
+  };
+}
+function staticClassTokens(el) {
+  const out = [];
+  for (const seg of el.classes.segments) {
+    if (seg.kind === "static") for (const t of seg.tokens) out.push(t.value);
+  }
+  return out;
+}
+function resolveStyles(doc, input, diagnostics) {
+  const { resolver, normalizer: normalizer2 } = input;
+  for (const id of elementIds(doc)) {
+    const el = getElement(doc, id);
+    if (!el || el.classes.opaque) continue;
+    const tokens = staticClassTokens(el);
+    if (tokens.length === 0) continue;
+    try {
+      const result = resolver.resolve({
+        classes: tokens,
+        element: {
+          tagName: el.tag,
+          namespace: el.namespace === "svg" ? "svg" : "html"
+        }
+      });
+      let styles = result.styles;
+      try {
+        styles = normalizer2.normalizeStyleMap(styles);
+      } catch {
+      }
+      el.computed = styles;
+      for (const w of result.warnings) {
+        diagnostics.push({
+          code: "DF_STYLE_CONFLICT_UNRESOLVED",
+          severity: w.severity,
+          message: w.message,
+          nodeId: id
+        });
+      }
+    } catch (err) {
+      diagnostics.push({
+        code: "DF_OP_PRECONDITION_FAILED",
+        severity: "debug",
+        message: `resolve skipped for <${el.tag}>: ${String(err?.message ?? err)}`,
+        nodeId: id,
+        cause: err
+      });
+    }
+  }
+}
+var ZERO_ITERATIONS = {
+  flatten: 0,
+  compress: 0,
+  extract: 0
+};
+var DefaultPipeline = class {
+  run(input) {
+    const startedAt = now();
+    const diagnostics = [];
+    const report = (d) => {
+      diagnostics.push(d);
+      input.reporter?.report(d);
+    };
+    const parseCtx = {
+      id: input.id,
+      kind: input.kind,
+      resolver: input.resolver,
+      normalizer: input.normalizer,
+      config: { preserveComments: input.config?.preserveComments ?? true },
+      onDiagnostic: report
+    };
+    if (input.babelAst !== void 0) parseCtx.babelAst = input.babelAst;
+    const parsed = input.frontend.parse(input.code, parseCtx);
+    for (const d of parsed.diagnostics) report(d);
+    const doc = parsed.doc;
+    const nodesIn = doc.nodes.size;
+    resolveStyles(doc, input, diagnostics);
+    const ctx = {
+      doc,
+      safetyCeiling: input.config?.safety ?? 2,
+      normalizer: input.normalizer,
+      selectors: createNullSelectorIndex(),
+      resolver: input.resolver
+    };
+    const { doc: optimized, results } = runPasses(doc, input.passes, ctx, fixpointFrom(input));
+    let opsApplied = 0;
+    const iterations = { ...ZERO_ITERATIONS };
+    for (const r of results) {
+      iterations[r.phase] = r.iterations;
+      for (const d of r.diagnostics) {
+        diagnostics.push(d);
+        input.reporter?.report(d);
+      }
+      opsApplied += r.touched.size;
+    }
+    const editPlan = {
+      moduleId: input.id,
+      ops: [],
+      provenance: /* @__PURE__ */ new Map()
+    };
+    const backendCtx = {
+      normalizer: input.normalizer,
+      resolver: input.resolver,
+      sink: createSyntheticSink(),
+      eol: eolOf(optimized),
+      onDiagnostic: report
+    };
+    const printed = input.backend.print(optimized, editPlan, backendCtx);
+    for (const d of printed.diagnostics) {
+      diagnostics.push(d);
+      input.reporter?.report(d);
+    }
+    const stats = {
+      nodesIn,
+      nodesOut: optimized.nodes.size,
+      opsApplied,
+      iterations,
+      durationMs: now() - startedAt
+    };
+    const touched = printed.edits.map((e) => e.span);
+    return {
+      code: printed.code,
+      map: printed.map,
+      changed: printed.code !== input.code,
+      touched,
+      diagnostics,
+      stats,
+      doc: optimized,
+      editPlan
+    };
+  }
+};
+function fixpointFrom(input) {
+  const fp = input.config?.fixpoint;
+  if (!fp) return void 0;
+  return {
+    maxIterations: fp.maxIterations ?? 16,
+    phases: fp.phases ?? {},
+    onBudgetExhausted: fp.onBudgetExhausted ?? "warn",
+    detectOscillation: fp.detectOscillation ?? true
+  };
+}
+function eolOf(doc) {
+  for (const src of doc.sources.values()) return src.eol;
+  return "\n";
+}
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function createPipeline() {
+  return new DefaultPipeline();
+}
+
+// ../core/src/reverse-emit.ts
+function staticTokensOf(cl) {
+  const out = [];
+  for (const seg of cl.segments) {
+    if (seg.kind === "static") for (const t of seg.tokens) out.push(t.value);
+  }
+  return out;
+}
+function staticClassList(prev, tokens) {
+  const classTokens = tokens.map((value) => ({ value }));
+  const seg = { kind: "static", tokens: classTokens };
+  return {
+    form: "string-literal",
+    segments: [seg],
+    valueSpan: prev.valueSpan,
+    attrSpan: prev.attrSpan,
+    hasDynamic: false,
+    opaque: false,
+    rewritable: true
+  };
+}
+function sameTokens(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+  return true;
+}
+function syncClassesFromComputed(doc, resolver, norm) {
+  const sink = createSyntheticSink();
+  for (const id of elementIds(doc)) {
+    const el = getElement(doc, id);
+    if (!el || !el.meta.touched) continue;
+    if (el.classes.opaque || el.classes.hasDynamic) continue;
+    const tokens = staticTokensOf(el.classes);
+    const ctx = { normalizer: norm, sink };
+    const emitted = resolver.emit(el.computed, ctx).classes;
+    if (emitted.length === 0) continue;
+    const emittedSet = new Set(emitted);
+    const next = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of tokens) {
+      if (seen.has(t)) continue;
+      const keep = emittedSet.has(t) || !resolver.selectorUsage(t).droppable;
+      if (keep) {
+        next.push(t);
+        seen.add(t);
+      }
+    }
+    for (const c of emitted) {
+      if (seen.has(c)) continue;
+      next.push(c);
+      seen.add(c);
+    }
+    if (sameTokens(next, tokens)) continue;
+    el.classes = staticClassList(el.classes, next);
+  }
+}
+
+// ../pattern-kit/src/define.ts
+var PHASES = /* @__PURE__ */ new Set(["flatten", "compress", "extract"]);
+var SAFETY_LEVELS = /* @__PURE__ */ new Set([0, 1, 2, 3]);
+function fail(name, why) {
+  throw new Error(`definePattern(${name || "<anonymous>"}): ${why}`);
+}
+function definePattern(spec) {
+  if (spec == null || typeof spec !== "object") {
+    throw new Error("definePattern: spec must be an object");
+  }
+  const name = spec.name;
+  if (typeof name !== "string" || name.length === 0) {
+    fail(String(name), "name must be a non-empty string");
+  }
+  if (typeof spec.category !== "string" || !spec.category.includes("/")) {
+    fail(name, `category must be a "<phase>/<slug>" string (got ${JSON.stringify(spec.category)})`);
+  }
+  const phase = spec.category.split("/", 1)[0];
+  if (!PHASES.has(phase)) {
+    fail(name, `category phase must be one of flatten|compress|extract (got "${phase}")`);
+  }
+  if (!SAFETY_LEVELS.has(spec.safety)) {
+    fail(name, `safety must be 0|1|2|3 (got ${JSON.stringify(spec.safety)})`);
+  }
+  if (typeof spec.evaluate !== "function") {
+    fail(name, "evaluate must be a function");
+  }
+  if (spec.priority !== void 0 && !Number.isFinite(spec.priority)) {
+    fail(name, "priority must be a finite number when provided");
+  }
+  return Object.freeze({ ...spec });
+}
+
+// ../pattern-kit/src/normalize.ts
+var INHERITED_PROPERTIES = [
+  "azimuth",
+  "border-collapse",
+  "border-spacing",
+  "caption-side",
+  "color",
+  "cursor",
+  "direction",
+  "empty-cells",
+  "font-family",
+  "font-feature-settings",
+  "font-kerning",
+  "font-size",
+  "font-size-adjust",
+  "font-stretch",
+  "font-style",
+  "font-variant",
+  "font-variant-caps",
+  "font-variant-numeric",
+  "font-weight",
+  "hyphens",
+  "letter-spacing",
+  "line-height",
+  "list-style-image",
+  "list-style-position",
+  "list-style-type",
+  "orphans",
+  "overflow-wrap",
+  "quotes",
+  "tab-size",
+  "text-align",
+  "text-align-last",
+  "text-decoration-color",
+  "text-indent",
+  "text-justify",
+  "text-rendering",
+  "text-shadow",
+  "text-transform",
+  "text-underline-position",
+  "visibility",
+  "white-space",
+  "widows",
+  "word-break",
+  "word-spacing",
+  "writing-mode",
+  "-webkit-font-smoothing"
+];
+function createInheritedTable() {
+  const properties = new Set(INHERITED_PROPERTIES);
+  return {
+    version: "domflax-inherited@1",
+    properties,
+    isInherited(property) {
+      return String(property).startsWith("--") || properties.has(property);
+    }
+  };
+}
+var ZERO_LENGTH_RE = /\b0(?:px|em|rem|ex|ch|vh|vw|vmin|vmax|vi|vb|pt|pc|cm|mm|in|q|lh|rlh|fr|deg|rad|turn|s|ms|%)\b/g;
+var FUNC_ARGS_RE = /\b(rgba?|hsla?|hwb|lab|lch|oklab|oklch)\(([^()]*)\)/gi;
+var RELATIVE_UNIT_RE = /(?:\d*\.?\d+)(?:em|ex|ch|lh)\b|%/i;
+function canonValue(raw) {
+  let v = raw.trim().replace(/\s+/g, " ");
+  v = v.replace(/#([0-9a-fA-F]{3,8})\b/g, (_m, hex) => "#" + hex.toLowerCase());
+  v = v.replace(
+    /#([0-9a-f])([0-9a-f])([0-9a-f])(?![0-9a-f])/g,
+    (_m, r, g, b) => `#${r}${r}${g}${g}${b}${b}`
+  );
+  v = v.replace(/\btransparent\b/gi, "rgba(0, 0, 0, 0)");
+  v = v.replace(/#00000000\b/g, "rgba(0, 0, 0, 0)");
+  v = v.replace(ZERO_LENGTH_RE, "0");
+  v = v.replace(FUNC_ARGS_RE, (_m, fn, args) => {
+    const parts = args.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    return `${fn.toLowerCase()}(${parts.join(", ")})`;
+  });
+  return v;
+}
+function isRelativeValue(value) {
+  return RELATIVE_UNIT_RE.test(value);
+}
+var BOX_SIDES = {
+  padding: ["padding-top", "padding-right", "padding-bottom", "padding-left"],
+  margin: ["margin-top", "margin-right", "margin-bottom", "margin-left"],
+  inset: ["top", "right", "bottom", "left"],
+  "border-width": [
+    "border-top-width",
+    "border-right-width",
+    "border-bottom-width",
+    "border-left-width"
+  ],
+  "border-style": [
+    "border-top-style",
+    "border-right-style",
+    "border-bottom-style",
+    "border-left-style"
+  ],
+  "border-color": [
+    "border-top-color",
+    "border-right-color",
+    "border-bottom-color",
+    "border-left-color"
+  ]
+};
+function splitTopLevel(value) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of value) {
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    if (depth === 0 && /\s/.test(ch)) {
+      if (cur.length > 0) {
+        out.push(cur);
+        cur = "";
+      }
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur.length > 0) out.push(cur);
+  return out;
+}
+function boxFourSides(values) {
+  const [a, b, c, d] = values;
+  switch (values.length) {
+    case 1:
+      return [a, a, a, a];
+    case 2:
+      return [a, b, a, b];
+    case 3:
+      return [a, b, c, b];
+    default:
+      return [a, b, c, d];
+  }
+}
+function expandShorthand(prop, value) {
+  const box = BOX_SIDES[prop];
+  if (box) {
+    const parts = splitTopLevel(value);
+    if (parts.length >= 1 && parts.length <= 4) {
+      const sides = boxFourSides(parts);
+      return box.map((p, i) => [p, sides[i]]);
+    }
+    return [[prop, value]];
+  }
+  if (prop === "gap" || prop === "grid-gap") {
+    const parts = splitTopLevel(value);
+    if (parts.length === 1) {
+      return [
+        ["row-gap", parts[0]],
+        ["column-gap", parts[0]]
+      ];
+    }
+    if (parts.length === 2) {
+      return [
+        ["row-gap", parts[0]],
+        ["column-gap", parts[1]]
+      ];
+    }
+    return [[prop, value]];
+  }
+  return [[prop, value]];
+}
+function makeDecl(table, prop, rawValue, important) {
+  const property = prop.trim().toLowerCase();
+  const value = canonValue(rawValue);
+  return {
+    property,
+    value,
+    important,
+    relativeToParent: isRelativeValue(value),
+    inherited: table.isInherited(property)
+  };
+}
+function createNormalizer() {
+  const inherited = createInheritedTable();
+  const normalizeDeclaration = (prop, value, important) => {
+    const p = prop.trim().toLowerCase();
+    const expanded = expandShorthand(p, value.trim());
+    return expanded.map(([lp, lv]) => makeDecl(inherited, lp, lv, important));
+  };
+  const normalizeValue = (prop, raw) => {
+    void prop;
+    return canonValue(raw);
+  };
+  const normalizeStyleMap = (sm) => {
+    const blocks = /* @__PURE__ */ new Map();
+    for (const block of sm.blocks.values()) {
+      const decls = /* @__PURE__ */ new Map();
+      for (const decl of block.decls.values()) {
+        const next = {
+          ...decl,
+          value: canonValue(String(decl.value)),
+          relativeToParent: isRelativeValue(String(decl.value)),
+          inherited: inherited.isInherited(decl.property)
+        };
+        decls.set(next.property, next);
+      }
+      const sorted = new Map(
+        [...decls.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
+      );
+      const key = conditionKey(block.condition);
+      blocks.set(key, { condition: block.condition, decls: sorted });
+    }
+    return { blocks };
+  };
+  const equals = (a, b) => {
+    const na = normalizeStyleMap(a);
+    const nb = normalizeStyleMap(b);
+    if (na.blocks.size !== nb.blocks.size) return false;
+    for (const [key, blockA] of na.blocks) {
+      const blockB = nb.blocks.get(key);
+      if (!blockB) return false;
+      if (blockA.decls.size !== blockB.decls.size) return false;
+      for (const [prop, declA] of blockA.decls) {
+        const declB = blockB.decls.get(prop);
+        if (!declB) return false;
+        if (declA.value !== declB.value || declA.important !== declB.important) return false;
+      }
+    }
+    return true;
+  };
+  return {
+    version: "domflax-normalizer@1",
+    normalizeDeclaration,
+    normalizeValue,
+    normalizeStyleMap,
+    equals,
+    inherited
+  };
+}
+var normalizer = createNormalizer();
+function isStyleSuperset(full, partial, norm = normalizer) {
+  const nf = norm.normalizeStyleMap(full);
+  const np = norm.normalizeStyleMap(partial);
+  for (const [key, want] of np.blocks) {
+    const have = nf.blocks.get(key) ?? nf.blocks.get(conditionKey(want.condition));
+    if (!have) return false;
+    for (const [prop, decl] of want.decls) {
+      const got = have.decls.get(prop);
+      if (!got || got.value !== decl.value) return false;
+    }
+  }
+  return true;
+}
+
+// ../pattern-kit/src/combinators.ts
+function asElement(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+function elementChildrenOf(el, ctx) {
+  const out = [];
+  for (const childId of el.children) {
+    const child = ctx.doc.nodes.get(childId);
+    if (child && child.kind === "element") out.push(child);
+  }
+  return out;
+}
+function and(...matchers) {
+  return (node, ctx) => matchers.every((m) => m(node, ctx));
+}
+function not(matcher) {
+  return (node, ctx) => !matcher(node, ctx);
+}
+function isElement(tag) {
+  const want = tag?.toLowerCase();
+  return (node) => {
+    const el = asElement(node);
+    if (!el) return false;
+    return want === void 0 || el.tag.toLowerCase() === want;
+  };
+}
+var hasSingleElementChild = (node, ctx) => {
+  const el = asElement(node);
+  if (!el) return false;
+  return elementChildrenOf(el, ctx).length === 1;
+};
+function computed(partial) {
+  return (node, ctx) => {
+    const el = asElement(node);
+    if (!el) return false;
+    const full = ctx.computedOf(el) ?? el.computed;
+    return isStyleSuperset(full, partial, normalizer);
+  };
+}
+var VISUAL_PROPERTIES = /* @__PURE__ */ new Set([
+  "background",
+  "background-color",
+  "background-image",
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width",
+  "border-top-style",
+  "border-right-style",
+  "border-bottom-style",
+  "border-left-style",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "border-radius",
+  "box-shadow",
+  "outline",
+  "outline-width",
+  "outline-style",
+  "outline-color",
+  "text-shadow",
+  "filter",
+  "backdrop-filter",
+  "mix-blend-mode",
+  "opacity"
+]);
+var EMPTY_VISUAL_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "0",
+  "normal",
+  "transparent",
+  "rgba(0, 0, 0, 0)",
+  "initial",
+  "unset",
+  "auto"
+]);
+var hasOwnVisualStyle = (node, ctx) => {
+  const el = asElement(node);
+  if (!el) return false;
+  if (el.meta.hasOwnVisualStyle) return true;
+  const computedMap = ctx.computedOf(el) ?? el.computed;
+  const norm = normalizer.normalizeStyleMap(computedMap);
+  for (const block of norm.blocks.values()) {
+    for (const decl of block.decls.values()) {
+      if (!VISUAL_PROPERTIES.has(String(decl.property))) continue;
+      if (!EMPTY_VISUAL_VALUES.has(String(decl.value))) return true;
+    }
+  }
+  return false;
+};
+var hasRef = (node) => asElement(node)?.meta.hasRef ?? false;
+var hasEventHandlers = (node) => asElement(node)?.meta.hasEventHandlers ?? false;
+var hasDynamicChildren = (node) => asElement(node)?.meta.hasDynamicChildren ?? false;
+var hasDynamicClasses = (node) => asElement(node)?.classes.hasDynamic ?? false;
+var targetedByCombinator = (node, ctx) => {
+  const el = asElement(node);
+  if (!el) return false;
+  if (el.meta.targetedByCombinator) return true;
+  return ctx.selectors.targetedByCombinator(el.id);
+};
+
+// ../pattern-kit/src/pattern.ts
+function camelToKebab(key) {
+  if (key.startsWith("--")) return key;
+  return key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+function plainToStyleMap(style) {
+  const decls = /* @__PURE__ */ new Map();
+  for (const [rawKey, rawValue] of Object.entries(style)) {
+    const prop = camelToKebab(rawKey);
+    for (const decl of normalizer.normalizeDeclaration(prop, String(rawValue), false)) {
+      decls.set(decl.property, decl);
+    }
+  }
+  const block = { condition: BASE_CONDITION, decls };
+  return { blocks: /* @__PURE__ */ new Map([[conditionKey(BASE_CONDITION), block]]) };
+}
+function asElement2(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+function metaFlag(flag) {
+  return (node) => Boolean(asElement2(node)?.meta[flag]);
+}
+var hasRawHtml = metaFlag("hasDangerousHtml");
+var affectsSelectorMatching = (node, ctx) => {
+  const el = asElement2(node);
+  if (!el) return false;
+  return ctx.selectors.reparentImpact(el.id).size > 0;
+};
+var FLATTEN_GUARDS = and(
+  not(hasRef),
+  not(hasEventHandlers),
+  not(hasDynamicChildren),
+  not(hasRawHtml),
+  not(targetedByCombinator),
+  not(affectsSelectorMatching)
+);
+function isFlattenCategory(category) {
+  return category.split("/", 1)[0] === "flatten";
+}
+function compileDeclarativeMatch(m) {
+  const parts = [isElement(m.tag)];
+  if (m.style) parts.push(computed(plainToStyleMap(m.style)));
+  if (m.onlyChild === "element") parts.push(hasSingleElementChild);
+  if (m.paintsNothing) parts.push(not(hasOwnVisualStyle));
+  if (m.where) {
+    const extra = Array.isArray(m.where) ? m.where : [m.where];
+    for (const w of extra) parts.push(w);
+  }
+  return and(...parts);
+}
+function compileMatch(match, category) {
+  if (typeof match === "function") return match;
+  const declarative = compileDeclarativeMatch(match ?? {});
+  const guarded = isFlattenCategory(category) ? and(declarative, FLATTEN_GUARDS) : declarative;
+  return (node, ctx) => guarded(node, ctx);
+}
+function pruneShadowed(sm, drop) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      const filtered = (decl.shadowed ?? []).filter(
+        (o) => !(o.kind === "class" && drop.has(o.className))
+      );
+      const rest = { ...decl };
+      delete rest.shadowed;
+      const next = filtered.length > 0 ? { ...rest, shadowed: filtered } : rest;
+      decls.set(prop, next);
+    }
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+function compileFlattenInto(recipe) {
+  const childGains = recipe.childGains ? plainToStyleMap(recipe.childGains) : null;
+  const fold = recipe.foldInherited !== false;
+  return (ctx, rw) => {
+    const wrapper = ctx.node;
+    const child = ctx.onlyElementChild();
+    if (!child) return null;
+    const ops = [];
+    if (fold) ops.push(rw.foldInheritedStyles(wrapper, child, { conditions: "all" }));
+    if (childGains) ops.push(rw.mergeStyle(child, null, childGains, "source-wins"));
+    ops.push(rw.unwrap(wrapper));
+    return ops;
+  };
+}
+function compileRewrite(rewrite) {
+  if (typeof rewrite === "function") return rewrite;
+  if ("flattenInto" in rewrite) return compileFlattenInto(rewrite);
+  if ("rewriteClasses" in rewrite) {
+    const preserveOpaque = rewrite.preserveOpaque ?? true;
+    return (ctx, rw) => {
+      const next = rewrite.rewriteClasses(ctx.computed(), ctx);
+      if (!next) return null;
+      return [rw.setClassList(ctx.node, next, preserveOpaque)];
+    };
+  }
+  if ("dropClasses" in rewrite) {
+    const preserveOpaque = rewrite.preserveOpaque ?? true;
+    return (ctx, rw) => {
+      const drop = new Set(rewrite.dropClasses(ctx.computed(), ctx));
+      if (drop.size === 0) return null;
+      return [rw.setClassList(ctx.node, pruneShadowed(ctx.computed(), drop), preserveOpaque)];
+    };
+  }
+  const style = plainToStyleMap(rewrite.mergeStyle);
+  const onConflict = rewrite.onConflict ?? "abort";
+  return (ctx, rw) => [rw.mergeStyle(ctx.node, null, style, onConflict)];
+}
+function pattern(config) {
+  const matchFn = compileMatch(config.match, config.category);
+  const rewriteFn = compileRewrite(config.rewrite);
+  const spec = {
+    name: config.name,
+    category: config.category,
+    safety: config.safety,
+    priority: config.priority,
+    precondition: config.precondition,
+    doc: config.doc,
+    examples: config.examples,
+    evaluate(ctx, rw) {
+      if (!matchFn(ctx.node, ctx)) return null;
+      const ops = rewriteFn(ctx, rw);
+      if (!ops || ops.length === 0) return null;
+      return { ops };
+    }
+  };
+  return definePattern(spec);
+}
+
+// ../patterns/src/flatten/empty-style-div.pattern.ts
+function asEl(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+function metaFlag2(flag) {
+  return (node) => Boolean(asEl(node)?.meta[flag]);
+}
+var establishesBox = metaFlag2("establishesBox");
+var establishesFormattingContext = metaFlag2("establishesFormattingContext");
+var establishesStackingContext = metaFlag2("establishesStackingContext");
+var isContainingBlock = metaFlag2("isContainingBlock");
+var declaresCustomProperties = metaFlag2("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
+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
+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
+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
+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
+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
+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 hasRawHtml2 = (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(hasRawHtml2),
+      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
+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 asElement3(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+var hasDangerousHtml2 = (node) => asElement3(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
+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
+var WIDTH = "width";
+var HEIGHT = "height";
+var SIZE = "size";
+var NON_COLLAPSIBLE_VALUES = /* @__PURE__ */ new Set(["auto", "initial", "unset"]);
+function asElement4(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+function baseBlock(sm) {
+  return sm.blocks.get(conditionKey(BASE_CONDITION));
+}
+var hasDangerousHtml3 = (node) => asElement4(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
+var builtinPatterns = [
+  emptyStyleDiv,
+  flexCenterWrapper,
+  nestedFlexMerge,
+  passthroughWrapper,
+  redundantFragment,
+  dedupeClasses,
+  insetShorthand,
+  marginShorthand,
+  paddingShorthand,
+  sizeShorthand
+];
+
+// ../frontend-jsx/src/frontend.ts
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var traverse = typeof import_traverse.default === "function" ? import_traverse.default : import_traverse.default.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 = (0, import_parser.parse)(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 staticTokensOf3 = (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 = staticTokensOf3(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
+var import_magic_string = __toESM(require("magic-string"), 1);
+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 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;
+}
+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 = staticTokensOf2(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 import_magic_string.default(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 = staticTokensOf2(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;
+}
+
+// ../resolver-tailwind/src/index.ts
+var import_node_module = require("module");
+var path = __toESM(require("path"), 1);
+function moduleBase() {
+  return typeof __filename === "string" ? __filename : importMetaUrl;
+}
+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 = (0, import_node_module.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
+var import_node_fs = require("fs");
+var import_node_module2 = require("module");
+var path2 = __toESM(require("path"), 1);
+function moduleBase2() {
+  return typeof __filename === "string" ? __filename : importMetaUrl;
+}
+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 = (0, import_node_module2.createRequire)(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: (0, import_node_fs.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("|")}`;
+}
+
+// src/index.ts
+var import_node_path = require("path");
+var import_node_url = require("url");
+var DEFAULT_INCLUDE = [".jsx", ".tsx", ".html"];
+function resolveOptions(options) {
+  return {
+    provider: options.provider ?? "auto",
+    cssFiles: options.cssFiles ?? [],
+    dryRun: options.dryRun ?? false,
+    safety: options.safety ?? 2,
+    include: options.include ?? DEFAULT_INCLUDE
+  };
+}
+function isSupported(id, include) {
+  const clean = id.split("?", 1)[0] ?? id;
+  return include.some((ext) => clean.endsWith(ext));
+}
+function jsxKindOf(id) {
+  const clean = id.split("?", 1)[0] ?? id;
+  if (clean.endsWith(".tsx")) return "tsx";
+  if (clean.endsWith(".jsx")) return "jsx";
+  return null;
+}
+function eolOf2(doc) {
+  for (const src of doc.sources.values()) return src.eol;
+  return "\n";
+}
+function buildPasses(patterns) {
+  const byPhase = /* @__PURE__ */ new Map();
+  for (const p of patterns) {
+    const phase = p.category.split("/", 1)[0] ?? "flatten";
+    let bucket = byPhase.get(phase);
+    if (!bucket) {
+      bucket = [];
+      byPhase.set(phase, bucket);
+    }
+    bucket.push(p);
+  }
+  const passes = [];
+  for (const [phase, pats] of byPhase) {
+    passes.push({ phase, category: `${phase}/builtin`, patterns: pats });
+  }
+  return passes;
+}
+function runJsxPipeline(code, id, kind, resolver, patterns, safety) {
+  const parsed = createJsxFrontend().parse(code, {
+    id,
+    kind,
+    resolver,
+    normalizer,
+    config: {},
+    onDiagnostic: () => {
+    }
+  });
+  const doc = parsed.doc;
+  for (const node of doc.nodes.values()) node.meta.safetyFloor = 3;
+  const ctx = {
+    doc,
+    safetyCeiling: safety,
+    normalizer,
+    // Real CSS-selector-safety index from the active resolver: a wrapper a combinator/structural
+    // selector depends on is flagged so the flatten guards refuse to flatten it. Tailwind (no
+    // complexSelectors) degrades to the null index — behaviour unchanged.
+    selectors: buildSelectorIndex(doc, resolver),
+    resolver
+  };
+  const { doc: optimized } = runPasses(doc, buildPasses(patterns), ctx);
+  syncClassesFromComputed(optimized, resolver, normalizer);
+  const printed = createJsxBackend().print(
+    optimized,
+    { moduleId: id, ops: [], provenance: /* @__PURE__ */ new Map() },
+    {
+      normalizer,
+      resolver,
+      sink: createSyntheticSink(),
+      eol: eolOf2(optimized),
+      onDiagnostic: () => {
+      }
+    }
+  );
+  return printed.code;
+}
+function createResolver(resolved) {
+  if (resolved.provider === "custom") {
+    return createCssResolver([], { files: resolved.cssFiles });
+  }
+  return createTailwindResolver();
+}
+function createDomflax(options = {}) {
+  const resolved = resolveOptions(options);
+  const pipeline = createPipeline();
+  const patterns = builtinPatterns;
+  let cachedResolver = null;
+  const getResolver = () => cachedResolver ??= createResolver(resolved);
+  return {
+    options: resolved,
+    pipeline,
+    get resolver() {
+      return getResolver();
+    },
+    patterns,
+    transform(code, id) {
+      if (!isSupported(id, resolved.include)) return { code, map: null };
+      const kind = jsxKindOf(id);
+      if (kind === null) return { code, map: null };
+      const out = runJsxPipeline(code, id, kind, getResolver(), patterns, resolved.safety);
+      return { code: out, map: null };
+    }
+  };
+}
+function vite(options = {}) {
+  const engine = createDomflax(options);
+  return {
+    name: "domflax",
+    enforce: "pre",
+    transform(code, id) {
+      if (!isSupported(id, engine.options.include)) return null;
+      const out = engine.transform(code, id);
+      return out.code === code ? null : out;
+    }
+  };
+}
+var WEBPACK_JSX_TEST = /\.[jt]sx$/;
+function webpackLoaderPath() {
+  const here = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return (0, import_node_path.join)(here, "webpack-loader.cjs");
+}
+function webpack(options = {}) {
+  createDomflax(options);
+  return {
+    name: "domflax",
+    apply(compiler) {
+      const host = compiler.options ?? compiler;
+      const mod = host.module ??= {};
+      const rules = mod.rules ??= [];
+      const rule = {
+        test: WEBPACK_JSX_TEST,
+        enforce: "pre",
+        exclude: /node_modules/,
+        use: [{ loader: webpackLoaderPath(), options }]
+      };
+      rules.push(rule);
+    }
+  };
+}
+var domflax = { createDomflax, vite, webpack };
+var src_default = domflax;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASE_CONDITION,
+  BASE_CONDITION_KEY,
+  DEFAULT_FIXPOINT,
+  applyGroups,
+  applyOps,
+  buildSelectorIndex,
+  builtinPatterns,
+  childIds,
+  cloneDocument,
+  conditionKey,
+  createBackrefTable,
+  createComment,
+  createDocument,
+  createDomflax,
+  createElement,
+  createExpr,
+  createExprRegistry,
+  createFragment,
+  createIdAllocator,
+  createNullResolver,
+  createNullSelectorIndex,
+  createPassManager,
+  createPipeline,
+  createRewriteFactory,
+  createSyntheticSink,
+  createText,
+  dedupeClasses,
+  defaultMeta,
+  elementIds,
+  emptyAttrMap,
+  emptyClassList,
+  emptyInlineStyle,
+  emptyStyleDiv,
+  emptyStyleMap,
+  flexCenterWrapper,
+  getElement,
+  getNode,
+  insetShorthand,
+  marginShorthand,
+  nestedFlexMerge,
+  paddingShorthand,
+  passthroughWrapper,
+  redundantFragment,
+  runPasses,
+  sizeShorthand,
+  syncClassesFromComputed,
+  vite,
+  walk,
+  webpack
+});
+//# sourceMappingURL=index.cjs.map