domflax 0.1.0

package/dist/chunk-77SLHRN6.js

@@ -0,0 +1,2047 @@
+import {
+  init_esm_shims
+} from "./chunk-6WVVF6AD.js";
+
+// ../core/src/builders.ts
+init_esm_shims();
+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
+init_esm_shims();
+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
+init_esm_shims();
+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
+init_esm_shims();
+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
+init_esm_shims();
+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);
+  }
+}
+
+// ../core/src/index.ts
+init_esm_shims();
+
+// ../pattern-kit/src/define.ts
+init_esm_shims();
+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
+init_esm_shims();
+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
+init_esm_shims();
+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 or(...matchers) {
+  return (node, ctx) => matchers.some((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/ops.ts
+init_esm_shims();
+function idOf2(ref) {
+  return typeof ref === "number" ? ref : ref.id;
+}
+function mergeStyle(target, source, style, onConflict = "abort") {
+  return {
+    op: "mergeStyle",
+    target: idOf2(target),
+    source: source == null ? null : idOf2(source),
+    style,
+    onConflict
+  };
+}
+function foldInheritedStyles(from, into, opts) {
+  const list = Array.isArray(into) ? into : [into];
+  return {
+    op: "foldInheritedStyles",
+    from: idOf2(from),
+    into: list.map(idOf2),
+    properties: opts?.only ?? "all-inherited",
+    conditions: opts?.conditions ?? "base"
+  };
+}
+function replaceWith(target, replacement) {
+  return { op: "replaceWith", target: idOf2(target), replacement };
+}
+function removeNode(target) {
+  return { op: "removeNode", target: idOf2(target) };
+}
+
+// ../pattern-kit/src/pattern.ts
+init_esm_shims();
+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);
+}
+
+// ../pattern-kit/src/index.ts
+init_esm_shims();
+
+export {
+  createIdAllocator,
+  createExprRegistry,
+  createBackrefTable,
+  defaultMeta,
+  BASE_CONDITION,
+  conditionKey,
+  BASE_CONDITION_KEY,
+  emptyStyleMap,
+  emptyClassList,
+  emptyAttrMap,
+  emptyInlineStyle,
+  createElement,
+  createText,
+  createExpr,
+  createFragment,
+  createComment,
+  createDocument,
+  childIds,
+  getNode,
+  getElement,
+  elementIds,
+  walk,
+  cloneDocument,
+  applyOps,
+  applyGroups,
+  DEFAULT_FIXPOINT,
+  createNullResolver,
+  createNullSelectorIndex,
+  buildSelectorIndex,
+  createRewriteFactory,
+  runPasses,
+  createPassManager,
+  createSyntheticSink,
+  createPipeline,
+  syncClassesFromComputed,
+  definePattern,
+  createNormalizer,
+  normalizer,
+  isStyleSuperset,
+  and,
+  or,
+  not,
+  isElement,
+  hasSingleElementChild,
+  computed,
+  hasOwnVisualStyle,
+  hasRef,
+  hasEventHandlers,
+  hasDynamicChildren,
+  hasDynamicClasses,
+  targetedByCombinator,
+  mergeStyle,
+  foldInheritedStyles,
+  replaceWith,
+  removeNode,
+  pattern
+};
+//# sourceMappingURL=chunk-77SLHRN6.js.map