domflax 0.1.2 → 0.2.0

package/dist/chunk-TTJEXWAC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../core/src/builders.ts","../../core/src/ops/runtime.ts","../../core/src/ops/apply.ts","../../core/src/ops.ts","../../core/src/pass-context.ts","../../core/src/flatten-safety.ts","../../core/src/pass-manager.ts","../../core/src/pipeline.ts","../../core/src/reverse-emit.ts","../../core/src/compress-engine.ts","../../core/src/index.ts","../../pattern-kit/src/normalize.ts","../../pattern-kit/src/combinators.ts","../../pattern-kit/src/ops.ts","../../pattern-kit/src/pattern.ts","../../pattern-kit/src/define.ts","../../pattern-kit/src/index.ts"],"sourcesContent":["/**\n * @domflax/core — runtime builders + traversal.\n *\n * Pure, dependency-free helpers to construct IR nodes, assemble an {@link IRDocument},\n * and walk the tree honouring {@link VisitSignal}. No heavy third-party deps: only the\n * type contract in `./types`.\n */\n\nimport type {\n  AttrMap,\n  Backref,\n  BackrefTable,\n  ClassList,\n  ConditionKey,\n  CssProperty,\n  ExprRecord,\n  ExprRef,\n  ExprRegistry,\n  FrontendKind,\n  IdAllocator,\n  IRComment,\n  IRDocument,\n  IRElement,\n  IRExpr,\n  IRFragment,\n  IRNamespace,\n  IRNode,\n  IRNodeId,\n  IRText,\n  InlineStyle,\n  NodeMeta,\n  SafetyLevel,\n  SourceSpan,\n  StyleBlock,\n  StyleCondition,\n  StyleMap,\n  Visitor,\n  VisitContext,\n  VisitSignal,\n} from './types';\n\n/* ───────────────────────── id / registry primitives ───────────────────────── */\n\n/** Monotonic IRNodeId allocator. `peek` reports the id `next()` would return. */\nexport function createIdAllocator(start = 1): IdAllocator {\n  let n = start;\n  return {\n    next(): IRNodeId {\n      const id = n;\n      n += 1;\n      return id as IRNodeId;\n    },\n    get peek(): IRNodeId {\n      return n as IRNodeId;\n    },\n  };\n}\n\n/** Minimal in-memory ExprRegistry. */\nexport function createExprRegistry(start = 1): ExprRegistry {\n  const map = new Map<ExprRef, ExprRecord>();\n  let n = start;\n  return {\n    get(r: ExprRef): ExprRecord | undefined {\n      return map.get(r);\n    },\n    intern(rec: Omit<ExprRecord, 'ref'>): ExprRef {\n      const ref = n as ExprRef;\n      n += 1;\n      map.set(ref, { ...rec, ref });\n      return ref;\n    },\n    releasePayloads(): void {\n      for (const [k, v] of map) map.set(k, { ...v, payload: undefined });\n    },\n  };\n}\n\n/** Mutable BackrefTable: frontends register backrefs as they parse. */\nexport interface MutableBackrefTable extends BackrefTable {\n  set(id: IRNodeId, backref: Backref): void;\n}\n\nexport function createBackrefTable(): MutableBackrefTable {\n  const map = new Map<IRNodeId, Backref>();\n  return {\n    get(id: IRNodeId): Backref | undefined {\n      return map.get(id);\n    },\n    span(id: IRNodeId): SourceSpan | null {\n      return map.get(id)?.span ?? null;\n    },\n    childrenSpan(id: IRNodeId): SourceSpan | null {\n      return map.get(id)?.innerSpan ?? null;\n    },\n    set(id: IRNodeId, backref: Backref): void {\n      map.set(id, backref);\n    },\n  };\n}\n\n/* ───────────────────────── default sub-structures ───────────────────────── */\n\n/** A NodeMeta with every barrier/flag cleared. */\nexport function defaultMeta(safetyFloor: SafetyLevel = 0): NodeMeta {\n  return {\n    hasRef: false,\n    hasEventHandlers: false,\n    hasKey: false,\n    hasSpreadAttrs: false,\n    hasDynamicChildren: false,\n    isComponent: false,\n    hasDangerousHtml: false,\n    hasUnresolvedClasses: false,\n    targetedByCombinator: false,\n    targetedByStructuralPseudo: false,\n    selectorDependents: 0,\n    hasOwnVisualStyle: false,\n    establishesBox: false,\n    establishesStackingContext: false,\n    isContainingBlock: false,\n    establishesFormattingContext: false,\n    declaresCustomProperties: false,\n    whitespaceSensitive: false,\n    touched: false,\n    styleDirty: false,\n    synthetic: false,\n    safetyFloor,\n  };\n}\n\n/** Canonical base style condition (`media:'' states:[] pseudoElement:''`). */\nexport const BASE_CONDITION: StyleCondition = { media: '', states: [], pseudoElement: '' };\n\n/** Stable serialization of a StyleCondition into a ConditionKey. */\nexport function conditionKey(c: StyleCondition): ConditionKey {\n  const states = [...c.states].sort().join(',');\n  return `${c.media}|${states}|${c.pseudoElement}` as ConditionKey;\n}\n\nexport const BASE_CONDITION_KEY: ConditionKey = conditionKey(BASE_CONDITION);\n\n/** An empty StyleMap (no blocks). */\nexport function emptyStyleMap(): StyleMap {\n  return { blocks: new Map<ConditionKey, StyleBlock>() };\n}\n\n/** An empty (absent) ClassList. */\nexport function emptyClassList(): ClassList {\n  return {\n    form: 'absent',\n    segments: [],\n    valueSpan: null,\n    hasDynamic: false,\n    opaque: false,\n    rewritable: false,\n  };\n}\n\n/** An empty AttrMap. */\nexport function emptyAttrMap(): AttrMap {\n  return { entries: new Map(), spreads: [], order: [] };\n}\n\n/** An empty InlineStyle. */\nexport function emptyInlineStyle(): InlineStyle {\n  return { decls: new Map<CssProperty, never>() as InlineStyle['decls'], dynamic: null };\n}\n\n/* ───────────────────────── node factories ───────────────────────── */\n\nexport interface ElementInit {\n  readonly tag: string;\n  readonly namespace?: IRNamespace;\n  readonly isComponent?: boolean;\n  readonly selfClosing?: boolean;\n  readonly classes?: ClassList;\n  readonly inlineStyle?: InlineStyle;\n  readonly computed?: StyleMap;\n  readonly attrs?: AttrMap;\n  readonly children?: IRNodeId[];\n  readonly parent?: IRNodeId | null;\n  readonly span?: SourceSpan | null;\n  readonly meta?: NodeMeta;\n}\n\nexport function createElement(id: IRNodeId, init: ElementInit): IRElement {\n  return {\n    id,\n    kind: 'element',\n    parent: init.parent ?? null,\n    span: init.span ?? null,\n    meta: init.meta ?? defaultMeta(),\n    tag: init.tag,\n    namespace: init.namespace ?? 'html',\n    isComponent: init.isComponent ?? false,\n    selfClosing: init.selfClosing ?? false,\n    classes: init.classes ?? emptyClassList(),\n    inlineStyle: init.inlineStyle ?? emptyInlineStyle(),\n    computed: init.computed ?? emptyStyleMap(),\n    attrs: init.attrs ?? emptyAttrMap(),\n    children: init.children ?? [],\n  };\n}\n\nexport function createText(\n  id: IRNodeId,\n  value: string,\n  opts?: { collapsible?: boolean; parent?: IRNodeId | null; span?: SourceSpan | null },\n): IRText {\n  return {\n    id,\n    kind: 'text',\n    parent: opts?.parent ?? null,\n    span: opts?.span ?? null,\n    meta: defaultMeta(),\n    value,\n    collapsible: opts?.collapsible ?? true,\n  };\n}\n\nexport function createExpr(\n  id: IRNodeId,\n  expr: ExprRef,\n  opts?: { parent?: IRNodeId | null; span?: SourceSpan | null },\n): IRExpr {\n  return {\n    id,\n    kind: 'expr',\n    parent: opts?.parent ?? null,\n    span: opts?.span ?? null,\n    meta: defaultMeta(),\n    expr,\n  };\n}\n\nexport function createFragment(\n  id: IRNodeId,\n  opts?: { children?: IRNodeId[]; parent?: IRNodeId | null; span?: SourceSpan | null },\n): IRFragment {\n  return {\n    id,\n    kind: 'fragment',\n    parent: opts?.parent ?? null,\n    span: opts?.span ?? null,\n    meta: defaultMeta(),\n    children: opts?.children ?? [],\n  };\n}\n\nexport function createComment(\n  id: IRNodeId,\n  value: string,\n  opts?: { parent?: IRNodeId | null; span?: SourceSpan | null },\n): IRComment {\n  return {\n    id,\n    kind: 'comment',\n    parent: opts?.parent ?? null,\n    span: opts?.span ?? null,\n    meta: defaultMeta(),\n    value,\n  };\n}\n\n/** Build an empty document whose root is a fresh fragment. */\nexport function createDocument(frontend: FrontendKind): IRDocument {\n  const alloc = createIdAllocator();\n  const rootId = alloc.next();\n  const root = createFragment(rootId);\n  const nodes = new Map<IRNodeId, IRNode>([[rootId, root]]);\n  return {\n    root: rootId,\n    nodes,\n    exprs: createExprRegistry(),\n    sources: new Map(),\n    backref: createBackrefTable(),\n    frontend,\n    alloc,\n  };\n}\n\n/* ───────────────────────── tree accessors ───────────────────────── */\n\n/** Returns the child id list for container nodes, or an empty array. */\nexport function childIds(node: IRNode): readonly IRNodeId[] {\n  return node.kind === 'element' || node.kind === 'fragment' ? node.children : [];\n}\n\n/** Returns the node, or undefined. */\nexport function getNode(doc: IRDocument, id: IRNodeId): IRNode | undefined {\n  return doc.nodes.get(id);\n}\n\n/** Returns the node iff it is an element. */\nexport function getElement(doc: IRDocument, id: IRNodeId): IRElement | undefined {\n  const n = doc.nodes.get(id);\n  return n && n.kind === 'element' ? n : undefined;\n}\n\n/** Pre-order list of every element id reachable from the root. */\nexport function elementIds(doc: IRDocument): IRNodeId[] {\n  const out: IRNodeId[] = [];\n  const visit = (id: IRNodeId): void => {\n    const n = doc.nodes.get(id);\n    if (!n) return;\n    if (n.kind === 'element') out.push(id);\n    for (const c of childIds(n)) visit(c);\n  };\n  visit(doc.root);\n  return out;\n}\n\n/* ───────────────────────── traversal ───────────────────────── */\n\n/**\n * Depth-first pre/post-order walk. `enter` may return `'skip'` (don't descend) or `'stop'`\n * (abort the whole walk); `exit` may return `'stop'`. The visitor receives a live {@link IRNode}\n * plus a {@link VisitContext} exposing depth and the parent node.\n */\nexport function walk(doc: IRDocument, visitor: Visitor): void {\n  const roDoc = doc as unknown as VisitContext['doc'];\n  let stopped = false;\n\n  const visit = (id: IRNodeId, depth: number): void => {\n    if (stopped) return;\n    const node = doc.nodes.get(id);\n    if (!node) return;\n\n    const ctx: VisitContext = {\n      doc: roDoc,\n      depth,\n      parent(): IRNode | null {\n        return node.parent == null ? null : doc.nodes.get(node.parent) ?? null;\n      },\n    };\n\n    const entered: VisitSignal = visitor.enter ? visitor.enter(node, ctx) : undefined;\n    if (entered === 'stop') {\n      stopped = true;\n      return;\n    }\n    if (entered !== 'skip') {\n      for (const child of childIds(node)) {\n        visit(child, depth + 1);\n        if (stopped) return;\n      }\n    }\n\n    const exited: VisitSignal = visitor.exit ? visitor.exit(node, ctx) : undefined;\n    if (exited === 'stop') stopped = true;\n  };\n\n  visit(doc.root, 0);\n}\n","/**\n * @domflax/core — applier runtime helpers (shared by the per-op handlers in `./apply`).\n *\n * Pure, dependency-free building blocks for the trusted mutator: input-preserving cloning, the\n * mutable apply state, small tree helpers, detached-spec materialization, and style merging.\n * Only depends on the `../types` contract and `../builders` runtime helpers.\n */\n\nimport type {\n  ApplyContext,\n  ApplyResult,\n  AttrMap,\n  AttrValue,\n  ConditionKey,\n  CssProperty,\n  Diagnostic,\n  DiagnosticCode,\n  ElementSpec,\n  IRDocument,\n  IRNode,\n  IRNodeId,\n  NodeSpec,\n  RewriteOp,\n  SkippedOpGroup,\n  StyleBlock,\n  StyleConflictPolicy,\n  StyleDecl,\n  StyleMap,\n} from '../types';\n\nimport {\n  createComment,\n  createElement,\n  createExpr,\n  createFragment,\n  createText,\n  defaultMeta,\n} from '../builders';\n\n/* ───────────────────────── result of an apply run ───────────────────────── */\n\nexport interface ApplyOutcome {\n  /** The new document (the input doc is never mutated). */\n  readonly doc: IRDocument;\n  readonly result: ApplyResult;\n}\n\nexport interface MutState {\n  readonly doc: IRDocument;\n  readonly touched: Set<IRNodeId>;\n  readonly removed: Set<IRNodeId>;\n  readonly created: Set<IRNodeId>;\n  readonly diagnostics: Diagnostic[];\n  readonly skipped: SkippedOpGroup[];\n  appliedGroups: number;\n  readonly ceiling: number;\n  readonly ctx: ApplyContext;\n}\n\n/* ───────────────────────── cloning (keep input pure) ───────────────────────── */\n\nexport function cloneStyleMap(sm: StyleMap): StyleMap {\n  const blocks = new Map<ConditionKey, StyleBlock>();\n  for (const [key, block] of sm.blocks) {\n    blocks.set(key, {\n      condition: block.condition,\n      decls: new Map<CssProperty, StyleDecl>(block.decls),\n    });\n  }\n  return { blocks };\n}\n\nfunction cloneNode(node: IRNode): IRNode {\n  const meta = { ...node.meta };\n  switch (node.kind) {\n    case 'element':\n      return {\n        ...node,\n        meta,\n        children: [...node.children],\n        computed: cloneStyleMap(node.computed),\n      };\n    case 'fragment':\n      return { ...node, meta, children: [...node.children] };\n    default:\n      return { ...node, meta };\n  }\n}\n\n/** Shallow-immutable clone: input doc and its node objects are never mutated. */\nexport function cloneDocument(doc: IRDocument): IRDocument {\n  const nodes = new Map<IRNodeId, IRNode>();\n  for (const [id, n] of doc.nodes) nodes.set(id, cloneNode(n));\n  return {\n    root: doc.root,\n    nodes,\n    exprs: doc.exprs,\n    sources: doc.sources,\n    backref: doc.backref,\n    frontend: doc.frontend,\n    alloc: doc.alloc,\n  };\n}\n\n/* ───────────────────────── small helpers ───────────────────────── */\n\nexport function diag(\n  code: DiagnosticCode,\n  message: string,\n  extra?: Partial<Diagnostic>,\n): Diagnostic {\n  return { code, severity: 'warn', message, ...extra };\n}\n\nexport function getParentChildren(doc: IRDocument, id: IRNodeId): IRNodeId[] | null {\n  const node = doc.nodes.get(id);\n  if (!node || node.parent == null) return null;\n  const parent = doc.nodes.get(node.parent);\n  if (!parent) return null;\n  if (parent.kind === 'element' || parent.kind === 'fragment') return parent.children;\n  return null;\n}\n\nexport function indexInParent(doc: IRDocument, id: IRNodeId): number {\n  const siblings = getParentChildren(doc, id);\n  return siblings ? siblings.indexOf(id) : -1;\n}\n\nexport function markTouched(state: MutState, id: IRNodeId): void {\n  const n = state.doc.nodes.get(id);\n  if (n) {\n    n.meta.touched = true;\n    state.touched.add(id);\n  }\n}\n\n/**\n * Mark a node whose OWN computed style a pass just rewrote (setClassList / mergeStyle onto it /\n * fold into it). Implies {@link markTouched}, and additionally raises `meta.styleDirty` — the signal\n * reverse-emit uses to re-derive class tokens. A purely structural bystander (a neighbour's unwrap /\n * merge / move) uses {@link markTouched} instead, so it is left byte-for-byte identical.\n */\nexport function markStyleDirty(state: MutState, id: IRNodeId): void {\n  const n = state.doc.nodes.get(id);\n  if (n) {\n    n.meta.touched = true;\n    n.meta.styleDirty = true;\n    state.touched.add(id);\n  }\n}\n\nexport function removeSubtree(state: MutState, id: IRNodeId): void {\n  const node = state.doc.nodes.get(id);\n  if (!node) return;\n  if (node.kind === 'element' || node.kind === 'fragment') {\n    for (const child of [...node.children]) removeSubtree(state, child);\n  }\n  state.doc.nodes.delete(id);\n  state.removed.add(id);\n}\n\nexport function precond(op: RewriteOp, nodeId: IRNodeId, message: string): Diagnostic {\n  return diag('DF_OP_PRECONDITION_FAILED', message, {\n    nodeId,\n    pattern: op.origin.pattern,\n    severity: 'error',\n  });\n}\n\nexport function primaryTarget(op: RewriteOp): IRNodeId | null {\n  switch (op.op) {\n    case 'removeNode':\n    case 'unwrap':\n    case 'replaceWith':\n    case 'wrap':\n    case 'moveNode':\n    case 'setClassList':\n    case 'mergeStyle':\n      return op.target;\n    case 'insertBefore':\n    case 'insertAfter':\n      return op.anchor;\n    case 'mergeSiblings':\n      return op.first;\n    case 'foldInheritedStyles':\n      return op.from;\n  }\n}\n\n/* ───────────────────────── spec materialization ───────────────────────── */\n\nfunction specToAttrs(map: ReadonlyMap<string, string | boolean> | undefined): AttrMap {\n  if (!map || map.size === 0) return { entries: new Map(), spreads: [], order: [] };\n  const entries = new Map<string, AttrValue>();\n  const order: string[] = [];\n  for (const [k, v] of map) {\n    entries.set(k, { kind: 'static', value: v });\n    order.push(k);\n  }\n  return { entries, spreads: [], order };\n}\n\n/** Materialize a detached {@link NodeSpec} into live nodes; returns the new (or reused) id. */\nexport function materialize(state: MutState, spec: NodeSpec, parent: IRNodeId | null): IRNodeId {\n  const { doc } = state;\n  if (spec.kind === 'ref') {\n    const existing = doc.nodes.get(spec.ref);\n    if (existing) existing.parent = parent;\n    return spec.ref;\n  }\n\n  const id = doc.alloc.next();\n  state.created.add(id);\n  switch (spec.kind) {\n    case 'element': {\n      const childIds: IRNodeId[] = [];\n      const el = createElement(id, {\n        tag: spec.tag,\n        namespace: spec.namespace,\n        selfClosing: spec.selfClosing,\n        attrs: specToAttrs(spec.attrs),\n        parent,\n        meta: { ...defaultMeta(), synthetic: true },\n      });\n      if (spec.classes) el.computed = cloneStyleMap(spec.classes);\n      doc.nodes.set(id, el);\n      for (const child of spec.children ?? []) {\n        childIds.push(materialize(state, child, id));\n      }\n      el.children = childIds;\n      return id;\n    }\n    case 'text': {\n      const t = createText(id, spec.value, { parent });\n      t.meta.synthetic = true;\n      doc.nodes.set(id, t);\n      return id;\n    }\n    case 'expr': {\n      const e = createExpr(id, spec.expr, { parent });\n      e.meta.synthetic = true;\n      doc.nodes.set(id, e);\n      return id;\n    }\n    case 'comment': {\n      const c = createComment(id, spec.value, { parent });\n      c.meta.synthetic = true;\n      doc.nodes.set(id, c);\n      return id;\n    }\n    case 'fragment': {\n      const frag = createFragment(id, { parent });\n      frag.meta.synthetic = true;\n      doc.nodes.set(id, frag);\n      const childIds: IRNodeId[] = [];\n      for (const child of spec.children) childIds.push(materialize(state, child, id));\n      frag.children = childIds;\n      return id;\n    }\n  }\n}\n\nexport function elementSpecToNode(\n  state: MutState,\n  spec: ElementSpec,\n  parent: IRNodeId | null,\n): IRNodeId {\n  return materialize(state, spec, parent);\n}\n\n/* ───────────────────────── style merging ───────────────────────── */\n\nexport function isInherited(state: MutState, decl: StyleDecl): boolean {\n  if (decl.inherited) return true;\n  const table = state.ctx.normalizer?.inherited;\n  if (table) {\n    try {\n      return table.isInherited(decl.property);\n    } catch {\n      return decl.inherited;\n    }\n  }\n  return decl.inherited;\n}\n\nexport interface MergeReport {\n  readonly map: StyleMap;\n  readonly conflict: boolean;\n}\n\n/** Merge `source` decls into `target`, condition-by-condition, per the conflict policy. */\nexport function mergeStyleMaps(\n  target: StyleMap,\n  source: StyleMap,\n  policy: StyleConflictPolicy,\n): MergeReport {\n  // Mutable working copy; returned (widened) as an immutable StyleMap.\n  const blocks = new Map<ConditionKey, StyleBlock>(cloneStyleMap(target).blocks);\n  let conflict = false;\n\n  for (const [key, srcBlock] of source.blocks) {\n    const existing = blocks.get(key);\n    if (!existing) {\n      blocks.set(key, {\n        condition: srcBlock.condition,\n        decls: new Map<CssProperty, StyleDecl>(srcBlock.decls),\n      });\n      continue;\n    }\n    const decls = new Map<CssProperty, StyleDecl>(existing.decls);\n    for (const [prop, srcDecl] of srcBlock.decls) {\n      const had = decls.get(prop);\n      if (had && had.value !== srcDecl.value) {\n        conflict = true;\n        if (policy === 'target-wins') continue;\n        // 'abort' is handled by the caller before commit; 'source-wins' falls through.\n      }\n      if (policy === 'target-wins' && had) continue;\n      decls.set(prop, srcDecl);\n    }\n    blocks.set(key, { condition: existing.condition, decls });\n  }\n  return { map: { blocks }, conflict };\n}\n","/**\n * @domflax/core — the per-op handlers + public apply entry points.\n *\n * {@link applyOps} validates each {@link RewriteOp} against the safety ceiling / node-local floor\n * and commits it to a clone of the document; {@link applyGroups} commits whole {@link RewriteGroup}s\n * atomically. Rejected ops are collected into {@link ApplyResult.skipped} rather than throwing.\n */\n\nimport type {\n  ApplyContext,\n  ApplyResult,\n  ConditionKey,\n  CssProperty,\n  Diagnostic,\n  IRDocument,\n  IRNodeId,\n  RewriteGroup,\n  RewriteOp,\n  SkippedOpGroup,\n  StyleBlock,\n  StyleDecl,\n} from '../types';\n\nimport { BASE_CONDITION_KEY } from '../builders';\n\nimport {\n  cloneDocument,\n  cloneStyleMap,\n  diag,\n  elementSpecToNode,\n  getParentChildren,\n  isInherited,\n  markStyleDirty,\n  markTouched,\n  materialize,\n  mergeStyleMaps,\n  precond,\n  primaryTarget,\n  removeSubtree,\n  type ApplyOutcome,\n  type MutState,\n} from './runtime';\n\nexport type { ApplyOutcome } from './runtime';\nexport { cloneDocument } from './runtime';\n\n/* ───────────────────────── per-op handlers ───────────────────────── */\n\nfunction safetyOk(state: MutState, op: RewriteOp, targetId: IRNodeId): Diagnostic | null {\n  const opSafety = op.origin.safety;\n  if (opSafety > state.ceiling) {\n    return diag(\n      'DF_SAFETY_CEILING_EXCEEDED',\n      `op '${op.op}' safety ${opSafety} exceeds ceiling ${state.ceiling}`,\n      { nodeId: targetId, pattern: op.origin.pattern, severity: 'error' },\n    );\n  }\n  const node = state.doc.nodes.get(targetId);\n  if (node && opSafety > node.meta.safetyFloor) {\n    return diag(\n      'DF_SAFETY_CEILING_EXCEEDED',\n      `op '${op.op}' safety ${opSafety} exceeds node ${targetId} floor ${node.meta.safetyFloor}`,\n      { nodeId: targetId, pattern: op.origin.pattern, severity: 'error' },\n    );\n  }\n  return null;\n}\n\n/** Returns a list of validation issues; empty ⇒ the op was applied. */\nfunction applyOne(state: MutState, op: RewriteOp): Diagnostic[] {\n  const { doc } = state;\n\n  const primary = primaryTarget(op);\n  if (primary != null) {\n    if (!doc.nodes.get(primary)) {\n      return [\n        diag('DF_OP_PRECONDITION_FAILED', `target node ${primary} not found`, {\n          nodeId: primary,\n          pattern: op.origin.pattern,\n          severity: 'error',\n        }),\n      ];\n    }\n    const safety = safetyOk(state, op, primary);\n    if (safety) return [safety];\n  }\n\n  switch (op.op) {\n    case 'removeNode': {\n      const siblings = getParentChildren(doc, op.target);\n      if (siblings) {\n        const i = siblings.indexOf(op.target);\n        if (i >= 0) siblings.splice(i, 1);\n      }\n      removeSubtree(state, op.target);\n      return [];\n    }\n\n    case 'unwrap': {\n      const node = doc.nodes.get(op.target);\n      if (!node || (node.kind !== 'element' && node.kind !== 'fragment')) {\n        return [precond(op, op.target, 'unwrap target is not a container')];\n      }\n      const siblings = getParentChildren(doc, op.target);\n      if (!siblings) return [precond(op, op.target, 'unwrap target has no parent')];\n      const at = siblings.indexOf(op.target);\n      const kids = node.children;\n      for (const k of kids) {\n        const kn = doc.nodes.get(k);\n        if (kn) kn.parent = node.parent;\n      }\n      siblings.splice(at, 1, ...kids);\n      doc.nodes.delete(op.target);\n      state.removed.add(op.target);\n      if (node.parent != null) markTouched(state, node.parent);\n      return [];\n    }\n\n    case 'replaceWith': {\n      const siblings = getParentChildren(doc, op.target);\n      if (!siblings) return [precond(op, op.target, 'replaceWith target has no parent')];\n      const at = siblings.indexOf(op.target);\n      const parentId = doc.nodes.get(op.target)?.parent ?? null;\n      const newId = materialize(state, op.replacement, parentId);\n      siblings.splice(at, 1, newId);\n      removeSubtree(state, op.target);\n      if (parentId != null) markTouched(state, parentId);\n      return [];\n    }\n\n    case 'wrap': {\n      const siblings = getParentChildren(doc, op.target);\n      if (!siblings) return [precond(op, op.target, 'wrap target has no parent')];\n      const at = siblings.indexOf(op.target);\n      const parentId = doc.nodes.get(op.target)?.parent ?? null;\n      const wrapperId = elementSpecToNode(state, op.wrapper, parentId);\n      const wrapper = doc.nodes.get(wrapperId);\n      const targetNode = doc.nodes.get(op.target);\n      if (wrapper && (wrapper.kind === 'element' || wrapper.kind === 'fragment')) {\n        wrapper.children.push(op.target);\n      }\n      if (targetNode) targetNode.parent = wrapperId;\n      siblings.splice(at, 1, wrapperId);\n      return [];\n    }\n\n    case 'insertBefore':\n    case 'insertAfter': {\n      const siblings = getParentChildren(doc, op.anchor);\n      if (!siblings) return [precond(op, op.anchor, 'insert anchor has no parent')];\n      const at = siblings.indexOf(op.anchor);\n      const parentId = doc.nodes.get(op.anchor)?.parent ?? null;\n      const newId = materialize(state, op.node, parentId);\n      siblings.splice(op.op === 'insertBefore' ? at : at + 1, 0, newId);\n      if (parentId != null) markTouched(state, parentId);\n      return [];\n    }\n\n    case 'moveNode': {\n      const newParent = doc.nodes.get(op.newParent);\n      if (!newParent || (newParent.kind !== 'element' && newParent.kind !== 'fragment')) {\n        return [precond(op, op.newParent, 'moveNode newParent is not a container')];\n      }\n      const siblings = getParentChildren(doc, op.target);\n      if (siblings) {\n        const i = siblings.indexOf(op.target);\n        if (i >= 0) siblings.splice(i, 1);\n      }\n      const target = doc.nodes.get(op.target);\n      if (target) target.parent = op.newParent;\n      const idx = Math.max(0, Math.min(op.index, newParent.children.length));\n      newParent.children.splice(idx, 0, op.target);\n      markTouched(state, op.newParent);\n      return [];\n    }\n\n    case 'mergeSiblings': {\n      const first = doc.nodes.get(op.first);\n      const second = doc.nodes.get(op.second);\n      if (!first || !second) return [precond(op, op.first, 'mergeSiblings node missing')];\n      if (\n        (first.kind === 'element' || first.kind === 'fragment') &&\n        (second.kind === 'element' || second.kind === 'fragment')\n      ) {\n        for (const c of second.children) {\n          const cn = doc.nodes.get(c);\n          if (cn) cn.parent = op.first;\n          first.children.push(c);\n        }\n        second.children = [];\n      }\n      const siblings = getParentChildren(doc, op.second);\n      if (siblings) {\n        const i = siblings.indexOf(op.second);\n        if (i >= 0) siblings.splice(i, 1);\n      }\n      doc.nodes.delete(op.second);\n      state.removed.add(op.second);\n      markTouched(state, op.first);\n      return [];\n    }\n\n    case 'setClassList': {\n      const el = doc.nodes.get(op.target);\n      if (!el || el.kind !== 'element') {\n        return [precond(op, op.target, 'setClassList target is not an element')];\n      }\n      el.computed = cloneStyleMap(op.style);\n      markStyleDirty(state, op.target);\n      return [];\n    }\n\n    case 'mergeStyle': {\n      const el = doc.nodes.get(op.target);\n      if (!el || el.kind !== 'element') {\n        return [precond(op, op.target, 'mergeStyle target is not an element')];\n      }\n      const report = mergeStyleMaps(el.computed, op.style, op.onConflict);\n      if (report.conflict && op.onConflict === 'abort') {\n        return [\n          diag('DF_STYLE_CONFLICT_UNRESOLVED', `mergeStyle aborted on conflict at ${op.target}`, {\n            nodeId: op.target,\n            pattern: op.origin.pattern,\n            severity: 'error',\n          }),\n        ];\n      }\n      el.computed = report.map;\n      if (op.source != null) {\n        const src = doc.nodes.get(op.source);\n        if (src) markTouched(state, op.source);\n      }\n      markStyleDirty(state, op.target);\n      return [];\n    }\n\n    case 'foldInheritedStyles':\n      return applyFold(state, op);\n  }\n}\n\nfunction applyFold(\n  state: MutState,\n  op: Extract<RewriteOp, { op: 'foldInheritedStyles' }>,\n): Diagnostic[] {\n  const { doc } = state;\n  const from = doc.nodes.get(op.from);\n  if (!from || from.kind !== 'element') {\n    return [precond(op, op.from, 'fold source is not an element')];\n  }\n  const issues: Diagnostic[] = [];\n  const onlyProps: ReadonlySet<CssProperty> | null =\n    op.properties === 'all-inherited' ? null : new Set(op.properties);\n\n  const conditionKeys =\n    op.conditions === 'all'\n      ? [...from.computed.blocks.keys()]\n      : [BASE_CONDITION_KEY];\n\n  for (const intoId of op.into) {\n    const into = doc.nodes.get(intoId);\n    if (!into || into.kind !== 'element') {\n      issues.push(precond(op, intoId, 'fold target is not an element'));\n      continue;\n    }\n    // Mutable working copy; assigned back (widened) as an immutable StyleMap.\n    const nextBlocks = new Map<ConditionKey, StyleBlock>(cloneStyleMap(into.computed).blocks);\n    let folded = false;\n\n    for (const key of conditionKeys) {\n      const srcBlock = from.computed.blocks.get(key);\n      if (!srcBlock) continue;\n      const dstBlock = nextBlocks.get(key);\n      const decls = dstBlock\n        ? new Map<CssProperty, StyleDecl>(dstBlock.decls)\n        : new Map<CssProperty, StyleDecl>();\n\n      for (const [prop, decl] of srcBlock.decls) {\n        if (onlyProps && !onlyProps.has(prop)) continue;\n        if (!isInherited(state, decl)) continue;\n        if (decl.relativeToParent) {\n          issues.push(\n            diag(\n              'DF_RELATIVE_UNIT_FOLD',\n              `refused to fold relative-unit declaration '${decl.property}' onto ${intoId}`,\n              { nodeId: intoId, pattern: op.origin.pattern, severity: 'warn' },\n            ),\n          );\n          continue;\n        }\n        if (!decls.has(prop)) {\n          decls.set(prop, decl);\n          folded = true;\n        }\n      }\n      nextBlocks.set(key, { condition: srcBlock.condition, decls });\n    }\n\n    if (folded) {\n      into.computed = { blocks: nextBlocks };\n      markStyleDirty(state, intoId);\n    }\n  }\n  // Non-blocking (DF_RELATIVE_UNIT_FOLD) diagnostics are recorded but do not skip the op.\n  for (const d of issues) state.diagnostics.push(d);\n  return [];\n}\n\n/* ───────────────────────── public entry points ───────────────────────── */\n\n/**\n * Apply a flat list of ops to a copy of `doc`. The input document is never mutated.\n * Each op is independently validated; failing ops are skipped (collected in\n * {@link ApplyResult.skipped}) instead of throwing.\n */\nexport function applyOps(\n  doc: IRDocument,\n  ops: readonly RewriteOp[],\n  ctx?: Partial<ApplyContext>,\n): ApplyOutcome {\n  const cloned = cloneDocument(doc);\n  const state: MutState = {\n    doc: cloned,\n    touched: new Set(),\n    removed: new Set(),\n    created: new Set(),\n    diagnostics: [],\n    skipped: [],\n    appliedGroups: 0,\n    ceiling: ctx?.safetyCeiling ?? 3,\n    ctx: { doc: cloned, safetyCeiling: ctx?.safetyCeiling ?? 3, ...ctx } as ApplyContext,\n  };\n\n  for (const op of ops) {\n    const issues = applyOne(state, op);\n    if (issues.length > 0) {\n      state.skipped.push({\n        group: { pattern: op.origin.pattern, anchor: primaryTarget(op) ?? doc.root, ops: [op] },\n        issues: issues.map((d) => ({ op, code: d.code, message: d.message })),\n      });\n      for (const d of issues) state.diagnostics.push(d);\n    } else {\n      state.appliedGroups += 1;\n    }\n  }\n\n  return { doc: cloned, result: finalize(state) };\n}\n\n/**\n * Apply pre-grouped ops (each {@link RewriteGroup} is committed atomically: if ANY op in the group\n * fails validation, the whole group is skipped and none of its ops mutate the tree).\n */\nexport function applyGroups(\n  doc: IRDocument,\n  groups: readonly RewriteGroup[],\n  ctx?: Partial<ApplyContext>,\n): ApplyOutcome {\n  // Group-atomicity is realized by working on a throwaway clone per group, then committing.\n  let current = cloneDocument(doc);\n  const touched = new Set<IRNodeId>();\n  const removed = new Set<IRNodeId>();\n  const created = new Set<IRNodeId>();\n  const diagnostics: Diagnostic[] = [];\n  const skipped: SkippedOpGroup[] = [];\n  let appliedGroups = 0;\n\n  for (const group of groups) {\n    const attempt = applyOps(current, group.ops, ctx);\n    if (attempt.result.skipped.length > 0) {\n      skipped.push({\n        group,\n        issues: attempt.result.skipped.flatMap((s) => s.issues),\n      });\n      for (const s of attempt.result.skipped) for (const i of s.issues) {\n        diagnostics.push(diag(i.code, i.message, { pattern: group.pattern }));\n      }\n      continue; // discard the attempt — group is atomic\n    }\n    current = attempt.doc;\n    appliedGroups += 1;\n    for (const id of attempt.result.touched) touched.add(id);\n    for (const id of attempt.result.removed) removed.add(id);\n    for (const id of attempt.result.created) created.add(id);\n    for (const d of attempt.result.diagnostics) diagnostics.push(d);\n  }\n\n  const result: ApplyResult = {\n    touched,\n    removed,\n    created,\n    appliedGroups,\n    skipped,\n    journal: [],\n    diagnostics,\n  };\n  return { doc: current, result };\n}\n\nfunction finalize(state: MutState): ApplyResult {\n  return {\n    touched: state.touched,\n    removed: state.removed,\n    created: state.created,\n    appliedGroups: state.appliedGroups,\n    skipped: state.skipped,\n    journal: [],\n    diagnostics: state.diagnostics,\n  };\n}\n","/**\n * @domflax/core — the pure applier (the one trusted mutator) — public barrel.\n *\n * {@link applyOps} takes an {@link IRDocument} plus a flat list of {@link RewriteOp}s and returns a\n * NEW, mutated document (the input is left untouched — \"pure\" in the input-immutability sense). Every\n * op is validated against the safety ceiling and node-local safety floor before it runs; rejected ops\n * are collected into {@link ApplyResult.skipped} with {@link Diagnostic}s rather than throwing.\n * Dependency-free: only the `./types` contract and `./builders` runtime helpers.\n *\n * The implementation is split for size: `./ops/runtime` holds the input-preserving cloning, mutable\n * state, tree helpers, spec materialization, and style merging; `./ops/apply` holds the per-op\n * handlers and the public entry points. This barrel preserves the original public surface.\n */\n\nexport type { ApplyOutcome } from './ops/runtime';\nexport { cloneDocument } from './ops/runtime';\nexport { applyOps, applyGroups } from './ops/apply';\n","/**\n * @domflax/core — pass-manager supporting contexts (resolvers, selector index, rewrite factory,\n * match context).\n *\n * Split out of `pass-manager.ts` so the sync engine, the async verifier-gated engine, and the\n * classification module can all share the same context construction without any of those files\n * exceeding the module-size budget. Dependency-free: only the `./types` contract + `./builders`.\n */\n\nimport type {\n  DeepReadonly,\n  ElementLike,\n  ElementSpec,\n  EmitContext,\n  EmitResult,\n  IRDocument,\n  IRElement,\n  IRNode,\n  IRNodeId,\n  MatchContext,\n  NodeLike,\n  NodeSpec,\n  PassPhase,\n  ResolveInput,\n  ResolveResult,\n  RewriteFactory,\n  RewriteOpDraft,\n  SelectorIndex,\n  SelectorUsage,\n  StyleConflictPolicy,\n  StyleMap,\n  StyleResolver,\n} from './types';\n\nimport { elementIds, emptyStyleMap, getElement } from './builders';\n\n/* ───────────────────────── default resolvers / selector index ───────────────────────── */\n\n/** A no-op resolver: owns nothing, resolves to empty styles. Useful as an injection default. */\nexport function createNullResolver(): StyleResolver {\n  const empty: ResolveResult = {\n    styles: emptyStyleMap(),\n    resolved: [],\n    unknown: [],\n    opaque: [],\n    warnings: [],\n  };\n  const usage: SelectorUsage = {\n    asSubject: false,\n    asAncestor: false,\n    asCompound: false,\n    asSibling: false,\n    asHasArgument: false,\n    asStructural: false,\n    droppable: true,\n  };\n  return {\n    id: 'null',\n    provider: 'null@0.0.0',\n    fingerprint: 'null',\n    owns(): boolean {\n      return false;\n    },\n    resolve(_input: ResolveInput): ResolveResult {\n      return empty;\n    },\n    emit(_styles: StyleMap, _ctx: EmitContext): EmitResult {\n      return { classes: [], exact: true, warnings: [] };\n    },\n    selectorUsage(): SelectorUsage {\n      return usage;\n    },\n  };\n}\n\n/** A SelectorIndex that reports zero CSS-targeting (no combinator/structural coupling). */\nexport function createNullSelectorIndex(): SelectorIndex {\n  const none: ReadonlySet<IRNodeId> = new Set();\n  return {\n    targetedByCombinator(): boolean {\n      return false;\n    },\n    targetedByStructuralPseudo(): boolean {\n      return false;\n    },\n    reparentImpact(): ReadonlySet<IRNodeId> {\n      return none;\n    },\n  };\n}\n\n/** Resolvers that can enumerate the project's COMPLEX selectors (the custom-CSS resolver) expose this. */\ninterface ComplexSelectorCapable {\n  complexSelectors(): readonly string[];\n}\n\nfunction hasComplexSelectors(r: StyleResolver): r is StyleResolver & ComplexSelectorCapable {\n  return typeof (r as Partial<ComplexSelectorCapable>).complexSelectors === 'function';\n}\n\n/**\n * Build a real {@link SelectorIndex} from the active resolver.\n *\n * For a resolver that reports project COMPLEX selectors — anything with a combinator (`>`/`+`/`~`/\n * descendant) or a structural pseudo, i.e. the custom-CSS resolver — every element whose static class\n * participates in such a selector is flagged so the flatten/compress guards (`targetedByCombinator` /\n * `affectsSelectorMatching`) fire and a wrapper a selector depends on is NOT flattened. An element is\n * combinator-coupled when one of its classes is used as a descendant/child ancestor, as a sibling\n * subject, or as a `:has()` argument; structural-coupled when used in `:nth-child(...)` etc.\n *\n * For a combinator-free resolver (Tailwind utilities — no `complexSelectors()`), this degrades to the\n * null index so behaviour is unchanged.\n */\nexport function buildSelectorIndex(doc: IRDocument, resolver: StyleResolver): SelectorIndex {\n  if (!hasComplexSelectors(resolver) || resolver.complexSelectors().length === 0) {\n    return createNullSelectorIndex();\n  }\n\n  const combinator = new Set<IRNodeId>();\n  const structural = new Set<IRNodeId>();\n\n  for (const id of elementIds(doc)) {\n    const el = getElement(doc, id);\n    if (!el) continue;\n    for (const seg of el.classes.segments) {\n      if (seg.kind !== 'static') continue;\n      for (const t of seg.tokens) {\n        const u = resolver.selectorUsage(t.value);\n        // Combinator coupling: descendant/child ancestor, sibling subject, or `:has()` argument —\n        // reparenting/removing the element would change a combinator match-set.\n        if (u.asAncestor || u.asSibling || u.asHasArgument) combinator.add(id);\n        if (u.asStructural) structural.add(id);\n      }\n    }\n  }\n\n  // reparentImpact(id): non-empty when removing/unwrapping `id` would change a combinator/structural\n  // match-set — `id` itself is coupled (its own match), or it is the matched ancestor of a child\n  // (removing it reparents that child out of the relation). Self + element children is conservative\n  // and sufficient for the flatten guard.\n  const impact = new Map<IRNodeId, Set<IRNodeId>>();\n  for (const id of elementIds(doc)) {\n    const el = getElement(doc, id);\n    if (!el) continue;\n    if (!combinator.has(id) && !structural.has(id)) continue;\n    const set = new Set<IRNodeId>([id]);\n    for (const c of el.children) {\n      const cn = doc.nodes.get(c);\n      if (cn && cn.kind === 'element') set.add(c);\n    }\n    impact.set(id, set);\n  }\n\n  const empty: ReadonlySet<IRNodeId> = new Set();\n  return {\n    targetedByCombinator: (id: IRNodeId): boolean => combinator.has(id),\n    targetedByStructuralPseudo: (id: IRNodeId): boolean => structural.has(id),\n    reparentImpact: (id: IRNodeId): ReadonlySet<IRNodeId> => impact.get(id) ?? empty,\n  };\n}\n\n/* ───────────────────────── rewrite factory (emits origin-free drafts) ───────────────────────── */\n\n/** Every {@link NodeLike}/{@link ElementLike} carries a readonly `id`. */\nfunction idOf(n: ElementLike | NodeLike): IRNodeId {\n  return (n as IRElement).id;\n}\n\n/** The pattern-kit factory: produces op DRAFTS and detached NodeSpecs without any allocation. */\nexport function createRewriteFactory(): RewriteFactory {\n  return {\n    unwrap(target: ElementLike): RewriteOpDraft {\n      return { op: 'unwrap', target: idOf(target) };\n    },\n    removeNode(target: NodeLike): RewriteOpDraft {\n      return { op: 'removeNode', target: idOf(target) };\n    },\n    replaceWith(target: NodeLike, replacement: NodeSpec): RewriteOpDraft {\n      return { op: 'replaceWith', target: idOf(target), replacement };\n    },\n    wrap(target: NodeLike, wrapper: ElementSpec): RewriteOpDraft {\n      return { op: 'wrap', target: idOf(target), wrapper };\n    },\n    insertBefore(anchor: NodeLike, node: NodeSpec): RewriteOpDraft {\n      return { op: 'insertBefore', anchor: idOf(anchor), node };\n    },\n    insertAfter(anchor: NodeLike, node: NodeSpec): RewriteOpDraft {\n      return { op: 'insertAfter', anchor: idOf(anchor), node };\n    },\n    moveNode(target: NodeLike, newParent: ElementLike, index: number): RewriteOpDraft {\n      return { op: 'moveNode', target: idOf(target), newParent: idOf(newParent), index };\n    },\n    mergeSiblings(first: NodeLike, second: NodeLike): RewriteOpDraft {\n      return { op: 'mergeSiblings', first: idOf(first), second: idOf(second) };\n    },\n    setClassList(target: ElementLike, style: StyleMap, preserveOpaque = true): RewriteOpDraft {\n      return { op: 'setClassList', target: idOf(target), style, preserveOpaque };\n    },\n    mergeStyle(\n      target: ElementLike,\n      source: ElementLike | null,\n      style: StyleMap,\n      onConflict: StyleConflictPolicy = 'abort',\n    ): RewriteOpDraft {\n      return {\n        op: 'mergeStyle',\n        target: idOf(target),\n        source: source ? idOf(source) : null,\n        style,\n        onConflict,\n      };\n    },\n    foldInheritedStyles(\n      from: ElementLike,\n      into: ElementLike | readonly ElementLike[],\n      opts?: { only?: readonly import('./types').CssProperty[]; conditions?: 'base' | 'all' },\n    ): RewriteOpDraft {\n      const list: readonly ElementLike[] = Array.isArray(into)\n        ? (into as readonly ElementLike[])\n        : [into as ElementLike];\n      return {\n        op: 'foldInheritedStyles',\n        from: idOf(from),\n        into: list.map((t) => idOf(t)),\n        properties: opts?.only ?? 'all-inherited',\n        conditions: opts?.conditions ?? 'base',\n      };\n    },\n    element(spec: ElementSpec): NodeSpec {\n      return spec;\n    },\n    text(value: string): NodeSpec {\n      return { kind: 'text', value };\n    },\n    keep(node: NodeLike): NodeSpec {\n      return { kind: 'ref', ref: idOf(node) };\n    },\n  };\n}\n\n/* ───────────────────────── match context ───────────────────────── */\n\nfunction ro<T>(v: T): DeepReadonly<T> {\n  return v as DeepReadonly<T>;\n}\n\n/** Build the read-only {@link MatchContext} a pattern's `evaluate` receives for one element. */\nexport function buildMatchContext(\n  doc: IRDocument,\n  elementId: IRNodeId,\n  resolver: StyleResolver,\n  selectors: SelectorIndex,\n  safety: import('./types').SafetyLevel,\n  phase: PassPhase,\n  iteration: number,\n): MatchContext {\n  const self = getElement(doc, elementId)!;\n\n  const parentEl = (): DeepReadonly<IRElement> | null => {\n    if (self.parent == null) return null;\n    const p = doc.nodes.get(self.parent);\n    return p && p.kind === 'element' ? ro(p) : null;\n  };\n\n  const elementChildren = (): readonly DeepReadonly<IRElement>[] => {\n    const out: DeepReadonly<IRElement>[] = [];\n    for (const c of self.children) {\n      const cn = doc.nodes.get(c);\n      if (cn && cn.kind === 'element') out.push(ro(cn));\n    }\n    return out;\n  };\n\n  const ancestors = (): readonly DeepReadonly<IRElement>[] => {\n    const out: DeepReadonly<IRElement>[] = [];\n    let cur: IRNodeId | null = self.parent;\n    while (cur != null) {\n      const n: IRNode | undefined = doc.nodes.get(cur);\n      if (!n) break;\n      if (n.kind === 'element') out.push(ro(n));\n      cur = n.parent;\n    }\n    return out;\n  };\n\n  const siblingAt = (delta: number): DeepReadonly<IRNode> | null => {\n    if (self.parent == null) return null;\n    const p = doc.nodes.get(self.parent);\n    if (!p || (p.kind !== 'element' && p.kind !== 'fragment')) return null;\n    const i = p.children.indexOf(elementId);\n    const sib = p.children[i + delta];\n    if (sib == null) return null;\n    const sn = doc.nodes.get(sib);\n    return sn ? ro(sn) : null;\n  };\n\n  const computedOf = (n: NodeLike): StyleMap => {\n    const node = doc.nodes.get((n as IRNode).id);\n    return node && node.kind === 'element' ? node.computed : emptyStyleMap();\n  };\n\n  return {\n    node: ro(self),\n    doc: ro(doc),\n    resolver,\n    selectors,\n    safety,\n    phase,\n    iteration,\n    parent: parentEl,\n    elementChildren,\n    onlyElementChild(): DeepReadonly<IRElement> | null {\n      const els = elementChildren();\n      return els.length === 1 ? els[0]! : null;\n    },\n    computed(): StyleMap {\n      return self.computed;\n    },\n    computedOf,\n    isOpaque(n?: ElementLike): boolean {\n      const target = n ? doc.nodes.get((n as IRElement).id) : self;\n      if (!target || target.kind !== 'element') return true;\n      return target.classes.opaque || target.meta.hasSpreadAttrs;\n    },\n    ancestors,\n    closest(pred): DeepReadonly<IRElement> | null {\n      for (const a of ancestors()) if (pred(a)) return a;\n      return null;\n    },\n    prevSibling(): DeepReadonly<IRNode> | null {\n      return siblingAt(-1);\n    },\n    nextSibling(): DeepReadonly<IRNode> | null {\n      return siblingAt(1);\n    },\n    nthChildIndex(): number {\n      if (self.parent == null) return 1;\n      const p = doc.nodes.get(self.parent);\n      if (!p || (p.kind !== 'element' && p.kind !== 'fragment')) return 1;\n      let idx = 0;\n      for (const c of p.children) {\n        const cn = doc.nodes.get(c);\n        if (cn && cn.kind === 'element') {\n          idx += 1;\n          if (c === elementId) return idx;\n        }\n      }\n      return idx;\n    },\n  };\n}\n","/**\n * @domflax/core — static classification of a flatten (the VERIFIER-GATED safety core).\n *\n * A flatten pattern matches on `paintsNothing` + a structural/style signature, but unwrapping a\n * wrapper can still change rendering: a wrapper with non-paint layout styles (e.g. `px-4 py-4`) drops\n * that padding when removed (it is NOT reproduced on the surviving child), and a centering wrapper\n * collapsed to `place-self:center` only stays centered when the child's NEW parent is flex/grid. The\n * existing emittability revert only checks the ADDED style is re-emittable — not that the wrapper's\n * own styles survive, nor that the parent context holds.\n *\n * {@link classifyFlattenOps} answers, for one applied flatten op-group, whether it is:\n *\n *   • `'provably-safe'`       — removing the wrapper changes NOTHING renderable: the wrapper\n *                                establishes no box/formatting/stacking context, has no non-inherited\n *                                own declaration that the rewrite does not reproduce on the surviving\n *                                child, AND the rewrite adds no parent-context-dependent self-alignment\n *                                (unless the new parent is statically flex/grid). Examples: passthrough\n *                                / empty-style / display-contents / redundant-fragment wrappers.\n *   • `'needs-verification'`  — anything else (drops/relies on a style, or centering→place-self).\n *\n * Pure + dependency-free: only the `./types` contract + `./builders` accessors.\n */\n\nimport { conditionKey, getElement } from './builders';\nimport type {\n  CssProperty,\n  IRDocument,\n  IRElement,\n  IRNodeId,\n  RewriteOp,\n  StyleBlock,\n  StyleDecl,\n  StyleMap,\n  StyleNormalizer,\n} from './types';\n\n/** The static verdict for one flatten op-group. */\nexport type FlattenClass = 'provably-safe' | 'needs-verification';\n\n/** A classified flatten plus the structural anchors a verifier needs to render before/after. */\nexport interface FlattenClassification {\n  readonly kind: FlattenClass;\n  /** The unwrapped wrapper (in the BEFORE doc), or null when the group removes no element box. */\n  readonly wrapperId: IRNodeId | null;\n  /** The surviving child styles fold onto (the AFTER subtree root), or null. */\n  readonly childId: IRNodeId | null;\n}\n\n/* ───────────────────────── display / context reasoning ───────────────────────── */\n\nconst DISPLAY = 'display' as CssProperty;\nconst POSITION = 'position' as CssProperty;\nconst TRANSFORM = 'transform' as CssProperty;\nconst ALIGN_ITEMS = 'align-items' as CssProperty;\nconst JUSTIFY_CONTENT = 'justify-content' as CssProperty;\nconst JUSTIFY_ITEMS = 'justify-items' as CssProperty;\nconst PLACE_ITEMS = 'place-items' as CssProperty;\nconst PLACE_SELF = 'place-self' as CssProperty;\n\n/** Displays that generate no independent formatting context for the wrapper's children. */\nconst CONTEXT_SAFE_DISPLAYS: ReadonlySet<string> = new Set(['block', 'contents', '']);\n/** `position` values that neither establish a containing block nor offset the element. */\nconst STATIC_POSITIONS: ReadonlySet<string> = new Set(['static', '']);\n\n/* ───────────────────────── context-compensated centering (grid-parent override) ───────────────────────── */\n\n/**\n * Displays under which a block-level wrapper carrying `align-items:center` + `justify-content:center`\n * truly centers a single child on BOTH axes (so collapsing it to `place-self:center` is lossless).\n * Restricted to the block-level `flex`/`grid` (per the CSS soundness rule) — the inline variants are\n * left `needs-verification`.\n */\nconst CENTERING_DISPLAYS: ReadonlySet<string> = new Set(['flex', 'grid']);\n/**\n * Parent displays that establish a GRID formatting context — the ONLY context in which the child's\n * `justify-self` (the horizontal half of `place-self:center`) is honored. A flex parent ignores\n * `justify-self`, and a block parent ignores both, so neither can host the flatten.\n */\nconst GRID_PARENT_DISPLAYS: ReadonlySet<string> = new Set(['grid']);\n/**\n * Item-alignment values under which a stretch-defaulted grid item FILLS its area. Only when the\n * wrapper fills its grid area does \"center inside the wrapper\" equal \"center inside the area\" (which\n * is what `place-self:center` on the child produces). Any other value (start/end/center/…) would let\n * the wrapper shrink and sit off-center, so the collapse could move the child → we preserve.\n */\nconst STRETCHY_ITEM_ALIGN: ReadonlySet<string> = new Set(['normal', 'stretch']);\n/** Parent item-alignment properties that, when non-stretch, stop the wrapper filling its grid area. */\nconst PARENT_ITEMS_ALIGN_PROPS: readonly CssProperty[] = [ALIGN_ITEMS, JUSTIFY_ITEMS, PLACE_ITEMS];\n\n/** True when a style condition is the unconditional base (no media / states / pseudo-element). */\nfunction isBaseCondition(block: StyleBlock): boolean {\n  const c = block.condition;\n  return c.media === '' && c.states.length === 0 && c.pseudoElement === '';\n}\n\n/** The base-condition value of `prop` in a NORMALIZED style map, or null when unset. */\nfunction baseValue(sm: StyleMap, prop: CssProperty): string | null {\n  for (const block of sm.blocks.values()) {\n    if (!isBaseCondition(block)) continue;\n    const d = block.decls.get(prop);\n    return d ? String(d.value) : null;\n  }\n  return null;\n}\n\n/**\n * True when unwrapping `wrapper` reparents the child under a statically-known GRID container that lets\n * the wrapper fill its area — the ONE parent context in which `place-self:center` reproduces the\n * wrapper's centering exactly. Requires (a) the parent is `display:grid`/`inline-grid` in the base\n * condition, (b) NO condition switches the parent to a non-grid display, and (c) NO condition forces a\n * non-stretch item-alignment (align-items/justify-items/place-items) that would shrink the wrapper off\n * its area. Anything else (flex/block/unknown parent, `place-items:center`, responsive `md:flex`, …)\n * → false → the flatten stays `needs-verification` (preserved).\n */\nfunction parentIsFillingGrid(before: IRDocument, wrapper: IRElement, norm: StyleNormalizer): boolean {\n  if (wrapper.parent == null) return false;\n  const p = before.nodes.get(wrapper.parent);\n  if (!p || p.kind !== 'element') return false;\n  const pc = norm.normalizeStyleMap(p.computed);\n  let baseIsGrid = false;\n  for (const block of pc.blocks.values()) {\n    const disp = block.decls.get(DISPLAY);\n    if (disp) {\n      if (!GRID_PARENT_DISPLAYS.has(String(disp.value))) return false; // any non-grid display → unsafe\n      if (isBaseCondition(block)) baseIsGrid = true;\n    }\n    for (const prop of PARENT_ITEMS_ALIGN_PROPS) {\n      const d = block.decls.get(prop);\n      if (d && !STRETCHY_ITEM_ALIGN.has(String(d.value))) return false; // wrapper would not fill its area\n    }\n  }\n  return baseIsGrid;\n}\n\n/**\n * True when the wrapper carries NOTHING beyond the base-condition centering signature\n * (`display:flex|grid` + `align-items:center` + `justify-content:center`) that removal would drop.\n * Those three are compensated by the child's new `place-self:center`; `position:static`/`transform:none`\n * are inert; inherited declarations are folded onto the child by `foldInheritedStyles`; and any decl the\n * child provably reproduces is not lost. ANY other non-inherited own declaration — in any condition\n * (padding, margin, sizing, border, background, gap, a NON-base or NON-center align-items/justify-content,\n * a non-static position, a transform, …) → false → not a pure centering wrapper → preserved.\n */\nfunction wrapperHasOnlyCenteringStyle(\n  wrapperComputed: StyleMap,\n  childComputed: StyleMap | null,\n  norm: StyleNormalizer,\n): boolean {\n  for (const block of wrapperComputed.blocks.values()) {\n    const base = isBaseCondition(block);\n    const ck = conditionKey(block.condition);\n    for (const [prop, decl] of block.decls) {\n      const val = String(decl.value);\n      if (prop === DISPLAY) {\n        if (base && CENTERING_DISPLAYS.has(val)) continue;\n        return false;\n      }\n      if (prop === ALIGN_ITEMS) {\n        if (base && val === 'center') continue;\n        return false;\n      }\n      if (prop === JUSTIFY_CONTENT) {\n        if (base && val === 'center') continue;\n        return false;\n      }\n      if (prop === POSITION) {\n        if (STATIC_POSITIONS.has(val)) continue;\n        return false;\n      }\n      if (prop === TRANSFORM) {\n        if (val === 'none') continue;\n        return false;\n      }\n      if (isInherited(decl, norm)) continue; // folded onto the child by foldInheritedStyles\n      if (childReproduces(childComputed, ck, prop, val)) continue;\n      return false; // some other own style would be dropped\n    }\n  }\n  return true;\n}\n\n/** True when `wrapper` has exactly ONE element child and no other RENDERED content (rule 4). */\nfunction wrapperCentersSingleElement(before: IRDocument, wrapper: IRElement): boolean {\n  let elements = 0;\n  for (const cid of wrapper.children) {\n    const n = before.nodes.get(cid);\n    if (!n) continue;\n    if (n.kind === 'element') {\n      elements += 1;\n      continue;\n    }\n    if (n.kind === 'comment') continue; // comments paint nothing and are not flex/grid items\n    if (n.kind === 'text' && n.value.trim() === '') continue; // collapsible whitespace ⇒ no item\n    return false; // real text / an `{expr}` island the wrapper's centering also positions\n  }\n  return elements === 1;\n}\n\n/** True when the child ALREADY carries a non-neutral self-alignment that place-self:center would override (rule 5). */\nfunction childHasSelfAlign(childBefore: StyleMap | null, norm: StyleNormalizer): boolean {\n  if (!childBefore) return false;\n  const sm = norm.normalizeStyleMap(childBefore);\n  for (const block of sm.blocks.values()) {\n    for (const prop of SELF_ALIGN_PROPS) {\n      const d = block.decls.get(prop);\n      if (d && !NEUTRAL_ALIGN.has(String(d.value))) return true;\n    }\n  }\n  return false;\n}\n\n/** True when the rewrite grants the child the `place-self:center` equivalent (rule 2, second half). */\nfunction childGainsPlaceSelfCenter(childAfter: StyleMap): boolean {\n  if (baseValue(childAfter, PLACE_SELF) === 'center') return true;\n  return (\n    baseValue(childAfter, 'align-self' as CssProperty) === 'center' &&\n    baseValue(childAfter, 'justify-self' as CssProperty) === 'center'\n  );\n}\n\n/**\n * The provably-sound override for the ubiquitous centering wrapper. Flattening\n *\n *   <P grid><W flex/grid items-center justify-center><C/></W></P>  →  <P grid><C place-self:center/></P>\n *\n * is render-identical ONLY when ALL hold (each proven statically from the before-tree):\n *   1. Parent P establishes a GRID formatting context that lets the wrapper fill its area — so the\n *      child's new `justify-self:center` (ignored under flex/block) is honored. ({@link parentIsFillingGrid})\n *   2. Wrapper W centers a single child on both axes (`display:flex|grid` + `align-items:center` +\n *      `justify-content:center`) and the child gains the equivalent `place-self:center`.\n *   3. W has no OTHER non-inherited box style whose removal would drop or shift anything.\n *      ({@link wrapperHasOnlyCenteringStyle})\n *   4. W has exactly one ELEMENT child and no other rendered content. ({@link wrapperCentersSingleElement})\n *   5. C does not already carry a conflicting `place-self`/`align-self`/`justify-self`. ({@link childHasSelfAlign})\n *\n * Any failure → false → the wrapper is preserved (the conservative default). Works identically for the\n * HTML and JSX pipelines: the parent display is read from the before-tree's resolved computed styles.\n */\nfunction isContextCompensatedCentering(\n  before: IRDocument,\n  wrapper: IRElement,\n  wrapperComputed: StyleMap,\n  childBefore: StyleMap | null,\n  childAfter: StyleMap | null,\n  norm: StyleNormalizer,\n): boolean {\n  if (!childAfter) return false;\n  // (2) wrapper centering signature (base condition) + the child actually gains place-self:center.\n  if (!CENTERING_DISPLAYS.has(baseValue(wrapperComputed, DISPLAY) ?? '')) return false;\n  if (baseValue(wrapperComputed, ALIGN_ITEMS) !== 'center') return false;\n  if (baseValue(wrapperComputed, JUSTIFY_CONTENT) !== 'center') return false;\n  const childAfterNorm = norm.normalizeStyleMap(childAfter);\n  if (!childGainsPlaceSelfCenter(childAfterNorm)) return false;\n  // (3) nothing else on the wrapper is dropped.\n  if (!wrapperHasOnlyCenteringStyle(wrapperComputed, childAfterNorm, norm)) return false;\n  // (4) exactly one element child, nothing else the wrapper positions.\n  if (!wrapperCentersSingleElement(before, wrapper)) return false;\n  // (5) the child has no pre-existing self-alignment place-self:center would override.\n  if (childHasSelfAlign(childBefore, norm)) return false;\n  // (1) the new parent is a statically-known grid that lets the wrapper fill its area.\n  return parentIsFillingGrid(before, wrapper, norm);\n}\n\n/** Self-alignment properties whose effect depends on the parent being a flex/grid container. */\nconst SELF_ALIGN_PROPS: readonly CssProperty[] = [\n  'place-self' as CssProperty,\n  'align-self' as CssProperty,\n  'justify-self' as CssProperty,\n];\n/** Self-alignment values that are no-ops (so adding them assumes nothing about the parent). */\nconst NEUTRAL_ALIGN: ReadonlySet<string> = new Set(['auto', 'normal', 'auto auto', '']);\n/** Parent displays under which `place-self`/`*-self` centering actually takes effect. */\nconst FLEX_GRID_DISPLAYS: ReadonlySet<string> = new Set(['flex', 'inline-flex', 'grid', 'inline-grid']);\n\n/**\n * True when the wrapper establishes a box/formatting/stacking context that positions or sizes its\n * children — so removing its box could move/resize the surviving child. Derived from the COMPUTED\n * style (the frontend leaves the `meta.establishes*` flags unset for class-resolved styles), exactly\n * how `hasOwnVisualStyle` reasons over the computed map.\n */\nfunction establishesChildContext(sm: StyleMap): boolean {\n  for (const block of sm.blocks.values()) {\n    const display = block.decls.get(DISPLAY);\n    if (display && !CONTEXT_SAFE_DISPLAYS.has(String(display.value))) return true;\n    const position = block.decls.get(POSITION);\n    if (position && !STATIC_POSITIONS.has(String(position.value))) return true;\n    const transform = block.decls.get(TRANSFORM);\n    if (transform && String(transform.value) !== 'none') return true;\n  }\n  return false;\n}\n\n/* ───────────────────────── declaration reasoning ───────────────────────── */\n\nfunction isInherited(decl: StyleDecl, norm: StyleNormalizer): boolean {\n  if (decl.inherited) return true;\n  try {\n    return norm.inherited.isInherited(decl.property);\n  } catch {\n    return false;\n  }\n}\n\n/** True when the child reproduces this exact declaration (same property + value) in the same condition. */\nfunction childReproduces(\n  childComputed: StyleMap | null,\n  conditionK: string,\n  prop: CssProperty,\n  value: string,\n): boolean {\n  if (!childComputed) return false;\n  const block = childComputed.blocks.get(conditionK as never);\n  if (!block) return false;\n  const d = block.decls.get(prop);\n  return d != null && String(d.value) === value;\n}\n\n/**\n * True when the wrapper carries a non-inherited declaration that is NOT reproduced on the surviving\n * child — i.e. flattening would DROP a renderable style. `display`/`position`/`transform` are skipped\n * because {@link establishesChildContext} already governs them (and when it passed they are no-ops).\n */\nfunction dropsOwnStyle(\n  wrapperComputed: StyleMap,\n  childComputed: StyleMap | null,\n  norm: StyleNormalizer,\n): boolean {\n  for (const block of wrapperComputed.blocks.values()) {\n    const ck = conditionKey(block.condition);\n    for (const [prop, decl] of block.decls) {\n      if (prop === DISPLAY || prop === POSITION || prop === TRANSFORM) continue;\n      if (isInherited(decl, norm)) continue; // folded onto the child by foldInheritedStyles\n      if (!childReproduces(childComputed, ck, prop, String(decl.value))) return true;\n    }\n  }\n  return false;\n}\n\n/* ───────────────────────── parent-context reasoning ───────────────────────── */\n\n/** The element's base-condition `display` value (normalized), or '' when unset/not an element. */\nfunction displayOf(el: IRElement | undefined, norm: StyleNormalizer): string {\n  if (!el) return '';\n  for (const block of norm.normalizeStyleMap(el.computed).blocks.values()) {\n    if (block.condition.media === '' && block.condition.states.length === 0 && block.condition.pseudoElement === '') {\n      const d = block.decls.get(DISPLAY);\n      if (d) return String(d.value);\n    }\n  }\n  return '';\n}\n\n/** True when unwrapping `wrapper` reparents the child UNDER a flex/grid container in the before-tree. */\nfunction newParentIsFlexOrGrid(before: IRDocument, wrapper: IRElement, norm: StyleNormalizer): boolean {\n  if (wrapper.parent == null) return false;\n  const p = before.nodes.get(wrapper.parent);\n  if (!p || p.kind !== 'element') return false;\n  return FLEX_GRID_DISPLAYS.has(displayOf(p, norm));\n}\n\n/**\n * True when the rewrite GRANTS the child a parent-context-dependent self-alignment (place-self /\n * align-self / justify-self with a non-neutral value) that was not already on it — centering that only\n * holds if the new parent is flex/grid.\n */\nfunction addsParentContextStyle(\n  childBefore: StyleMap | null,\n  childAfter: StyleMap | null,\n  norm: StyleNormalizer,\n): boolean {\n  if (!childAfter) return false;\n  const before = childBefore ? norm.normalizeStyleMap(childBefore) : null;\n  const after = norm.normalizeStyleMap(childAfter);\n  for (const block of after.blocks.values()) {\n    const ck = conditionKey(block.condition);\n    for (const prop of SELF_ALIGN_PROPS) {\n      const d = block.decls.get(prop);\n      if (!d || NEUTRAL_ALIGN.has(String(d.value))) continue;\n      const prev = before?.blocks.get(ck as never)?.decls.get(prop);\n      if (!prev || String(prev.value) !== String(d.value)) return true;\n    }\n  }\n  return false;\n}\n\n/* ───────────────────────── op-group anchors ───────────────────────── */\n\n/** The wrapper the group unwraps (the structural removal), or null when the group removes no box. */\nfunction unwrapTargetOf(ops: readonly RewriteOp[]): IRNodeId | null {\n  for (const op of ops) if (op.op === 'unwrap') return op.target;\n  return null;\n}\n\n/** The surviving child styles fold onto: the mergeStyle/fold target, else the wrapper's sole element child. */\nfunction survivingChildOf(ops: readonly RewriteOp[], wrapper: IRElement, before: IRDocument): IRNodeId | null {\n  for (const op of ops) if (op.op === 'mergeStyle') return op.target;\n  for (const op of ops) if (op.op === 'foldInheritedStyles' && op.into.length > 0) return op.into[0]!;\n  for (const c of wrapper.children) {\n    const n = before.nodes.get(c);\n    if (n && n.kind === 'element') return c;\n  }\n  return null;\n}\n\n/* ───────────────────────── the classifier ───────────────────────── */\n\n/**\n * Statically classify one applied flatten op-group. `before` is the doc as it was BEFORE the group's\n * ops; `after` is the result of applying them.\n *\n * A group that unwraps no element box (e.g. {@link redundant-fragment}, or a style-only flatten) is\n * `provably-safe` — there is no box whose removal could move/resize anything. Otherwise the three\n * criteria above decide.\n */\nexport function classifyFlattenOps(\n  before: IRDocument,\n  after: IRDocument,\n  ops: readonly RewriteOp[],\n  norm: StyleNormalizer,\n): FlattenClassification {\n  const wrapperId = unwrapTargetOf(ops);\n  if (wrapperId == null) return { kind: 'provably-safe', wrapperId: null, childId: null };\n\n  const wrapper = before.nodes.get(wrapperId);\n  // A fragment carries no box and no computed style — unwrapping it is always layout-identical.\n  if (!wrapper || wrapper.kind !== 'element') {\n    return { kind: 'provably-safe', wrapperId: null, childId: null };\n  }\n\n  // SAFETY (Layer 2, backstop): if ANY of the wrapper's own class tokens was UNRESOLVED, its true\n  // style is UNKNOWN — `wrapper.computed` is only the resolved subset, so the static \"inert\" reasoning\n  // below (which sees an empty/partial map) could wrongly clear it. Never treat such a wrapper as\n  // provably safe to unwrap. Under the default `'provably-safe'` gate this reverts (preserves) the\n  // flatten; the match-time `hasOwnVisualStyle` gate already blocks the paintsNothing patterns, so this\n  // catches a positive-computed flatten (e.g. nested-flex-merge) that also carries an unknown token.\n  if (wrapper.meta.hasUnresolvedClasses) {\n    return { kind: 'needs-verification', wrapperId, childId: survivingChildOf(ops, wrapper, before) };\n  }\n\n  const childId = survivingChildOf(ops, wrapper, before);\n  const wrapperComputed = norm.normalizeStyleMap(wrapper.computed);\n  const childAfter = childId != null ? getElement(after, childId)?.computed ?? null : null;\n  const childBefore = childId != null ? getElement(before, childId)?.computed ?? null : null;\n\n  // (OVERRIDE) A flex/grid centering wrapper establishes a formatting context — so (A) below would\n  // reject it — YET collapsing it to `place-self:center` on the sole child is provably layout-neutral\n  // when the child's NEW parent is a statically-known grid that lets the wrapper fill its area (and the\n  // wrapper carries nothing else). This is the ONE context-compensated case; verified render-identical\n  // in Chromium. Everything that fails any rule falls through to the conservative criteria below.\n  if (isContextCompensatedCentering(before, wrapper, wrapperComputed, childBefore, childAfter, norm)) {\n    return { kind: 'provably-safe', wrapperId, childId };\n  }\n\n  // (A) wrapper positions/sizes its children → removing its box can move/resize them.\n  if (establishesChildContext(wrapperComputed)) {\n    return { kind: 'needs-verification', wrapperId, childId };\n  }\n  // (B) wrapper drops a non-inherited own style the child does not reproduce.\n  if (dropsOwnStyle(wrapperComputed, childAfter ? norm.normalizeStyleMap(childAfter) : null, norm)) {\n    return { kind: 'needs-verification', wrapperId, childId };\n  }\n  // (C) rewrite adds parent-context-dependent centering, but the new parent is not statically flex/grid.\n  if (addsParentContextStyle(childBefore, childAfter, norm) && !newParentIsFlexOrGrid(before, wrapper, norm)) {\n    return { kind: 'needs-verification', wrapperId, childId };\n  }\n\n  return { kind: 'provably-safe', wrapperId, childId };\n}\n","/**\n * @domflax/core — pass manager (the sync, static flatten driver).\n *\n * Runs {@link Pattern}s grouped by {@link PassPhase} in declared order, driving the `flatten` phase to\n * a fixpoint under a max-iteration budget, isolating per-node pattern errors into {@link Diagnostic}s\n * (a thrown pattern never aborts the run — it becomes `DF_PATTERN_THREW`), and applying the static\n * flatten policy ({@link ApplyContext.gate}) — under `'provably-safe'` only provably layout-neutral\n * flattens commit, so the transform never changes rendering and never launches a browser.\n *\n * The supporting contexts (resolvers, selector index, rewrite factory, match context) live in\n * `./pass-context`; the static flatten classifier in `./flatten-safety`. Dependency-free: only the\n * `./types` contract + sibling runtime helpers.\n */\n\nimport type {\n  ApplyContext,\n  Diagnostic,\n  FixpointConfig,\n  HaltReason,\n  IRDocument,\n  IRNodeId,\n  Pass,\n  PassManager,\n  PassPhase,\n  Pattern,\n  PhaseRunResult,\n  RewriteFactory,\n  RewriteOp,\n  RewriteOpDraft,\n  StyleMap,\n  StyleNormalizer,\n  StyleResolver,\n  SyntheticSink,\n  EmitContext,\n} from './types';\n\nimport { childIds, elementIds, getElement } from './builders';\nimport { applyOps } from './ops';\nimport { buildMatchContext, createRewriteFactory } from './pass-context';\nimport { classifyFlattenOps } from './flatten-safety';\n\n// Re-export the supporting contexts so `@domflax/core` consumers keep importing them from here / the\n// barrel exactly as before this module was split.\nexport {\n  buildMatchContext,\n  buildSelectorIndex,\n  createNullResolver,\n  createNullSelectorIndex,\n  createRewriteFactory,\n} from './pass-context';\n\n/* ───────────────────────── defaults ───────────────────────── */\n\nexport const DEFAULT_FIXPOINT: FixpointConfig = {\n  maxIterations: 16,\n  phases: { flatten: 16, compress: 8, extract: 4 },\n  onBudgetExhausted: 'warn',\n  detectOscillation: true,\n};\n\nexport const PHASE_ORDER: readonly PassPhase[] = ['flatten', 'compress', 'extract'];\n\n/* ───────────────────────── op stamping + phase grouping ───────────────────────── */\n\nexport function stampOrigin(draft: RewriteOpDraft, pattern: Pattern): RewriteOp {\n  return {\n    ...draft,\n    origin: { pattern: pattern.name, category: pattern.category, safety: pattern.safety },\n  } as RewriteOp;\n}\n\nexport function patternsForPhase(passes: readonly Pass[], phase: PassPhase): Pattern[] {\n  const out: Pattern[] = [];\n  for (const pass of passes) {\n    if (pass.phase !== phase) continue;\n    for (const p of pass.patterns) out.push(p);\n  }\n  out.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));\n  return out;\n}\n\nexport interface RunState {\n  doc: IRDocument;\n}\n\n/* ───────────────────────── flatten residual-skip (never drop an unreproducible style) ───────────────────────── */\n\n/** A throwaway {@link SyntheticSink} for the emit exactness probe (registrations are discarded). */\nfunction probeSink(): SyntheticSink {\n  return {\n    register(s): string {\n      return s.className;\n    },\n    drain(): readonly never[] {\n      return [];\n    },\n  };\n}\n\n/** Nodes a group writes STYLE onto (the survivors a flatten transfers declarations to). */\nfunction styleWriteTargets(ops: readonly RewriteOp[]): IRNodeId[] {\n  const ids: IRNodeId[] = [];\n  for (const op of ops) {\n    if (op.op === 'mergeStyle' || op.op === 'setClassList') ids.push(op.target);\n    else if (op.op === 'foldInheritedStyles') ids.push(...op.into);\n  }\n  return ids;\n}\n\n/** True iff the resolver can EXACTLY reverse-emit `sm` (no residual). An empty map is trivially exact. */\nfunction emitIsExact(resolver: StyleResolver, normalizer: StyleNormalizer, sm: StyleMap): boolean {\n  if (sm.blocks.size === 0) return true;\n  try {\n    const ctx: EmitContext = { normalizer, sink: probeSink() };\n    const r = resolver.emit(sm, ctx);\n    return r.exact && r.residual == null;\n  } catch {\n    return true; // a throwing resolver must never block a flatten\n  }\n}\n\n/**\n * T5 — flatten must never DROP a style it can't reproduce. After a flatten transfers declarations onto\n * a surviving (rewritable) element, if the resolver can no longer EXACTLY reverse-emit that element's\n * computed style — and it could before — the flatten would silently lose the residual declarations\n * during reverse-emit, so the whole flatten is reverted (the wrapper is kept). Pre-existing residue\n * (already non-exact before the flatten) is not blamed on the flatten and does not trigger a revert.\n */\nexport function flattenWouldDropStyle(\n  before: IRDocument,\n  after: IRDocument,\n  ops: readonly RewriteOp[],\n  resolver: StyleResolver,\n  normalizer: StyleNormalizer,\n): boolean {\n  for (const id of styleWriteTargets(ops)) {\n    const newEl = getElement(after, id);\n    if (!newEl) continue; // target was itself removed — its style lives on the survivor we also check\n    // Opaque / dynamic class lists are kept verbatim by reverse-emit, so no style is dropped there.\n    if (newEl.classes.opaque || newEl.classes.hasDynamic) continue;\n    if (emitIsExact(resolver, normalizer, newEl.computed)) continue;\n    const oldEl = getElement(before, id);\n    const wasExact = !oldEl || emitIsExact(resolver, normalizer, oldEl.computed);\n    if (wasExact) return true; // the flatten introduced an unreproducible style → revert\n  }\n  return false;\n}\n\n/* ───────────────────────── flatten gate decision (shared sync core) ───────────────────────── */\n\nexport type FlattenVerdict = 'commit' | 'revert';\n\n/**\n * Decide what to do with a freshly-applied flatten op-group, given the gate. Returns:\n *   • `'commit'` — keep the outcome (the historical path for `'all'`, and provably-safe flattens).\n *   • `'revert'` — discard + bar the node (residual-drop, or a needs-verification flatten under the\n *                  `'provably-safe'` gate).\n *\n * `before`/`after` are the docs immediately around the group's application.\n */\nexport function flattenVerdict(\n  before: IRDocument,\n  after: IRDocument,\n  ops: readonly RewriteOp[],\n  ctx: ApplyContext,\n): FlattenVerdict {\n  // T5 (independent of the gate): a flatten must never drop a style the resolver can't re-emit.\n  if (flattenWouldDropStyle(before, after, ops, ctx.resolver, ctx.normalizer)) return 'revert';\n\n  const gate = ctx.gate ?? 'all';\n  if (gate === 'all') return 'commit';\n\n  const cls = classifyFlattenOps(before, after, ops, ctx.normalizer);\n  return cls.kind === 'provably-safe' ? 'commit' : 'revert';\n}\n\n/* ───────────────────────── per-element pattern evaluation (shared) ───────────────────────── */\n\n/**\n * Evaluate every pattern against `elId` until one produces ops; returns the stamped op list (and its\n * pattern), or null when no pattern matched. Pattern throws become `DF_PATTERN_THREW` diagnostics.\n */\nexport function evaluateElement(\n  doc: IRDocument,\n  elId: IRNodeId,\n  patterns: readonly Pattern[],\n  ctx: ApplyContext,\n  factory: RewriteFactory,\n  phase: PassPhase,\n  iteration: number,\n  diagnostics: Diagnostic[],\n): { ops: RewriteOp[]; pattern: Pattern } | null {\n  for (const pattern of patterns) {\n    if (pattern.safety > ctx.safetyCeiling) continue;\n    let drafts: readonly RewriteOpDraft[] = [];\n    try {\n      const mctx = buildMatchContext(doc, elId, ctx.resolver, ctx.selectors, ctx.safetyCeiling, phase, iteration);\n      const result = pattern.evaluate(mctx, factory);\n      if (!result) continue;\n      drafts = result.ops;\n      if (result.diagnostics) for (const d of result.diagnostics) diagnostics.push(d);\n    } catch (err) {\n      diagnostics.push({\n        code: 'DF_PATTERN_THREW',\n        severity: 'error',\n        message: `pattern '${pattern.name}' threw: ${String((err as Error)?.message ?? err)}`,\n        nodeId: elId,\n        pattern: pattern.name,\n        phase,\n        iteration,\n        cause: err,\n      });\n      continue;\n    }\n    if (drafts.length === 0) continue;\n    return { ops: drafts.map((d) => stampOrigin(d, pattern)), pattern };\n  }\n  return null;\n}\n\n/** Emit the diagnostic recorded when a flatten is reverted by the gate / residual guard. */\nexport function revertDiagnostic(\n  pattern: Pattern,\n  elId: IRNodeId,\n  phase: PassPhase,\n  iteration: number,\n  resolverId: string,\n): Diagnostic {\n  return {\n    code: 'DF_VERIFY_REVERTED',\n    severity: 'warn',\n    message:\n      `flatten '${pattern.name}' reverted on node ${elId}: it would change rendering (drops a style, ` +\n      `establishes layout context, or assumes a parent context) and was not proven safe by resolver ` +\n      `'${resolverId}'`,\n    nodeId: elId,\n    pattern: pattern.name,\n    phase,\n    iteration,\n  };\n}\n\n/* ───────────────────────── one sweep (sync) ───────────────────────── */\n\n/**\n * One sweep of a phase: evaluate every pattern against every live element, collect op drafts, stamp\n * origin, apply, then commit/revert per {@link flattenVerdict}. Returns the number of ops applied\n * (0 ⇒ fixpoint for this phase). Under the `'provably-safe'` gate, any flatten that is not provably\n * safe is reverted — the transform is fully static and never changes rendering.\n */\nfunction runSweep(\n  state: RunState,\n  patterns: readonly Pattern[],\n  ctx: ApplyContext,\n  factory: RewriteFactory,\n  phase: PassPhase,\n  iteration: number,\n  touched: Set<IRNodeId>,\n  diagnostics: Diagnostic[],\n  flattenBarred: Set<IRNodeId>,\n): number {\n  let appliedOps = 0;\n\n  for (const elId of elementIds(state.doc)) {\n    const el = getElement(state.doc, elId);\n    if (!el) continue; // removed earlier in this sweep\n    if (phase === 'flatten' && flattenBarred.has(elId)) continue;\n\n    const evaluated = evaluateElement(state.doc, elId, patterns, ctx, factory, phase, iteration, diagnostics);\n    if (!evaluated) continue;\n    const { ops, pattern } = evaluated;\n\n    const outcome = applyOps(state.doc, ops, ctx);\n    for (const d of outcome.result.diagnostics) diagnostics.push(d);\n    if (outcome.result.appliedGroups === 0) continue;\n\n    if (phase === 'flatten') {\n      const verdict = flattenVerdict(state.doc, outcome.doc, ops, ctx);\n      if (verdict !== 'commit') {\n        // Discard the outcome (keep the wrapper) AND bar this node from any further flatten this run.\n        diagnostics.push(revertDiagnostic(pattern, elId, phase, iteration, ctx.resolver.id));\n        flattenBarred.add(elId);\n        continue;\n      }\n    }\n\n    state.doc = outcome.doc;\n    appliedOps += outcome.result.appliedGroups;\n    for (const id of outcome.result.touched) touched.add(id);\n    for (const id of outcome.result.created) touched.add(id);\n  }\n  return appliedOps;\n}\n\n/* ───────────────────────── oscillation fingerprint ───────────────────────── */\n\n/** Cheap structural fingerprint of the document for oscillation detection. */\nexport function docFingerprint(doc: IRDocument): string {\n  const parts: string[] = [];\n  const visit = (id: IRNodeId): void => {\n    const n = doc.nodes.get(id);\n    if (!n) return;\n    parts.push(`${id}:${n.kind}`);\n    for (const c of childIds(n)) visit(c);\n  };\n  visit(doc.root);\n  return parts.join('|');\n}\n\n/* ───────────────────────── the fixpoint driver (sync) ───────────────────────── */\n\n/** A single phase's terminal result, built from the loop's accounting. */\nexport interface PhaseLoopState {\n  iterations: number;\n  converged: boolean;\n  haltReason: HaltReason;\n  readonly touched: Set<IRNodeId>;\n  readonly diagnostics: Diagnostic[];\n  readonly seen: Set<string>;\n}\n\n/** Record the budget-exhausted diagnostic + finalize a phase result. Shared by sync + async drivers. */\nexport function finalizePhase(\n  phase: PassPhase,\n  s: PhaseLoopState,\n  budget: number,\n  onBudgetExhausted: 'warn' | 'error',\n): PhaseRunResult {\n  if (!s.converged && s.haltReason !== 'oscillation') {\n    s.haltReason = 'budget';\n    s.diagnostics.push({\n      code: 'DF_FIXPOINT_BUDGET',\n      severity: onBudgetExhausted === 'error' ? 'error' : 'warn',\n      message: `phase '${phase}' exhausted ${budget}-iteration budget`,\n      phase,\n      iteration: s.iterations,\n    });\n  }\n  return {\n    phase,\n    iterations: s.iterations,\n    converged: s.converged,\n    haltReason: s.haltReason,\n    touched: s.touched,\n    diagnostics: s.diagnostics,\n  };\n}\n\n/**\n * Runs `passes` over `doc` to a per-phase fixpoint (synchronous). This is the concrete entry the\n * pipeline calls. Under the `'provably-safe'` gate, flattens that are not provably layout-neutral are\n * reverted — the transform is fully static and never changes rendering.\n */\nexport function runPasses(\n  doc: IRDocument,\n  passes: readonly Pass[],\n  ctx: ApplyContext,\n  config?: FixpointConfig,\n): { readonly doc: IRDocument; readonly results: readonly PhaseRunResult[] } {\n  const cfg: FixpointConfig = { ...DEFAULT_FIXPOINT, ...config };\n  const factory = createRewriteFactory();\n  const state: RunState = { doc };\n  const results: PhaseRunResult[] = [];\n  // Nodes barred from flattening after a revert — persists across sweeps/phases.\n  const flattenBarred = new Set<IRNodeId>();\n\n  for (const phase of PHASE_ORDER) {\n    const patterns = patternsForPhase(passes, phase);\n    const budget = cfg.phases[phase] ?? cfg.maxIterations;\n    const s: PhaseLoopState = {\n      iterations: 0,\n      converged: false,\n      haltReason: 'converged',\n      touched: new Set(),\n      diagnostics: [],\n      seen: new Set(),\n    };\n\n    if (patterns.length === 0) {\n      s.converged = true;\n      results.push(finalizePhase(phase, s, budget, cfg.onBudgetExhausted));\n      continue;\n    }\n\n    while (s.iterations < budget) {\n      s.iterations += 1;\n      const applied = runSweep(\n        state,\n        patterns,\n        ctx,\n        factory,\n        phase,\n        s.iterations,\n        s.touched,\n        s.diagnostics,\n        flattenBarred,\n      );\n\n      if (applied === 0) {\n        s.converged = true;\n        break;\n      }\n\n      if (cfg.detectOscillation) {\n        const fp = docFingerprint(state.doc);\n        if (s.seen.has(fp)) {\n          s.haltReason = 'oscillation';\n          s.diagnostics.push({\n            code: 'DF_FIXPOINT_OSCILLATION',\n            severity: 'warn',\n            message: `phase '${phase}' oscillated; halting`,\n            phase,\n            iteration: s.iterations,\n          });\n          break;\n        }\n        s.seen.add(fp);\n      }\n    }\n\n    results.push(finalizePhase(phase, s, budget, cfg.onBudgetExhausted));\n  }\n\n  return { doc: state.doc, results };\n}\n\n/** A {@link PassManager} that runs the given passes (carried on the manager instance). */\nexport function createPassManager(passes: readonly Pass[]): PassManager {\n  return {\n    run(doc: IRDocument, ctx: ApplyContext, config?: FixpointConfig): readonly PhaseRunResult[] {\n      return runPasses(doc, passes, ctx, config).results;\n    },\n  };\n}\n","/**\n * @domflax/core — the pure, single-file pipeline.\n *\n * Wires injected interfaces together: {@link Frontend} → resolve → {@link PassManager} →\n * {@link Backend}. Core itself stays dependency-free; the resolver, frontend, and backend are all\n * supplied by the caller, so no heavy third-party libs ever reach this package.\n */\n\nimport type {\n  ApplyContext,\n  Backend,\n  BackendContext,\n  CodegenResult,\n  Diagnostic,\n  EditPlan,\n  Frontend,\n  FrontendParseContext,\n  IRDocument,\n  IRElement,\n  PassPhase,\n  Pipeline,\n  PipelineInput,\n  PipelineOutput,\n  PipelineStats,\n  SourceSpan,\n  StyleMap,\n  SyntheticClass,\n  SyntheticSink,\n} from './types';\n\nimport { elementIds, getElement } from './builders';\nimport { createNullSelectorIndex, runPasses } from './pass-manager';\n\n/* ───────────────────────── synthetic sink ───────────────────────── */\n\n/** A minimal in-memory {@link SyntheticSink}: dedupes by className, drains in insertion order. */\nexport function createSyntheticSink(): SyntheticSink {\n  const map = new Map<string, SyntheticClass>();\n  return {\n    register(s: SyntheticClass): string {\n      if (!map.has(s.className)) map.set(s.className, s);\n      return s.className;\n    },\n    drain(): readonly SyntheticClass[] {\n      return [...map.values()];\n    },\n  };\n}\n\n/* ───────────────────────── resolve step ───────────────────────── */\n\nfunction staticClassTokens(el: IRElement): string[] {\n  const out: string[] = [];\n  for (const seg of el.classes.segments) {\n    if (seg.kind === 'static') for (const t of seg.tokens) out.push(t.value);\n  }\n  return out;\n}\n\n/**\n * Populate each element's `computed` StyleMap from its author classes via the injected resolver.\n * Opaque/spread elements and elements without static classes are left untouched. Resolver throws\n * are isolated into diagnostics (a stub resolver may legitimately be NotImplemented).\n */\nfunction resolveStyles(\n  doc: IRDocument,\n  input: PipelineInput,\n  diagnostics: Diagnostic[],\n): void {\n  const { resolver, normalizer } = input;\n  for (const id of elementIds(doc)) {\n    const el = getElement(doc, id);\n    if (!el || el.classes.opaque) continue;\n    const tokens = staticClassTokens(el);\n    if (tokens.length === 0) continue;\n    try {\n      const result = resolver.resolve({\n        classes: tokens,\n        element: {\n          tagName: el.tag,\n          namespace: el.namespace === 'svg' ? 'svg' : 'html',\n        },\n      });\n      let styles: StyleMap = result.styles;\n      try {\n        styles = normalizer.normalizeStyleMap(styles);\n      } catch {\n        /* normalizer is optional/stubbed — keep raw styles */\n      }\n      el.computed = styles;\n      for (const w of result.warnings) {\n        diagnostics.push({\n          code: 'DF_STYLE_CONFLICT_UNRESOLVED',\n          severity: w.severity,\n          message: w.message,\n          nodeId: id,\n        });\n      }\n    } catch (err) {\n      diagnostics.push({\n        code: 'DF_OP_PRECONDITION_FAILED',\n        severity: 'debug',\n        message: `resolve skipped for <${el.tag}>: ${String((err as Error)?.message ?? err)}`,\n        nodeId: id,\n        cause: err,\n      });\n    }\n  }\n}\n\n/* ───────────────────────── the pipeline ───────────────────────── */\n\nconst ZERO_ITERATIONS: Readonly<Record<PassPhase, number>> = {\n  flatten: 0,\n  compress: 0,\n  extract: 0,\n};\n\nclass DefaultPipeline implements Pipeline {\n  run(input: PipelineInput): PipelineOutput {\n    const startedAt = now();\n    const diagnostics: Diagnostic[] = [];\n    const report = (d: Diagnostic): void => {\n      diagnostics.push(d);\n      input.reporter?.report(d);\n    };\n\n    // 1. PARSE ────────────────────────────────────────────────────────────\n    const parseCtx: FrontendParseContext = {\n      id: input.id,\n      kind: input.kind,\n      resolver: input.resolver,\n      normalizer: input.normalizer,\n      config: { preserveComments: input.config?.preserveComments ?? true },\n      onDiagnostic: report,\n    };\n    if (input.babelAst !== undefined) parseCtx.babelAst = input.babelAst;\n\n    const parsed = input.frontend.parse(input.code, parseCtx);\n    for (const d of parsed.diagnostics) report(d);\n    const doc = parsed.doc;\n    const nodesIn = doc.nodes.size;\n\n    // 2. RESOLVE ──────────────────────────────────────────────────────────\n    resolveStyles(doc, input, diagnostics);\n\n    // 3. PASSES (fixpoint per phase) ──────────────────────────────────────\n    const ctx: ApplyContext = {\n      doc,\n      safetyCeiling: input.config?.safety ?? 2,\n      normalizer: input.normalizer,\n      selectors: createNullSelectorIndex(),\n      resolver: input.resolver,\n    };\n    const { doc: optimized, results } = runPasses(doc, input.passes, ctx, fixpointFrom(input));\n\n    let opsApplied = 0;\n    const iterations: Record<PassPhase, number> = { ...ZERO_ITERATIONS };\n    for (const r of results) {\n      iterations[r.phase] = r.iterations;\n      for (const d of r.diagnostics) {\n        diagnostics.push(d);\n        input.reporter?.report(d);\n      }\n      opsApplied += r.touched.size;\n    }\n\n    // 4. PRINT ────────────────────────────────────────────────────────────\n    const editPlan: EditPlan = {\n      moduleId: input.id,\n      ops: [],\n      provenance: new Map(),\n    };\n    const backendCtx: BackendContext = {\n      normalizer: input.normalizer,\n      resolver: input.resolver,\n      sink: createSyntheticSink(),\n      eol: eolOf(optimized),\n      onDiagnostic: report,\n    };\n    const printed: CodegenResult = input.backend.print(optimized, editPlan, backendCtx);\n    for (const d of printed.diagnostics) {\n      diagnostics.push(d);\n      input.reporter?.report(d);\n    }\n\n    // 5. ASSEMBLE OUTPUT ──────────────────────────────────────────────────\n    const stats: PipelineStats = {\n      nodesIn,\n      nodesOut: optimized.nodes.size,\n      opsApplied,\n      iterations,\n      durationMs: now() - startedAt,\n    };\n    const touched: readonly SourceSpan[] = printed.edits.map((e) => e.span);\n\n    return {\n      code: printed.code,\n      map: printed.map,\n      changed: printed.code !== input.code,\n      touched,\n      diagnostics,\n      stats,\n      doc: optimized,\n      editPlan,\n    };\n  }\n}\n\nfunction fixpointFrom(input: PipelineInput): import('./types').FixpointConfig | undefined {\n  const fp = input.config?.fixpoint;\n  if (!fp) return undefined;\n  return {\n    maxIterations: fp.maxIterations ?? 16,\n    phases: fp.phases ?? {},\n    onBudgetExhausted: fp.onBudgetExhausted ?? 'warn',\n    detectOscillation: fp.detectOscillation ?? true,\n  };\n}\n\nfunction eolOf(doc: IRDocument): '\\n' | '\\r\\n' {\n  for (const src of doc.sources.values()) return src.eol;\n  return '\\n';\n}\n\n// `performance` is a host global (node20 / browser) not covered by the ES2023 lib;\n// declared minimally so the runtime feature-detection below stays type-safe.\ndeclare const performance: { now(): number } | undefined;\n\nfunction now(): number {\n  return typeof performance !== 'undefined' && typeof performance.now === 'function'\n    ? performance.now()\n    : Date.now();\n}\n\n/** Build the pure single-file {@link Pipeline}. */\nexport function createPipeline(): Pipeline {\n  return new DefaultPipeline();\n}\n","/**\r\n * @domflax/core — the shared reverse-emit step (computed → className).\r\n *\r\n * The backend re-prints `className` from each element's {@link ClassList}, but the pass manager\r\n * records optimized styles on `computed`. This module folds those optimized computed styles back\r\n * into the element's static class tokens, and is the SINGLE source of truth shared by every\r\n * orchestrator (the `domflax` meta package, `@domflax/cli`, and the pattern auto-test harness) so\r\n * their pipelines cannot diverge.\r\n *\r\n * ## Only STYLE-DIRTY elements are re-emitted (never inflate a bystander)\r\n *\r\n * Reverse-emit runs ONLY on elements a pass actually rewrote the computed style of — `meta.styleDirty`\r\n * (a `setClassList`, a `mergeStyle` onto it, or an inherited fold into it). An element that was merely\r\n * `touched` as a STRUCTURAL BYSTANDER — a child was flattened/unwrapped, a sibling merged/moved, a\r\n * node inserted next to it — never has its own computed changed, so its `class` attribute is left\r\n * BYTE-FOR-BYTE IDENTICAL. This is what stops a real custom-CSS site from INFLATING: an unchanged\r\n * `<div class=\"product-art\">` can no longer gain a redundant `.bg-cream-deep` just because an inert\r\n * child next to it was flattened.\r\n *\r\n * ## REPLACE, not append — with retained-class coverage SUBTRACTED\r\n *\r\n * For every style-dirty, rewritable (non-opaque, non-dynamic) element we ask the resolver for the\r\n * MINIMAL class set reproducing the element's computed style, then REPLACE the element's droppable\r\n * tokens with it — rather than appending. Replacing is what lets a compress pass actually shorten\r\n * output: `px-4 py-4` collapses to `p-4`, equal `w/h` to `size-*`, the four insets to `inset-0`, and\r\n * fully-overridden duplicates simply disappear.\r\n *\r\n * Crucially, before choosing what to emit we SUBTRACT the style already supplied by the element's\r\n * RETAINED (kept, non-droppable) classes: we emit only for the RESIDUAL declarations those classes do\r\n * not already reproduce. So reverse-emit can never materialize a utility for a property a semantic\r\n * class the element keeps already sets (the `.product-art` background is never re-added as\r\n * `.bg-cream-deep`). Output therefore never grows with a class whose contribution is already covered.\r\n *\r\n * ## Droppability gate (never lose a load-bearing class)\r\n *\r\n * A token is only removed when `resolver.selectorUsage(token).droppable` is true — i.e. it is a\r\n * plain, resolver-owned utility whose entire contribution is reproducible from `computed`. Tokens\r\n * that are unknown to the resolver, opaque (combinator/at-rule utilities whose effect never folds\r\n * onto the element's own box), variant-bound, or referenced by a custom-CSS selector are NOT\r\n * droppable and are preserved verbatim. As a safety net, if the residual `emit` produces nothing at\r\n * all we leave the element's tokens untouched (a resolver that failed to load must never erase\r\n * classes).\r\n */\r\n\r\nimport { elementIds, getElement } from './builders';\r\nimport { createSyntheticSink } from './pipeline';\r\nimport type {\r\n  ClassList,\r\n  ClassSegment,\r\n  ClassToken,\r\n  ConditionKey,\r\n  CssProperty,\r\n  EmitContext,\r\n  IRDocument,\r\n  SafetyLevel,\r\n  StyleBlock,\r\n  StyleDecl,\r\n  StyleMap,\r\n  StyleNormalizer,\r\n  StyleResolver,\r\n} from './types';\r\n\r\n/** All static class tokens of a {@link ClassList}, in source order. */\r\nfunction staticTokensOf(cl: ClassList): string[] {\r\n  const out: string[] = [];\r\n  for (const seg of cl.segments) {\r\n    if (seg.kind === 'static') for (const t of seg.tokens) out.push(t.value);\r\n  }\r\n  return out;\r\n}\r\n\r\n/** A rewritable static {@link ClassList} over `tokens`, preserving the previous list's spans. */\r\nfunction staticClassList(prev: ClassList, tokens: readonly string[]): ClassList {\r\n  const classTokens: ClassToken[] = tokens.map((value) => ({ value }));\r\n  const seg: ClassSegment = { kind: 'static', tokens: classTokens };\r\n  return {\r\n    form: 'string-literal',\r\n    segments: [seg],\r\n    valueSpan: prev.valueSpan,\r\n    attrSpan: prev.attrSpan,\r\n    hasDynamic: false,\r\n    opaque: false,\r\n    rewritable: true,\r\n  };\r\n}\r\n\r\n/** Two token lists are equal iff same length and same tokens in the same order. */\r\nfunction sameTokens(a: readonly string[], b: readonly string[]): boolean {\r\n  if (a.length !== b.length) return false;\r\n  for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;\r\n  return true;\r\n}\r\n\r\n/**\r\n * Return the RESIDUAL of `computed` after removing every declaration the element's retained classes\r\n * already reproduce EXACTLY (same value + `!important`, in the same style condition). What's left is\r\n * the set of declarations the emitted classes must actually cover — so reverse-emit never re-adds a\r\n * utility for a property a kept class already supplies. A declaration whose retained-class value\r\n * DIFFERS from the computed one (i.e. the class was overridden) is kept in the residual: the final\r\n * value still has to be emitted by something.\r\n */\r\nfunction residualStyle(computed: StyleMap, covered: StyleMap, norm: StyleNormalizer): StyleMap {\r\n  const cov = norm.normalizeStyleMap(covered);\r\n  const blocks = new Map<ConditionKey, StyleBlock>();\r\n  for (const [key, block] of norm.normalizeStyleMap(computed).blocks) {\r\n    const covBlock = cov.blocks.get(key);\r\n    const decls = new Map<CssProperty, StyleDecl>();\r\n    for (const [prop, decl] of block.decls) {\r\n      const covDecl = covBlock?.decls.get(prop);\r\n      if (covDecl && covDecl.value === decl.value && covDecl.important === decl.important) continue;\r\n      decls.set(prop, decl);\r\n    }\r\n    if (decls.size > 0) blocks.set(key, { condition: block.condition, decls });\r\n  }\r\n  return { blocks };\r\n}\r\n\r\n/** The rendered `class=\"…\"` byte length of a token list (tokens joined by single spaces). */\r\nfunction joinedLength(tokens: readonly string[]): number {\r\n  if (tokens.length === 0) return 0;\r\n  let len = tokens.length - 1; // joining spaces\r\n  for (const t of tokens) len += t.length;\r\n  return len;\r\n}\r\n\r\n/** SafetyLevel a `compress/*` rewrite carried — an opaque (floor-0) element is off-limits to it. */\r\nconst COMPRESS_FLOOR: SafetyLevel = 1;\r\n\r\n/**\r\n * Fold each rewritable element's computed style back into the MINIMAL static class-token set — the\r\n * general compress engine (see module docs + {@link import('./compress-engine')}). Mutates `doc`.\r\n *\r\n * TWO kinds of element are processed, and their guarantees differ:\r\n *\r\n *   • STYLE-DIRTY — a pass rewrote this element's own computed style (a flatten fold / merge). Its\r\n *     computed CHANGED, so its classes MUST be re-derived to represent the new style (which may\r\n *     legitimately need MORE tokens than before). Handled exactly as it always was.\r\n *\r\n *   • COMPRESS-ONLY — no pass touched it; we run the exact-cover engine purely to SHORTEN its class\r\n *     string (`px-4 py-4 → p-4`, drop a redundant class, pick a custom class that covers the same\r\n *     style, …). This is a pure class-string rewrite that must NEVER change the render or GROW the\r\n *     output, so it carries two extra hard backstops below: the rewritten set must re-resolve to the\r\n *     element's exact computed style, and it must not be longer than the original. A structural\r\n *     bystander with no compression opportunity therefore keeps its `class` attribute byte-for-byte.\r\n */\r\nexport function syncClassesFromComputed(\r\n  doc: IRDocument,\r\n  resolver: StyleResolver,\r\n  norm: StyleNormalizer,\r\n): void {\r\n  const sink = createSyntheticSink();\r\n  // A token is safe to drop/replace only when the resolver OWNS it (an unknown / JS-hook / typo class\r\n  // is preserved verbatim) AND its whole contribution is a plain, reproducible subject utility. Owning\r\n  // is checked explicitly so a custom-CSS resolver that has no usage record for an unknown token (its\r\n  // conservative default is \"droppable\") can never erase it.\r\n  const isDroppable = (t: string): boolean =>\r\n    resolver.owns(t) && resolver.selectorUsage(t).droppable;\r\n\r\n  for (const id of elementIds(doc)) {\r\n    const el = getElement(doc, id);\r\n    if (!el) continue;\r\n    if (el.classes.opaque || el.classes.hasDynamic) continue;\r\n\r\n    const compressOnly = !el.meta.styleDirty;\r\n    // COMPRESS-ONLY mirrors the compress patterns' applier gate: an opaque (floor-0) element — an HTML\r\n    // `id`/`on*=`/`<script>` node, a synthetic wrapper — is never rewritten. STYLE-DIRTY elements were\r\n    // already rewritten by an op the applier authorized, so their floor is irrelevant here.\r\n    if (compressOnly && el.meta.safetyFloor < COMPRESS_FLOOR) continue;\r\n\r\n    const tokens = staticTokensOf(el.classes);\r\n    if (tokens.length === 0) continue;\r\n\r\n    // Tokens that are ALWAYS retained (unknown / opaque / variant / selector-bound). Their style is\r\n    // subtracted from the computed map so we never re-emit a class for a property they already cover.\r\n    const retained = tokens.filter((t) => !isDroppable(t));\r\n    // A pure-compress element with NOTHING droppable can never shorten — leave it byte-for-byte.\r\n    if (compressOnly && retained.length === tokens.length) continue;\r\n\r\n    const covered = retained.length > 0 ? resolver.resolve({ classes: retained }).styles : null;\r\n    const target = covered ? residualStyle(el.computed, covered, norm) : el.computed;\r\n\r\n    // Minimal class set reproducing the residual (computed MINUS retained-class coverage).\r\n    const ctx: EmitContext = { normalizer: norm, sink };\r\n    const emitted = resolver.emit(target, ctx).classes;\r\n    // A resolver that reverse-synthesized nothing must never erase the element's classes.\r\n    if (emitted.length === 0) continue;\r\n\r\n    const emittedSet = new Set(emitted);\r\n    const next: string[] = [];\r\n    const seen = new Set<string>();\r\n\r\n    // 1. Keep each existing token that is either NOT droppable (unknown / opaque / variant /\r\n    //    selector-bound) or still part of the emitted minimal set — preserving source order.\r\n    for (const t of tokens) {\r\n      if (seen.has(t)) continue;\r\n      const keep = emittedSet.has(t) || !isDroppable(t);\r\n      if (keep) {\r\n        next.push(t);\r\n        seen.add(t);\r\n      }\r\n    }\r\n    // 2. Append any newly-emitted classes not already present, in emit order.\r\n    for (const c of emitted) {\r\n      if (seen.has(c)) continue;\r\n      next.push(c);\r\n      seen.add(c);\r\n    }\r\n\r\n    if (sameTokens(next, tokens)) continue; // no churn when nothing actually changed\r\n\r\n    if (compressOnly) {\r\n      // Hard correctness backstop for a pure compress: the rewritten token set must reproduce the\r\n      // element's EXACT computed style (never change a pixel) and must NOT be longer than the original\r\n      // (never inflate). Either failing ⇒ keep the original classes untouched.\r\n      if (!norm.equals(resolver.resolve({ classes: next }).styles, el.computed)) continue;\r\n      if (joinedLength(next) > joinedLength(tokens)) continue;\r\n    }\r\n\r\n    el.classes = staticClassList(el.classes, next);\r\n  }\r\n}\r\n","/**\r\n * @domflax/core — the general COMPRESS ENGINE: a minimal-string exact-cover solver.\r\n *\r\n * ## What it replaces\r\n *\r\n * The hand-written compress patterns (padding/margin/inset/size/gap/place/border/overflow/…-shorthand\r\n * and dedupe-classes) each recognised ONE shorthand shape and folded it. This module subsumes them\r\n * ALL with a SINGLE, provider-uniform algorithm: given an element's target computed style, find the\r\n * class set that reproduces it EXACTLY with the SHORTEST total `class=\"…\"` string, searching the whole\r\n * vocabulary (every Tailwind utility AND the project's custom-CSS classes at once).\r\n *\r\n * ## The algorithm (per element, per style-condition — all folded into one solve)\r\n *\r\n * Given a normalized target StyleMap `U`:\r\n *   1. UNIVERSE = the set of `(conditionKey, property, value, important)` tuples in `U`\r\n *      (a `tupleKey` per {@link tupleKey}).\r\n *   2. CANDIDATES = the vocabulary classes whose FULL normalized-longhand declaration set is a SUBSET\r\n *      of `U` (never introduces a declaration `U` does not already contain). The caller feeds the\r\n *      vocabulary; the element's own droppable tokens are part of it, guaranteeing feasibility and the\r\n *      \"never worse than the original\" property.\r\n *   3. COST(class) = token length + 1 (the token plus its joining space) — so minimizing total cost\r\n *      minimizes the rendered `class=\"…\"` byte length exactly.\r\n *   4. MIN-COST EXACT COVER via bitmask DP over `U`'s tuples: `dp[coveredMask]` = least cost reaching\r\n *      that coverage; each transition adds one candidate's mask. Because every candidate AGREES with\r\n *      `U` on every tuple it sets, ANY full cover reproduces `U` at the tuple level.\r\n *   5. `|U|` is BOUNDED ({@link DEFAULT_MAX_UNIVERSE}); a larger condition-block returns `null` so the\r\n *      caller falls back to its greedy emit for that element.\r\n *\r\n * The **correctness backstop** (re-resolve the chosen set and assert it equals `U` exactly) lives in\r\n * each resolver's `emit` — it owns the forward `resolve`, and running the check there keeps this core\r\n * helper pure and provider-agnostic. A chosen set that fails the backstop is discarded and the greedy\r\n * emit is used instead, so a set that does not reproduce `U` is NEVER emitted.\r\n */\r\n\r\nimport type { StyleMap, StyleNormalizer } from './types';\r\n\r\n/** Field separator for {@link tupleKey} — a control char that never appears in CSS text. */\r\nconst SEP = '\u0001';\r\n\r\n/**\r\n * The canonical key for one normalized declaration under one style condition: the atomic unit both the\r\n * target universe and every vocabulary class are expressed in. Equal keys ⇔ the SAME declaration.\r\n */\r\nexport function tupleKey(\r\n  condition: string,\r\n  property: string,\r\n  value: string,\r\n  important: boolean,\r\n): string {\r\n  return `${condition}${SEP}${property}${SEP}${value}${SEP}${important ? '1' : '0'}`;\r\n}\r\n\r\n/**\r\n * Flatten a StyleMap into its set of {@link tupleKey}s (normalizing first). This is how BOTH the target\r\n * universe and each vocabulary class's declarations are lowered, so a class's tuples can be tested for\r\n * subset-membership in the universe by plain string equality.\r\n */\r\nexport function styleMapTuples(map: StyleMap, norm: StyleNormalizer): string[] {\r\n  const out: string[] = [];\r\n  const normalized = norm.normalizeStyleMap(map);\r\n  for (const [ck, block] of normalized.blocks) {\r\n    for (const [prop, decl] of block.decls) {\r\n      out.push(tupleKey(String(ck), String(prop), String(decl.value), decl.important));\r\n    }\r\n  }\r\n  return out;\r\n}\r\n\r\n/** One vocabulary entry: a class token and the {@link tupleKey}s its full declaration set produces. */\r\nexport interface CoverClass {\r\n  readonly token: string;\r\n  readonly tuples: readonly string[];\r\n}\r\n\r\nexport interface MinCoverOptions {\r\n  /** Upper bound on `|U|`; above it the DP is skipped (`null`) so the caller uses its greedy emit. */\r\n  readonly maxUniverse?: number;\r\n}\r\n\r\n/**\r\n * The largest universe the bitmask DP will solve. 20 tuples ⇒ a `2^20` (~1M) DP table, comfortably\r\n * fast and bounded in memory; a heavier element (rare) falls back to the resolver's greedy emit.\r\n */\r\nexport const DEFAULT_MAX_UNIVERSE = 20;\r\n\r\n/**\r\n * Solve the minimal-string exact cover of `universe` using `vocabulary`.\r\n *\r\n * Returns the chosen class tokens (sorted, de-duplicated) whose union reproduces `universe` EXACTLY at\r\n * least total string cost, or `null` when there is no exact cover OR the universe exceeds the bound (in\r\n * both cases the caller falls back to its greedy emit). An empty universe yields `[]`.\r\n *\r\n * Pure and provider-agnostic: the caller performs the re-resolve correctness backstop.\r\n */\r\nexport function minStringCover(\r\n  universe: readonly string[],\r\n  vocabulary: Iterable<CoverClass>,\r\n  options: MinCoverOptions = {},\r\n): readonly string[] | null {\r\n  const uniq = [...new Set(universe)];\r\n  if (uniq.length === 0) return [];\r\n  const n = uniq.length;\r\n  const max = options.maxUniverse ?? DEFAULT_MAX_UNIVERSE;\r\n  if (n > max) return null;\r\n\r\n  const bitOf = new Map<string, number>();\r\n  uniq.forEach((t, i) => bitOf.set(t, i));\r\n\r\n  interface Cand {\r\n    readonly token: string;\r\n    readonly mask: number;\r\n    readonly cost: number;\r\n  }\r\n  // A candidate is any vocabulary class ALL of whose tuples lie in the universe (a subset fit). Two\r\n  // classes with the same coverage mask are collapsed to the cheaper (shorter, then lexicographically\r\n  // smaller) one — an equal-mask class can never help beyond the cheapest representative.\r\n  const byMask = new Map<number, Cand>();\r\n  for (const entry of vocabulary) {\r\n    if (entry.tuples.length === 0) continue;\r\n    let mask = 0;\r\n    let ok = true;\r\n    for (const t of entry.tuples) {\r\n      const b = bitOf.get(t);\r\n      if (b === undefined) {\r\n        ok = false;\r\n        break;\r\n      }\r\n      mask |= 1 << b;\r\n    }\r\n    if (!ok || mask === 0) continue;\r\n    const cost = entry.token.length + 1;\r\n    const prev = byMask.get(mask);\r\n    if (!prev || cost < prev.cost || (cost === prev.cost && entry.token < prev.token)) {\r\n      byMask.set(mask, { token: entry.token, mask, cost });\r\n    }\r\n  }\r\n  const cands = [...byMask.values()];\r\n  if (cands.length === 0) return null;\r\n\r\n  const full = (1 << n) - 1;\r\n\r\n  // For each universe bit, the candidates that cover it — the DP only ever expands the lowest still-\r\n  // uncovered bit, which bounds the branching without missing any optimum.\r\n  const byBit: number[][] = Array.from({ length: n }, () => []);\r\n  cands.forEach((c, ci) => {\r\n    for (let b = 0; b < n; b += 1) if (c.mask & (1 << b)) byBit[b]!.push(ci);\r\n  });\r\n\r\n  const size = full + 1;\r\n  const dp = new Float64Array(size).fill(Infinity);\r\n  const fromCand = new Int32Array(size).fill(-1);\r\n  const fromMask = new Int32Array(size).fill(-1);\r\n  dp[0] = 0;\r\n\r\n  for (let mask = 0; mask < full; mask += 1) {\r\n    const cur = dp[mask]!;\r\n    if (!Number.isFinite(cur)) continue;\r\n    // Lowest uncovered bit — every optimal cover must include a candidate covering it.\r\n    let b = 0;\r\n    while (b < n && mask & (1 << b)) b += 1;\r\n    for (const ci of byBit[b]!) {\r\n      const c = cands[ci]!;\r\n      const nm = mask | c.mask;\r\n      const cost = cur + c.cost;\r\n      if (cost < dp[nm]!) {\r\n        dp[nm] = cost;\r\n        fromCand[nm] = ci;\r\n        fromMask[nm] = mask;\r\n      }\r\n    }\r\n  }\r\n\r\n  if (!Number.isFinite(dp[full]!)) return null;\r\n\r\n  const chosen: string[] = [];\r\n  let m = full;\r\n  while (m !== 0) {\r\n    const ci = fromCand[m]!;\r\n    if (ci < 0) return null;\r\n    chosen.push(cands[ci]!.token);\r\n    m = fromMask[m]!;\r\n  }\r\n  return [...new Set(chosen)].sort();\r\n}\r\n","/**\r\n * @domflax/core — public API barrel.\r\n *\r\n * The type contract (`./types`) is the single source of truth for the whole monorepo; the runtime\r\n * modules below are the dependency-free reference implementations of the IR, the trusted applier,\r\n * the pass manager, and the pure pipeline.\r\n */\r\n\r\n// Type contract (pure types — zero runtime).\r\nexport type * from './types';\r\n\r\n// Runtime: IR builders + traversal.\r\nexport * from './builders';\r\n\r\n// Runtime: the trusted applier.\r\nexport * from './ops';\r\n\r\n// Runtime: pass manager + match/rewrite contexts (re-exports ./pass-context's public surface).\r\nexport * from './pass-manager';\r\n\r\n// Runtime: static flatten classifier (the safety core for the provably-safe gate).\r\nexport * from './flatten-safety';\r\n\r\n// Runtime: the pure single-file pipeline.\r\nexport * from './pipeline';\r\n\r\n// Runtime: the shared reverse-emit step (computed → className).\r\nexport * from './reverse-emit';\r\n\r\n// Runtime: the provider-uniform minimal-string exact-cover compress engine.\r\nexport * from './compress-engine';\r\n","/**\r\n * @domflax/pattern-kit — the shared StyleMap normalizer.\r\n *\r\n * A single, syntactic-only {@link StyleNormalizer} implementation that core, the patterns, and the\r\n * verifier all reuse so they agree, byte-for-byte, on what two style declarations \"mean\". It NEVER\r\n * resolves initial/inherited/computed defaults (that is the verifier's job) — it only:\r\n *\r\n *   • canonicalizes colors (`transparent` ⇒ `rgba(0, 0, 0, 0)`, hex lower-cased + 3→6 expanded,\r\n *     `rgb()/rgba()/hsl()/hsla()` argument spacing normalized),\r\n *   • canonicalizes units (whitespace collapsed, zero-lengths `0px`/`0%`/… ⇒ `0`),\r\n *   • expands a fixed set of box shorthands to longhands (`padding`/`margin`/`inset`/`border-width`\r\n *     into their four sides, `gap` into `row-gap`/`column-gap`),\r\n *   • orders declarations by property for stable comparison.\r\n *\r\n * Dependency-free: only `@domflax/core` (types + the StyleMap builder helpers).\r\n */\r\n\r\nimport type {\r\n  CssProperty,\r\n  CssValue,\r\n  ConditionKey,\r\n  InheritedPropertyTable,\r\n  StyleBlock,\r\n  StyleDecl,\r\n  StyleMap,\r\n  StyleNormalizer,\r\n} from '@domflax/core';\r\n\r\nimport { conditionKey, emptyStyleMap } from '@domflax/core';\r\n\r\n/* ───────────────────────── inherited-property table ───────────────────────── */\r\n\r\n/**\r\n * Canonical, versioned set of inherited CSS longhands. Any author custom property (`--*`) is\r\n * also treated as inherited via the `isInherited` predicate.\r\n */\r\nconst INHERITED_PROPERTIES: readonly string[] = [\r\n  'azimuth',\r\n  'border-collapse',\r\n  'border-spacing',\r\n  'caption-side',\r\n  'color',\r\n  'cursor',\r\n  'direction',\r\n  'empty-cells',\r\n  'font-family',\r\n  'font-feature-settings',\r\n  'font-kerning',\r\n  'font-size',\r\n  'font-size-adjust',\r\n  'font-stretch',\r\n  'font-style',\r\n  'font-variant',\r\n  'font-variant-caps',\r\n  'font-variant-numeric',\r\n  'font-weight',\r\n  'hyphens',\r\n  'letter-spacing',\r\n  'line-height',\r\n  'list-style-image',\r\n  'list-style-position',\r\n  'list-style-type',\r\n  'orphans',\r\n  'overflow-wrap',\r\n  'quotes',\r\n  'tab-size',\r\n  'text-align',\r\n  'text-align-last',\r\n  'text-decoration-color',\r\n  'text-indent',\r\n  'text-justify',\r\n  'text-rendering',\r\n  'text-shadow',\r\n  'text-transform',\r\n  'text-underline-position',\r\n  'visibility',\r\n  'white-space',\r\n  'widows',\r\n  'word-break',\r\n  'word-spacing',\r\n  'writing-mode',\r\n  '-webkit-font-smoothing',\r\n];\r\n\r\nfunction createInheritedTable(): InheritedPropertyTable {\r\n  const properties = new Set<CssProperty>(INHERITED_PROPERTIES as unknown as CssProperty[]);\r\n  return {\r\n    version: 'domflax-inherited@1',\r\n    properties,\r\n    isInherited(property: CssProperty): boolean {\r\n      // Author custom properties (`--*`) inherit by definition.\r\n      return String(property).startsWith('--') || properties.has(property);\r\n    },\r\n  };\r\n}\r\n\r\n/* ───────────────────────── value canonicalization ───────────────────────── */\r\n\r\nconst ZERO_LENGTH_RE =\r\n  /\\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;\r\n\r\nconst FUNC_ARGS_RE = /\\b(rgba?|hsla?|hwb|lab|lch|oklab|oklch)\\(([^()]*)\\)/gi;\r\n\r\nconst RELATIVE_UNIT_RE = /(?:\\d*\\.?\\d+)(?:em|ex|ch|lh)\\b|%/i;\r\n\r\n/**\r\n * Pure, syntactic value canonicalization. Idempotent: `canon(canon(v)) === canon(v)`.\r\n */\r\nfunction canonValue(raw: string): string {\r\n  let v = raw.trim().replace(/\\s+/g, ' ');\r\n\r\n  // Lower-case hex colors (#abc / #aabbcc / #aabbccff).\r\n  v = v.replace(/#([0-9a-fA-F]{3,8})\\b/g, (_m, hex: string) => '#' + hex.toLowerCase());\r\n\r\n  // Expand 3-digit hex (#abc → #aabbcc) — only when exactly 3 hex digits.\r\n  v = v.replace(\r\n    /#([0-9a-f])([0-9a-f])([0-9a-f])(?![0-9a-f])/g,\r\n    (_m, r: string, g: string, b: string) => `#${r}${r}${g}${g}${b}${b}`,\r\n  );\r\n\r\n  // Canonical fully-transparent color.\r\n  v = v.replace(/\\btransparent\\b/gi, 'rgba(0, 0, 0, 0)');\r\n  v = v.replace(/#00000000\\b/g, 'rgba(0, 0, 0, 0)');\r\n\r\n  // Collapse zero lengths/angles/times to a bare `0`.\r\n  v = v.replace(ZERO_LENGTH_RE, '0');\r\n\r\n  // Normalize the argument spacing of color/space functions: single space after each comma.\r\n  v = v.replace(FUNC_ARGS_RE, (_m, fn: string, args: string) => {\r\n    const parts = args\r\n      .split(',')\r\n      .map((s) => s.trim())\r\n      .filter((s) => s.length > 0);\r\n    return `${fn.toLowerCase()}(${parts.join(', ')})`;\r\n  });\r\n\r\n  return v;\r\n}\r\n\r\n/** True when the (canonicalized) value uses a parent-relative unit (em/ex/ch/lh/%). */\r\nfunction isRelativeValue(value: string): boolean {\r\n  return RELATIVE_UNIT_RE.test(value);\r\n}\r\n\r\n/* ───────────────────────── shorthand expansion ───────────────────────── */\r\n\r\n/** Box-model shorthands whose 1–4 value form expands to four explicit sides. */\r\nconst BOX_SIDES: Readonly<Record<string, readonly [string, string, string, string]>> = {\r\n  padding: ['padding-top', 'padding-right', 'padding-bottom', 'padding-left'],\r\n  margin: ['margin-top', 'margin-right', 'margin-bottom', 'margin-left'],\r\n  inset: ['top', 'right', 'bottom', 'left'],\r\n  'scroll-margin': [\r\n    'scroll-margin-top',\r\n    'scroll-margin-right',\r\n    'scroll-margin-bottom',\r\n    'scroll-margin-left',\r\n  ],\r\n  'scroll-padding': [\r\n    'scroll-padding-top',\r\n    'scroll-padding-right',\r\n    'scroll-padding-bottom',\r\n    'scroll-padding-left',\r\n  ],\r\n  'border-width': [\r\n    'border-top-width',\r\n    'border-right-width',\r\n    'border-bottom-width',\r\n    'border-left-width',\r\n  ],\r\n  'border-style': [\r\n    'border-top-style',\r\n    'border-right-style',\r\n    'border-bottom-style',\r\n    'border-left-style',\r\n  ],\r\n  'border-color': [\r\n    'border-top-color',\r\n    'border-right-color',\r\n    'border-bottom-color',\r\n    'border-left-color',\r\n  ],\r\n  // `border-radius` 1–4 value form maps to the four CORNERS (TL, TR, BR, BL) — the same positional\r\n  // pattern boxFourSides implements. Only the slash-free form is expanded (see expandShorthand).\r\n  'border-radius': [\r\n    'border-top-left-radius',\r\n    'border-top-right-radius',\r\n    'border-bottom-right-radius',\r\n    'border-bottom-left-radius',\r\n  ],\r\n};\r\n\r\n/** Two-axis shorthands whose 1–2 value form expands to an explicit [x/block-start, y/inline-…] pair. */\r\nconst AXIS_PAIRS: Readonly<Record<string, readonly [string, string]>> = {\r\n  overflow: ['overflow-x', 'overflow-y'],\r\n  'overscroll-behavior': ['overscroll-behavior-x', 'overscroll-behavior-y'],\r\n  'place-items': ['align-items', 'justify-items'],\r\n  'place-content': ['align-content', 'justify-content'],\r\n  'place-self': ['align-self', 'justify-self'],\r\n};\r\n\r\n/**\r\n * LOGICAL box shorthands (Tailwind v4 emits these for `px-*`/`py-*`/`mx-*`/`inset-x-*`, …). Their\r\n * SINGLE-value form is direction-INDEPENDENT — `padding-inline: X` sets left AND right to the same `X`\r\n * regardless of writing mode — so it is canonicalized to the physical side pair, letting the compress\r\n * engine reconcile v4's `px-4 py-4` with the physical `p-4` (which expands via {@link BOX_SIDES}).\r\n * A TWO-value logical form (`A B`) is direction-DEPENDENT (start/end ≠ left/right under RTL) and is\r\n * left verbatim — Tailwind never generates it from a single utility, so no compression is lost.\r\n */\r\nconst LOGICAL_PAIRS: Readonly<Record<string, readonly [string, string]>> = {\r\n  'padding-inline': ['padding-left', 'padding-right'],\r\n  'padding-block': ['padding-top', 'padding-bottom'],\r\n  'margin-inline': ['margin-left', 'margin-right'],\r\n  'margin-block': ['margin-top', 'margin-bottom'],\r\n  'inset-inline': ['left', 'right'],\r\n  'inset-block': ['top', 'bottom'],\r\n  'scroll-padding-inline': ['scroll-padding-left', 'scroll-padding-right'],\r\n  'scroll-padding-block': ['scroll-padding-top', 'scroll-padding-bottom'],\r\n  'scroll-margin-inline': ['scroll-margin-left', 'scroll-margin-right'],\r\n  'scroll-margin-block': ['scroll-margin-top', 'scroll-margin-bottom'],\r\n};\r\n\r\n/** Split on top-level whitespace, keeping `fn(a, b)` groups intact. */\r\nfunction splitTopLevel(value: string): string[] {\r\n  const out: string[] = [];\r\n  let depth = 0;\r\n  let cur = '';\r\n  for (const ch of value) {\r\n    if (ch === '(') depth += 1;\r\n    else if (ch === ')') depth = Math.max(0, depth - 1);\r\n    if (depth === 0 && /\\s/.test(ch)) {\r\n      if (cur.length > 0) {\r\n        out.push(cur);\r\n        cur = '';\r\n      }\r\n      continue;\r\n    }\r\n    cur += ch;\r\n  }\r\n  if (cur.length > 0) out.push(cur);\r\n  return out;\r\n}\r\n\r\n/** Map a 1–4 value box shorthand onto its [top, right, bottom, left] sides. */\r\nfunction boxFourSides(values: readonly string[]): [string, string, string, string] {\r\n  const [a, b, c, d] = values;\r\n  switch (values.length) {\r\n    case 1:\r\n      return [a!, a!, a!, a!];\r\n    case 2:\r\n      return [a!, b!, a!, b!];\r\n    case 3:\r\n      return [a!, b!, c!, b!];\r\n    default:\r\n      return [a!, b!, c!, d!];\r\n  }\r\n}\r\n\r\n/** Expand one declaration into longhand `[property, value]` pairs (single pair if not shorthand). */\r\nfunction expandShorthand(prop: string, value: string): Array<[string, string]> {\r\n  // `border-radius` with a `/` carries distinct horizontal/vertical radii per corner — a shape our\r\n  // per-corner single-value longhands cannot represent — so it is left as the shorthand verbatim.\r\n  if (prop === 'border-radius' && value.includes('/')) return [[prop, value]];\r\n\r\n  const box = BOX_SIDES[prop];\r\n  if (box) {\r\n    const parts = splitTopLevel(value);\r\n    if (parts.length >= 1 && parts.length <= 4) {\r\n      const sides = boxFourSides(parts);\r\n      return box.map((p, i) => [p, sides[i]!] as [string, string]);\r\n    }\r\n    return [[prop, value]];\r\n  }\r\n\r\n  const axis = AXIS_PAIRS[prop];\r\n  if (axis) {\r\n    const parts = splitTopLevel(value);\r\n    if (parts.length === 1) return [[axis[0], parts[0]!], [axis[1], parts[0]!]];\r\n    if (parts.length === 2) return [[axis[0], parts[0]!], [axis[1], parts[1]!]];\r\n    return [[prop, value]];\r\n  }\r\n\r\n  const logical = LOGICAL_PAIRS[prop];\r\n  if (logical) {\r\n    const parts = splitTopLevel(value);\r\n    // Only the direction-independent single-value form maps to physical sides (see LOGICAL_PAIRS).\r\n    if (parts.length === 1) return [[logical[0], parts[0]!], [logical[1], parts[0]!]];\r\n    return [[prop, value]];\r\n  }\r\n\r\n  if (prop === 'gap' || prop === 'grid-gap') {\r\n    const parts = splitTopLevel(value);\r\n    if (parts.length === 1) {\r\n      return [\r\n        ['row-gap', parts[0]!],\r\n        ['column-gap', parts[0]!],\r\n      ];\r\n    }\r\n    if (parts.length === 2) {\r\n      return [\r\n        ['row-gap', parts[0]!],\r\n        ['column-gap', parts[1]!],\r\n      ];\r\n    }\r\n    return [[prop, value]];\r\n  }\r\n\r\n  return [[prop, value]];\r\n}\r\n\r\n/* ───────────────────────── the normalizer ───────────────────────── */\r\n\r\nfunction makeDecl(\r\n  table: InheritedPropertyTable,\r\n  prop: string,\r\n  rawValue: string,\r\n  important: boolean,\r\n): StyleDecl {\r\n  const property = prop.trim().toLowerCase() as CssProperty;\r\n  const value = canonValue(rawValue) as CssValue;\r\n  return {\r\n    property,\r\n    value,\r\n    important,\r\n    relativeToParent: isRelativeValue(value),\r\n    inherited: table.isInherited(property),\r\n  };\r\n}\r\n\r\nexport function createNormalizer(): StyleNormalizer {\r\n  const inherited = createInheritedTable();\r\n\r\n  const normalizeDeclaration = (\r\n    prop: string,\r\n    value: string,\r\n    important: boolean,\r\n  ): readonly StyleDecl[] => {\r\n    const p = prop.trim().toLowerCase();\r\n    const expanded = expandShorthand(p, value.trim());\r\n    return expanded.map(([lp, lv]) => makeDecl(inherited, lp, lv, important));\r\n  };\r\n\r\n  const normalizeValue = (prop: CssProperty, raw: string): CssValue => {\r\n    void prop;\r\n    return canonValue(raw) as CssValue;\r\n  };\r\n\r\n  const normalizeStyleMap = (sm: StyleMap): StyleMap => {\r\n    const blocks = new Map<ConditionKey, StyleBlock>();\r\n    for (const block of sm.blocks.values()) {\r\n      const decls = new Map<CssProperty, StyleDecl>();\r\n      // Re-canonicalize every value and re-key (the decls are already longhand).\r\n      for (const decl of block.decls.values()) {\r\n        const next: StyleDecl = {\r\n          ...decl,\r\n          value: canonValue(String(decl.value)) as CssValue,\r\n          relativeToParent: isRelativeValue(String(decl.value)),\r\n          inherited: inherited.isInherited(decl.property),\r\n        };\r\n        decls.set(next.property, next);\r\n      }\r\n      // Property-sorted for deterministic iteration/serialization.\r\n      const sorted = new Map<CssProperty, StyleDecl>(\r\n        [...decls.entries()].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)),\r\n      );\r\n      const key = conditionKey(block.condition);\r\n      blocks.set(key, { condition: block.condition, decls: sorted });\r\n    }\r\n    return { blocks };\r\n  };\r\n\r\n  const equals = (a: StyleMap, b: StyleMap): boolean => {\r\n    const na = normalizeStyleMap(a);\r\n    const nb = normalizeStyleMap(b);\r\n    if (na.blocks.size !== nb.blocks.size) return false;\r\n    for (const [key, blockA] of na.blocks) {\r\n      const blockB = nb.blocks.get(key);\r\n      if (!blockB) return false;\r\n      if (blockA.decls.size !== blockB.decls.size) return false;\r\n      for (const [prop, declA] of blockA.decls) {\r\n        const declB = blockB.decls.get(prop);\r\n        if (!declB) return false;\r\n        if (declA.value !== declB.value || declA.important !== declB.important) return false;\r\n      }\r\n    }\r\n    return true;\r\n  };\r\n\r\n  return {\r\n    version: 'domflax-normalizer@1',\r\n    normalizeDeclaration,\r\n    normalizeValue,\r\n    normalizeStyleMap,\r\n    equals,\r\n    inherited,\r\n  };\r\n}\r\n\r\n/** The shared, process-wide normalizer instance reused by core / patterns / verify. */\r\nexport const normalizer: StyleNormalizer = createNormalizer();\r\n\r\n/* ───────────────────────── superset helper (used by `computed()` matcher) ───────────────────────── */\r\n\r\n/**\r\n * True when `full` contains every declaration of `partial` with an equal normalized value\r\n * (a per-condition, per-declaration superset test). Both maps are normalized first so the\r\n * comparison is meaning-based, not string-based. Empty `partial` ⇒ always `true`.\r\n */\r\nexport function isStyleSuperset(\r\n  full: StyleMap,\r\n  partial: StyleMap,\r\n  norm: StyleNormalizer = normalizer,\r\n): boolean {\r\n  const nf = norm.normalizeStyleMap(full);\r\n  const np = norm.normalizeStyleMap(partial);\r\n  for (const [key, want] of np.blocks) {\r\n    const have = nf.blocks.get(key) ?? nf.blocks.get(conditionKey(want.condition));\r\n    if (!have) return false;\r\n    for (const [prop, decl] of want.decls) {\r\n      const got = have.decls.get(prop);\r\n      if (!got || got.value !== decl.value) return false;\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n/** Re-exported for callers that want to (de)construct keys without importing core directly. */\r\nexport { emptyStyleMap };\r\n","/**\r\n * @domflax/pattern-kit — composable matcher vocabulary.\r\n *\r\n * A {@link Matcher} is a PURE predicate over a node + its {@link MatchContext}. Matchers never\r\n * mutate; they only read the (DeepReadonly) IR and the precomputed targeting/selector facts the\r\n * context exposes. Authors compose them with {@link and}/{@link or}/{@link not} and feed the\r\n * result into a pattern's `evaluate`.\r\n *\r\n * Style-aware matchers (`computed`, `hasOwnVisualStyle`) reason over the NORMALIZED StyleMap via\r\n * the shared normalizer in `./normalize`, so they query meaning, not raw CSS strings.\r\n */\r\n\r\nimport type {\r\n  DeepReadonly,\r\n  ElementLike,\r\n  IRElement,\r\n  IRNode,\r\n  IRNodeId,\r\n  MatchContext,\r\n  NodeLike,\r\n  StyleMap,\r\n} from '@domflax/core';\r\n\r\nimport { isStyleSuperset, normalizer } from './normalize';\r\n\r\n/** A pure predicate: does `node` satisfy this condition in the given match context? */\r\nexport type Matcher = (node: NodeLike, ctx: MatchContext) => boolean;\r\n\r\n/* ───────────────────────── internal helpers ───────────────────────── */\r\n\r\nfunction asElement(node: NodeLike): DeepReadonly<IRElement> | null {\r\n  const n = node as DeepReadonly<IRNode>;\r\n  return n.kind === 'element' ? (n as DeepReadonly<IRElement>) : null;\r\n}\r\n\r\nfunction elementChildrenOf(\r\n  el: DeepReadonly<IRElement>,\r\n  ctx: MatchContext,\r\n): DeepReadonly<IRElement>[] {\r\n  const out: DeepReadonly<IRElement>[] = [];\r\n  for (const childId of el.children) {\r\n    const child = ctx.doc.nodes.get(childId);\r\n    if (child && child.kind === 'element') out.push(child as DeepReadonly<IRElement>);\r\n  }\r\n  return out;\r\n}\r\n\r\n/* ───────────────────────── boolean combinators ───────────────────────── */\r\n\r\n/** Logical AND. Empty list ⇒ always matches. Short-circuits on the first failure. */\r\nexport function and(...matchers: readonly Matcher[]): Matcher {\r\n  return (node, ctx) => matchers.every((m) => m(node, ctx));\r\n}\r\n\r\n/** Logical OR. Empty list ⇒ never matches. Short-circuits on the first success. */\r\nexport function or(...matchers: readonly Matcher[]): Matcher {\r\n  return (node, ctx) => matchers.some((m) => m(node, ctx));\r\n}\r\n\r\n/** Logical NOT. */\r\nexport function not(matcher: Matcher): Matcher {\r\n  return (node, ctx) => !matcher(node, ctx);\r\n}\r\n\r\n/* ───────────────────────── structural matchers ───────────────────────── */\r\n\r\n/** Matches any element; with `tag`, only elements whose (case-insensitive) tag equals it. */\r\nexport function isElement(tag?: string): Matcher {\r\n  const want = tag?.toLowerCase();\r\n  return (node) => {\r\n    const el = asElement(node);\r\n    if (!el) return false;\r\n    return want === undefined || el.tag.toLowerCase() === want;\r\n  };\r\n}\r\n\r\n/** Matches an element with exactly one ELEMENT child (text/expr/comment children ignored). */\r\nexport const hasSingleElementChild: Matcher = (node, ctx) => {\r\n  const el = asElement(node);\r\n  if (!el) return false;\r\n  return elementChildrenOf(el, ctx).length === 1;\r\n};\r\n\r\n/* ───────────────────────── style matchers ───────────────────────── */\r\n\r\n/**\r\n * Matches when the node's computed StyleMap is a SUPERSET of `partial` — i.e. every declaration\r\n * in `partial` is present in `node.computed` with an equal normalized value. Comparison is\r\n * meaning-based (both sides normalized first). Empty `partial` always matches.\r\n */\r\nexport function computed(partial: StyleMap): Matcher {\r\n  return (node, ctx) => {\r\n    const el = asElement(node);\r\n    if (!el) return false;\r\n    const full = ctx.computedOf(el as unknown as NodeLike) ?? (el.computed as StyleMap);\r\n    return isStyleSuperset(full as StyleMap, partial, normalizer);\r\n  };\r\n}\r\n\r\n/** Visual (paint-establishing) properties that count as \"own visual style\", beyond pure layout. */\r\nconst VISUAL_PROPERTIES: ReadonlySet<string> = new Set<string>([\r\n  'background',\r\n  'background-color',\r\n  'background-image',\r\n  'border-top-width',\r\n  'border-right-width',\r\n  'border-bottom-width',\r\n  'border-left-width',\r\n  'border-top-style',\r\n  'border-right-style',\r\n  'border-bottom-style',\r\n  'border-left-style',\r\n  'border-top-color',\r\n  'border-right-color',\r\n  'border-bottom-color',\r\n  'border-left-color',\r\n  // `border-radius` is expanded to its four corner longhands by the shared normalizer, so the\r\n  // paint-establishing check must match those (a rounded wrapper still clips its background).\r\n  'border-top-left-radius',\r\n  'border-top-right-radius',\r\n  'border-bottom-right-radius',\r\n  'border-bottom-left-radius',\r\n  'box-shadow',\r\n  'outline',\r\n  'outline-width',\r\n  'outline-style',\r\n  'outline-color',\r\n  'text-shadow',\r\n  'filter',\r\n  'backdrop-filter',\r\n  'mix-blend-mode',\r\n  'opacity',\r\n]);\r\n\r\n/** Values that mean \"no paint\" — a visual property set to one of these does NOT count. */\r\nconst EMPTY_VISUAL_VALUES: ReadonlySet<string> = new Set<string>([\r\n  'none',\r\n  '0',\r\n  'normal',\r\n  'transparent',\r\n  'rgba(0, 0, 0, 0)',\r\n  'initial',\r\n  'unset',\r\n  'auto',\r\n]);\r\n\r\n/**\r\n * Matches when the element paints something of its own: a meaningful background, border, shadow,\r\n * outline, filter, etc. across ANY style condition. Honours the frontend-set `meta.hasOwnVisualStyle`\r\n * fast-path, then falls back to scanning the normalized computed StyleMap.\r\n */\r\nexport const hasOwnVisualStyle: Matcher = (node, ctx) => {\r\n  const el = asElement(node);\r\n  if (!el) return false;\r\n  if (el.meta.hasOwnVisualStyle) return true;\r\n  // SAFETY (Layer 2): an element with an UNRESOLVED class has an UNKNOWN true style — we cannot prove\r\n  // it paints nothing, so it must NOT satisfy `paintsNothing` (`not(hasOwnVisualStyle)`). Reporting\r\n  // \"has own visual style\" here makes every flatten pattern gated on paintsNothing decline to match,\r\n  // so the element is preserved. This is the primary flatten fail-safe (the flatten-safety classifier\r\n  // is the backstop). Compress is unaffected — its guards never consult hasOwnVisualStyle.\r\n  if (el.meta.hasUnresolvedClasses) return true;\r\n\r\n  const computedMap = ctx.computedOf(el as unknown as NodeLike) ?? (el.computed as StyleMap);\r\n  const norm = normalizer.normalizeStyleMap(computedMap as StyleMap);\r\n  for (const block of norm.blocks.values()) {\r\n    for (const decl of block.decls.values()) {\r\n      if (!VISUAL_PROPERTIES.has(String(decl.property))) continue;\r\n      if (!EMPTY_VISUAL_VALUES.has(String(decl.value))) return true;\r\n    }\r\n  }\r\n  return false;\r\n};\r\n\r\n/* ───────────────────────── opacity-barrier / meta matchers ───────────────────────── */\r\n\r\n/** Element carries a `ref` (hard opacity barrier). */\r\nexport const hasRef: Matcher = (node) => asElement(node)?.meta.hasRef ?? false;\r\n\r\n/** Element has event handlers (onClick, …). */\r\nexport const hasEventHandlers: Matcher = (node) => asElement(node)?.meta.hasEventHandlers ?? false;\r\n\r\n/** Element has dynamic children (mapped/conditional islands). */\r\nexport const hasDynamicChildren: Matcher = (node) =>\r\n  asElement(node)?.meta.hasDynamicChildren ?? false;\r\n\r\n/** Element's class list contains a dynamic segment (template/expr) → not freely rewritable. */\r\nexport const hasDynamicClasses: Matcher = (node) => asElement(node)?.classes.hasDynamic ?? false;\r\n\r\n/**\r\n * Element's class list is wholly dynamic / spread-derived (`classes.opaque`, or spread attrs) — its\r\n * concrete tokens can't be seen or statically rewritten, so a class-rewriting (compress) pattern\r\n * must decline. Delegates to the context's authoritative {@link MatchContext.isOpaque}.\r\n */\r\nexport const opaque: Matcher = (node, ctx) => {\r\n  const el = asElement(node);\r\n  if (!el) return false;\r\n  return ctx.isOpaque(el as unknown as ElementLike);\r\n};\r\n\r\n/**\r\n * Element is the subject of a combinator selector (`>`/`+`/`~`). Honours the frontend-set meta\r\n * flag and the precomputed {@link SelectorIndex} in the context.\r\n */\r\nexport const targetedByCombinator: Matcher = (node, ctx) => {\r\n  const el = asElement(node);\r\n  if (!el) return false;\r\n  if (el.meta.targetedByCombinator) return true;\r\n  // `el.id` is a branded number; DeepReadonly widens the brand, so re-narrow for the index call.\r\n  return ctx.selectors.targetedByCombinator(el.id as unknown as IRNodeId);\r\n};\r\n","/**\n * @domflax/pattern-kit — ergonomic op-draft constructors.\n *\n * Thin, pure helpers that build the core {@link RewriteOpDraft} objects so pattern authors can\n * assemble a `MatchResult.ops` array without hand-writing discriminant literals. Drafts carry NO\n * `origin` — the pass-manager stamps `{ pattern, category, safety }` when it schedules the op\n * (see core's `stampOrigin`). Each helper accepts a live node, a DeepReadonly view, or a bare\n * {@link IRNodeId}.\n *\n * Mirrors the four ops a rewrite typically reaches for: `mergeStyle`, `foldInheritedStyles`,\n * `replaceWith`, `removeNode`.\n */\n\nimport type {\n  CssProperty,\n  ElementLike,\n  IRNode,\n  IRNodeId,\n  NodeLike,\n  NodeSpec,\n  RewriteOpDraft,\n  StyleConflictPolicy,\n  StyleMap,\n} from '@domflax/core';\n\n/** Accept a live/readonly node or a bare id. */\ntype Ref = NodeLike | ElementLike | IRNodeId;\n\nfunction idOf(ref: Ref): IRNodeId {\n  return typeof ref === 'number' ? (ref as IRNodeId) : ((ref as IRNode).id as IRNodeId);\n}\n\n/* ───────────────────────── style ops ───────────────────────── */\n\n/**\n * Merge `style` onto `target`, optionally pulling from `source` (or `null` for a literal patch).\n * `onConflict` defaults to `'abort'` — the safest policy (the applier refuses rather than guess).\n */\nexport function mergeStyle(\n  target: Ref,\n  source: Ref | null,\n  style: StyleMap,\n  onConflict: StyleConflictPolicy = 'abort',\n): RewriteOpDraft {\n  return {\n    op: 'mergeStyle',\n    target: idOf(target),\n    source: source == null ? null : idOf(source),\n    style,\n    onConflict,\n  };\n}\n\n/**\n * Fold inheritable declarations from `from` down into one or more descendants. `conditions:'all'`\n * folds across every StyleCondition (states/media/pseudo-elements); the default `'base'` folds only\n * the unconditional block. `only` restricts the property set (otherwise `'all-inherited'`).\n */\nexport function foldInheritedStyles(\n  from: Ref,\n  into: Ref | readonly Ref[],\n  opts?: { only?: readonly CssProperty[]; conditions?: 'base' | 'all' },\n): RewriteOpDraft {\n  const list: readonly Ref[] = Array.isArray(into) ? (into as readonly Ref[]) : [into as Ref];\n  return {\n    op: 'foldInheritedStyles',\n    from: idOf(from),\n    into: list.map(idOf),\n    properties: opts?.only ?? 'all-inherited',\n    conditions: opts?.conditions ?? 'base',\n  };\n}\n\n/* ───────────────────────── structural ops ───────────────────────── */\n\n/** Replace `target` with a detached {@link NodeSpec} (the applier materializes ids on apply). */\nexport function replaceWith(target: Ref, replacement: NodeSpec): RewriteOpDraft {\n  return { op: 'replaceWith', target: idOf(target), replacement };\n}\n\n/** Remove `target` (and its subtree) from the tree. */\nexport function removeNode(target: Ref): RewriteOpDraft {\n  return { op: 'removeNode', target: idOf(target) };\n}\n","/**\n * @domflax/pattern-kit — `definePattern()`: THE declarative pattern-authoring surface.\n *\n * `definePattern(config)` is the single public way to author a rewrite pattern: definition AND its\n * tests are co-located in one call. It compiles down to the private lower-level\n * {@link import('./define').validatePattern}/{@link Pattern} contract (it never replaces the\n * engine). Authors describe the match as a plain DATA object and the rewrite as a named RECIPE; this\n * module maps each key to the existing matcher combinators and op-draft factories, auto-applies the\n * phase-appropriate safety guards (the full opacity-barrier + selector set for `flatten/*`; the\n * narrower class-rewrite-safety set for `compress/*`) so authors never hand-write them, and threads\n * `doc`/`test` through. Two escape hatches — a `match` predicate and a `rewrite` function — keep\n * exotic patterns (e.g. ones anchored on a parent fragment) expressible.\n *\n * The co-located {@link PatternTest} (`provider`/`cssFiles`/`cases`/`noMatch`/`custom`) is carried on\n * the compiled {@link AuthoredPattern} as `.test`, where the generic harness (`./testing`) reads it:\n * each `case` asserts `before → after`, each `noMatch` asserts the input is left unchanged, and the\n * optional `custom` hook runs arbitrary assertions against the built transform.\n *\n * `style` blocks in the declarative match (and in `childGains`/`mergeStyle` recipes) are PLAIN\n * objects (camelCase or kebab keys) auto-normalized into a superset StyleMap via the shared\n * normalizer — authors never import the normalizer or hand-build a StyleMap.\n *\n * `pattern` remains exported as a DEPRECATED alias of `definePattern` for backward compatibility.\n */\n\nimport type {\n  Captures,\n  ConditionKey,\n  CssProperty,\n  DeepReadonly,\n  IRElement,\n  IRNode,\n  IRNodeId,\n  MatchContext,\n  MatchResult,\n  NodeLike,\n  NodeMeta,\n  PassCategory,\n  PassPhase,\n  Pattern,\n  PatternDoc,\n  PreconditionSketch,\n  RewriteFactory,\n  RewriteOpDraft,\n  SafetyLevel,\n  StyleBlock,\n  StyleDecl,\n  StyleMap,\n  StyleOrigin,\n  StyleConflictPolicy,\n} from '@domflax/core';\nimport { BASE_CONDITION, conditionKey } from '@domflax/core';\n\nimport {\n  and,\n  computed,\n  hasDynamicChildren,\n  hasDynamicClasses,\n  hasEventHandlers,\n  hasOwnVisualStyle,\n  hasRef,\n  hasSingleElementChild,\n  isElement,\n  not,\n  opaque,\n  targetedByCombinator,\n  type Matcher,\n} from './combinators';\nimport { validatePattern } from './define';\nimport { normalizer } from './normalize';\n\n/* ───────────────────────── public config shapes ───────────────────────── */\n\n/** A plain CSS style object: camelCase or kebab-case keys, string or number values. */\nexport type PlainStyle = Readonly<Record<string, string | number>>;\n\n/**\n * Declarative match as DATA. Every key maps to one of the existing matcher combinators; an empty\n * object matches any element. Use the `match` FUNCTION escape hatch for anything not expressible\n * here (relational/ancestor/sibling shapes, parent-anchored patterns, …).\n */\nexport interface DeclarativeMatch {\n  /** Restrict to a tag (case-insensitive). Omit to match any element. */\n  readonly tag?: string;\n  /** Computed style the node must be a SUPERSET of (plain object, auto-normalized). */\n  readonly style?: PlainStyle;\n  /** Require exactly one ELEMENT child. */\n  readonly onlyChild?: 'element';\n  /** Require the element to paint nothing of its own (no own visual style). */\n  readonly paintsNothing?: boolean;\n  /** Extra, hand-written predicate AND-ed into the declarative match. */\n  readonly where?: Matcher | readonly Matcher[];\n}\n\n/** Escape hatch: a raw match predicate (no auto-guards are added). */\nexport type MatchFn = (node: NodeLike, ctx: MatchContext) => boolean;\n\n/**\n * Flatten recipe: fold inherited styles onto the sole element child (default on), optionally merge\n * `childGains` onto it, then unwrap the node (id-preserving). Mirrors the flatten exemplars.\n */\nexport interface FlattenIntoRecipe {\n  readonly flattenInto: 'child';\n  /** Plain style merged onto the surviving child (source-wins) before unwrap. */\n  readonly childGains?: PlainStyle;\n  /** Fold inheritable declarations onto the child first. Default `true`. */\n  readonly foldInherited?: boolean;\n}\n\n/** Compress recipe: rebuild the element's class StyleMap; return `null` to decline. */\nexport interface RewriteClassesRecipe {\n  readonly rewriteClasses: (computed: StyleMap, ctx: MatchContext) => StyleMap | null;\n  /** Keep opaque/selector-bound tokens verbatim. Default `true`. */\n  readonly preserveOpaque?: boolean;\n}\n\n/** Compress recipe: drop fully-overridden class tokens (provenance is pruned automatically). */\nexport interface DropClassesRecipe {\n  readonly dropClasses: (computed: StyleMap, ctx: MatchContext) => Iterable<string>;\n  /** Keep opaque/selector-bound tokens verbatim. Default `true`. */\n  readonly preserveOpaque?: boolean;\n}\n\n/** Merge a literal plain style onto the matched element. */\nexport interface MergeStyleRecipe {\n  readonly mergeStyle: PlainStyle;\n  readonly onConflict?: StyleConflictPolicy;\n}\n\nexport type RewriteRecipe =\n  | FlattenIntoRecipe\n  | RewriteClassesRecipe\n  | DropClassesRecipe\n  | MergeStyleRecipe;\n\n/** Escape hatch: a raw rewrite that returns op drafts (or `null`/`[]` for no-op). */\nexport type RewriteFn = (\n  ctx: MatchContext,\n  rw: RewriteFactory,\n) => readonly RewriteOpDraft[] | null;\n\n/** A single positive before→after assertion run through the pattern's built transform. */\nexport interface PatternTestCase {\n  readonly name?: string;\n  readonly before: string;\n  readonly after: string;\n}\n\n/** Helpers handed to a {@link PatternTest.custom} hook (the built transform + expectation sugar). */\nexport interface TestHelpers {\n  /** Run the pattern's transform on `code` (default filename `'X.tsx'`). */\n  readonly transform: (code: string, filename?: string) => string;\n  /** Assert `before` transforms to `after` (whitespace-normalized). */\n  readonly expectTransforms: (before: string, after: string) => void;\n  /** Assert `code` is left unchanged (whitespace-normalized). */\n  readonly expectUnchanged: (code: string) => void;\n}\n\n/**\n * Co-located test spec for a pattern. The generic harness (`./testing`) builds a transform for the\n * declared `provider` (default `'tailwind'`; `'custom'` resolves the listed `cssFiles`), then runs\n * every `case` (`before → after`), every `noMatch` (left unchanged), and the optional `custom` hook.\n */\nexport interface PatternTest {\n  /** Which style provider the harness builds the transform from. Default `'tailwind'`. */\n  readonly provider?: 'tailwind' | 'custom';\n  /** For `provider: 'custom'` — the project stylesheet paths backing the CSS resolver. */\n  readonly cssFiles?: readonly string[];\n  /** Positive before→after assertions. */\n  readonly cases?: readonly PatternTestCase[];\n  /** Inputs the pattern must leave UNCHANGED (barriers, non-matching shapes, safety reverts). */\n  readonly noMatch?: readonly string[];\n  /** Arbitrary extra assertions against the built transform. */\n  readonly custom?: (h: TestHelpers) => void;\n}\n\nexport interface PatternConfig {\n  readonly name: string;\n  readonly category: PassCategory;\n  readonly safety: SafetyLevel;\n  readonly priority?: number;\n  readonly precondition?: PreconditionSketch;\n  readonly doc?: PatternDoc;\n  /** Co-located tests consumed by the generic harness (`./testing`). */\n  readonly test?: PatternTest;\n  /** Declarative match DATA, or a raw predicate escape hatch. Defaults to \"any element\". */\n  readonly match?: DeclarativeMatch | MatchFn;\n  /** A named rewrite recipe, or a raw op-draft factory escape hatch. */\n  readonly rewrite: RewriteRecipe | RewriteFn;\n}\n\n/** A {@link Pattern} that also carries its co-located {@link PatternTest} for the test harness. */\nexport interface AuthoredPattern<C extends Captures = Captures> extends Pattern {\n  readonly test?: PatternTest;\n  evaluate(ctx: MatchContext, rw: RewriteFactory): MatchResult<C> | null;\n}\n\n/* ───────────────────────── plain-style → StyleMap ───────────────────────── */\n\nfunction camelToKebab(key: string): string {\n  if (key.startsWith('--')) return key; // custom property — leave verbatim\n  return key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);\n}\n\n/** Build a single-(base-)condition StyleMap from a plain style object via the shared normalizer. */\nfunction plainToStyleMap(style: PlainStyle): StyleMap {\n  const decls = new Map<CssProperty, StyleDecl>();\n  for (const [rawKey, rawValue] of Object.entries(style)) {\n    const prop = camelToKebab(rawKey);\n    for (const decl of normalizer.normalizeDeclaration(prop, String(rawValue), false)) {\n      decls.set(decl.property, decl);\n    }\n  }\n  const block: StyleBlock = { condition: BASE_CONDITION, decls };\n  return { blocks: new Map<ConditionKey, StyleBlock>([[conditionKey(BASE_CONDITION), block]]) };\n}\n\n/* ───────────────────────── local meta / selector matchers ───────────────────────── */\n\nfunction asElement(node: NodeLike): DeepReadonly<IRElement> | null {\n  const n = node as DeepReadonly<IRNode>;\n  return n.kind === 'element' ? (n as DeepReadonly<IRElement>) : null;\n}\n\nfunction metaFlag(flag: keyof NodeMeta): Matcher {\n  return (node) => Boolean(asElement(node)?.meta[flag]);\n}\n\n/** Element renders raw/`dangerouslySetInnerHTML` markup — a hard opacity barrier. */\nconst hasRawHtml: Matcher = metaFlag('hasDangerousHtml');\n\n/**\n * Unwrapping/removing this node would change the combinator / structural-pseudo match-set of itself,\n * its child, or a former sibling. Empty `reparentImpact` ⇒ structurally safe to hoist.\n */\nconst affectsSelectorMatching: Matcher = (node, ctx) => {\n  const el = asElement(node);\n  if (!el) return false;\n  return ctx.selectors.reparentImpact(el.id as unknown as IRNodeId).size > 0;\n};\n\n/**\n * The opacity-barrier + selector-safety guards every `flatten/*` pattern must carry. Auto-applied to\n * the declarative match so authors never hand-write them (the flatten exemplars spell them out).\n *\n * Flatten UNWRAPS the element (moving its children into a new parent and dropping its box), so every\n * opacity barrier matters: a ref, event handler, dynamic child, or raw HTML on the wrapper — or any\n * selector the reparent would disturb — makes the flatten unsafe.\n */\nconst FLATTEN_GUARDS: Matcher = and(\n  not(hasRef),\n  not(hasEventHandlers),\n  not(hasDynamicChildren),\n  not(hasRawHtml),\n  not(targetedByCombinator),\n  not(affectsSelectorMatching),\n);\n\n/**\n * The guards every `compress/*` pattern must carry. Compress ONLY ever rewrites the element's OWN\n * class tokens (e.g. `px-4 py-4 → p-4`) — it never touches the element's structure, children, or\n * identity. A dynamic `{expr}` child, a ref, an event handler, or `dangerouslySetInnerHTML` is\n * therefore wholly unaffected by a class-only change, so — unlike flatten — those opacity barriers\n * must NOT gate compress. Compress is gated ONLY on what actually makes a class rewrite unsafe:\n *   • a className we can't statically rewrite — a dynamic segment ({@link hasDynamicClasses}) or a\n *     wholly dynamic / spread-derived list ({@link opaque}); and\n *   • the selector-safety guard — a class a CSS combinator selector structurally depends on\n *     ({@link targetedByCombinator}) must not be dropped or rewritten.\n */\nconst COMPRESS_GUARDS: Matcher = and(\n  not(hasDynamicClasses),\n  not(opaque),\n  not(targetedByCombinator),\n);\n\n/* ───────────────────────── match compilation ───────────────────────── */\n\n/** The auto-applied guard set for a pattern's phase (compress vs flatten get different barriers). */\nfunction autoGuardsFor(category: PassCategory): Matcher | null {\n  switch (category.split('/', 1)[0] as PassPhase) {\n    case 'flatten':\n      return FLATTEN_GUARDS;\n    case 'compress':\n      return COMPRESS_GUARDS;\n    default:\n      return null;\n  }\n}\n\nfunction compileDeclarativeMatch(m: DeclarativeMatch): Matcher {\n  const parts: Matcher[] = [isElement(m.tag)];\n  if (m.style) parts.push(computed(plainToStyleMap(m.style)));\n  if (m.onlyChild === 'element') parts.push(hasSingleElementChild);\n  if (m.paintsNothing) parts.push(not(hasOwnVisualStyle));\n  if (m.where) {\n    const extra = Array.isArray(m.where) ? (m.where as readonly Matcher[]) : [m.where as Matcher];\n    for (const w of extra) parts.push(w);\n  }\n  return and(...parts);\n}\n\nfunction compileMatch(\n  match: DeclarativeMatch | MatchFn | undefined,\n  category: PassCategory,\n): MatchFn {\n  // Escape hatch: a raw predicate takes full control (no auto-guards).\n  if (typeof match === 'function') return match;\n\n  const declarative = compileDeclarativeMatch(match ?? {});\n  const guards = autoGuardsFor(category);\n  const guarded = guards ? and(declarative, guards) : declarative;\n  return (node, ctx) => guarded(node, ctx);\n}\n\n/* ───────────────────────── rewrite compilation ───────────────────────── */\n\n/** Clone `sm`, pruning every `shadowed` provenance entry that references a dropped class token. */\nfunction pruneShadowed(sm: StyleMap, drop: ReadonlySet<string>): StyleMap {\n  const blocks = new Map<ConditionKey, StyleBlock>();\n  for (const [key, block] of sm.blocks) {\n    const decls = new Map<CssProperty, StyleDecl>();\n    for (const [prop, decl] of block.decls) {\n      const filtered = (decl.shadowed ?? []).filter(\n        (o) => !(o.kind === 'class' && drop.has(o.className)),\n      );\n      const rest: StyleDecl = { ...decl };\n      delete (rest as { shadowed?: readonly StyleOrigin[] }).shadowed;\n      const next: StyleDecl = filtered.length > 0 ? { ...rest, shadowed: filtered } : rest;\n      decls.set(prop, next);\n    }\n    blocks.set(key, { condition: block.condition, decls });\n  }\n  return { blocks };\n}\n\nfunction compileFlattenInto(recipe: FlattenIntoRecipe): RewriteFn {\n  const childGains = recipe.childGains ? plainToStyleMap(recipe.childGains) : null;\n  const fold = recipe.foldInherited !== false;\n  return (ctx, rw) => {\n    const wrapper = ctx.node;\n    const child = ctx.onlyElementChild();\n    if (!child) return null;\n    const ops: RewriteOpDraft[] = [];\n    if (fold) ops.push(rw.foldInheritedStyles(wrapper, child, { conditions: 'all' }));\n    if (childGains) ops.push(rw.mergeStyle(child, null, childGains, 'source-wins'));\n    ops.push(rw.unwrap(wrapper));\n    return ops;\n  };\n}\n\nfunction compileRewrite(rewrite: RewriteRecipe | RewriteFn): RewriteFn {\n  if (typeof rewrite === 'function') return rewrite;\n\n  if ('flattenInto' in rewrite) return compileFlattenInto(rewrite);\n\n  if ('rewriteClasses' in rewrite) {\n    const preserveOpaque = rewrite.preserveOpaque ?? true;\n    return (ctx, rw) => {\n      const next = rewrite.rewriteClasses(ctx.computed(), ctx);\n      if (!next) return null;\n      return [rw.setClassList(ctx.node, next, preserveOpaque)];\n    };\n  }\n\n  if ('dropClasses' in rewrite) {\n    const preserveOpaque = rewrite.preserveOpaque ?? true;\n    return (ctx, rw) => {\n      const drop = new Set<string>(rewrite.dropClasses(ctx.computed(), ctx));\n      if (drop.size === 0) return null;\n      return [rw.setClassList(ctx.node, pruneShadowed(ctx.computed(), drop), preserveOpaque)];\n    };\n  }\n\n  // MergeStyleRecipe\n  const style = plainToStyleMap(rewrite.mergeStyle);\n  const onConflict = rewrite.onConflict ?? 'abort';\n  return (ctx, rw) => [rw.mergeStyle(ctx.node, null, style, onConflict)];\n}\n\n/* ───────────────────────── the public factory ───────────────────────── */\n\n/**\n * THE declarative pattern-authoring function. Compile a {@link PatternConfig} (definition + co-located\n * {@link PatternTest}) into a validated {@link AuthoredPattern}: a normal {@link Pattern} (registerable\n * into any {@link import('@domflax/core').Pass}) that also exposes its `test` for the generic harness.\n */\nexport function definePattern(config: PatternConfig): AuthoredPattern {\n  const matchFn = compileMatch(config.match, config.category);\n  const rewriteFn = compileRewrite(config.rewrite);\n\n  const spec: AuthoredPattern = {\n    name: config.name,\n    category: config.category,\n    safety: config.safety,\n    priority: config.priority,\n    precondition: config.precondition,\n    doc: config.doc,\n    test: config.test,\n    evaluate(ctx: MatchContext, rw: RewriteFactory): MatchResult | null {\n      if (!matchFn(ctx.node as unknown as NodeLike, ctx)) return null;\n      const ops = rewriteFn(ctx, rw);\n      if (!ops || ops.length === 0) return null;\n      return { ops };\n    },\n  };\n\n  // `validatePattern` validates + freezes; the spread preserves `test` at runtime.\n  return validatePattern(spec) as AuthoredPattern;\n}\n\n/**\n * @deprecated Use {@link definePattern}. Retained as a thin alias for backward compatibility.\n */\nexport const pattern = definePattern;\n","/**\n * @domflax/pattern-kit — `validatePattern` (INTERNAL).\n *\n * A small, eager validator + identity wrapper that turns a lowered {@link Pattern} spec into a\n * frozen, contract-checked Pattern. Catching shape errors here (bad category/phase, missing\n * `evaluate`, out-of-range safety) keeps the pass-manager's hot loop free of defensive checks and\n * gives authors an immediate, actionable error at module-load time.\n *\n * This is the PRIVATE lower-level core: it is consumed only by the declarative\n * {@link import('./pattern').definePattern} authoring surface (which compiles a high-level config\n * down to a {@link Pattern} and then runs it through this validator). It is intentionally NOT part\n * of the public package surface — authors use `definePattern` instead.\n */\n\nimport type { PassPhase, Pattern, SafetyLevel } from '@domflax/core';\n\nconst PHASES: ReadonlySet<PassPhase> = new Set<PassPhase>(['flatten', 'compress', 'extract']);\nconst SAFETY_LEVELS: ReadonlySet<SafetyLevel> = new Set<SafetyLevel>([0, 1, 2, 3]);\n\nfunction fail(name: string, why: string): never {\n  throw new Error(`definePattern(${name || '<anonymous>'}): ${why}`);\n}\n\n/**\n * Validate and freeze a {@link Pattern}. Throws on any contract violation; otherwise returns the\n * (shallow-frozen) spec unchanged so it can be registered into a {@link Pass}. INTERNAL — see the\n * module header; authors call the declarative {@link import('./pattern').definePattern}.\n */\nexport function validatePattern(spec: Pattern): Pattern {\n  if (spec == null || typeof spec !== 'object') {\n    throw new Error('definePattern: spec must be an object');\n  }\n\n  const name = spec.name;\n  if (typeof name !== 'string' || name.length === 0) {\n    fail(String(name), 'name must be a non-empty string');\n  }\n\n  if (typeof spec.category !== 'string' || !spec.category.includes('/')) {\n    fail(name, `category must be a \"<phase>/<slug>\" string (got ${JSON.stringify(spec.category)})`);\n  }\n\n  const phase = spec.category.split('/', 1)[0] as PassPhase;\n  if (!PHASES.has(phase)) {\n    fail(name, `category phase must be one of flatten|compress|extract (got \"${phase}\")`);\n  }\n\n  if (!SAFETY_LEVELS.has(spec.safety)) {\n    fail(name, `safety must be 0|1|2|3 (got ${JSON.stringify(spec.safety)})`);\n  }\n\n  if (typeof spec.evaluate !== 'function') {\n    fail(name, 'evaluate must be a function');\n  }\n\n  if (spec.priority !== undefined && !Number.isFinite(spec.priority)) {\n    fail(name, 'priority must be a finite number when provided');\n  }\n\n  return Object.freeze({ ...spec });\n}\n","/**\n * @domflax/pattern-kit — the authoring surface for rewrite patterns.\n *\n * Re-exports the pillars pattern authors compose with:\n *   • {@link definePattern} — THE declarative pattern factory (definition + co-located tests). The\n *     lower-level validator it compiles down to is intentionally kept private (see `./define`).\n *   • the matcher vocabulary (`and`/`or`/`not`/`isElement`/`computed`/… ) from `./combinators`.\n *   • the op-draft constructors (`mergeStyle`/`foldInheritedStyles`/`replaceWith`/`removeNode`).\n *   • the shared {@link normalizer} (also consumed by core + verify) from `./normalize`.\n *\n * The generic test harness lives in the separate `./testing` entry (it imports vitest) so the main\n * authoring surface stays runtime-light and frontend-agnostic.\n */\n\nexport * from './combinators';\nexport * from './ops';\nexport * from './normalize';\nexport * from './pattern';\n"],"mappings":"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","names":["childIds","isInherited","pattern","normalizer","normalizer","computed","idOf","asElement"]}

package/dist/{chunk-6WVVF6AD.js → chunk-U5GOONKV.js}

@@ -36,11 +36,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // ../../node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
-var getFilename, __filename;
+var getFilename, getDirname, __dirname, __filename;
 var init_esm_shims = __esm({
   "../../node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
     getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
     __filename = /* @__PURE__ */ getFilename();
   }
 });
@@ -49,7 +51,8 @@ export {
   __require,
   __commonJS,
   __toESM,
+  __dirname,
   __filename,
   init_esm_shims
 };
-//# sourceMappingURL=chunk-6WVVF6AD.js.map
+//# sourceMappingURL=chunk-U5GOONKV.js.map

package/dist/{chunk-6WVVF6AD.js.map → chunk-U5GOONKV.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../../node_modules/tsup/assets/esm_shims.js"],"sourcesContent":["// Shim globals in esm bundle\nimport path from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\nconst getFilename = () => fileURLToPath(import.meta.url)\nconst getDirname = () => path.dirname(getFilename())\n\nexport const __dirname = /* @__PURE__ */ getDirname()\nexport const __filename = /* @__PURE__ */ getFilename()\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAF9B,IAIM,aAIO;AARb;AAAA;AAAA;AAIA,IAAM,cAAc,MAAM,cAAc,YAAY,GAAG;AAIhD,IAAM,aAA6B,4BAAY;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../../../node_modules/tsup/assets/esm_shims.js"],"sourcesContent":["// Shim globals in esm bundle\nimport path from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\nconst getFilename = () => fileURLToPath(import.meta.url)\nconst getDirname = () => path.dirname(getFilename())\n\nexport const __dirname = /* @__PURE__ */ getDirname()\nexport const __filename = /* @__PURE__ */ getFilename()\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAF9B,IAIM,aACA,YAEO,WACA;AARb;AAAA;AAAA;AAIA,IAAM,cAAc,MAAM,cAAc,YAAY,GAAG;AACvD,IAAM,aAAa,MAAM,KAAK,QAAQ,YAAY,CAAC;AAE5C,IAAM,YAA4B,2BAAW;AAC7C,IAAM,aAA6B,4BAAY;AAAA;AAAA;","names":[]}