domflax 0.1.4 → 0.2.0

package/dist/chunk-FPT4EJ6Q.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../patterns/src/library/flex/flex-center-wrapper.pattern.ts","../../patterns/src/library/fragment/redundant-fragment.pattern.ts","../../patterns/src/library/grid/grid-center-wrapper.pattern.ts","../../patterns/src/library/wrapper/display-contents-wrapper.pattern.ts","../../patterns/src/library/wrapper/empty-style-div.pattern.ts","../../patterns/src/library/wrapper/inherited-only-wrapper.pattern.ts","../../patterns/src/library/wrapper/passthrough-wrapper.pattern.ts","../../patterns/src/library/wrapper/redundant-inline-wrapper.pattern.ts","../../patterns/src/_registry.generated.ts","../../patterns/src/index.ts","../../resolver-tailwind/src/tailwind/resolver.ts","../../resolver-tailwind/src/tailwind/emit.ts","../../resolver-tailwind/src/tailwind/fingerprint.ts","../../resolver-tailwind/src/tailwind/engine.ts","../../resolver-tailwind/src/tailwind/engine-v4.ts","../../resolver-tailwind/src/tailwind/v4-bridge.ts","../../resolver-tailwind/src/tailwind/v4-css.ts","../../resolver-tailwind/src/tailwind/extract.ts","../../resolver-tailwind/src/tailwind/selector.ts","../../resolver-tailwind/src/tailwind/serialize.ts","../../resolver-tailwind/src/tailwind/stylemap.ts","../../resolver-tailwind/src/tailwind/usage.ts","../../resolver-tailwind/src/index.ts","../../resolver-css/src/resolver.ts","../../resolver-css/src/constants.ts","../../resolver-css/src/engine.ts","../../resolver-css/src/postcss-helpers.ts","../../resolver-css/src/misc-helpers.ts","../../resolver-css/src/selector-helpers.ts","../../resolver-css/src/index.ts","../../frontend-html/src/index.ts","../../frontend-html/src/backend.ts","../../frontend-html/src/parse.ts","../../frontend-html/src/walk.ts","../../frontend-jsx/src/frontend.ts","../../frontend-jsx/src/frontend-ast.ts","../../frontend-jsx/src/frontend-parse.ts","../../frontend-jsx/src/backend.ts","../../frontend-jsx/src/index.ts"],"sourcesContent":["/**\n * @domflax/patterns — flatten pattern: `flex-center-wrapper`.\n *\n * Collapses the ubiquitous \"centering wrapper\" idiom\n *\n *   <div style=\"display:flex; align-items:center; justify-content:center\"><Child/></div>\n *\n * into its sole child, pushing the centering intent down onto the child as `place-self: center`.\n * The wrapper only exists to center one element; once `place-self:center` lives on the child the\n * wrapper is pure structural noise and can go.\n *\n * Authored with the declarative {@link definePattern} API: the match is the flex-centering\n * computed-style signature on a single-element-child `<div>` that paints nothing of its own; the\n * recipe folds inheritable styles onto the child, grants it `place-self:center`, then unwraps the\n * wrapper (id-preserving). The opacity-barrier + selector-safety guards are applied automatically by\n * the `definePattern` factory for every `flatten/*` pattern.\n */\n\nimport { definePattern } from '@domflax/pattern-kit';\n\n/**\n * Flatten a flex-centering `<div>` wrapper into its sole element child, granting the child\n * `place-self:center`.\n */\nexport const flexCenterWrapper = definePattern({\n  name: 'flex-center-wrapper',\n  category: 'flatten/flex/flex-center-wrapper',\n  safety: 2,\n  doc: {\n    title: 'Flatten flex-centering wrapper',\n    summary:\n      'A div that only centers a single child (display:flex; align-items:center; ' +\n      'justify-content:center) is removed; the child gains place-self:center.',\n    before: '<div style=\"display:flex;align-items:center;justify-content:center\"><Child/></div>',\n    after: '<Child style=\"place-self:center\"/>',\n    safetyRationale:\n      'Wrapper paints nothing, carries no ref/handlers/dynamic children, and is not a combinator ' +\n      'subject; inheritable styles are folded onto the child before removal.',\n  },\n  match: {\n    tag: 'div',\n    style: { display: 'flex', alignItems: 'center', justifyContent: 'center' },\n    onlyChild: 'element',\n    paintsNothing: true,\n  },\n  rewrite: {\n    flattenInto: 'child',\n    childGains: { placeSelf: 'center' },\n  },\n  // Collapsing a flex-centering wrapper to `place-self:center` on the child is render-identical ONLY\n  // when the child's NEW parent is a statically-known GRID that lets the wrapper fill its area (there\n  // `place-self`'s align-self AND justify-self both take effect). Under that ONE context the flatten is\n  // classified `provably-safe` and commits; under a flex/block/unknown parent — or when the wrapper\n  // drops any own style — it stays `needs-verification` and the conservative production gate PRESERVES\n  // it. Op-level correctness (purity, id-preserving unwrap, opacity-barrier safety) is additionally\n  // asserted by the invariant suite over every pattern.\n  test: {\n    cases: [\n      {\n        name: 'grid parent → flattened (child gains place-self-center)',\n        before:\n          '<div className=\"grid\">' +\n          '<div className=\"flex items-center justify-center\"><span className=\"bg-red-200\">x</span></div>' +\n          '</div>',\n        after: '<div className=\"grid\"><span className=\"bg-red-200 place-self-center\">x</span></div>',\n      },\n    ],\n    noMatch: [\n      // Non-grid (flex) parent (document root): `justify-self` is ignored in flex → not provably safe.\n      '<div className=\"flex justify-center items-center\"><div className=\"bg-red-200\">Hello</div></div>',\n      // Grid parent, but the wrapper drops padding when removed → not layout-neutral (rule 3).\n      '<div className=\"grid\">' +\n        '<div className=\"p-4 flex items-center justify-center\"><span className=\"bg-red-200\">x</span></div>' +\n        '</div>',\n      // Grid parent forcing place-items-center: the wrapper would not fill its area → fill guard skips.\n      '<div className=\"grid place-items-center\">' +\n        '<div className=\"flex items-center justify-center\"><span className=\"bg-red-200\">x</span></div>' +\n        '</div>',\n      // onClick is a hard opacity barrier → the wrapper is load-bearing regardless of the gate.\n      '<div className=\"flex justify-center items-center\" onClick={handleClick}>' +\n        '<div className=\"bg-red-200\">Hello</div>' +\n        '</div>',\n    ],\n  },\n});\n","/**\n * @domflax/patterns — flatten pattern: `redundant-fragment`.\n *\n * Collapses a fragment that wraps exactly one child\n *\n *   <><Child/></>            →   <Child/>\n *\n * A fragment renders no box of its own, so a fragment whose sole purpose is to wrap a single node\n * is pure structural noise: splicing the child up into the fragment's slot is invisible in both\n * the rendered DOM and the project's CSS cascade.\n *\n * Anchoring: the pass manager only visits ELEMENT nodes (see core's `elementIds`), never fragments,\n * so this pattern is anchored on the fragment's sole *element* child and removes the PARENT fragment.\n * Because the match is PARENT-anchored (and reads a fragment's `meta`, which the element-only\n * combinator vocabulary cannot inspect), it uses the declarative API's two escape hatches: a raw\n * `match` predicate and a raw `rewrite` op-draft factory.\n */\n\nimport type {\n  DeepReadonly,\n  ElementLike,\n  IRNode,\n  IRNodeId,\n  MatchContext,\n  NodeLike,\n  RewriteFactory,\n  RewriteOpDraft,\n} from '@domflax/core';\n\nimport { definePattern } from '@domflax/pattern-kit';\n\n/* ───────────────────────── match predicate (escape hatch) ───────────────────────── */\n\n/**\n * Matches an element whose PARENT is a redundant, unwrappable fragment: a non-root fragment with\n * exactly one child (this element), free of every opacity barrier and CSS-targeting coupling.\n */\nfunction parentIsRedundantFragment(node: NodeLike, ctx: MatchContext): boolean {\n  const el = node as DeepReadonly<IRNode>;\n  if (el.kind !== 'element') return false;\n\n  const parentId = el.parent;\n  if (parentId == null) return false;\n\n  const parent = ctx.doc.nodes.get(parentId);\n  if (!parent || parent.kind !== 'fragment') return false;\n\n  // Never unwrap the document root (it must always be a fragment — IRDocument invariant).\n  if (parent.parent == null) return false;\n\n  // Exactly one child (counting EVERY kind) ⇒ the anchor element is the fragment's sole child.\n  if (parent.children.length !== 1) return false;\n\n  // Hard opacity barriers on the fragment: keyed `<Fragment key>`, ref/handlers/dynamic children/\n  // dangerous HTML/spread/component identity. Any of these means the fragment is load-bearing.\n  const m = parent.meta;\n  if (\n    m.hasKey ||\n    m.hasRef ||\n    m.hasEventHandlers ||\n    m.hasDynamicChildren ||\n    m.hasDangerousHtml ||\n    m.hasSpreadAttrs ||\n    m.isComponent\n  ) {\n    return false;\n  }\n\n  // CSS-selector safety: the fragment (or its reparented child) must not move any combinator /\n  // structural-pseudo match-set. Honour both the frontend-set meta flags and the SelectorIndex.\n  if (m.targetedByCombinator || m.targetedByStructuralPseudo) return false;\n  const fid = parentId as unknown as IRNodeId;\n  if (ctx.selectors.targetedByCombinator(fid) || ctx.selectors.targetedByStructuralPseudo(fid)) {\n    return false;\n  }\n  if (ctx.selectors.reparentImpact(fid).size > 0) return false;\n\n  return true;\n}\n\n/* ───────────────────────── the pattern ───────────────────────── */\n\n/**\n * Flatten a fragment that wraps exactly one child into that child.\n *\n * Safety level 1 (`safe`): a purely structural, style-free, selector-transparent cleanup.\n */\nexport const redundantFragment = definePattern({\n  name: 'redundant-fragment',\n  category: 'flatten/fragment/redundant-fragment',\n  safety: 1,\n  doc: {\n    title: 'Flatten redundant single-child fragment',\n    summary:\n      'A fragment whose only child is a single node is removed; the child is spliced up into the ' +\n      \"fragment's slot, preserving its IRNodeId, siblings, attributes and the CSS cascade.\",\n    before: '<><Child/></>',\n    after: '<Child/>',\n    safetyRationale:\n      'A fragment paints nothing and renders no box; with exactly one child its removal changes ' +\n      'no sibling/structural-pseudo match-set. Keyed fragments and fragments carrying ' +\n      'ref/handlers/dynamic-children/raw-html/spread are excluded as opacity barriers.',\n  },\n  match: parentIsRedundantFragment,\n  rewrite: (ctx: MatchContext, rw: RewriteFactory): readonly RewriteOpDraft[] | null => {\n    const parentId = ctx.node.parent;\n    if (parentId == null) return null;\n    const fragment = ctx.doc.nodes.get(parentId);\n    if (!fragment || fragment.kind !== 'fragment') return null;\n    // Splice the sole child up into the fragment's slot, deleting ONLY the fragment node.\n    return [rw.unwrap(fragment as unknown as ElementLike)];\n  },\n  test: {\n    cases: [\n      {\n        // A fragment renders no box, so unwrapping a single-child fragment is always layout-identical\n        // → a provably-safe flatten: the child is spliced up into the fragment's slot.\n        before: '<><span className=\"bg-red-200\">Hi</span></>',\n        after: '<span className=\"bg-red-200\">Hi</span>',\n      },\n    ],\n    noMatch: [\n      // Two children ⇒ not a single-child fragment, so the fragment is load-bearing and stays.\n      '<><span className=\"bg-red-200\">A</span><span className=\"bg-green-200\">B</span></>',\n    ],\n  },\n});\n","/**\n * @domflax/patterns — flatten pattern: `grid-center-wrapper`.\n *\n * Collapses the grid flavour of the \"centering wrapper\" idiom\n *\n *   <div style=\"display:grid; align-items:center; justify-content:center\"><Child/></div>\n *\n * into its sole child, pushing the centering intent down onto the child as `place-self:center`. This is\n * the grid analogue of `flex-center-wrapper`: the wrapper only exists to center one element, and once\n * `place-self:center` lives on the child the wrapper is pure structural noise.\n *\n * Authored with the declarative {@link definePattern} API: the match is the grid-centering computed-style\n * signature on a single-element-child `<div>` that paints nothing of its own; the recipe folds\n * inheritable styles onto the child, grants it `place-self:center`, then unwraps the wrapper. The\n * opacity-barrier + selector-safety guards are auto-applied for every `flatten/*` pattern.\n *\n * Genuinely additive under the conservative gate: unlike a plain passthrough (which the gate REVERTS on\n * a grid wrapper because grid establishes a formatting context), the compensating `place-self:center`\n * makes the flatten `provably-safe` — but ONLY when the child's NEW parent is a statically-known grid\n * that lets the wrapper fill its area (the ONE context where the child's `justify-self` is honored).\n */\n\nimport { definePattern } from '@domflax/pattern-kit';\n\n/**\n * Flatten a grid-centering `<div>` wrapper into its sole element child, granting the child\n * `place-self:center`.\n */\nexport const gridCenterWrapper = definePattern({\n  name: 'grid-center-wrapper',\n  category: 'flatten/grid/grid-center-wrapper',\n  safety: 2,\n  doc: {\n    title: 'Flatten grid-centering wrapper',\n    summary:\n      'A div that only centers a single child (display:grid; align-items:center; ' +\n      'justify-content:center) is removed; the child gains place-self:center.',\n    before: '<div style=\"display:grid;align-items:center;justify-content:center\"><Child/></div>',\n    after: '<Child style=\"place-self:center\"/>',\n    safetyRationale:\n      'Wrapper paints nothing, carries no ref/handlers/dynamic children, and is not a combinator ' +\n      'subject; inheritable styles are folded onto the child before removal. The place-self:center ' +\n      'collapse is committed by the gate only under a statically-known filling grid parent.',\n  },\n  match: {\n    tag: 'div',\n    style: { display: 'grid', alignItems: 'center', justifyContent: 'center' },\n    onlyChild: 'element',\n    paintsNothing: true,\n  },\n  rewrite: {\n    flattenInto: 'child',\n    childGains: { placeSelf: 'center' },\n  },\n  // Like `flex-center-wrapper`, collapsing to `place-self:center` is render-identical ONLY when the\n  // child's NEW parent is a statically-known GRID that lets the wrapper fill its area (there both halves\n  // of place-self take effect). Under that ONE context the flatten is `provably-safe` and commits; under\n  // a flex/block/unknown parent — or when the wrapper drops any own style — it stays `needs-verification`\n  // and the conservative production gate PRESERVES it. Op-level correctness is asserted by the invariant suite.\n  test: {\n    cases: [\n      {\n        name: 'grid parent → flattened (child gains place-self-center)',\n        before:\n          '<div className=\"grid\">' +\n          '<div className=\"grid items-center justify-center\"><span className=\"bg-red-200\">x</span></div>' +\n          '</div>',\n        after: '<div className=\"grid\"><span className=\"bg-red-200 place-self-center\">x</span></div>',\n      },\n    ],\n    noMatch: [\n      // Non-grid (document-root) parent: justify-self is ignored outside a grid → not provably safe.\n      '<div className=\"grid justify-center items-center\"><div className=\"bg-red-200\">Hello</div></div>',\n      // Grid parent, but the wrapper drops padding when removed → not layout-neutral, preserved.\n      '<div className=\"grid\">' +\n        '<div className=\"p-4 grid items-center justify-center\"><span className=\"bg-red-200\">x</span></div>' +\n        '</div>',\n      // onClick is a hard opacity barrier → the wrapper is load-bearing regardless of the gate.\n      '<div className=\"grid justify-center items-center\" onClick={handleClick}>' +\n        '<div className=\"bg-red-200\">Hello</div>' +\n        '</div>',\n    ],\n  },\n});\n","/**\n * @domflax/patterns — flatten pattern: `display-contents-wrapper`.\n *\n * Collapses a wrapper that has explicitly opted OUT of generating a box:\n *\n *   <div style=\"display:contents\"><Child/></div>   →   <Child/>\n *\n * `display:contents` makes an element generate NO box of its own — its children render exactly as if\n * they were direct children of the element's parent. A `display:contents` wrapper with a single\n * element child is therefore already a layout passthrough: it contributes nothing to flow, paint\n * (a contents box paints nothing), formatting, stacking, or containing-block resolution. Removing it\n * and hoisting the child produces a tree that is layout-identical — the wrapper's only remaining\n * effect was inheritance, which is preserved by folding inheritable declarations onto the child first.\n *\n * This is the safest possible wrapper-elimination: the box being removed provably did not exist.\n * The opacity-barrier + selector-safety guards (ref/handlers/dynamic-children/raw-html/combinator/\n * reparent-impact) are auto-applied for every `flatten/*` pattern; the `where` predicates add the\n * passthrough-specific requirements (no own attrs / dynamic-or-spread classes, no `var()` coupling,\n * not a component, not a structural-pseudo subject).\n *\n * (Chosen as the safe variant of the size-hoisting \"full-size passthrough\" idea: hoisting an explicit\n * `width/height:100%` onto a child is only sound when the child is block-level and unsized, which is\n * not knowable from the wrapper alone — whereas a `display:contents` box is a passthrough by definition.)\n */\n\nimport type {\n  DeepReadonly,\n  IRElement,\n  IRNode,\n  IRNodeId,\n  NodeLike,\n  NodeMeta,\n} from '@domflax/core';\n\nimport { definePattern, hasDynamicClasses, not, type Matcher } from '@domflax/pattern-kit';\n\n/* ───────────────────────── local meta/attr/selector matchers ───────────────────────── */\n\nfunction asEl(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 metaOf(node: NodeLike): DeepReadonly<NodeMeta> | null {\n  return asEl(node)?.meta ?? null;\n}\n\n/**\n * Element exposes custom properties to a descendant — removing its box could sever a `var()` coupling,\n * so it is NOT a free passthrough. (A `display:contents` box establishes no formatting/stacking/box\n * context and is no containing block, so those flags need not be checked.)\n */\nconst declaresCustomProperties: Matcher = (node) => metaOf(node)?.declaresCustomProperties ?? false;\n\n/** Hard opacity barriers beyond the auto-applied set: spread attrs, component identity. */\nconst hasSpreadAttrs: Matcher = (node) => metaOf(node)?.hasSpreadAttrs ?? false;\nconst isComponentNode: Matcher = (node) => metaOf(node)?.isComponent ?? false;\n\n/** Element carries own attributes (id / data-* / …) beyond its class list — possible selector/JS hook. */\nconst hasOwnAttrs: Matcher = (node) => {\n  const el = asEl(node);\n  if (!el) return false;\n  return el.attrs.entries.size > 0 || el.attrs.spreads.length > 0;\n};\n\n/**\n * Element is the subject of a structural pseudo (`:first/:last/:only/:nth-*`). Honours the meta flag\n * and the precomputed {@link SelectorIndex}.\n */\nconst targetedByStructuralPseudo: Matcher = (node, ctx) => {\n  const el = asEl(node);\n  if (!el) return false;\n  if (el.meta.targetedByStructuralPseudo) return true;\n  return ctx.selectors.targetedByStructuralPseudo(el.id as unknown as IRNodeId);\n};\n\n/* ───────────────────────── the pattern ───────────────────────── */\n\n/**\n * Flatten a `display:contents` wrapper (a box that generates no box) into its sole element child,\n * folding any inheritable styles down first so inherited values survive the removal.\n */\nexport const displayContentsWrapper = definePattern({\n  name: 'display-contents-wrapper',\n  category: 'flatten/wrapper/display-contents-wrapper',\n  safety: 2,\n  doc: {\n    title: 'Flatten display:contents wrapper',\n    summary:\n      'A div with display:contents (which generates no box) wrapping a single element child, with ' +\n      'no own visual style, no attributes beyond an inert class, and no opacity barriers, is removed; ' +\n      'its sole child is hoisted in its place.',\n    before: '<div style=\"display:contents\"><Child/></div>',\n    after: '<Child/>',\n    safetyRationale:\n      'A display:contents element generates no box at all, so its children already render as direct ' +\n      \"children of its parent; removing it is layout-identical. It paints nothing, establishes no \" +\n      'formatting/stacking/box context, is no containing block, carries no ' +\n      'ref/handlers/dynamic-children/html/spread/component identity, owns no targetable attrs / ' +\n      'custom-property coupling, and is not a combinator/structural-pseudo subject; inheritable ' +\n      'styles are folded onto the child before removal.',\n  },\n  match: {\n    tag: 'div',\n    style: { display: 'contents' },\n    onlyChild: 'element',\n    paintsNothing: true,\n    where: [\n      not(declaresCustomProperties),\n      not(hasOwnAttrs),\n      not(hasDynamicClasses),\n      not(hasSpreadAttrs),\n      not(isComponentNode),\n      not(targetedByStructuralPseudo),\n    ],\n  },\n  rewrite: { flattenInto: 'child' },\n  test: {\n    cases: [\n      {\n        // `display:contents` generates no box, so removing it is provably layout-identical → the\n        // wrapper is flattened even under the conservative gate; the child is hoisted.\n        before: '<div className=\"contents\"><a className=\"text-blue-500\">Link</a></div>',\n        after: '<a className=\"text-blue-500\">Link</a>',\n      },\n    ],\n    noMatch: [\n      // A ref pins the wrapper's element identity (a hard opacity barrier) → not a passthrough.\n      '<div className=\"contents\" ref={rootRef}><a className=\"text-blue-500\">Link</a></div>',\n    ],\n  },\n});\n","/**\n * @domflax/patterns — flatten pattern: `empty-style-div`.\n *\n * Collapses the most common piece of structural noise of all: a `<div>` whose ONLY role is to wrap\n * a single child while contributing nothing to layout or paint —\n *\n *   <div><Child/></div>            (no styles at all)\n *   <div style=\"display:block\"><Child/></div>   (the default; still a no-op box)\n *\n * Such a div is layout-neutral: it is a plain block box with no own visual style, establishes no\n * box / formatting / stacking context, is not a containing block, and declares no custom properties\n * a descendant might read. Its box is therefore indistinguishable from \"not being there\", so it can\n * be unwrapped into its sole child.\n *\n * Authored with the declarative {@link definePattern} API. The opacity-barrier + selector-safety\n * guards (ref/handlers/dynamic-children/raw-html/combinator/reparent-impact) are applied\n * automatically for every `flatten/*` pattern; the `where` predicates below add the LAYOUT-neutrality\n * requirements specific to this pattern (no non-block display, no box/formatting/stacking context, no\n * containing block, no custom-property coupling, no structural-pseudo targeting).\n */\n\nimport type {\n  CssProperty,\n  DeepReadonly,\n  IRElement,\n  IRNode,\n  IRNodeId,\n  NodeLike,\n  NodeMeta,\n  StyleMap,\n} from '@domflax/core';\n\nimport { definePattern, not, type Matcher } from '@domflax/pattern-kit';\n\n/* ───────────────────────── local matcher helpers ───────────────────────── */\n\n/** Narrow a NodeLike to a (readonly) element, or null. */\nfunction asEl(node: NodeLike): DeepReadonly<IRElement> | null {\n  const n = node as DeepReadonly<IRNode>;\n  return n.kind === 'element' ? (n as DeepReadonly<IRElement>) : null;\n}\n\n/** A boolean `meta` flag, lifted into a {@link Matcher}. Mirrors how core's combinators read meta. */\nfunction metaFlag(flag: keyof NodeMeta): Matcher {\n  return (node) => Boolean(asEl(node)?.meta[flag]);\n}\n\n/** Wrapper establishes an intrinsic/explicit box (sizing) — NOT layout-neutral. */\nconst establishesBox = metaFlag('establishesBox');\n/** Wrapper establishes a formatting context (flex/grid/flow-root/…) — NOT layout-neutral. */\nconst establishesFormattingContext = metaFlag('establishesFormattingContext');\n/** Wrapper establishes a stacking context (transform/opacity<1/z-index/…) — NOT layout-neutral. */\nconst establishesStackingContext = metaFlag('establishesStackingContext');\n/** Wrapper is the containing block for abs/fixed descendants — removing it would reposition them. */\nconst isContainingBlock = metaFlag('isContainingBlock');\n/** Wrapper sets `--*` custom properties a descendant reads (author-var coupling). */\nconst declaresCustomProperties = metaFlag('declaresCustomProperties');\n\n/**\n * Wrapper is a structural-pseudo target (:first/:last/:only/:nth-child/-of-type). Honours the\n * frontend-set meta flag and the precomputed {@link SelectorIndex}. Unwrapping such a node would\n * change a selector's match-set.\n */\nconst targetedByStructuralPseudo: Matcher = (node, ctx) => {\n  const el = asEl(node);\n  if (!el) return false;\n  if (el.meta.targetedByStructuralPseudo) return true;\n  return ctx.selectors.targetedByStructuralPseudo(el.id as unknown as IRNodeId);\n};\n\nconst DISPLAY = 'display' as CssProperty;\n\n/**\n * True when the wrapper sets `display` to anything other than the block default in ANY condition.\n * An `inline`/`inline-block`/`flex`/`grid`/`contents`/`none` div is NOT layout-neutral — its box (or\n * lack of one) participates in layout differently from its surviving child.\n */\nconst hasNonBlockDisplay: Matcher = (node, ctx) => {\n  const el = asEl(node);\n  if (!el) return false;\n  const sm: StyleMap = ctx.computedOf(el as unknown as NodeLike) ?? (el.computed as StyleMap);\n  for (const block of sm.blocks.values()) {\n    const decl = block.decls.get(DISPLAY);\n    if (decl && String(decl.value) !== 'block') return true;\n  }\n  return false;\n};\n\n/* ───────────────────────── the pattern ───────────────────────── */\n\n/**\n * Flatten a layout-neutral, style-free `<div>` wrapper into its sole element child.\n */\nexport const emptyStyleDiv = definePattern({\n  name: 'empty-style-div',\n  category: 'flatten/wrapper/empty-style-div',\n  safety: 1,\n  doc: {\n    title: 'Flatten empty-style div wrapper',\n    summary:\n      'A layout-neutral div (display:block default, no box/visual styles) that wraps a single ' +\n      'child is removed; the child is hoisted into its place.',\n    before: '<div><Child/></div>',\n    after: '<Child/>',\n    safetyRationale:\n      'Wrapper is a plain block box that paints nothing, establishes no box/formatting/stacking ' +\n      'context, is no containing block, has no custom-property coupling, carries no ' +\n      'ref/handlers/dynamic children/raw HTML, and is neither a combinator subject nor a ' +\n      'structural-pseudo target; inheritable styles are folded onto the child before removal.',\n  },\n  match: {\n    tag: 'div',\n    onlyChild: 'element',\n    paintsNothing: true,\n    where: [\n      not(hasNonBlockDisplay),\n      not(establishesBox),\n      not(establishesFormattingContext),\n      not(establishesStackingContext),\n      not(isContainingBlock),\n      not(declaresCustomProperties),\n      not(targetedByStructuralPseudo),\n    ],\n  },\n  rewrite: { flattenInto: 'child' },\n  test: {\n    cases: [\n      {\n        // A layout-neutral, style-free block div is a provably-safe flatten → removed, child hoisted.\n        before: '<div><span className=\"bg-red-200\">Hi</span></div>',\n        after: '<span className=\"bg-red-200\">Hi</span>',\n      },\n    ],\n    noMatch: [\n      // The wrapper paints its own background (own visual style) → not layout-neutral, kept.\n      '<div className=\"bg-blue-500\"><span className=\"bg-red-200\">Hi</span></div>',\n    ],\n  },\n});\n","/**\n * @domflax/patterns — flatten pattern: `inherited-only-wrapper`.\n *\n * Collapses a paint-free wrapper whose ONLY own declarations are INHERITED properties\n * (`text-align`, `color`, `font-*`, `line-height`, `letter-spacing`, `white-space`, …):\n *\n *   <div style=\"text-align:center\"><Child/></div>   →   <Child style=\"text-align:center\"/>\n *\n * An inherited property on a wrapper reaches its descendants purely through inheritance, so folding it\n * onto the sole child and removing the box is render-identical — the child (and everything below it)\n * still sees the same inherited value. The wrapper carries nothing NON-inherited (no padding, margin,\n * sizing, border, background, layout), so its box contributes nothing to flow or paint.\n *\n * Distinct from `passthrough-wrapper` in INTENT: it recognizes the common \"styling wrapper\" idiom —\n * a box that exists only to set an inherited text/font property on a subtree — and pushes that intent\n * down onto the child. `foldInheritedStyles` (auto-applied by the flatten recipe) performs the fold;\n * the `where` predicate restricts the match to wrappers whose entire own style is inheritable.\n */\n\nimport type { DeepReadonly, IRElement, IRNode } from '@domflax/core';\n\nimport { definePattern, normalizer, not, type Matcher } from '@domflax/pattern-kit';\n\n/**\n * The wrapper is an inert host element — a `<div>` (block) or `<span>` (inline) — whose user-agent\n * default display/box is layout-neutral. Removing such a box is provably safe; removing a UA-significant\n * element instead (`<li>`/`<p>`/`<td>`/…, whose default display or margins are NOT captured in the\n * class-derived computed style) or a component is NOT, so those are excluded. This mirrors the tag guard\n * every other safe wrapper pattern (passthrough/empty-style-div/redundant-inline) relies on.\n */\nconst INERT_HOST_TAGS: ReadonlySet<string> = new Set(['div', 'span']);\nconst isInertHostTag: Matcher = (node) => {\n  const n = node as DeepReadonly<IRNode>;\n  if (n.kind !== 'element') return false;\n  return INERT_HOST_TAGS.has(String((n as DeepReadonly<IRElement>).tag).toLowerCase());\n};\n\n/** Component identity is a hard opacity barrier — never fold-and-remove a component wrapper. */\nconst isComponentNode: Matcher = (node) => {\n  const n = node as DeepReadonly<IRNode>;\n  return n.kind === 'element' ? (n as DeepReadonly<IRElement>).meta.isComponent : false;\n};\n\n/**\n * The wrapper carries at least one own declaration and EVERY own declaration is an inherited property\n * — so the whole wrapper style survives the box removal by being folded onto the child.\n */\nconst hasOnlyInheritedStyle: Matcher = (node, ctx) => {\n  const sm = normalizer.normalizeStyleMap(ctx.computed());\n  let sawAny = false;\n  for (const block of sm.blocks.values()) {\n    for (const decl of block.decls.values()) {\n      sawAny = true;\n      const inherited = decl.inherited || normalizer.inherited.isInherited(decl.property);\n      if (!inherited) return false;\n    }\n  }\n  return sawAny;\n};\n\n/**\n * Flatten a wrapper whose only own style is inherited into its sole element child (folding the\n * inherited declarations down first so the subtree keeps the same inherited values).\n */\nexport const inheritedOnlyWrapper = definePattern({\n  name: 'inherited-only-wrapper',\n  category: 'flatten/wrapper/inherited-only-wrapper',\n  safety: 2,\n  doc: {\n    title: 'Flatten inherited-only styling wrapper',\n    summary:\n      'A paint-free wrapper whose only own declarations are inherited properties (text-align, color, ' +\n      'font-*, …) is removed; its inherited style is folded onto the sole child, which keeps the ' +\n      'same inherited values for the whole subtree.',\n    before: '<div style=\"text-align:center\"><Child/></div>',\n    after: '<Child style=\"text-align:center\"/>',\n    safetyRationale:\n      'Inherited properties reach descendants purely through inheritance, so folding them onto the ' +\n      'child and removing the box is render-identical. The wrapper carries nothing non-inherited, ' +\n      'establishes no box/formatting/stacking context, and is guarded by the auto-applied ' +\n      'opacity-barrier + selector-safety set.',\n  },\n  match: {\n    onlyChild: 'element',\n    paintsNothing: true,\n    where: [isInertHostTag, not(isComponentNode), hasOnlyInheritedStyle],\n  },\n  rewrite: { flattenInto: 'child' },\n  test: {\n    cases: [\n      {\n        // `text-align:center` is inherited → folded onto the child; the paint-free wrapper is removed.\n        before: '<div className=\"text-center\"><p className=\"bg-red-200\">x</p></div>',\n        after: '<p className=\"bg-red-200 text-center\">x</p>',\n      },\n    ],\n    noMatch: [\n      // `p-4` is a NON-inherited padding: removing the box would drop it, so the flatten-safety gate\n      // reverts the unwrap and the wrapper is left unchanged.\n      '<div className=\"p-4\"><p className=\"bg-red-200\">x</p></div>',\n      // A `<p>` wrapper is NOT an inert host box: its UA default display/margins are not captured in the\n      // class-derived computed style, so removing it is not provably layout-neutral → left unchanged.\n      '<p className=\"text-center\"><span className=\"bg-red-200\">x</span></p>',\n    ],\n  },\n});\n","/**\n * @domflax/patterns — flatten pattern: `passthrough-wrapper`.\n *\n * Collapses a purely-structural wrapper that exists for no reason at all:\n *\n *   <div><Child/></div>\n *\n * The wrapper paints nothing, establishes no box / formatting / stacking context, carries no\n * attributes beyond an (optional) inert class, holds exactly one element child, and is free of every\n * opacity barrier (ref / event-handlers / dynamic children / dangerous html / spread / component).\n * Such a `<div>` is pure DOM noise: removing it and hoisting the child is invisible to both paint\n * and layout.\n *\n * Authored with the declarative {@link definePattern} API. The opacity-barrier + selector-safety\n * guards (ref/handlers/dynamic-children/raw-html/combinator/reparent-impact) are applied\n * automatically for every `flatten/*` pattern; the `where` predicates add the passthrough-specific\n * requirements (no box/formatting/stacking context, no own attrs, no dynamic/spread classes, not a\n * component, not a structural-pseudo subject).\n */\n\nimport type {\n  DeepReadonly,\n  IRElement,\n  IRNode,\n  IRNodeId,\n  NodeLike,\n  NodeMeta,\n} from '@domflax/core';\n\nimport { definePattern, hasDynamicClasses, not, type Matcher } from '@domflax/pattern-kit';\n\n/* ───────────────────────── local meta/attr/selector matchers ───────────────────────── */\n\nfunction metaOf(node: NodeLike): DeepReadonly<NodeMeta> | null {\n  const n = node as DeepReadonly<IRNode>;\n  return n.kind === 'element' ? (n as DeepReadonly<IRElement>).meta : null;\n}\n\nfunction elementOf(node: NodeLike): DeepReadonly<IRElement> | null {\n  const n = node as DeepReadonly<IRNode>;\n  return n.kind === 'element' ? (n as DeepReadonly<IRElement>) : null;\n}\n\n/**\n * Element establishes some box / formatting / stacking context, is a containing block, or exposes\n * custom properties to a descendant — any of which means removing its box could shift layout or\n * break a `var()` coupling, so it is NOT a passthrough.\n */\nconst establishesContext: Matcher = (node) => {\n  const m = metaOf(node);\n  if (!m) return false;\n  return (\n    m.establishesBox ||\n    m.establishesFormattingContext ||\n    m.establishesStackingContext ||\n    m.isContainingBlock ||\n    m.declaresCustomProperties\n  );\n};\n\n/** Hard opacity barriers beyond the auto-applied set: spread attrs, component identity. */\nconst hasSpreadAttrs: Matcher = (node) => metaOf(node)?.hasSpreadAttrs ?? false;\nconst isComponentNode: Matcher = (node) => metaOf(node)?.isComponent ?? false;\n\n/** Element carries own attributes (id / data-* / …) beyond its class list — possible selector/JS hook. */\nconst hasOwnAttrs: Matcher = (node) => {\n  const el = elementOf(node);\n  if (!el) return false;\n  return el.attrs.entries.size > 0 || el.attrs.spreads.length > 0;\n};\n\n/**\n * Element is the subject of a structural pseudo (`:first/:last/:only/:nth-*`). Honours the meta flag\n * and the precomputed {@link SelectorIndex}.\n */\nconst targetedByStructuralPseudo: Matcher = (node, ctx) => {\n  const el = elementOf(node);\n  if (!el) return false;\n  if (el.meta.targetedByStructuralPseudo) return true;\n  return ctx.selectors.targetedByStructuralPseudo(el.id as unknown as IRNodeId);\n};\n\n/* ───────────────────────── the pattern ───────────────────────── */\n\n/**\n * Flatten a do-nothing `<div>` wrapper into its sole element child, folding any inheritable styles\n * down first so inherited values survive the box removal.\n */\nexport const passthroughWrapper = definePattern({\n  name: 'passthrough-wrapper',\n  category: 'flatten/wrapper/passthrough-wrapper',\n  safety: 2,\n  doc: {\n    title: 'Flatten passthrough wrapper',\n    summary:\n      'A div with no own visual/box style, no attributes beyond an inert class, exactly one ' +\n      'element child, and no opacity barriers is removed; its sole child is hoisted in its place.',\n    before: '<div><Child/></div>',\n    after: '<Child/>',\n    safetyRationale:\n      'Wrapper paints nothing and establishes no layout/paint/var context, carries no ' +\n      'ref/handlers/dynamic-children/html/spread/component identity, owns no targetable attrs, ' +\n      'and is not a combinator/structural-pseudo subject (reparenting changes no match-set); ' +\n      'inheritable styles are folded onto the child before removal.',\n  },\n  match: {\n    tag: 'div',\n    onlyChild: 'element',\n    paintsNothing: true,\n    where: [\n      not(establishesContext),\n      not(hasOwnAttrs),\n      not(hasDynamicClasses),\n      not(hasSpreadAttrs),\n      not(isComponentNode),\n      not(targetedByStructuralPseudo),\n    ],\n  },\n  rewrite: { flattenInto: 'child' },\n  test: {\n    cases: [\n      {\n        // A plain, style-free wrapper paints nothing and establishes no context → a provably-safe\n        // flatten under the conservative gate: the wrapper is removed and its sole child hoisted.\n        before: '<div><a className=\"bg-red-200\">Link</a></div>',\n        after: '<a className=\"bg-red-200\">Link</a>',\n      },\n    ],\n    noMatch: [\n      // A ref pins the wrapper's element identity (a hard opacity barrier) → not a passthrough.\n      '<div ref={rootRef}><a className=\"bg-red-200\">Link</a></div>',\n      // A `display:flex` wrapper establishes a formatting context, so removing its box is NOT\n      // provably layout-neutral → the conservative gate leaves it in place.\n      '<div className=\"flex\"><a className=\"bg-red-200\">Link</a></div>',\n    ],\n  },\n});\n","/**\n * @domflax/patterns — flatten pattern: `redundant-inline-wrapper`.\n *\n * Collapses a purely-structural INLINE wrapper:\n *\n *   <span><Child/></span>            (display:inline, no own style)\n *\n * An inline `<span>` that paints nothing, establishes no box / formatting / stacking context, carries\n * no attributes beyond an (optional) inert class, declares no custom properties, and holds exactly one\n * element child is pure inline noise. An empty inline box merely wraps its child's box; removing it and\n * hoisting the child leaves both paint and layout untouched (the surviving child folds the inheritable\n * declarations the span carried).\n *\n * This is the inline sibling of `passthrough-wrapper` (which targets `<div>`): the same opacity-barrier\n * + selector-safety guards are auto-applied by the `pattern()` factory for every `flatten/*` pattern;\n * the `where` predicates add the inline-passthrough requirements (display must be the inline default,\n * no box/formatting/stacking context or var coupling, no own attrs / dynamic-or-spread classes, not a\n * component, not a structural-pseudo subject).\n */\n\nimport type {\n  CssProperty,\n  DeepReadonly,\n  IRElement,\n  IRNode,\n  IRNodeId,\n  NodeLike,\n  NodeMeta,\n  StyleMap,\n} from '@domflax/core';\n\nimport { definePattern, hasDynamicClasses, not, type Matcher } from '@domflax/pattern-kit';\n\n/* ───────────────────────── local meta/attr/selector matchers ───────────────────────── */\n\nfunction asEl(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 metaOf(node: NodeLike): DeepReadonly<NodeMeta> | null {\n  return asEl(node)?.meta ?? null;\n}\n\n/**\n * Element establishes some box / formatting / stacking context, is a containing block, or exposes\n * custom properties to a descendant — removing its box could shift layout or sever a `var()` coupling,\n * so it is NOT an inline passthrough.\n */\nconst establishesContext: Matcher = (node) => {\n  const m = metaOf(node);\n  if (!m) return false;\n  return (\n    m.establishesBox ||\n    m.establishesFormattingContext ||\n    m.establishesStackingContext ||\n    m.isContainingBlock ||\n    m.declaresCustomProperties\n  );\n};\n\n/** Hard opacity barriers beyond the auto-applied set: spread attrs, component identity. */\nconst hasSpreadAttrs: Matcher = (node) => metaOf(node)?.hasSpreadAttrs ?? false;\nconst isComponentNode: Matcher = (node) => metaOf(node)?.isComponent ?? false;\n\n/** Element carries own attributes (id / data-* / …) beyond its class list — possible selector/JS hook. */\nconst hasOwnAttrs: Matcher = (node) => {\n  const el = asEl(node);\n  if (!el) return false;\n  return el.attrs.entries.size > 0 || el.attrs.spreads.length > 0;\n};\n\n/**\n * Element is the subject of a structural pseudo (`:first/:last/:only/:nth-*`). Honours the meta flag\n * and the precomputed {@link SelectorIndex}.\n */\nconst targetedByStructuralPseudo: Matcher = (node, ctx) => {\n  const el = asEl(node);\n  if (!el) return false;\n  if (el.meta.targetedByStructuralPseudo) return true;\n  return ctx.selectors.targetedByStructuralPseudo(el.id as unknown as IRNodeId);\n};\n\nconst DISPLAY = 'display' as CssProperty;\n\n/**\n * Element sets `display` to anything other than the inline default in ANY condition. An\n * inline-block / block / flex / grid / contents span is NOT an inline passthrough — its box (or lack\n * of one) participates in layout differently from a bare inline box.\n */\nconst hasNonInlineDisplay: Matcher = (node, ctx) => {\n  const el = asEl(node);\n  if (!el) return false;\n  const sm: StyleMap = ctx.computedOf(el as unknown as NodeLike) ?? (el.computed as StyleMap);\n  for (const block of sm.blocks.values()) {\n    const decl = block.decls.get(DISPLAY);\n    if (decl && String(decl.value) !== 'inline') return true;\n  }\n  return false;\n};\n\n/* ───────────────────────── the pattern ───────────────────────── */\n\n/**\n * Flatten a do-nothing inline `<span>` wrapper into its sole element child, folding any inheritable\n * styles down first so inherited values survive the box removal.\n */\nexport const redundantInlineWrapper = definePattern({\n  name: 'redundant-inline-wrapper',\n  category: 'flatten/wrapper/redundant-inline-wrapper',\n  safety: 2,\n  doc: {\n    title: 'Flatten redundant inline wrapper',\n    summary:\n      'An inline span with no own visual/box style, no attributes beyond an inert class, exactly ' +\n      'one element child, and no opacity barriers is removed; its sole child is hoisted in its place.',\n    before: '<span><Child/></span>',\n    after: '<Child/>',\n    safetyRationale:\n      'An empty inline box paints nothing and establishes no layout/paint/var context; with the ' +\n      'inline default display and a single element child its removal changes no paint and no flow. ' +\n      'The span carries no ref/handlers/dynamic-children/html/spread/component identity, owns no ' +\n      'targetable attrs, and is not a combinator/structural-pseudo subject; inheritable styles are ' +\n      'folded onto the child before removal.',\n  },\n  match: {\n    tag: 'span',\n    onlyChild: 'element',\n    paintsNothing: true,\n    where: [\n      not(hasNonInlineDisplay),\n      not(establishesContext),\n      not(hasOwnAttrs),\n      not(hasDynamicClasses),\n      not(hasSpreadAttrs),\n      not(isComponentNode),\n      not(targetedByStructuralPseudo),\n    ],\n  },\n  rewrite: { flattenInto: 'child' },\n  test: {\n    cases: [\n      {\n        // An empty inline span paints nothing and establishes no context → a provably-safe flatten:\n        // the span is removed and its sole child hoisted in place.\n        before: '<span><a className=\"text-blue-500\">Link</a></span>',\n        after: '<a className=\"text-blue-500\">Link</a>',\n      },\n    ],\n    noMatch: [\n      // A ref pins the span's element identity (a hard opacity barrier) → not a passthrough.\n      '<span ref={spanRef}><a className=\"text-blue-500\">Link</a></span>',\n      // The span paints its own background (own visual style) → kept.\n      '<span className=\"bg-green-200\"><a className=\"text-blue-500\">Link</a></span>',\n      // Non-inline display (inline-block) participates in layout differently → kept.\n      '<span className=\"inline-block\"><a className=\"text-blue-500\">Link</a></span>',\n    ],\n  },\n});\n","/**\n * AUTO-GENERATED by `scripts/gen-registry.mjs` — DO NOT EDIT BY HAND.\n *\n * Regenerate with `npm run generate` (also runs automatically before build/typecheck/test).\n * Patterns are discovered by the recursive `*.pattern.ts` file convention (organized into DOMAIN\n * folders under `src/library/`); the array below is sorted flatten-before-compress.\n */\n\nimport type { Pattern } from '@domflax/core';\n\nimport { flexCenterWrapper } from './library/flex/flex-center-wrapper.pattern';\nimport { redundantFragment } from './library/fragment/redundant-fragment.pattern';\nimport { gridCenterWrapper } from './library/grid/grid-center-wrapper.pattern';\nimport { displayContentsWrapper } from './library/wrapper/display-contents-wrapper.pattern';\nimport { emptyStyleDiv } from './library/wrapper/empty-style-div.pattern';\nimport { inheritedOnlyWrapper } from './library/wrapper/inherited-only-wrapper.pattern';\nimport { passthroughWrapper } from './library/wrapper/passthrough-wrapper.pattern';\nimport { redundantInlineWrapper } from './library/wrapper/redundant-inline-wrapper.pattern';\n\nexport {\n  flexCenterWrapper,\n  redundantFragment,\n  gridCenterWrapper,\n  displayContentsWrapper,\n  emptyStyleDiv,\n  inheritedOnlyWrapper,\n  passthroughWrapper,\n  redundantInlineWrapper,\n};\n\n/** Every built-in pattern, in registration order (flatten patterns before compress). */\nexport const builtinPatterns: readonly Pattern[] = [\n  flexCenterWrapper,\n  redundantFragment,\n  gridCenterWrapper,\n  displayContentsWrapper,\n  emptyStyleDiv,\n  inheritedOnlyWrapper,\n  passthroughWrapper,\n  redundantInlineWrapper,\n];\n\nexport default builtinPatterns;\n","/**\n * @domflax/patterns — the built-in rewrite pattern library.\n *\n * Patterns are AUTO-DISCOVERED by file convention: any `*.pattern.ts` under a DOMAIN folder in\n * `src/library/` (e.g. `wrapper/`, `flex/`, `grid/`, `fragment/`, `layout/`) that default- or\n * named-exports a `definePattern()`-built Pattern is picked up by `scripts/gen-registry.mjs`, which\n * writes `src/_registry.generated.ts` (a gitignored build artifact, regenerated before\n * build/typecheck/test). Adding a pattern therefore needs no manual edit to this file — just drop in\n * a new `*.pattern.ts`. The pass PHASE is derived from each pattern's `category` first segment, not\n * its folder.\n *\n * This barrel simply re-exports the generated registry: every pattern individually, the assembled\n * {@link builtinPatterns} array (flatten patterns before compress), and that array as the default.\n */\n\nimport { builtinPatterns } from './_registry.generated';\n\nexport * from './_registry.generated';\n\nexport default builtinPatterns;\n","/**\r\n * @domflax/resolver-tailwind — the {@link StyleResolver} implementation + public factory.\r\n */\r\n\r\nimport type {\r\n  CoverClass,\r\n  CssProperty,\r\n  EmitContext,\r\n  EmitResult,\r\n  OpaqueToken,\r\n  ResolveInput,\r\n  ResolveResult,\r\n  SelectorUsage,\r\n  StyleCondition,\r\n  StyleDecl,\r\n  StyleMap,\r\n  StyleOrigin,\r\n  StyleResolver,\r\n} from '@domflax/core';\r\nimport { BASE_CONDITION, conditionKey, minStringCover, styleMapTuples, tupleKey } from '@domflax/core';\r\nimport { normalizer } from '@domflax/pattern-kit';\r\n\r\nimport type { TailwindResolverConfig } from './config';\r\nimport { expandForEmit, synthesizeResidual } from './emit';\r\nimport { loadEngine } from './engine';\r\nimport type { ExtractedToken } from './extract';\r\nimport { extractToken } from './extract';\r\nimport { fnv1a } from './fingerprint';\r\nimport { parseSelector, unescapeClass } from './selector';\r\nimport { serializeCssNode } from './serialize';\r\nimport { buildStyleMap, shadowedBy } from './stylemap';\r\nimport type { TwEngine, TwGeneratedDecl, TwGeneratedRule } from './types';\r\nimport { DROPPABLE_USAGE, OPAQUE_USAGE } from './usage';\r\n\r\n/**\r\n * Providers already warned about an unsupported Tailwind major, so the diagnostic is emitted ONCE per\r\n * distinct provider/version even when many resolvers (per-file caches, multiple runs) are constructed.\r\n */\r\nconst warnedUnsupported = new Set<string>();\r\n\r\nclass TailwindResolver implements StyleResolver {\r\n  readonly id = 'tailwind';\r\n  readonly provider: string;\r\n  readonly fingerprint: string;\r\n  /**\r\n   * SAFETY (Layer 1): the detected Tailwind MAJOR when the project's version is one this resolver\r\n   * cannot drive (v4+), else `null`. When set, {@link resolve} reports every token as unknown, so\r\n   * downstream files are left unchanged (never mis-optimized). Exposed for diagnostics/tests.\r\n   */\r\n  readonly unsupportedMajor: number | null;\r\n\r\n  readonly #engine: TwEngine | null;\r\n  /** Per-token extraction cache (engine output is pure for a fixed config). */\r\n  readonly #tokenCache = new Map<string, ExtractedToken>();\r\n  /** Per-class-set forward-resolution cache. */\r\n  readonly #resolveCache = new Map<string, ResolveResult>();\r\n  /** Lazily built reverse index for the greedy {@link emit} fallback. */\r\n  #reverseIndex: ReadonlyArray<readonly [string, ReadonlyMap<CssProperty, string>]> | null = null;\r\n  /** Lazily built cover vocabulary (base-condition tuple sets) for the exact-cover engine. */\r\n  #coverVocab: readonly CoverClass[] | null = null;\r\n\r\n  constructor(config: TailwindResolverConfig = {}) {\r\n    const loaded = loadEngine(config);\r\n    this.#engine = loaded.engine;\r\n    this.unsupportedMajor = loaded.unsupportedMajor;\r\n    this.provider =\r\n      config.provider ??\r\n      (loaded.version ? `tailwindcss@${loaded.version}` : 'tailwindcss');\r\n    const seed = JSON.stringify(config.config ?? {}) + (config.configPath ?? '');\r\n    this.fingerprint = config.fingerprint ?? `${this.provider}/${fnv1a(seed)}`;\r\n\r\n    // SAFETY (Layer 1): fail LOUDLY (once) when a v4+ project's real design system could NOT be\r\n    // loaded (the v4 adapter fell through — e.g. `@tailwindcss/node` is missing). Every class then\r\n    // resolves to `unknown` (below), so the per-element fail-safe leaves files unchanged instead of\r\n    // unsafely flattening. A v4 project whose design system DID load has `unsupportedMajor === null`\r\n    // and resolves normally — no warning.\r\n    if (this.unsupportedMajor !== null && !warnedUnsupported.has(this.provider)) {\r\n      warnedUnsupported.add(this.provider);\r\n      // eslint-disable-next-line no-console\r\n      console.warn(\r\n        `domflax: detected Tailwind v${this.unsupportedMajor} (${this.provider}) but could not load its ` +\r\n          `design system (is @tailwindcss/node installed?); classes cannot be resolved, so files are ` +\r\n          `left unchanged to avoid unsafe edits.`,\r\n      );\r\n    }\r\n  }\r\n\r\n  /** Engine-backed, cached single-token extraction. */\r\n  #extract(token: string): ExtractedToken {\r\n    const cached = this.#tokenCache.get(token);\r\n    if (cached) return cached;\r\n    let result: ExtractedToken;\r\n    if (!this.#engine) {\r\n      result = { blocks: [], produced: false };\r\n    } else {\r\n      try {\r\n        result = extractToken(token, this.#engine.generate([token]));\r\n      } catch {\r\n        result = { blocks: [], produced: false };\r\n      }\r\n    }\r\n    this.#tokenCache.set(token, result);\r\n    return result;\r\n  }\r\n\r\n  owns(token: string): boolean {\r\n    if (token.length === 0) return false;\r\n    return this.#extract(token).produced;\r\n  }\r\n\r\n  resolve(input: ResolveInput): ResolveResult {\r\n    const key = JSON.stringify(input.classes);\r\n    const cached = this.#resolveCache.get(key);\r\n    if (cached) return cached;\r\n\r\n    // condition-key → { condition, longhand decls }. Iterating classes in source order means later\r\n    // utilities overwrite earlier ones on the same property (equal-specificity cascade).\r\n    const blockMaps = new Map<\r\n      string,\r\n      { condition: StyleCondition; decls: Map<CssProperty, StyleDecl> }\r\n    >();\r\n    const resolved: string[] = [];\r\n    const unknown: string[] = [];\r\n    const opaque: OpaqueToken[] = [];\r\n\r\n    input.classes.forEach((token, tokenIndex) => {\r\n      const extracted = this.#extract(token);\r\n      if (!extracted.produced) {\r\n        unknown.push(token);\r\n        return;\r\n      }\r\n      if (extracted.opaque) opaque.push(extracted.opaque);\r\n      if (extracted.blocks.length === 0) return; // produced only opaque rules\r\n\r\n      const origin: StyleOrigin = { kind: 'class', tokenIndex, className: token };\r\n      let contributed = false;\r\n      for (const block of extracted.blocks) {\r\n        const ck = conditionKey(block.condition);\r\n        let bucket = blockMaps.get(ck);\r\n        if (!bucket) {\r\n          bucket = { condition: block.condition, decls: new Map() };\r\n          blockMaps.set(ck, bucket);\r\n        }\r\n        for (const [prop, value, important] of block.decls) {\r\n          for (const decl of normalizer.normalizeDeclaration(prop, value, important)) {\r\n            // Record provenance: a LATER token on the same property shadows the earlier one. The\r\n            // overridden origin (plus anything it already shadowed) is carried in `shadowed`, which\r\n            // is exactly what the `dedupe-classes` pattern reads to find fully-overridden tokens.\r\n            // This only enriches decl metadata — the resolved VALUES are unchanged.\r\n            const prev = bucket.decls.get(decl.property);\r\n            const shadowed = prev ? shadowedBy(prev) : undefined;\r\n            bucket.decls.set(decl.property, shadowed ? { ...decl, origin, shadowed } : { ...decl, origin });\r\n            contributed = true;\r\n          }\r\n        }\r\n      }\r\n      if (contributed) resolved.push(token);\r\n    });\r\n\r\n    const result: ResolveResult = {\r\n      styles: buildStyleMap(blockMaps),\r\n      resolved,\r\n      unknown,\r\n      opaque,\r\n      warnings: [],\r\n    };\r\n    this.#resolveCache.set(key, result);\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Lazily build the reverse index from the engine's own enumerable class list. Each indexable\r\n   * utility maps to its NORMALIZED BASE longhand declarations (property → canonical value). Utilities\r\n   * with variant conditions, combinator selectors, or no BASE declarations are skipped. Sorted by\r\n   * declaration count (desc) so greedier (shorthand-like) utilities are tried first.\r\n   */\r\n  #buildReverseIndex(): ReadonlyArray<readonly [string, ReadonlyMap<CssProperty, string>]> {\r\n    if (this.#reverseIndex) return this.#reverseIndex;\r\n    const index: Array<readonly [string, Map<CssProperty, string>]> = [];\r\n    if (this.#engine) {\r\n      try {\r\n        const classes = this.#engine.context\r\n          .getClassList()\r\n          .filter((c): c is string => typeof c === 'string');\r\n        const nodes = this.#engine.generate(classes);\r\n        // Re-extract per class would be costly; instead group decls by their (single) class selector.\r\n        for (const node of nodes) {\r\n          if (node.type !== 'rule') continue; // skip @media / @keyframes wrappers (⇒ variants only)\r\n          const rule = node as TwGeneratedRule;\r\n          const parsed = parseSelector(rule.selector);\r\n          if (parsed.kind !== 'simple' || parsed.states.length > 0 || parsed.pseudoElement !== '') {\r\n            continue; // BASE-only\r\n          }\r\n          const className = unescapeClass(rule.selector);\r\n          if (className === null) continue;\r\n          const decls = new Map<CssProperty, string>();\r\n          for (const child of rule.nodes ?? []) {\r\n            if (child.type !== 'decl') continue;\r\n            const d = child as TwGeneratedDecl;\r\n            if (typeof d.value !== 'string') continue;\r\n            for (const decl of normalizer.normalizeDeclaration(d.prop, d.value, d.important === true)) {\r\n              decls.set(decl.property, String(decl.value));\r\n            }\r\n          }\r\n          if (decls.size > 0) index.push([className, decls]);\r\n        }\r\n      } catch {\r\n        /* leave index empty on failure — emit degrades to a no-op */\r\n      }\r\n    }\r\n    index.sort((a, b) => b[1].size - a[1].size || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));\r\n    this.#reverseIndex = index;\r\n    return index;\r\n  }\r\n\r\n  /**\r\n   * The cover vocabulary: every base-condition, plain-subject utility mapped to the {@link tupleKey}s\r\n   * of its full normalized-longhand declaration set. Built once from a SINGLE engine `generate` over\r\n   * the enumerable class list (grouped by selector), so it is the same cost as {@link #buildReverseIndex}.\r\n   * This is what the provider-uniform exact-cover engine searches; the element's own droppable tokens\r\n   * are members of it, guaranteeing feasibility. Variant / combinator / pseudo utilities are excluded\r\n   * (their effect is not the element's own base box), so a target carrying such conditions simply finds\r\n   * no cover and falls back to the greedy emit.\r\n   */\r\n  #buildCoverVocab(): readonly CoverClass[] {\r\n    if (this.#coverVocab) return this.#coverVocab;\r\n    const baseCk = String(conditionKey(BASE_CONDITION));\r\n    const out: CoverClass[] = [];\r\n    if (this.#engine) {\r\n      try {\r\n        const classes = this.#engine.context\r\n          .getClassList()\r\n          .filter((c): c is string => typeof c === 'string');\r\n        const nodes = this.#engine.generate(classes);\r\n        for (const node of nodes) {\r\n          if (node.type !== 'rule') continue;\r\n          const rule = node as TwGeneratedRule;\r\n          const parsed = parseSelector(rule.selector);\r\n          if (parsed.kind !== 'simple' || parsed.states.length > 0 || parsed.pseudoElement !== '') {\r\n            continue; // BASE-only, own-box utilities only\r\n          }\r\n          const className = unescapeClass(rule.selector);\r\n          if (className === null) continue;\r\n          const tuples: string[] = [];\r\n          const seen = new Set<string>();\r\n          for (const child of rule.nodes ?? []) {\r\n            if (child.type !== 'decl') continue;\r\n            const d = child as TwGeneratedDecl;\r\n            if (typeof d.value !== 'string') continue;\r\n            for (const decl of normalizer.normalizeDeclaration(d.prop, d.value, d.important === true)) {\r\n              const k = tupleKey(baseCk, String(decl.property), String(decl.value), decl.important);\r\n              if (!seen.has(k)) {\r\n                seen.add(k);\r\n                tuples.push(k);\r\n              }\r\n            }\r\n          }\r\n          if (tuples.length > 0) out.push({ token: className, tuples });\r\n        }\r\n      } catch {\r\n        /* leave vocab empty on failure — cover degrades to the greedy fallback */\r\n      }\r\n    }\r\n    this.#coverVocab = out;\r\n    return out;\r\n  }\r\n\r\n  /**\r\n   * Try the minimal-string exact-cover engine over the WHOLE utility vocabulary. On success the chosen\r\n   * set is verified by the mandatory CORRECTNESS BACKSTOP — re-resolve it and assert it reproduces the\r\n   * target's tuples EXACTLY — before it is returned; any mismatch (or no cover / oversize universe)\r\n   * yields `null` so {@link emit} uses its greedy fallback. Never returns a set that misrepresents `U`.\r\n   */\r\n  #tryCover(normalized: StyleMap, norm: EmitContext['normalizer']): EmitResult | null {\r\n    const universe = styleMapTuples(normalized, norm);\r\n    if (universe.length === 0) return { classes: [], exact: true, warnings: [] };\r\n    const chosen = minStringCover(universe, this.#buildCoverVocab());\r\n    if (!chosen || chosen.length === 0) return null;\r\n    const reTuples = new Set(styleMapTuples(this.resolve({ classes: chosen }).styles, norm));\r\n    if (reTuples.size !== universe.length) return null;\r\n    for (const t of universe) if (!reTuples.has(t)) return null;\r\n    return { classes: chosen, exact: true, warnings: [] };\r\n  }\r\n\r\n  emit(styles: StyleMap, ctx: EmitContext): EmitResult {\r\n    const norm = ctx.normalizer ?? normalizer;\r\n    const normalized = norm.normalizeStyleMap(styles);\r\n\r\n    // Primary path: the provider-uniform minimal-string exact cover over the full vocabulary.\r\n    const cover = this.#tryCover(normalized, norm);\r\n    if (cover) return cover;\r\n\r\n    const base = normalized.blocks.get(conditionKey(BASE_CONDITION));\r\n    if (!base || base.decls.size === 0) return { classes: [], exact: true, warnings: [] };\r\n\r\n    // Only the BASE block is reverse-synthesized (see module LIMITATION). Any non-base condition\r\n    // present in the target means we cannot be exact.\r\n    const hasNonBase = normalized.blocks.size > 1;\r\n\r\n    // The target longhand map. The IR's compress passes hand us SHORTHAND properties (`padding`,\r\n    // `margin`, `inset`, `inset-block`, `inset-inline`, `size`); we expand them to the same longhand\r\n    // basis the reverse index is keyed on, so a single shorthand utility (`p-4`, `size-4`, `inset-0`)\r\n    // can cover them.\r\n    const target = new Map<CssProperty, string>();\r\n    for (const [prop, decl] of base.decls) {\r\n      for (const [lp, lv] of expandForEmit(norm, String(prop), String(decl.value), decl.important)) {\r\n        target.set(lp, lv);\r\n      }\r\n    }\r\n\r\n    // Keep only utilities every one of whose declarations matches the target (an exact-fit subset);\r\n    // emitting a utility that sets an unwanted property/value would change the computed style.\r\n    const candidates: Array<readonly [string, ReadonlyMap<CssProperty, string>]> = [];\r\n    for (const entry of this.#buildReverseIndex()) {\r\n      const [, declMap] = entry;\r\n      if (declMap.size === 0 || declMap.size > target.size) continue;\r\n      let fits = true;\r\n      for (const [prop, value] of declMap) {\r\n        if (target.get(prop) !== value) {\r\n          fits = false;\r\n          break;\r\n        }\r\n      }\r\n      if (fits) candidates.push(entry);\r\n    }\r\n\r\n    // Greedy set-cover: repeatedly take the candidate covering the MOST still-needed declarations,\r\n    // so a shorthand (`p-4`, 4 decls) beats `px-4`+`py-4`. Ties break toward the tighter decl-set\r\n    // then lexicographically, for deterministic output.\r\n    const remaining = new Map(target);\r\n    const classes: string[] = [];\r\n    while (remaining.size > 0) {\r\n      let best: readonly [string, ReadonlyMap<CssProperty, string>] | null = null;\r\n      let bestCover = 0;\r\n      for (const entry of candidates) {\r\n        const [token, declMap] = entry;\r\n        let cover = 0;\r\n        for (const prop of declMap.keys()) if (remaining.has(prop)) cover += 1;\r\n        if (cover === 0) continue;\r\n        const better =\r\n          best === null ||\r\n          cover > bestCover ||\r\n          (cover === bestCover && declMap.size < best[1].size) ||\r\n          (cover === bestCover && declMap.size === best[1].size && token < best[0]);\r\n        if (better) {\r\n          best = entry;\r\n          bestCover = cover;\r\n        }\r\n      }\r\n      if (!best) break; // nothing covers any still-needed declaration → residual\r\n      classes.push(best[0]);\r\n      for (const prop of best[1].keys()) remaining.delete(prop);\r\n    }\r\n\r\n    const exact = remaining.size === 0 && !hasNonBase;\r\n    if (remaining.size === 0) return { classes, exact, warnings: [] };\r\n\r\n    // Surface what no utility could cover as a residual synthetic (never thrown, never invented).\r\n    const residual = synthesizeResidual(remaining, ctx);\r\n    return residual\r\n      ? { classes, residual, exact, warnings: [] }\r\n      : { classes, exact, warnings: [] };\r\n  }\r\n\r\n  /**\r\n   * Generate a CSS stylesheet that defines `classes`, so a verifier can render a subtree with the\r\n   * real Tailwind styling applied. Backed by the same engine `resolve` uses (`generate(candidates)`),\r\n   * serialized to plain CSS. Returns `''` when the engine is unavailable or generates nothing.\r\n   */\r\n  cssFor(classes: readonly string[]): string {\r\n    if (!this.#engine) return '';\r\n    const tokens = [...new Set(classes)].filter((c) => c.length > 0);\r\n    if (tokens.length === 0) return '';\r\n    try {\r\n      return this.#engine\r\n        .generate(tokens)\r\n        .map((n) => serializeCssNode(n))\r\n        .filter((s) => s.length > 0)\r\n        .join('\\n');\r\n    } catch {\r\n      return '';\r\n    }\r\n  }\r\n\r\n  selectorUsage(token: string): SelectorUsage {\r\n    // No project selector graph yet, so we cannot know how a CUSTOM (non-Tailwind) class is\r\n    // referenced — treat it as load-bearing (preserved verbatim). A resolver-OWNED utility, by\r\n    // contrast, is safe to drop/replace iff its whole effect is reproducible from `computed`: it\r\n    // must be a plain (non-opaque) utility contributing ONLY base-condition declarations. Opaque\r\n    // (combinator/at-rule) and variant-bound utilities are kept, because `emit` cannot rebuild them.\r\n    const ex = this.#extract(token);\r\n    if (!ex.produced || ex.opaque) return OPAQUE_USAGE;\r\n    const baseOnly =\r\n      ex.blocks.length > 0 &&\r\n      ex.blocks.every((b) => conditionKey(b.condition) === conditionKey(BASE_CONDITION));\r\n    if (!baseOnly) return OPAQUE_USAGE;\r\n    return DROPPABLE_USAGE;\r\n  }\r\n}\r\n\r\n/** Factory: build a Tailwind-backed {@link StyleResolver}. */\r\nexport function createTailwindResolver(config?: TailwindResolverConfig): StyleResolver {\r\n  return new TailwindResolver(config);\r\n}\r\n","/**\n * @domflax/resolver-tailwind — emit-side shorthand expansion + residual synthesis.\n */\n\nimport type {\n  CssProperty,\n  EmitContext,\n  StyleBlock,\n  StyleDecl,\n  StyleMap,\n  SyntheticClass,\n} from '@domflax/core';\nimport { BASE_CONDITION, conditionKey } from '@domflax/core';\nimport { normalizer } from '@domflax/pattern-kit';\n\nimport { fnv1a } from './fingerprint';\n\n/**\n * Expand a single computed declaration into the canonical LONGHAND `[property, value]` pairs the\n * reverse index is keyed on. The shared normalizer already expands the physical box shorthands\n * (`padding`/`margin`/`inset`/`border-*`); we additionally expand the few logical shorthands the\n * compress passes synthesize that the normalizer leaves intact (`size`, `inset-block`,\n * `inset-inline`). Values are re-canonicalized via the normalizer so they match the index exactly.\n */\nexport function expandForEmit(\n  norm: { normalizeDeclaration: typeof normalizer.normalizeDeclaration },\n  prop: string,\n  value: string,\n  important: boolean,\n): Array<readonly [CssProperty, string]> {\n  const pairsFor = (p: string, v: string): Array<readonly [CssProperty, string]> =>\n    norm.normalizeDeclaration(p, v, important).map((d) => [d.property, String(d.value)] as const);\n\n  if (prop === 'size') {\n    return [...pairsFor('width', value), ...pairsFor('height', value)];\n  }\n  if (prop === 'inset-block' || prop === 'inset-inline') {\n    const parts = value.split(/\\s+/).filter((s) => s.length > 0);\n    const a = parts[0] ?? value;\n    const b = parts[1] ?? a;\n    const sides = prop === 'inset-block' ? (['top', 'bottom'] as const) : (['left', 'right'] as const);\n    return [...pairsFor(sides[0], a), ...pairsFor(sides[1], b)];\n  }\n  return pairsFor(prop, value);\n}\n\n/** Build a residual {@link SyntheticClass} for declarations no utility covered; `null` on failure. */\nexport function synthesizeResidual(\n  remaining: ReadonlyMap<CssProperty, string>,\n  ctx: EmitContext,\n): SyntheticClass | undefined {\n  if (remaining.size === 0) return undefined;\n  const norm = ctx.normalizer ?? normalizer;\n  const decls = new Map<CssProperty, StyleDecl>();\n  for (const [prop, value] of remaining) {\n    for (const decl of norm.normalizeDeclaration(String(prop), value, false)) {\n      decls.set(decl.property, decl);\n    }\n  }\n  const block: StyleBlock = { condition: BASE_CONDITION, decls };\n  const styleMap: StyleMap = { blocks: new Map([[conditionKey(BASE_CONDITION), block]]) };\n  const css = [...remaining].map(([p, v]) => `${p}:${v}`).join(';');\n  const className = `df-${fnv1a(css)}`;\n  const synthetic: SyntheticClass = { className, decls: styleMap, css: `.${className}{${css}}` };\n  try {\n    ctx.sink.register(synthetic);\n  } catch {\n    /* a sink that rejects registration must not break emit */\n  }\n  return synthetic;\n}\n","/**\n * @domflax/resolver-tailwind — tiny dependency-free hash for cache-busting fingerprints.\n */\n\n/** Tiny, dependency-free FNV-1a string hash (hex). Used to derive the cache-busting fingerprint. */\nexport function fnv1a(input: string): string {\n  let h = 0x811c9dc5;\n  for (let i = 0; i < input.length; i += 1) {\n    h ^= input.charCodeAt(i);\n    h = Math.imul(h, 0x01000193);\n  }\n  return (h >>> 0).toString(16).padStart(8, '0');\n}\n","/**\n * @domflax/resolver-tailwind — engine loading (synchronous v3 internals).\n *\n * The forward/reverse engine lives in tailwindcss' CommonJS internals. We load them through\n * `createRequire` (rather than `import`) so the exact same code path works whether this module is\n * bundled to ESM or CJS, and so the untyped internal subpaths don't need ambient declarations.\n *\n * CRITICAL (bundling): tailwindcss must be resolved from the CONSUMER'S project, NOT from the file\n * this module happens to live in. When `domflax` inlines this resolver into its own bundle\n * (`noExternal: [/^@domflax\\//]`), a require based on the bundle's location (`__filename`) would\n * look for `tailwindcss` next to `domflax/dist`, where it does not exist — so the engine silently\n * failed to load and `emit`'s reverse index came up empty. Instead we root the require in the user's\n * project (an explicit project root, then `process.cwd()`), exactly how prettier-plugin-tailwindcss\n * and the Tailwind IntelliSense engine locate a project's Tailwind. The bundle/source location is\n * kept only as a last-resort fallback (covers the non-bundled / in-repo dev case). The first base\n * from which `tailwindcss/package.json` resolves wins.\n */\n\nimport { createRequire } from 'node:module';\nimport * as path from 'node:path';\n\nimport type { TailwindResolverConfig } from './config';\nimport { loadV4Engine } from './engine-v4';\nimport type { TwContext, TwEngine, TwNode } from './types';\n\n/**\n * This module's own location, used as a last-resort require base. esbuild substitutes a real\n * `__filename` in a CJS bundle; in an ESM bundle `__filename` is undefined and we fall back to\n * `import.meta.url` (a `file://` URL, which `createRequire` accepts).\n */\nfunction moduleBase(): string {\n  return typeof __filename === 'string' ? __filename : import.meta.url;\n}\n\n/**\n * Build a `require` rooted in the consumer's project so engine resolution is independent of where\n * this (possibly bundled) module physically lives. Returns `null` if `tailwindcss` resolves from no\n * candidate base.\n */\nfunction projectRequire(projectRoot?: string): NodeRequire | null {\n  const bases: string[] = [];\n  // A real file name is irrelevant — `createRequire` only uses the containing directory for\n  // resolution; the file need not exist.\n  if (projectRoot) bases.push(path.join(projectRoot, '__domflax__.js'));\n  bases.push(path.join(process.cwd(), '__domflax__.js'));\n  bases.push(moduleBase());\n  for (const base of bases) {\n    try {\n      const candidate = createRequire(base);\n      candidate.resolve('tailwindcss/package.json');\n      return candidate;\n    } catch {\n      /* try the next base */\n    }\n  }\n  return null;\n}\n\n/**\n * The FIRST major whose engine internals the v3 CODE PATH cannot drive. v4+ is handled by a separate\n * adapter ({@link loadV4Engine}); only when THAT adapter also fails do we treat the major as\n * unsupported and fall back to the safe \"everything UNKNOWN ⇒ files unchanged\" behavior.\n */\nexport const FIRST_UNSUPPORTED_MAJOR = 4;\n\n/** The outcome of trying to load the project's Tailwind engine. */\nexport interface LoadedEngine {\n  /** The synchronous forward/reverse engine, or `null` when it could not be built. */\n  readonly engine: TwEngine | null;\n  /** The resolved `tailwindcss` version, or `null` when the package could not be located at all. */\n  readonly version: string | null;\n  /**\n   * SAFETY (Layer 1): set to the detected MAJOR when the project's `tailwindcss` is a version this\n   * resolver cannot drive (>= {@link FIRST_UNSUPPORTED_MAJOR}, e.g. v4's rewritten engine). In that\n   * case `engine` is `null` and — rather than silently resolving every class to empty and then\n   * mis-optimizing — the resolver reports every token as UNKNOWN so files are left UNCHANGED, and\n   * surfaces a one-time diagnostic. `null` for a supported/driveable (or absent) Tailwind.\n   */\n  readonly unsupportedMajor: number | null;\n}\n\n/** Parse the leading integer major from a semver-ish version string, or `null`. */\nfunction majorOf(version: string): number | null {\n  const m = /^\\s*(\\d+)/.exec(version);\n  return m ? Number(m[1]) : null;\n}\n\n/**\n * Load a synchronous Tailwind engine for the given resolved config. Detects the project's\n * `tailwindcss` version FIRST: a MAJOR this resolver cannot drive (v4+) fails LOUDLY via\n * {@link LoadedEngine.unsupportedMajor} (engine `null`) instead of silently returning empty\n * resolutions. Any other initialization failure returns a `null` engine with no version.\n */\nexport function loadEngine(options: TailwindResolverConfig): LoadedEngine {\n  const req = projectRequire(options.projectRoot);\n  if (!req) return { engine: null, version: null, unsupportedMajor: null };\n\n  // Read the version BEFORE touching the (v3-shaped) internals: v4 ships a different engine at\n  // `dist/lib.js` and has no `lib/lib/*.js` CJS internals, so probing them would only throw — we want\n  // to positively identify v4 and refuse to drive it, not fall through to a generic failure.\n  let version: string | null = null;\n  try {\n    version = (req('tailwindcss/package.json') as { version: string }).version;\n  } catch {\n    return { engine: null, version: null, unsupportedMajor: null };\n  }\n  const major = majorOf(version);\n  if (major !== null && major >= FIRST_UNSUPPORTED_MAJOR) {\n    // v4+: drive the project's REAL design system through the v4 adapter (a synchronous snapshot of\n    // its async API). Success ⇒ a normal, fully-resolving engine. Failure ⇒ fall back to the fail-safe\n    // (`unsupportedMajor` set ⇒ every class UNKNOWN ⇒ files left unchanged), never a wrong resolution.\n    const projectRoot = options.projectRoot ?? process.cwd();\n    let v4: TwEngine | null = null;\n    try {\n      v4 = loadV4Engine(projectRoot, version);\n    } catch {\n      v4 = null;\n    }\n    if (v4) return { engine: v4, version, unsupportedMajor: null };\n    return { engine: null, version, unsupportedMajor: major };\n  }\n\n  try {\n    const resolveConfig = req('tailwindcss/resolveConfig.js') as (c: unknown) => unknown;\n    const { createContext } = req('tailwindcss/lib/lib/setupContextUtils.js') as {\n      createContext: (config: unknown) => TwContext;\n    };\n    const { generateRules } = req('tailwindcss/lib/lib/generateRules.js') as {\n      generateRules: (candidates: Set<string>, context: TwContext) => Array<[number, TwNode]>;\n    };\n\n    let userConfig: unknown = options.config ?? { content: [{ raw: '' }] };\n    if (options.configPath !== undefined) {\n      const loadConfig = req('tailwindcss/loadConfig.js') as (p: string) => unknown;\n      userConfig = loadConfig(options.configPath);\n    }\n    const resolved = resolveConfig(userConfig);\n    const context = createContext(resolved);\n\n    return {\n      engine: {\n        version,\n        context,\n        generate(candidates: readonly string[]): TwNode[] {\n          const rules = generateRules(new Set(candidates), context);\n          return rules.map(([, node]) => node);\n        },\n      },\n      version,\n      unsupportedMajor: null,\n    };\n  } catch {\n    return { engine: null, version, unsupportedMajor: null };\n  }\n}\n","/**\n * @domflax/resolver-tailwind — Tailwind v4 engine adapter.\n *\n * Builds a {@link TwEngine} (the SAME interface the v3 path exposes) backed by a synchronous snapshot\n * of the project's real v4 design system (see {@link runV4Bridge}). Because it satisfies `TwEngine`\n * exactly — `version`, `context.getClassList()`, `generate(candidates)` — the resolver, extractor,\n * emitter and serializer all work UNCHANGED; the only v4-specific step is parsing each utility's CSS\n * ({@link parseUtilityCss}), which yields the identical flat {@link TwNode} shape v3 produces.\n *\n * SAFETY: if the snapshot cannot be built (no `@tailwindcss/node`, load error, timeout, …) this\n * returns `null` and the caller falls back to the fail-safe (every class UNKNOWN ⇒ files unchanged).\n */\n\nimport { readdirSync, readFileSync, statSync } from 'node:fs';\nimport * as path from 'node:path';\n\nimport { runV4Bridge } from './v4-bridge';\nimport type { V4CssEntry } from './v4-bridge';\nimport type { TwEngine, TwNode } from './types';\nimport { parseUtilityCss } from './v4-css';\n\n/** Directories worth scanning for the Tailwind CSS entry; anything else is skipped. */\nconst SEARCH_DIRS = ['', 'src', 'app', 'styles', 'src/styles', 'src/app', 'app/styles', 'assets/css', 'css'];\nconst SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'out', '.next', 'coverage']);\nconst ENTRY_RE = /@import\\s+[\"']tailwindcss[\"']|@tailwind\\b|@theme\\b/;\n\n/** Shallowly scan one directory (non-recursive) for a `.css` file that looks like the TW entry. */\nfunction scanDir(dir: string): V4CssEntry | null {\n  let names: string[];\n  try {\n    names = readdirSync(dir);\n  } catch {\n    return null;\n  }\n  for (const name of names) {\n    if (!name.toLowerCase().endsWith('.css')) continue;\n    const file = path.join(dir, name);\n    try {\n      if (!statSync(file).isFile()) continue;\n      const css = readFileSync(file, 'utf8');\n      if (ENTRY_RE.test(css)) return { css, base: path.dirname(file) };\n    } catch {\n      /* unreadable file — skip */\n    }\n  }\n  return null;\n}\n\n/**\n * Assemble the ordered CSS-entry candidates the bridge should try: the project's real Tailwind entry\n * (found by a bounded scan of a few conventional directories) first, then a minimal\n * `@import \"tailwindcss\";` default so a design system can still be loaded when no entry is found.\n */\nexport function findCssEntries(projectRoot: string): V4CssEntry[] {\n  const out: V4CssEntry[] = [];\n  const seen = new Set<string>();\n  for (const rel of SEARCH_DIRS) {\n    const dir = path.resolve(projectRoot, rel);\n    if (seen.has(dir) || [...SKIP_DIRS].some((s) => dir.includes(`${path.sep}${s}`))) continue;\n    seen.add(dir);\n    const hit = scanDir(dir);\n    if (hit) {\n      out.push(hit);\n      break; // first plausible entry wins (conventional dirs are ordered shallow → deep)\n    }\n  }\n  out.push({ css: '@import \"tailwindcss\";', base: projectRoot });\n  return out;\n}\n\n/**\n * Adapt a class→CSS snapshot into a {@link TwEngine}. Per-class CSS is parsed lazily (and cached) into\n * the flat {@link TwNode} shape shared with v3, so `generate([...])` is a lookup + parse.\n */\nfunction makeV4Engine(entries: ReadonlyArray<readonly [string, string]>, version: string): TwEngine {\n  const cssByClass = new Map<string, string>(entries.map(([name, css]) => [name, css] as const));\n  const nodeCache = new Map<string, TwNode[]>();\n\n  const nodesFor = (token: string): TwNode[] => {\n    let cached = nodeCache.get(token);\n    if (!cached) {\n      const css = cssByClass.get(token);\n      cached = css ? parseUtilityCss(css) : [];\n      nodeCache.set(token, cached);\n    }\n    return cached;\n  };\n\n  return {\n    version,\n    context: {\n      // The resolver keeps only string entries; we hand it the concrete class names directly.\n      getClassList: () => [...cssByClass.keys()],\n    },\n    generate(candidates: readonly string[]): TwNode[] {\n      const out: TwNode[] = [];\n      for (const c of candidates) for (const n of nodesFor(c)) out.push(n);\n      return out;\n    },\n  };\n}\n\n/**\n * Try to build a v4-backed {@link TwEngine} for the project. Returns `null` (⇒ fail-safe) when the\n * design-system snapshot cannot be produced. `version` is the already-detected `tailwindcss` version.\n */\nexport function loadV4Engine(projectRoot: string, version: string): TwEngine | null {\n  const snapshot = runV4Bridge({ projectRoot, entries: findCssEntries(projectRoot) });\n  if (!snapshot) return null;\n  return makeV4Engine(snapshot.entries, version);\n}\n","/**\n * @domflax/resolver-tailwind — SYNCHRONOUS bridge to Tailwind v4's async design-system API.\n *\n * The {@link StyleResolver} contract is fully synchronous, but every v4 programmatic entry point\n * (`__unstable__loadDesignSystem`, `compile`) returns a Promise and there is no synchronous\n * design-system constructor. Rather than a blocking-on-promise hack in-process, we run the async load\n * ONCE, at resolver construction, inside a short-lived child `node` process via `execFileSync` (which\n * is synchronous by nature). The child loads the project's real design system, enumerates its full\n * class list, and returns each utility's CSS (`candidatesToCss`) as `[className, css]` pairs. The\n * parent then drives everything synchronously off that snapshot — forward resolution is a map lookup +\n * {@link parseUtilityCss}, and the reverse index is built from the same pairs.\n *\n * SAFETY: the child is fully guarded and its result is treated as advisory — ANY failure (missing\n * `@tailwindcss/node`, load error, timeout, non-JSON output) makes {@link runV4Bridge} return `null`,\n * and the caller then falls back to the fail-safe (every class UNKNOWN ⇒ files left unchanged).\n */\n\nimport { execFileSync } from 'node:child_process';\nimport { mkdtempSync, rmSync, writeFileSync } from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport * as path from 'node:path';\n\n/** A single CSS entry the child should try to load the design system from. */\nexport interface V4CssEntry {\n  readonly css: string;\n  readonly base: string;\n}\n\nexport interface V4BridgePayload {\n  readonly projectRoot: string;\n  /** Candidate CSS entries, tried in order until one loads (the last is a minimal default). */\n  readonly entries: readonly V4CssEntry[];\n}\n\nexport interface V4BridgeResult {\n  /** `[className, cssText]` for every utility whose `candidatesToCss` produced CSS. */\n  readonly entries: ReadonlyArray<readonly [string, string]>;\n}\n\n/**\n * The child script, kept as a source STRING (not an imported module) so it survives domflax's bundle\n * and resolves the project's Tailwind independently of where the bundle physically lives. Written to a\n * temp `.mjs` at runtime and executed with `node <script> <payload.json>`; it prints a JSON result.\n */\nconst CHILD_SOURCE = String.raw`\nimport { createRequire } from 'node:module';\nimport { pathToFileURL } from 'node:url';\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\n\nfunction out(obj) { process.stdout.write(JSON.stringify(obj)); process.exit(0); }\n\nlet payload;\ntry { payload = JSON.parse(fs.readFileSync(process.argv[2], 'utf8')); }\ncatch { out({ ok: false }); }\n\nconst projectRoot = payload.projectRoot;\nconst entries = payload.entries || [];\nconst req = createRequire(path.join(projectRoot, '__domflax_tw4__.js'));\n\nasync function importFrom(id) {\n  const resolved = req.resolve(id);\n  return import(pathToFileURL(resolved).href);\n}\n\n// Primary loader: @tailwindcss/node (the companion every v4 build tool installs). It resolves\n// '@import \"tailwindcss\"' and @theme against the project on disk.\nasync function loadViaNode() {\n  let mod;\n  try { mod = await importFrom('@tailwindcss/node'); } catch { return null; }\n  if (!mod || typeof mod.__unstable__loadDesignSystem !== 'function') return null;\n  for (const e of entries) {\n    try { return await mod.__unstable__loadDesignSystem(e.css, { base: e.base }); } catch {}\n  }\n  return null;\n}\n\n// Secondary loader: bare 'tailwindcss' with a filesystem stylesheet resolver (best-effort).\nasync function loadViaCore() {\n  let tw;\n  try { tw = await importFrom('tailwindcss'); } catch { return null; }\n  if (!tw || typeof tw.__unstable__loadDesignSystem !== 'function') return null;\n  const loadStylesheet = async (id, base) => {\n    const r = createRequire(path.join(base, '__domflax_tw4__.js'));\n    let p;\n    const tries = id === 'tailwindcss' ? ['tailwindcss/index.css', 'tailwindcss'] : [id, id + '/index.css'];\n    for (const t of tries) { try { p = r.resolve(t); break; } catch {} }\n    if (!p) p = path.resolve(base, id);\n    return { path: p, base: path.dirname(p), content: fs.readFileSync(p, 'utf8') };\n  };\n  const loadModule = async (id, base) => {\n    const r = createRequire(path.join(base, '__domflax_tw4__.js'));\n    const p = r.resolve(id);\n    return { path: p, base: path.dirname(p), module: (await import(pathToFileURL(p).href)).default };\n  };\n  for (const e of entries) {\n    try { return await tw.__unstable__loadDesignSystem(e.css, { base: e.base, loadStylesheet, loadModule }); } catch {}\n  }\n  return null;\n}\n\nconst ds = (await loadViaNode()) || (await loadViaCore());\nif (!ds) out({ ok: false });\n\nlet names = [];\ntry {\n  names = ds.getClassList().map((e) => (Array.isArray(e) ? e[0] : e)).filter((n) => typeof n === 'string');\n} catch { out({ ok: false }); }\n\nlet css = [];\ntry { css = ds.candidatesToCss(names); } catch { out({ ok: false }); }\n\nconst result = [];\nfor (let i = 0; i < names.length; i += 1) {\n  const c = css[i];\n  if (typeof c === 'string' && c.length > 0) result.push([names[i], c]);\n}\nout({ ok: true, entries: result });\n`;\n\n/**\n * Run the v4 bridge synchronously. Returns the class→CSS snapshot, or `null` on ANY failure (the\n * caller then uses the fail-safe path). Never throws.\n */\nexport function runV4Bridge(payload: V4BridgePayload): V4BridgeResult | null {\n  let dir: string | null = null;\n  try {\n    dir = mkdtempSync(path.join(tmpdir(), 'domflax-tw4-'));\n    const scriptPath = path.join(dir, 'bridge.mjs');\n    const payloadPath = path.join(dir, 'payload.json');\n    writeFileSync(scriptPath, CHILD_SOURCE, 'utf8');\n    writeFileSync(payloadPath, JSON.stringify(payload), 'utf8');\n\n    const stdout = execFileSync(process.execPath, [scriptPath, payloadPath], {\n      cwd: payload.projectRoot,\n      encoding: 'utf8',\n      timeout: 90_000,\n      maxBuffer: 256 * 1024 * 1024,\n      stdio: ['ignore', 'pipe', 'ignore'],\n    });\n\n    const parsed = JSON.parse(stdout) as { ok?: boolean; entries?: Array<[string, string]> };\n    if (!parsed.ok || !Array.isArray(parsed.entries) || parsed.entries.length === 0) return null;\n    const entries = parsed.entries.filter(\n      (e): e is [string, string] =>\n        Array.isArray(e) && typeof e[0] === 'string' && typeof e[1] === 'string',\n    );\n    return entries.length > 0 ? { entries } : null;\n  } catch {\n    return null;\n  } finally {\n    if (dir) {\n      try {\n        rmSync(dir, { recursive: true, force: true });\n      } catch {\n        /* best-effort temp cleanup */\n      }\n    }\n  }\n}\n","/**\n * @domflax/resolver-tailwind — parse + FLATTEN Tailwind v4 `candidatesToCss` output into the same\n * flat, v3-shaped {@link TwNode} array the rest of the resolver (extract / emit / serialize) already\n * consumes. This is the ONE v4-specific adapter; everything downstream stays version-agnostic.\n *\n * ## Why a bespoke parser (no postcss)\n *\n * v4's `candidatesToCss(tokens)` returns per-token CSS in the modern NESTED authoring form, e.g.\n *\n *     .px-4        { padding-inline: calc(var(--spacing) * 4); }\n *     .container   { width: 100%; @media (width >= 40rem) { max-width: 40rem; } }\n *     .divide-y    { :where(& > :not(:last-child)) { border-top-width: …; } }\n *     .hover\\:x    { &:hover { @media (hover: hover) { … } } }\n *\n * The v3 engine, by contrast, emits FLAT postcss rules (`@media { .md\\:x { … } }`, and combinator\n * utilities as top-level complex-selector rules). `extract.ts` is written against that flat shape and\n * — crucially for SAFETY — classifies a combinator/`&`-nested selector as {@link OpaqueToken} so the\n * element is preserved, never treated as inert. So instead of re-teaching `extract` about nesting, we\n * FLATTEN here: resolve `&` against the parent selector, hoist `@media` into wrapping at-rules, and\n * emit exactly the flat structure v3 produces. A combinator like `divide-y` then flattens to a\n * `:where(.divide-y > …)` rule → `extract` marks it opaque → the element is kept. Bundling postcss\n * into domflax's dist is explicitly avoided (project convention), and a tiny, fail-safe parser we own\n * is unit-testable end to end.\n *\n * ## Fail-safe\n *\n * Any parse/flatten error yields `[]` (⇒ the token is reported UNKNOWN ⇒ the element is preserved).\n * We never invent declarations from malformed input.\n */\n\nimport type { TwGeneratedDecl, TwGeneratedRule, TwNode } from './types';\n\n/* ───────────────────────── raw parse tree ───────────────────────── */\n\ninterface RawDecl {\n  readonly type: 'decl';\n  readonly prop: string;\n  readonly value: string;\n  readonly important: boolean;\n}\ninterface RawRule {\n  readonly type: 'rule';\n  readonly selector: string;\n  readonly nodes: RawNode[];\n}\ninterface RawAtRule {\n  readonly type: 'atrule';\n  readonly name: string;\n  readonly params: string;\n  readonly nodes: RawNode[];\n}\ntype RawNode = RawDecl | RawRule | RawAtRule;\n\n/** Strip `/* … *​/` comments (v4 prepends a license banner to some output). */\nfunction stripComments(src: string): string {\n  return src.replace(/\\/\\*[\\s\\S]*?\\*\\//g, '');\n}\n\n/** Turn a `prop: value` buffer into a declaration, or `null` for empties / at-statements. */\nfunction toDecl(buffer: string): RawDecl | null {\n  const buf = buffer.trim();\n  if (buf.length === 0 || buf[0] === '@') return null; // `@import …;` etc. carry no element box style\n  const colon = buf.indexOf(':');\n  if (colon <= 0) return null;\n  const prop = buf.slice(0, colon).trim();\n  let value = buf.slice(colon + 1).trim();\n  if (prop.length === 0 || value.length === 0) return null;\n  let important = false;\n  const bang = /!\\s*important\\s*$/i.exec(value);\n  if (bang) {\n    important = true;\n    value = value.slice(0, bang.index).trim();\n  }\n  return { type: 'decl', prop, value, important };\n}\n\n/** Split a `@name params` prelude into its parts. */\nfunction splitAtRule(prelude: string): { name: string; params: string } {\n  const m = /^@([A-Za-z-]+)\\s*([\\s\\S]*)$/.exec(prelude);\n  if (!m) return { name: prelude.slice(1).trim(), params: '' };\n  return { name: m[1]!.toLowerCase(), params: m[2]!.trim() };\n}\n\n/**\n * Recursive-descent block parser. Declaration values in Tailwind output never contain `{`/`}`/`;`\n * (function args use parentheses), so a plain brace/semicolon scanner is sufficient and robust.\n */\nfunction parseBlock(src: string, start: number): { nodes: RawNode[]; next: number } {\n  const nodes: RawNode[] = [];\n  let buf = '';\n  let i = start;\n  while (i < src.length) {\n    const c = src[i]!;\n    if (c === '{') {\n      const prelude = buf.trim();\n      buf = '';\n      const inner = parseBlock(src, i + 1);\n      i = inner.next;\n      if (prelude.startsWith('@')) {\n        const { name, params } = splitAtRule(prelude);\n        nodes.push({ type: 'atrule', name, params, nodes: inner.nodes });\n      } else if (prelude.length > 0) {\n        nodes.push({ type: 'rule', selector: prelude, nodes: inner.nodes });\n      }\n    } else if (c === '}') {\n      const d = toDecl(buf);\n      if (d) nodes.push(d);\n      return { nodes, next: i + 1 };\n    } else if (c === ';') {\n      const d = toDecl(buf);\n      if (d) nodes.push(d);\n      buf = '';\n      i += 1;\n    } else {\n      buf += c;\n      i += 1;\n    }\n  }\n  const tail = toDecl(buf);\n  if (tail) nodes.push(tail);\n  return { nodes, next: i };\n}\n\n/* ───────────────────────── nesting flatten ───────────────────────── */\n\ninterface AtFrame {\n  readonly name: string;\n  readonly params: string;\n}\ninterface Leaf {\n  readonly selector: string;\n  readonly at: readonly AtFrame[];\n  readonly decls: readonly RawDecl[];\n}\n\n/** Resolve a nested selector against its parent per CSS Nesting (`&` = parent; else descendant). */\nfunction resolveNesting(child: string, parent: string): string {\n  const c = child.trim();\n  if (parent.length === 0) return c;\n  if (c.includes('&')) return c.split('&').join(parent);\n  return `${parent} ${c}`;\n}\n\n/** At-rules that never contribute to the element's own box and carry no nested element styles. */\nconst DROP_ATRULES = new Set(['property', 'keyframes', 'font-face', 'charset', 'import']);\n\n/** Recursively hoist a nested tree into flat {@link Leaf}s (selector + at-rule stack + own decls). */\nfunction flattenNodes(nodes: readonly RawNode[], selector: string, at: readonly AtFrame[], out: Leaf[]): void {\n  const own: RawDecl[] = [];\n  for (const n of nodes) if (n.type === 'decl') own.push(n);\n  if (own.length > 0 && selector.length > 0) out.push({ selector, at: [...at], decls: own });\n\n  for (const n of nodes) {\n    if (n.type === 'rule') {\n      flattenNodes(n.nodes, resolveNesting(n.selector, selector), at, out);\n    } else if (n.type === 'atrule') {\n      if (n.name === 'media') {\n        flattenNodes(n.nodes, selector, [...at, { name: 'media', params: n.params }], out);\n      } else if (n.name === 'layer') {\n        flattenNodes(n.nodes, selector, at, out); // @layer only affects cascade order → transparent\n      } else if (!DROP_ATRULES.has(n.name)) {\n        // @supports / @container / unknown → keep the wrapper so `extract` treats it as opaque.\n        flattenNodes(n.nodes, selector, [...at, { name: n.name, params: n.params }], out);\n      }\n    }\n  }\n}\n\n/** Build a flat {@link TwNode} (at-rule-wrapped rule) from one hoisted leaf. */\nfunction leafToNode(leaf: Leaf): TwNode {\n  const declNodes: TwGeneratedDecl[] = leaf.decls.map((d) => ({\n    type: 'decl',\n    prop: d.prop,\n    value: d.value,\n    important: d.important,\n  }));\n  let node: TwNode = { type: 'rule', selector: leaf.selector, nodes: declNodes } satisfies TwGeneratedRule;\n  for (let i = leaf.at.length - 1; i >= 0; i -= 1) {\n    node = { type: 'atrule', name: leaf.at[i]!.name, params: leaf.at[i]!.params, nodes: [node] };\n  }\n  return node;\n}\n\n/**\n * Parse one v4 `candidatesToCss` string and return the FLAT {@link TwNode}s (identical in shape to\n * what the v3 engine yields). Returns `[]` on any failure — the fail-safe that keeps the token\n * UNKNOWN so its element is preserved.\n */\nexport function parseUtilityCss(css: string): TwNode[] {\n  try {\n    const { nodes } = parseBlock(stripComments(css), 0);\n    const leaves: Leaf[] = [];\n    flattenNodes(nodes, '', [], leaves);\n    return leaves.map(leafToNode);\n  } catch {\n    return [];\n  }\n}\n","/**\n * @domflax/resolver-tailwind — rule extraction (engine nodes → usable blocks).\n */\n\nimport type { OpaqueToken, StyleCondition } from '@domflax/core';\n\nimport { makeCondition, parseSelector } from './selector';\nimport type { TwGeneratedAtRule, TwGeneratedDecl, TwGeneratedRule, TwNode } from './types';\n\nexport interface ExtractedBlock {\n  readonly condition: StyleCondition;\n  readonly decls: ReadonlyArray<readonly [string, string, boolean]>;\n}\n\nexport interface ExtractedToken {\n  /** Usable (BASE + supported-variant) blocks. */\n  readonly blocks: readonly ExtractedBlock[];\n  /** True if the engine emitted at least one rule for the token (even an opaque one). */\n  readonly produced: boolean;\n  /** Set when the token only resolves via combinator / unsupported at-rule selectors. */\n  readonly opaque?: OpaqueToken;\n}\n\n/** Collect every leaf `rule` node together with the `@media` stack that wraps it. */\nfunction collectRules(\n  node: TwNode,\n  mediaStack: readonly string[],\n  inUnsupportedAtRule: boolean,\n  out: Array<{ rule: TwGeneratedRule; media: readonly string[]; unsupported: boolean }>,\n): void {\n  if (node.type === 'rule') {\n    out.push({ rule: node as TwGeneratedRule, media: mediaStack, unsupported: inUnsupportedAtRule });\n    return;\n  }\n  if (node.type === 'atrule') {\n    const at = node as TwGeneratedAtRule;\n    const children = at.nodes ?? [];\n    if (at.name === 'media') {\n      const nextStack = at.params ? [...mediaStack, at.params] : mediaStack;\n      for (const child of children) collectRules(child, nextStack, inUnsupportedAtRule, out);\n    } else {\n      // @supports / @container / etc. — recurse but flag as unsupported (⇒ opaque).\n      for (const child of children) collectRules(child, mediaStack, true, out);\n    }\n  }\n}\n\n/** Extract usable blocks + opacity info for a single candidate token from its generated nodes. */\nexport function extractToken(token: string, nodes: readonly TwNode[]): ExtractedToken {\n  if (nodes.length === 0) return { blocks: [], produced: false };\n\n  const leaves: Array<{ rule: TwGeneratedRule; media: readonly string[]; unsupported: boolean }> = [];\n  for (const node of nodes) collectRules(node, [], false, leaves);\n\n  const blocks: ExtractedBlock[] = [];\n  let sawComplex = false;\n\n  for (const { rule, media, unsupported } of leaves) {\n    const parsed = parseSelector(rule.selector);\n    if (parsed.kind === 'complex' || unsupported) {\n      sawComplex = true;\n      continue;\n    }\n    const decls: Array<readonly [string, string, boolean]> = [];\n    for (const child of rule.nodes ?? []) {\n      if (child.type !== 'decl') continue; // skip @defaults markers, comments, nested rules\n      const d = child as TwGeneratedDecl;\n      if (typeof d.value !== 'string') continue;\n      decls.push([d.prop, d.value, d.important === true]);\n    }\n    if (decls.length === 0) continue;\n    const mediaQuery = media.join(' and ');\n    blocks.push({ condition: makeCondition(mediaQuery, parsed.states, parsed.pseudoElement), decls });\n  }\n\n  const opaque: OpaqueToken | undefined =\n    sawComplex && blocks.length === 0\n      ? { token, reason: 'combinator-variant', detail: 'utility targets descendants/siblings, not its own box' }\n      : undefined;\n\n  return { blocks, produced: true, opaque };\n}\n","/**\n * @domflax/resolver-tailwind — selector / condition parsing.\n */\n\nimport type { StyleCondition } from '@domflax/core';\n\n/** Pseudo-elements that Tailwind may emit with a legacy single colon. */\nconst LEGACY_PSEUDO_ELEMENTS = new Set([\n  ':before',\n  ':after',\n  ':first-line',\n  ':first-letter',\n]);\n\nexport type ParsedSelector =\n  | { readonly kind: 'simple'; readonly states: readonly string[]; readonly pseudoElement: string }\n  | { readonly kind: 'complex' };\n\n/**\n * Parse a generated selector into a {@link StyleCondition} fragment. Accepts ONLY a single class\n * selector optionally followed by pseudo-class / pseudo-element parts (`.x`, `.x:hover`,\n * `.x::before`, `.x:focus:hover`). Anything with a combinator, a second compound class, an attribute\n * selector, or a selector list is `complex` (⇒ opaque) because its declarations do not apply to the\n * element's own box.\n */\nexport function parseSelector(selector: string): ParsedSelector {\n  const sel = selector.trim();\n  if (sel.length === 0 || sel[0] !== '.') return { kind: 'complex' };\n\n  // Consume the class identifier, honoring CSS backslash escapes (`\\:`, `\\/`, `\\[`, …).\n  let i = 1;\n  for (; i < sel.length; i += 1) {\n    const c = sel[i]!;\n    if (c === '\\\\') {\n      i += 1; // skip the escaped char\n      continue;\n    }\n    if (c === ':' || c === '.' || c === '[' || c === ' ' || c === '>' || c === '+' || c === '~' || c === ',') {\n      break;\n    }\n  }\n\n  const remainder = sel.slice(i);\n  if (remainder.length === 0) {\n    return { kind: 'simple', states: [], pseudoElement: '' };\n  }\n  // The remainder must be EXCLUSIVELY pseudo parts — no combinator / compound / attribute follows.\n  if (!/^(?:::?[-a-z]+(?:\\([^()]*\\))?)+$/i.test(remainder)) {\n    return { kind: 'complex' };\n  }\n\n  const parts = remainder.match(/::?[-a-z]+(?:\\([^()]*\\))?/gi) ?? [];\n  const states: string[] = [];\n  let pseudoElement = '';\n  for (const part of parts) {\n    if (part.startsWith('::') || LEGACY_PSEUDO_ELEMENTS.has(part)) {\n      pseudoElement = part.startsWith('::') ? part : `:${part}`;\n    } else {\n      states.push(part);\n    }\n  }\n  return { kind: 'simple', states, pseudoElement };\n}\n\nexport function makeCondition(media: string, states: readonly string[], pseudoElement: string): StyleCondition {\n  return {\n    media,\n    states: [...new Set(states)].sort(),\n    pseudoElement,\n  };\n}\n\n/** Recover a class name from a simple `.escaped-class` selector, or `null` if it isn't simple. */\nexport function unescapeClass(selector: string): string | null {\n  const sel = selector.trim();\n  if (sel[0] !== '.') return null;\n  let out = '';\n  for (let i = 1; i < sel.length; i += 1) {\n    const c = sel[i]!;\n    if (c === '\\\\') {\n      i += 1;\n      if (i < sel.length) out += sel[i];\n      continue;\n    }\n    if (c === ':' || c === '.' || c === '[' || c === ' ' || c === '>' || c === '+' || c === '~' || c === ',') {\n      return null; // not a bare single-class selector\n    }\n    out += c;\n  }\n  return out.length > 0 ? out : null;\n}\n","/**\n * @domflax/resolver-tailwind — CSS serialization for `cssFor`.\n */\n\nimport type { TwGeneratedAtRule, TwGeneratedDecl, TwGeneratedRule, TwNode } from './types';\n\n/** Serialize one engine-emitted node (rule / atrule / decl) into plain CSS text. */\nexport function serializeCssNode(node: TwNode): string {\n  if (node.type === 'decl') {\n    const d = node as TwGeneratedDecl;\n    if (typeof d.value !== 'string') return '';\n    return `${d.prop}:${d.value}${d.important === true ? ' !important' : ''}`;\n  }\n  if (node.type === 'rule') {\n    const r = node as TwGeneratedRule;\n    const body = (r.nodes ?? [])\n      .map((c) => serializeCssNode(c))\n      .filter((s) => s.length > 0)\n      .join(';');\n    return `${r.selector}{${body}}`;\n  }\n  if (node.type === 'atrule') {\n    const a = node as TwGeneratedAtRule;\n    const body = (a.nodes ?? [])\n      .map((c) => serializeCssNode(c))\n      .filter((s) => s.length > 0)\n      .join('');\n    return `@${a.name} ${a.params}{${body}}`;\n  }\n  return '';\n}\n","/**\n * @domflax/resolver-tailwind — StyleMap assembly + provenance helpers.\n */\n\nimport type {\n  CssProperty,\n  StyleBlock,\n  StyleCondition,\n  StyleDecl,\n  StyleMap,\n  StyleOrigin,\n} from '@domflax/core';\nimport { conditionKey, emptyStyleMap } from '@domflax/core';\nimport { normalizer } from '@domflax/pattern-kit';\n\nexport function buildStyleMap(\n  blockMaps: Map<string, { condition: StyleCondition; decls: Map<CssProperty, StyleDecl> }>,\n): StyleMap {\n  if (blockMaps.size === 0) return emptyStyleMap();\n  const blocks = new Map<ReturnType<typeof conditionKey>, StyleBlock>();\n  for (const { condition, decls } of blockMaps.values()) {\n    if (decls.size === 0) continue;\n    blocks.set(conditionKey(condition), { condition, decls });\n  }\n  if (blocks.size === 0) return emptyStyleMap();\n  return normalizer.normalizeStyleMap({ blocks });\n}\n\n/**\n * The shadow chain a newly-winning declaration inherits when it overrides `prev` on the same\n * property: everything `prev` already shadowed, plus `prev`'s own origin (now shadowed too). Deduped\n * by class name and restricted to class origins (the only kind `dedupe-classes` acts on).\n */\nexport function shadowedBy(prev: StyleDecl): readonly StyleOrigin[] | undefined {\n  const out: StyleOrigin[] = [];\n  const seen = new Set<string>();\n  const add = (o: StyleOrigin | undefined): void => {\n    if (!o || o.kind !== 'class' || seen.has(o.className)) return;\n    seen.add(o.className);\n    out.push(o);\n  };\n  for (const o of prev.shadowed ?? []) add(o);\n  add(prev.origin);\n  return out.length > 0 ? out : undefined;\n}\n","/**\n * @domflax/resolver-tailwind — conservative {@link SelectorUsage} constants.\n */\n\nimport type { SelectorUsage } from '@domflax/core';\n\n/**\n * A conservative, never-droppable {@link SelectorUsage}. Until a real project selector graph exists\n * we must assume a class could be referenced in any unsafe position, so nothing is safe to rewrite.\n */\nexport const OPAQUE_USAGE: SelectorUsage = {\n  asSubject: true,\n  asAncestor: true,\n  asCompound: true,\n  asSibling: true,\n  asHasArgument: true,\n  asStructural: true,\n  droppable: false,\n};\n\n/**\n * A plain-subject {@link SelectorUsage}: the class is a resolver-owned, base-only utility whose\n * whole effect is reproducible from `computed`, so it is safe to drop/replace during reverse-emit.\n */\nexport const DROPPABLE_USAGE: SelectorUsage = {\n  asSubject: true,\n  asAncestor: false,\n  asCompound: false,\n  asSibling: false,\n  asHasArgument: false,\n  asStructural: false,\n  droppable: true,\n};\n","/**\n * @domflax/resolver-tailwind — Tailwind-aware {@link StyleResolver}, backed by the REAL Tailwind\n * engine.\n *\n * ## Engine + approach\n *\n * The {@link StyleResolver} contract is **synchronous**. For a **v3** project the resolver drives the\n * engine directly (`createContext(resolveConfig(...))` + `generateRules(candidates, ctx)`) — the same\n * synchronous JIT path `prettier-plugin-tailwindcss` and the Tailwind IntelliSense engine use.\n *\n * For a **v4** project (whose entire programmatic surface — `compile`, `__unstable__loadDesignSystem`\n * — is async, with no synchronous design-system constructor) the resolver builds an equivalent\n * synchronous engine from a one-time SNAPSHOT: at construction it loads the project's REAL design\n * system in a short-lived child process (`@tailwindcss/node`'s `__unstable__loadDesignSystem`),\n * enumerates its full class list, and captures each utility's CSS via `candidatesToCss`. That snapshot\n * is parsed (v4's nested authoring CSS is flattened to the same node shape v3 emits — see\n * `v4-css.ts`) into an object that satisfies the SAME internal engine interface, so everything below\n * (extract / emit / serialize) is version-agnostic. SAFETY: if the v4 snapshot cannot be built\n * (missing `@tailwindcss/node`, load error, timeout), the resolver falls back to reporting every class\n * `unknown`, so files are left unchanged — never a wrong resolution. v4 arbitrary-value/variant tokens\n * that are not in the enumerated class list are likewise reported `unknown` (⇒ preserved).\n *\n * ## Forward (`resolve`)\n *\n * `resolve(classes)` feeds each candidate class name to the real engine, reads back the generated\n * CSS rules, and converts them into a normalized, condition-keyed {@link StyleMap}:\n *\n *   • a simple `.utility { … }` rule contributes to the unconditional `BASE_CONDITION` block,\n *   • a `:hover` / `:focus` / … suffix becomes a `StyleCondition.states` entry,\n *   • a `::before` / `::placeholder` / … suffix becomes a `StyleCondition.pseudoElement`,\n *   • a wrapping `@media (…)` (responsive variants like `md:`) becomes `StyleCondition.media`.\n *\n * Every declaration is run through the SHARED {@link normalizer} from `@domflax/pattern-kit`, so\n * values are canonical and box shorthands (`p-4`, `gap-4`, `inset-0`, …) expand to longhands exactly\n * the way patterns + verify expect. BASE coverage is the must-have; variant conditions are produced\n * best-effort. Utilities whose selector uses a combinator / compound / attribute selector (e.g.\n * `space-x-4`, `divide-y`) cannot be folded onto the element's own box and are surfaced as\n * {@link OpaqueToken}s rather than contributing misleading declarations. Unknown / unresolvable\n * classes contribute nothing and are reported in `unknown` — `resolve` never throws.\n *\n * ## Reverse (`emit`)\n *\n * `emit(styleMap)` is best-effort reverse synthesis backed by a reverse index built from the engine's\n * own class list (`context.getClassList()`): each indexable utility is generated, its normalized BASE\n * declarations are recorded, and the index is greedily matched against the requested StyleMap\n * (largest declaration-sets first), consuming matched properties so each is mapped to at most one\n * utility. The index is built lazily on first `emit()` and cached.\n *\n * LIMITATION (v0.1.0): `emit` is intentionally less complete than `resolve`. It only matches against\n * the engine's enumerable named utilities and only their unconditional BASE declarations; variant\n * conditions (hover/responsive/pseudo-element) and arbitrary-value utilities are not reverse-synthesized,\n * and no synthetic class is produced for the residual (it is surfaced via `exact:false`). Anything\n * with no matching utility is simply left unmatched — `emit` never throws and never invents a class.\n */\n\nexport type { TailwindResolverConfig } from './tailwind/config';\nexport { createTailwindResolver } from './tailwind/resolver';\n","import type {\r\n  ConditionKey,\r\n  CoverClass,\r\n  CssProperty,\r\n  EmitContext,\r\n  EmitResult,\r\n  ResolveInput,\r\n  ResolveResult,\r\n  SelectorUsage,\r\n  StyleBlock,\r\n  StyleCondition,\r\n  StyleDecl,\r\n  StyleMap,\r\n  StyleOrigin,\r\n  StyleResolver,\r\n} from '@domflax/core';\r\nimport { conditionKey, emptyStyleMap, minStringCover, styleMapTuples } from '@domflax/core';\r\nimport { normalizer } from '@domflax/pattern-kit';\r\nimport type selectorParser from 'postcss-selector-parser';\r\nimport {\r\n  CSS_RESOLVER_ID,\r\n  CSS_RESOLVER_PROVIDER,\r\n  FUNCTIONAL_PSEUDOS,\r\n  STRUCTURAL_PSEUDOS,\r\n} from './constants';\r\nimport { ensurePostcss, pc, sp } from './engine';\r\nimport { collectDecls, mediaContext } from './postcss-helpers';\r\nimport { deriveFingerprint, isPlainClassToken, readCssPath } from './misc-helpers';\r\nimport {\r\n  isPseudoElement,\r\n  normalizePseudoElement,\r\n  pseudoName,\r\n  splitCompounds,\r\n} from './selector-helpers';\r\nimport type {\r\n  CssFile,\r\n  CssResolverOptions,\r\n  MutableUsage,\r\n  RawDecl,\r\n  ReverseEntry,\r\n  RuleEntry,\r\n} from './types';\r\n\r\n/* ────────────────────────────────────────────────────────────────────────── *\r\n * CustomCSSResolver\r\n * ────────────────────────────────────────────────────────────────────────── */\r\n\r\n/**\r\n * Resolves plain CSS classes against a fixed set of project stylesheets parsed with postcss.\r\n */\r\nexport class CustomCSSResolver implements StyleResolver {\r\n  public readonly id: string = CSS_RESOLVER_ID;\r\n  public readonly provider: string = CSS_RESOLVER_PROVIDER;\r\n  public readonly fingerprint: string;\r\n\r\n  readonly #files: readonly CssFile[];\r\n  /** Forward map: class token → simple-`.class` rule contributions (source order). */\r\n  readonly #classIndex = new Map<string, RuleEntry[]>();\r\n  /** Selector-participation facts per class token. */\r\n  readonly #usage = new Map<string, MutableUsage>();\r\n  /** Every class referenced anywhere in the stylesheets (forward-resolvable or not). */\r\n  readonly #known = new Set<string>();\r\n  /** Distinct COMPLEX selectors (combinator or structural pseudo), sorted. */\r\n  readonly #complex: readonly string[];\r\n\r\n  #reverse: readonly ReverseEntry[] | null = null;\r\n  /** Lazily built cover vocabulary (full condition-keyed tuple sets) for the exact-cover engine. */\r\n  #coverVocab: readonly CoverClass[] | null = null;\r\n\r\n  public constructor(cssFiles: readonly CssFile[] = [], options: CssResolverOptions = {}) {\r\n    ensurePostcss(options.projectRoot);\r\n    const fromDisk = (options.files ?? []).map(readCssPath);\r\n    this.#files = [...cssFiles, ...fromDisk];\r\n    this.fingerprint = options.fingerprint ?? deriveFingerprint(this.provider, this.#files);\r\n\r\n    const complex = new Set<string>();\r\n    let order = 0;\r\n    for (const file of this.#files) {\r\n      order = this.#indexFile(file, order, complex);\r\n    }\r\n    this.#complex = [...complex].sort();\r\n  }\r\n\r\n  /** The stylesheets this resolver was constructed with (raw sources + any read from disk). */\r\n  public get files(): readonly CssFile[] {\r\n    return this.#files;\r\n  }\r\n\r\n  /** Owns any plain class token referenced by one of {@link files}. */\r\n  public owns(token: string): boolean {\r\n    return isPlainClassToken(token) && this.#known.has(token);\r\n  }\r\n\r\n  public resolve(input: ResolveInput): ResolveResult {\r\n    const styles = this.#resolveTokens(input.classes, input.classes);\r\n    const resolved: string[] = [];\r\n    const unknown: string[] = [];\r\n    for (const token of input.classes) {\r\n      if (this.#classIndex.has(token)) resolved.push(token);\r\n      else unknown.push(token);\r\n    }\r\n    return { styles, resolved, unknown, opaque: [], warnings: [] };\r\n  }\r\n\r\n  public emit(styles: StyleMap, ctx: EmitContext): EmitResult {\r\n    const norm = ctx.normalizer ?? normalizer;\r\n    const normalized = norm.normalizeStyleMap(styles);\r\n\r\n    // Primary path: the provider-uniform minimal-string exact cover over the whole class vocabulary —\r\n    // this is what lets custom CSS finally compress (pick the shortest class set, or the single\r\n    // semantic class, that reproduces the target; drop a class another class fully covers). The\r\n    // element's own droppable tokens are members of the vocabulary, so a cover always exists when the\r\n    // target is reproducible. The chosen set is verified by the mandatory re-resolve backstop below.\r\n    const universe = styleMapTuples(normalized, norm);\r\n    if (universe.length === 0) return { classes: [], exact: true, warnings: [] };\r\n    const chosen = minStringCover(universe, this.#buildCoverVocab());\r\n    if (chosen && chosen.length > 0) {\r\n      const reTuples = new Set(styleMapTuples(this.resolve({ classes: chosen }).styles, norm));\r\n      let ok = reTuples.size === universe.length;\r\n      if (ok) for (const t of universe) if (!reTuples.has(t)) { ok = false; break; }\r\n      if (ok) return { classes: chosen, exact: true, warnings: [] };\r\n    }\r\n\r\n    // Fallback: the original greedy set-cover (also surfaces uncovered decls via `exact:false`).\r\n    const remaining = new Map<string, string>();\r\n    for (const [ck, block] of normalized.blocks) {\r\n      for (const [prop, decl] of block.decls) {\r\n        remaining.set(`${ck} ${prop}`, String(decl.value));\r\n      }\r\n    }\r\n    if (remaining.size === 0) return { classes: [], exact: true, warnings: [] };\r\n\r\n    const classes: string[] = [];\r\n    // Greedy set-cover: larger classes first so the emitted set stays minimal.\r\n    for (const { token, keyed } of this.#reverseIndex()) {\r\n      let matches = true;\r\n      for (const [key, value] of keyed) {\r\n        if (remaining.get(key) !== value) {\r\n          matches = false;\r\n          break;\r\n        }\r\n      }\r\n      if (!matches) continue;\r\n      classes.push(token);\r\n      for (const key of keyed.keys()) remaining.delete(key);\r\n      if (remaining.size === 0) break;\r\n    }\r\n\r\n    // Unmatched declarations are left as-is (no synthetic residual) — surfaced via `exact:false`.\r\n    return { classes, exact: remaining.size === 0, warnings: [] };\r\n  }\r\n\r\n  /**\r\n   * Return a CSS stylesheet defining the given class tokens, so a verifier can render a subtree with\r\n   * the project's real styling applied. The source stylesheets ARE the definition, so we hand back\r\n   * their concatenation verbatim (every relevant rule — including combinator/structural selectors —\r\n   * is preserved). `classes` is accepted for interface parity but the full source is always returned.\r\n   */\r\n  public cssFor(_classes: readonly string[]): string {\r\n    return this.#files.map((f) => f.css).join('\\n');\r\n  }\r\n\r\n  public selectorUsage(token: string): SelectorUsage {\r\n    const u = this.#usage.get(token);\r\n    if (!u) {\r\n      return {\r\n        asSubject: false,\r\n        asAncestor: false,\r\n        asCompound: false,\r\n        asSibling: false,\r\n        asHasArgument: false,\r\n        asStructural: false,\r\n        droppable: true,\r\n      };\r\n    }\r\n    return {\r\n      asSubject: u.asSubject,\r\n      asAncestor: u.asAncestor,\r\n      asCompound: u.asCompound,\r\n      asSibling: u.asSibling,\r\n      asHasArgument: u.asHasArgument,\r\n      asStructural: u.asStructural,\r\n      // Safe to drop/rename only when every reference is the lone subject of a bare `.x {}`.\r\n      droppable: u.referenced && !u.loadBearing,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * The distinct COMPLEX selectors found across all stylesheets — anything containing a combinator\r\n   * (descendant / `>` / `+` / `~`) or a structural pseudo (`:nth-child`, `:first-child`, …). Feeds\r\n   * domflax's CSS-selector-safety guard.\r\n   */\r\n  public complexSelectors(): readonly string[] {\r\n    return this.#complex;\r\n  }\r\n\r\n  /* ─────────────────────────── internals ─────────────────────────── */\r\n\r\n  /** Parse one stylesheet and fold its rules into the indexes. Returns the advanced order counter. */\r\n  #indexFile(file: CssFile, startOrder: number, complex: Set<string>): number {\r\n    let order = startOrder;\r\n    let root;\r\n    try {\r\n      root = pc!(file.css, { from: file.id });\r\n    } catch {\r\n      // Malformed CSS contributes nothing (never throws — only clear input errors do).\r\n      return order;\r\n    }\r\n\r\n    root.walkRules((rule) => {\r\n      const media = mediaContext(rule);\r\n      if (media.skip) return; // inside @keyframes / @font-face etc. — not class rules\r\n      const decls = collectDecls(rule);\r\n\r\n      let ast;\r\n      try {\r\n        ast = sp!().astSync(rule.selector);\r\n      } catch {\r\n        return;\r\n      }\r\n\r\n      for (const sel of ast.nodes) {\r\n        const thisOrder = order;\r\n        this.#analyzeSelector(sel as selectorParser.Selector, media.media, decls, thisOrder, complex);\r\n      }\r\n      order += 1;\r\n    });\r\n\r\n    return order;\r\n  }\r\n\r\n  /** Analyze one comma-segment selector: forward indexing, usage facts, complex detection. */\r\n  #analyzeSelector(\r\n    selector: selectorParser.Selector,\r\n    media: string,\r\n    decls: readonly RawDecl[],\r\n    order: number,\r\n    complex: Set<string>,\r\n  ): void {\r\n    const compounds = splitCompounds(selector);\r\n    let hasCombinator = false;\r\n    let hasStructural = false;\r\n\r\n    compounds.forEach((compound, index) => {\r\n      const isSubject = index === compounds.length - 1;\r\n      const rightCombinator = index < compounds.length - 1 ? compounds[index + 1]!.leftCombinator : null;\r\n      if (rightCombinator) hasCombinator = true;\r\n\r\n      const classes = compound.nodes.filter((n) => sp!.isClassName(n));\r\n      const otherSimple = compound.nodes.some(\r\n        (n) =>\r\n          sp!.isTag(n) ||\r\n          sp!.isIdentifier(n) ||\r\n          sp!.isAttribute(n) ||\r\n          sp!.isUniversal(n) ||\r\n          sp!.isNesting(n),\r\n      );\r\n      const pseudos = compound.nodes.filter((n) => sp!.isPseudo(n));\r\n      const structuralPseudo = pseudos.some((p) => STRUCTURAL_PSEUDOS.has(pseudoName(p)));\r\n      const functionalPseudo = pseudos.some((p) => FUNCTIONAL_PSEUDOS.has(pseudoName(p)));\r\n      const statePseudos = pseudos.filter(\r\n        (p) =>\r\n          sp!.isPseudoClass(p) &&\r\n          !STRUCTURAL_PSEUDOS.has(pseudoName(p)) &&\r\n          !FUNCTIONAL_PSEUDOS.has(pseudoName(p)),\r\n      );\r\n      const elementPseudos = pseudos.filter((p) => isPseudoElement(p));\r\n      const qualified = classes.length > 1 || otherSimple || functionalPseudo || statePseudos.length > 0;\r\n\r\n      if (structuralPseudo) hasStructural = true;\r\n\r\n      for (const cls of classes) {\r\n        const token = cls.value;\r\n        this.#known.add(token);\r\n        const u = this.#getUsage(token);\r\n        u.referenced = true;\r\n        if (isSubject) u.asSubject = true;\r\n        if (rightCombinator === ' ' || rightCombinator === '>') u.asAncestor = true;\r\n        if (rightCombinator === '+' || rightCombinator === '~') u.asSibling = true;\r\n        if (qualified) u.asCompound = true;\r\n        if (structuralPseudo) u.asStructural = true;\r\n        if (rightCombinator !== null || qualified || structuralPseudo || elementPseudos.length > 0) {\r\n          u.loadBearing = true;\r\n        }\r\n\r\n        // Forward indexing: a single bare `.class` compound, optionally qualified by state\r\n        // pseudo-classes and/or a pseudo-element, with NO other simple selector and NO\r\n        // structural/functional pseudo and NO combinator on this compound's right edge.\r\n        const forwardEligible =\r\n          compounds.length === 1 &&\r\n          classes.length === 1 &&\r\n          !otherSimple &&\r\n          !structuralPseudo &&\r\n          !functionalPseudo &&\r\n          elementPseudos.length <= 1;\r\n        if (forwardEligible && decls.length > 0) {\r\n          const condition: StyleCondition = {\r\n            media,\r\n            states: statePseudos.map(pseudoName).sort(),\r\n            pseudoElement: elementPseudos.length === 1 ? normalizePseudoElement(elementPseudos[0]!) : '',\r\n          };\r\n          this.#addRuleEntry(token, { order, token, condition, decls });\r\n        }\r\n      }\r\n\r\n      // Classes nested inside selector-argument pseudos (:has/:is/:where/:not) are references too.\r\n      for (const p of pseudos) {\r\n        const isHas = pseudoName(p) === ':has';\r\n        p.walkClasses((inner) => {\r\n          const token = inner.value;\r\n          this.#known.add(token);\r\n          const u = this.#getUsage(token);\r\n          u.referenced = true;\r\n          u.loadBearing = true;\r\n          if (isHas) u.asHasArgument = true;\r\n        });\r\n      }\r\n    });\r\n\r\n    if (hasCombinator || hasStructural) {\r\n      complex.add(selector.toString().trim());\r\n    }\r\n  }\r\n\r\n  #addRuleEntry(token: string, entry: RuleEntry): void {\r\n    const list = this.#classIndex.get(token);\r\n    if (list) list.push(entry);\r\n    else this.#classIndex.set(token, [entry]);\r\n  }\r\n\r\n  #getUsage(token: string): MutableUsage {\r\n    let u = this.#usage.get(token);\r\n    if (!u) {\r\n      u = {\r\n        referenced: false,\r\n        asSubject: false,\r\n        asAncestor: false,\r\n        asCompound: false,\r\n        asSibling: false,\r\n        asHasArgument: false,\r\n        asStructural: false,\r\n        loadBearing: false,\r\n      };\r\n      this.#usage.set(token, u);\r\n    }\r\n    return u;\r\n  }\r\n\r\n  /**\r\n   * Resolve a set of tokens into a normalized condition-keyed StyleMap. `tokenList` is the original\r\n   * class list (for per-declaration `tokenIndex` provenance); `request` is the set being resolved.\r\n   */\r\n  #resolveTokens(request: readonly string[], tokenList: readonly string[]): StyleMap {\r\n    const entries: RuleEntry[] = [];\r\n    for (const token of new Set(request)) {\r\n      const list = this.#classIndex.get(token);\r\n      if (list) entries.push(...list);\r\n    }\r\n    if (entries.length === 0) return emptyStyleMap();\r\n\r\n    // Equal-specificity single-class rules cascade by source order — later wins.\r\n    entries.sort((a, b) => a.order - b.order);\r\n\r\n    const acc = new Map<ConditionKey, { condition: StyleCondition; decls: Map<CssProperty, StyleDecl> }>();\r\n    for (const entry of entries) {\r\n      const key = conditionKey(entry.condition);\r\n      let block = acc.get(key);\r\n      if (!block) {\r\n        block = { condition: entry.condition, decls: new Map() };\r\n        acc.set(key, block);\r\n      }\r\n      const tokenIndex = tokenList.indexOf(entry.token);\r\n      const origin: StyleOrigin = { kind: 'class', tokenIndex, className: entry.token };\r\n      for (const [prop, value, important] of entry.decls) {\r\n        for (const decl of normalizer.normalizeDeclaration(prop, value, important)) {\r\n          block.decls.set(decl.property, { ...decl, origin });\r\n        }\r\n      }\r\n    }\r\n\r\n    const rawBlocks = new Map<ConditionKey, StyleBlock>();\r\n    for (const [key, block] of acc) {\r\n      if (block.decls.size === 0) continue;\r\n      rawBlocks.set(key, { condition: block.condition, decls: block.decls });\r\n    }\r\n    if (rawBlocks.size === 0) return emptyStyleMap();\r\n    return normalizer.normalizeStyleMap({ blocks: rawBlocks });\r\n  }\r\n\r\n  /**\r\n   * Build (once) the cover vocabulary for the exact-cover engine: every forward-resolvable class\r\n   * mapped to the {@link styleMapTuples} of its full (condition-keyed, `!important`-aware) declaration\r\n   * set. Unlike {@link #reverseIndex} this carries ALL style conditions and the important flag, so the\r\n   * engine can pick a custom class covering hover/media declarations too.\r\n   */\r\n  #buildCoverVocab(): readonly CoverClass[] {\r\n    if (this.#coverVocab) return this.#coverVocab;\r\n    const out: CoverClass[] = [];\r\n    for (const token of this.#classIndex.keys()) {\r\n      const tuples = styleMapTuples(this.#resolveTokens([token], [token]), normalizer);\r\n      if (tuples.length > 0) out.push({ token, tuples });\r\n    }\r\n    this.#coverVocab = out;\r\n    return out;\r\n  }\r\n\r\n  /** Build (once) the reverse index used by the greedy {@link emit} fallback. */\r\n  #reverseIndex(): readonly ReverseEntry[] {\r\n    if (this.#reverse) return this.#reverse;\r\n    const out: ReverseEntry[] = [];\r\n    for (const token of this.#classIndex.keys()) {\r\n      const styles = this.#resolveTokens([token], [token]);\r\n      const keyed = new Map<string, string>();\r\n      for (const [ck, block] of styles.blocks) {\r\n        for (const [prop, decl] of block.decls) keyed.set(`${ck} ${prop}`, String(decl.value));\r\n      }\r\n      if (keyed.size > 0) out.push({ token, keyed });\r\n    }\r\n    // Larger declaration sets first → greedy minimal cover in `emit`.\r\n    out.sort((a, b) => b.keyed.size - a.keyed.size);\r\n    this.#reverse = out;\r\n    return out;\r\n  }\r\n}\r\n\r\n/* ────────────────────────────────────────────────────────────────────────── *\r\n * Factory\r\n * ────────────────────────────────────────────────────────────────────────── */\r\n\r\n/**\r\n * Construct a {@link CustomCSSResolver} from raw CSS sources and/or file paths.\r\n *\r\n * @param cssFiles raw stylesheets (`{ id, css }`) — pass `[]` when loading only from disk.\r\n * @param options  optional disk paths (`files`) and/or an explicit `fingerprint`.\r\n */\r\nexport function createCssResolver(\r\n  cssFiles: readonly CssFile[] = [],\r\n  options?: CssResolverOptions,\r\n): StyleResolver {\r\n  return new CustomCSSResolver(cssFiles, options);\r\n}\r\n","/* ────────────────────────────────────────────────────────────────────────── *\n * Resolver identity + selector classification constants\n * ────────────────────────────────────────────────────────────────────────── */\n\n/** Stable resolver id surfaced on {@link StyleResolver.id}. */\nexport const CSS_RESOLVER_ID = 'css';\n\n/** Provider tag surfaced on {@link StyleResolver.provider}. */\nexport const CSS_RESOLVER_PROVIDER = 'custom-css';\n\n/** Version stamp for the index/cascade machinery; bump when its semantics change (cache-busting). */\nexport const ENGINE_VERSION = 'css-index@1';\n\n/** Structural pseudo-classes — their presence makes a class structurally targeted (review-1 blocker). */\nexport const STRUCTURAL_PSEUDOS: ReadonlySet<string> = new Set([\n  ':nth-child',\n  ':nth-last-child',\n  ':first-child',\n  ':last-child',\n  ':only-child',\n  ':nth-of-type',\n  ':nth-last-of-type',\n  ':first-of-type',\n  ':last-of-type',\n  ':only-of-type',\n]);\n\n/** Functional pseudos whose argument is itself a selector list — opaque to forward resolution. */\nexport const FUNCTIONAL_PSEUDOS: ReadonlySet<string> = new Set([\n  ':not',\n  ':is',\n  ':where',\n  ':has',\n  ':matches',\n]);\n\n/** Legacy single-colon pseudo-ELEMENTS that the parser may not flag via `isPseudoElement`. */\nexport const LEGACY_PSEUDO_ELEMENTS: ReadonlySet<string> = new Set([\n  ':before',\n  ':after',\n  ':first-line',\n  ':first-letter',\n]);\n","import { createRequire } from 'node:module';\nimport * as path from 'node:path';\nimport type { Root as PostcssRoot } from 'postcss';\nimport type selectorParser from 'postcss-selector-parser';\n\n/* ────────────────────────────────────────────────────────────────────────── *\n * Lazy engine loading (postcss + postcss-selector-parser)\n * ────────────────────────────────────────────────────────────────────────── *\n *\n * postcss and postcss-selector-parser are OPTIONAL peers of the published `domflax` package: a\n * Tailwind-only user need not install them. They must therefore be loaded LAZILY (only when this\n * resolver is actually constructed) and from the CONSUMER'S project — never via a static top-level\n * `import`, which would (a) crash on module load for a postcss-less install and (b), once this\n * resolver is inlined into domflax's bundle, resolve relative to `domflax/dist` instead of the\n * user's project. We root the require in `process.cwd()` (or an explicit project root), exactly as\n * the Tailwind resolver does, with the bundle/source location as a last-resort fallback.\n */\n\n/** This module's own location — esbuild fills `__filename` in CJS; ESM falls back to `import.meta.url`. */\nexport function moduleBase(): string {\n  return typeof __filename === 'string' ? __filename : import.meta.url;\n}\n\n/** The single postcss entry point this resolver calls at runtime. */\nexport type PostcssParseApi = (css: string, opts?: { from?: string }) => PostcssRoot;\n\n/** The subset of the postcss-selector-parser API this resolver calls at runtime (guards preserve narrowing). */\nexport interface SelectorParserApi {\n  (): { astSync(selector: string): selectorParser.Root };\n  isClassName(n: selectorParser.Node): n is selectorParser.ClassName;\n  isTag(n: selectorParser.Node): n is selectorParser.Tag;\n  isIdentifier(n: selectorParser.Node): n is selectorParser.Identifier;\n  isAttribute(n: selectorParser.Node): n is selectorParser.Attribute;\n  isUniversal(n: selectorParser.Node): n is selectorParser.Universal;\n  isNesting(n: selectorParser.Node): n is selectorParser.Nesting;\n  isPseudo(n: selectorParser.Node): n is selectorParser.Pseudo;\n  isPseudoClass(n: selectorParser.Node): n is selectorParser.Pseudo;\n  isPseudoElement(n: selectorParser.Node): n is selectorParser.Pseudo;\n  isCombinator(n: selectorParser.Node): n is selectorParser.Combinator;\n}\n\nexport interface PostcssEngine {\n  readonly parse: PostcssParseApi;\n  readonly selectorParser: SelectorParserApi;\n}\n\n/** Resolve postcss + postcss-selector-parser from the consumer's project; `null` if unavailable. */\nexport function loadPostcssEngine(projectRoot?: string): PostcssEngine | null {\n  const bases: string[] = [];\n  if (projectRoot) bases.push(path.join(projectRoot, '__domflax__.js'));\n  bases.push(path.join(process.cwd(), '__domflax__.js'));\n  bases.push(moduleBase());\n  for (const base of bases) {\n    try {\n      const req = createRequire(base);\n      req.resolve('postcss');\n      req.resolve('postcss-selector-parser');\n      const postcss = req('postcss') as { parse: PostcssParseApi };\n      const raw = req('postcss-selector-parser') as SelectorParserApi & { default?: SelectorParserApi };\n      // postcss-selector-parser is CJS with a default export under interop; accept both shapes.\n      const selector = raw.default ?? raw;\n      return { parse: postcss.parse, selectorParser: selector };\n    } catch {\n      /* try the next base */\n    }\n  }\n  return null;\n}\n\n/* ────────────────────────────────────────────────────────────────────────── *\n * Lazily-loaded postcss engine (module singleton)\n * ────────────────────────────────────────────────────────────────────────── */\n\n/** Runtime postcss `parse`, populated on first resolver construction. */\nexport let pc: PostcssParseApi | null = null;\n/** Runtime postcss-selector-parser, populated on first resolver construction. */\nexport let sp: SelectorParserApi | null = null;\n\n/** Ensure the postcss engine is loaded; throws a clear error if the optional peers are absent. */\nexport function ensurePostcss(projectRoot?: string): void {\n  if (pc && sp) return;\n  const engine = loadPostcssEngine(projectRoot);\n  if (!engine) {\n    throw new Error(\n      '@domflax/resolver-css requires \"postcss\" and \"postcss-selector-parser\" to be installed in ' +\n        'your project (they are optional peer dependencies of domflax, loaded only when the custom-CSS ' +\n        'provider is used). Install them with: npm install postcss postcss-selector-parser',\n    );\n  }\n  pc = engine.parse;\n  sp = engine.selectorParser;\n}\n","import type { AtRule, Rule } from 'postcss';\nimport type { RawDecl } from './types';\n\n/* ────────────────────────────────────────────────────────────────────────── *\n * postcss helpers\n * ────────────────────────────────────────────────────────────────────────── */\n\ninterface MediaContext {\n  readonly media: string;\n  /** True when the rule lives under an at-rule that is not a style context (keyframes/font-face). */\n  readonly skip: boolean;\n}\n\n/** Walk a rule's at-rule ancestry, collecting `@media` params and detecting non-style contexts. */\nexport function mediaContext(rule: Rule): MediaContext {\n  const parts: string[] = [];\n  let skip = false;\n  let parent = rule.parent;\n  while (parent && parent.type === 'atrule') {\n    const at = parent as AtRule;\n    const name = at.name.toLowerCase();\n    if (name === 'media') parts.unshift(at.params.trim().replace(/\\s+/g, ' '));\n    else if (name === 'keyframes' || name.endsWith('keyframes') || name === 'font-face') skip = true;\n    parent = parent.parent;\n  }\n  return { media: parts.join(' and '), skip };\n}\n\n/** A rule's direct declarations, in source order, as raw `[prop, value, important]` triples. */\nexport function collectDecls(rule: Rule): RawDecl[] {\n  const out: RawDecl[] = [];\n  for (const node of rule.nodes) {\n    if (node.type === 'decl') out.push([node.prop, node.value, node.important === true]);\n  }\n  return out;\n}\n","import { readFileSync } from 'node:fs';\nimport { ENGINE_VERSION } from './constants';\nimport type { CssFile } from './types';\n\n/* ────────────────────────────────────────────────────────────────────────── *\n * Misc helpers\n * ────────────────────────────────────────────────────────────────────────── */\n\n/** Cheap, allocation-free CSS-identifier check used by {@link CustomCSSResolver.owns}. */\nexport function isPlainClassToken(token: string): boolean {\n  return token.length > 0 && !/[\\s.#>+~:[\\]()]/.test(token);\n}\n\n/** Read a CSS file from disk; surfaces unreadable paths as a clear input error. */\nexport function readCssPath(path: string): CssFile {\n  try {\n    return { id: path, css: readFileSync(path, 'utf8') };\n  } catch (cause) {\n    throw new Error(`resolver-css: cannot read CSS file \"${path}\"`, { cause });\n  }\n}\n\n/**\n * Derive a deterministic fingerprint from the provider tag, engine version, and each file's id +\n * length. Cheap and good enough to bust downstream caches when the source CSS set changes.\n */\nexport function deriveFingerprint(provider: string, files: readonly CssFile[]): string {\n  const parts = files.map((f) => `${f.id}:${f.css.length}`).sort();\n  return `${provider}/${ENGINE_VERSION}::${parts.join('|')}`;\n}\n","import type selectorParser from 'postcss-selector-parser';\nimport { LEGACY_PSEUDO_ELEMENTS } from './constants';\nimport { sp } from './engine';\n\n/* ────────────────────────────────────────────────────────────────────────── *\n * Selector helpers\n * ────────────────────────────────────────────────────────────────────────── */\n\nexport interface Compound {\n  /** The combinator immediately to this compound's LEFT (`null` for the first compound). */\n  readonly leftCombinator: string | null;\n  readonly nodes: readonly selectorParser.Node[];\n}\n\n/** Split a selector's flat node list into compounds delimited by combinator nodes. */\nexport function splitCompounds(selector: selectorParser.Selector): Compound[] {\n  const compounds: Compound[] = [];\n  let current: selectorParser.Node[] = [];\n  let leftCombinator: string | null = null;\n  for (const node of selector.nodes) {\n    if (sp!.isCombinator(node)) {\n      compounds.push({ leftCombinator, nodes: current });\n      current = [];\n      leftCombinator = combinatorValue(node);\n    } else {\n      current.push(node);\n    }\n  }\n  compounds.push({ leftCombinator, nodes: current });\n  return compounds;\n}\n\n/** A combinator's normalized value — descendant combinators are a single space. */\nfunction combinatorValue(node: selectorParser.Combinator): string {\n  const v = node.value;\n  return v.trim() === '' ? ' ' : v.trim();\n}\n\n/** The pseudo's lower-cased name including its leading colon(s), without any argument. */\nexport function pseudoName(node: selectorParser.Pseudo): string {\n  return node.value.toLowerCase();\n}\n\nexport function isPseudoElement(node: selectorParser.Pseudo): boolean {\n  return sp!.isPseudoElement(node) || LEGACY_PSEUDO_ELEMENTS.has(pseudoName(node));\n}\n\n/** Canonicalize a pseudo-element to the modern double-colon form (e.g. `:before` → `::before`). */\nexport function normalizePseudoElement(node: selectorParser.Pseudo): string {\n  const name = pseudoName(node);\n  return name.startsWith('::') ? name : `::${name.replace(/^:/, '')}`;\n}\n","/**\n * @domflax/resolver-css — a {@link StyleResolver} backed by the project's own CSS files.\n *\n * Role: parse user-authored stylesheets with postcss, index every selector + declaration block, and\n * answer the resolver contract for plain `class=\"…\"` tokens:\n *\n *   • `resolve(classes)` — FORWARD. Union the declarations of every rule whose selector is a simple\n *     `.class` selector (optionally qualified by state pseudo-classes / a pseudo-element / wrapped in\n *     an `@media`, which become {@link StyleCondition}s) into a normalized, condition-keyed\n *     {@link StyleMap}. The shared {@link normalizer} expands shorthands and canonicalizes values so\n *     resolver + patterns + verify agree byte-for-byte. Equal-specificity single-class rules cascade\n *     by SOURCE order (later wins); BASE is the unconditional must-have block.\n *   • `emit(styles)` — REVERSE. Best-effort map a {@link StyleMap} back to the minimal set of existing\n *     class names whose own declarations are all present in the target. If nothing matches it returns\n *     no classes and `exact:false`; it never throws.\n *   • `selectorUsage(token)` — how a class participates in project selectors (subject / ancestor /\n *     sibling / compound / `:has()` argument / structural pseudo), driving compress safety. Backed by\n *     postcss-selector-parser so combinator and structural-pseudo facts are accurate.\n *   • {@link CustomCSSResolver.complexSelectors} — the list of COMPLEX selectors (anything with a\n *     combinator or a structural pseudo). This feeds domflax's CSS-selector-safety guard.\n *\n * CSS is accepted as raw sources (id + text) and/or as file paths read synchronously from disk, so\n * the resolver is fully unit-testable without touching the filesystem. Malformed CSS never throws —\n * an unparseable stylesheet simply contributes nothing; only genuine input errors (e.g. an\n * unreadable file path) surface as thrown errors.\n */\n\nexport { CSS_RESOLVER_ID, CSS_RESOLVER_PROVIDER } from './constants';\nexport { createCssResolver, CustomCSSResolver } from './resolver';\nexport type { CssFile, CssResolverOptions } from './types';\n","/**\n * @domflax/frontend-html — parse5 HTML <-> IR frontend + backend.\n *\n * A {@link Frontend} that parses HTML into an {@link IRDocument} (parse5 tree → IR, resolving each\n * element's `class` attribute onto `computed`), and a matching {@link Backend} that prints the edited\n * document back to HTML with SURGICAL, span-based edits over the original source (never re-serializing\n * the parse5 tree). Untouched bytes — doctype, comments, whitespace, scripts, attribute order — stay\n * byte-for-byte identical.\n *\n * parse5 is a real dependency but is LAZILY required inside `parse()` (see `./parse`), so the JSX-only\n * path never loads it. The parse walk + opacity/span helpers live in `./walk` + `./parse`; the reverse\n * codegen in `./backend`. This module is the public assembly point.\n */\n\nimport type {\n  Backend,\n  BackendContext,\n  CodegenResult,\n  EditPlan,\n  Frontend,\n  FrontendParseContext,\n  IRDocument,\n  ParseResult,\n} from '@domflax/core';\n\nimport { doPrint } from './backend';\nimport { doParse } from './parse';\nimport { HTML_LANGS, looksLikeHtml } from './walk';\n\nexport { HTML_LANGS, looksLikeHtml } from './walk';\n\n/** HTML frontend: parse5 HTML → IR (with source spans for surgical codegen). */\nexport const htmlFrontend: Frontend = {\n  name: 'html',\n  langs: HTML_LANGS,\n  canParse(id: string, code: string): boolean {\n    return looksLikeHtml(id, code);\n  },\n  parse(code: string, ctx: FrontendParseContext): ParseResult {\n    return doParse(code, ctx);\n  },\n};\n\n/** Factory mirror — returns a fresh handle to the (stateless) HTML frontend. */\nexport function createHtmlFrontend(): Frontend {\n  return htmlFrontend;\n}\n\n/** HTML backend: IR → HTML via span-based surgical edits over the retained verbatim source. */\nexport const htmlBackend: Backend = {\n  name: 'html',\n  langs: HTML_LANGS,\n  print(doc: IRDocument, _plan: EditPlan, _ctx: BackendContext): CodegenResult {\n    return { code: doPrint(doc), map: null, edits: [], diagnostics: [] };\n  },\n};\n\n/** Factory mirror — returns a fresh handle to the (stateless) HTML backend. */\nexport function createHtmlBackend(): Backend {\n  return htmlBackend;\n}\n\nexport default htmlFrontend;\n","/**\n * @domflax/frontend-html — IR → HTML backend (SURGICAL, verbatim-preserving).\n *\n * The pass manager mutates the IR tree that was lowered from a complete HTML document. The backend\n * emits the SAME document back with ONLY the diffs the passes produced, applied as span edits over the\n * ORIGINAL source via `magic-string`. It NEVER re-serializes the parse5 tree — doing so would normalize\n * quoting/whitespace/attribute order across the whole file. Every untouched byte (doctype, `<head>`,\n * comments, scripts, whitespace, attribute ordering) stays byte-for-byte identical.\n *\n *   • CLASS CHANGE — for a surviving element whose static class list differs from its source text,\n *     overwrite just the `class` attribute VALUE span (quotes included) with the new tokens.\n *   • UNWRAP (flatten) — when a wrapper element was removed but a descendant survived, delete ONLY the\n *     wrapper's open- and close-tag spans; the children (their entire subtrees) survive verbatim.\n *   • FULL REMOVAL — when a node was removed with no surviving descendant, delete its whole span.\n */\n\nimport MagicString from 'magic-string';\n\nimport type {\n  Backref,\n  ClassList,\n  IRDocument,\n  IRElement,\n  IRNode,\n  IRNodeId,\n  SourceFile,\n  SourceSpan,\n} from '@domflax/core';\n\n/* ───────────────────────── shared helpers ───────────────────────── */\n\n/** All static class tokens of a {@link ClassList}, in source order. */\nfunction staticTokensOf(classes: ClassList): string[] {\n  const out: string[] = [];\n  for (const seg of classes.segments) {\n    if (seg.kind === 'static') for (const t of seg.tokens) out.push(t.value);\n  }\n  return out;\n}\n\n/** Two token lists are equal iff same length and same tokens in the same order. */\nfunction sameTokens(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;\n  return true;\n}\n\n/** Pick the single retained source file this document was parsed from (if any). */\nfunction primarySource(doc: IRDocument): SourceFile | null {\n  for (const sf of doc.sources.values()) {\n    if (typeof sf.text === 'string' && sf.text.length > 0) return sf;\n  }\n  return null;\n}\n\n/** Collect every node reachable from the root of the (mutated) tree. */\nfunction collectKept(doc: IRDocument): IRNode[] {\n  const out: IRNode[] = [];\n  const seen = new Set<IRNodeId>();\n  const visit = (id: IRNodeId): void => {\n    if (seen.has(id)) return;\n    seen.add(id);\n    const n = doc.nodes.get(id);\n    if (!n) return;\n    out.push(n);\n    if (n.kind === 'element' || n.kind === 'fragment') for (const c of n.children) visit(c);\n  };\n  visit(doc.root);\n  return out;\n}\n\n/** Span `a` strictly contains span `b` (same file, b nested inside, not identical). */\nfunction strictlyContains(a: SourceSpan, b: SourceSpan): boolean {\n  if (a.file !== b.file) return false;\n  if (a.start <= b.start && b.end <= a.end) return !(a.start === b.start && a.end === b.end);\n  return false;\n}\n\n/** All ids the backref table knows about (every originally-parsed element with a source location). */\nfunction backrefIds(doc: IRDocument): IRNodeId[] {\n  const out: IRNodeId[] = [];\n  const max = doc.alloc.peek as unknown as number;\n  for (let i = 1; i < max; i += 1) {\n    const id = i as IRNodeId;\n    if (doc.backref.get(id)) out.push(id);\n  }\n  return out;\n}\n\n/* ───────────────────────── class-value rewrite ───────────────────────── */\n\n/** The tokens currently written in the class value span (quotes/whitespace stripped). */\nfunction currentTokens(sf: SourceFile, valueSpan: SourceSpan): string[] {\n  const raw = sf.text.slice(valueSpan.start, valueSpan.end).trim();\n  const unquoted = raw.replace(/^['\"]/, '').replace(/['\"]$/, '');\n  return unquoted.split(/\\s+/).filter((t) => t.length > 0);\n}\n\n/** Apply the class-list diff for one surviving element. Returns true if a byte edit was made. */\nfunction editClasses(ms: MagicString, doc: IRDocument, sf: SourceFile, el: IRElement): boolean {\n  const classes = el.classes;\n  if (classes.hasDynamic || classes.opaque) return false; // never rewrite an opaque/dynamic list\n\n  const tokens = staticTokensOf(classes);\n  const valueSpan = classes.valueSpan;\n\n  if (valueSpan && valueSpan.file === sf.id) {\n    if (sameTokens(currentTokens(sf, valueSpan), tokens)) return false; // unchanged → leave verbatim\n    const current = sf.text.slice(valueSpan.start, valueSpan.end).trim();\n    const quote = current.startsWith(\"'\") ? \"'\" : '\"';\n    ms.overwrite(valueSpan.start, valueSpan.end, `${quote}${tokens.join(' ')}${quote}`);\n    return true;\n  }\n\n  // No class attribute originally, but the passes added classes ⇒ insert one on the opening tag.\n  if (tokens.length === 0) return false;\n  const openTag = doc.backref.get(el.id)?.openTagSpan;\n  if (!openTag || openTag.file !== sf.id) return false;\n  ms.appendLeft(openTag.start + 1 + el.tag.length, ` class=\"${tokens.join(' ')}\"`);\n  return true;\n}\n\n/* ───────────────────────── surgical codegen ───────────────────────── */\n\ninterface RemovedRegion {\n  readonly backref: Backref;\n  /** A surviving node nested inside this region ⇒ this was an UNWRAP (keep inner, drop tags). */\n  readonly unwrapped: boolean;\n}\n\n/** Surgical whole-document codegen. Returns null when the document has no retained source. */\nfunction surgicalPrint(doc: IRDocument): string | null {\n  const sf = primarySource(doc);\n  if (!sf) return null;\n\n  const ms = new MagicString(sf.text);\n\n  const kept = collectKept(doc);\n  const keptSpans: SourceSpan[] = [];\n  for (const n of kept) if (n.span && n.span.file === sf.id) keptSpans.push(n.span);\n\n  // 1) Structural removals — an id in the backref table but absent from the live node map was removed\n  //    by the passes. Classify as UNWRAP (a surviving node nests inside) or FULL removal.\n  const removed: RemovedRegion[] = [];\n  for (const id of backrefIds(doc)) {\n    if (doc.nodes.has(id)) continue;\n    const back = doc.backref.get(id);\n    if (!back || back.span.file !== sf.id) continue;\n    const unwrapped = keptSpans.some((k) => strictlyContains(back.span, k));\n    removed.push({ backref: back, unwrapped });\n  }\n\n  // Skip any removed region nested inside a FULL-removal region (already deleted by the ancestor), so\n  // every delete stays disjoint (magic-string requires it).\n  const fullRemovals = removed.filter((r) => !r.unwrapped).map((r) => r.backref.span);\n  for (const r of removed) {\n    const s = r.backref.span;\n    if (fullRemovals.some((f) => f !== s && strictlyContains(f, s))) continue;\n\n    if (r.unwrapped) {\n      const open = r.backref.openTagSpan;\n      const close = r.backref.closeTagSpan;\n      if (open && open.file === sf.id && open.end > open.start) ms.remove(open.start, open.end);\n      if (close && close.file === sf.id && close.end > close.start) ms.remove(close.start, close.end);\n    } else {\n      ms.remove(s.start, s.end);\n    }\n  }\n\n  // 2) Class-list diffs on every surviving element.\n  for (const n of kept) if (n.kind === 'element') editClasses(ms, doc, sf, n);\n\n  return ms.toString();\n}\n\n/** Emit the (possibly edited) document. Falls back to the empty string only for a source-less doc. */\nexport function doPrint(doc: IRDocument): string {\n  return surgicalPrint(doc) ?? '';\n}\n","/**\n * @domflax/frontend-html — the parse5 HTML → IR parse pass.\n *\n * Parses HTML with parse5 (WHATWG-compliant tree construction) and lowers its tree into the\n * `@domflax/core` IR: every element → {@link IRElement} (tag + non-class attributes, with the `class`\n * attribute resolved through `ctx.resolver`/`ctx.normalizer` into `computed` so downstream patterns\n * match on resolved style), text → {@link IRText}, comments → {@link IRComment}. Doctype and\n * auto-inserted (`<html>`/`<head>`/`<body>`) wrappers are preserved verbatim: doctype is not\n * represented, synthetic wrappers become opaque (never edited).\n *\n * Precise SOURCE SPANS from parse5 location info (element span, open-/close-tag spans, and the `class`\n * VALUE span) are recorded in the {@link MutableBackrefTable} so the backend edits surgically instead\n * of re-serializing (which would reformat the whole document).\n *\n * OPACITY (never flatten/rewrite), enforced via `meta.safetyFloor = 0` (blocks every op above lint):\n *   • elements with an `id`, any inline `on*=` handler, or `contenteditable` (element only);\n *   • `<script>`/`<style>`/`<template>`/`<svg>`/`<pre>`/`<textarea>` subtrees (not descended into);\n *   • synthetic (auto-inserted) elements carrying no source location.\n *\n * parse5 is LAZILY required (via `createRequire`, since {@link Frontend.parse} is synchronous) INSIDE\n * `doParse`, so the JSX-only path never loads it.\n */\n\nimport { createRequire } from 'node:module';\n\nimport type {\n  AttrMap,\n  AttrValue,\n  ClassList,\n  ClassSegment,\n  Diagnostic,\n  FrontendParseContext,\n  IRDocument,\n  IRElement,\n  IRFragment,\n  IRNodeId,\n  MutableBackrefTable,\n  NodeMeta,\n  ParseResult,\n  SourceFile,\n  StyleMap,\n} from '@domflax/core';\nimport {\n  createComment,\n  createDocument,\n  createElement,\n  createText,\n  defaultMeta,\n  emptyClassList,\n  emptyStyleMap,\n} from '@domflax/core';\n\nimport type { P5Attr, P5Location, P5Node, Parse5Module } from './walk';\nimport {\n  FILE_ID,\n  attrsLocOf,\n  classValueSpan,\n  elementIsOpaque,\n  hasEventHandler,\n  isOpaqueSubtreeTag,\n  span,\n} from './walk';\n\n/* ───────────────────────── lazy parse5 ───────────────────────── */\n\nlet cachedParse5: Parse5Module | null = null;\n\n/**\n * Load parse5 lazily via `createRequire` (NOT a top-level import): {@link Frontend.parse} is\n * synchronous, so a dynamic `import()` is unavailable, and the JSX-only path must never pull parse5\n * into memory. Rooted at THIS module so it resolves the parse5 the frontend depends on.\n */\nfunction loadParse5(): Parse5Module {\n  if (cachedParse5) return cachedParse5;\n  const req = createRequire(import.meta.url);\n  cachedParse5 = req('parse5') as Parse5Module;\n  return cachedParse5;\n}\n\n/* ───────────────────────── parse pass ───────────────────────── */\n\nexport function doParse(code: string, ctx: FrontendParseContext): ParseResult {\n  const diagnostics: Diagnostic[] = [];\n  const doc: IRDocument = createDocument('html');\n  const backref = doc.backref as MutableBackrefTable;\n\n  const parse5 = loadParse5();\n  const document = parse5.parse(code, { sourceCodeLocationInfo: true });\n\n  const eol: '\\n' | '\\r\\n' = code.includes('\\r\\n') ? '\\r\\n' : '\\n';\n  const sourceFile: SourceFile = {\n    id: FILE_ID,\n    path: ctx.id,\n    text: code,\n    frontend: 'html',\n    eol,\n    indentUnit: '  ',\n    native: document,\n  };\n  doc.sources.set(FILE_ID, sourceFile);\n\n  /* ----- class resolution (static classes → computed style) ----- */\n\n  const resolveComputed = (\n    tokens: readonly string[],\n    tag: string,\n    nodeId: IRNodeId,\n    meta: NodeMeta,\n  ): StyleMap => {\n    if (tokens.length === 0) return emptyStyleMap();\n    const res = ctx.resolver.resolve({ classes: tokens, element: { tagName: tag, namespace: 'html' } });\n    // SAFETY (Layer 2): any unresolved token → the element's true style is UNKNOWN → mark it opaque\n    // for flatten (never unwrap it as inert). Resolved-to-no-paint elements keep hasUnresolvedClasses\n    // false and stay flatten-eligible.\n    if (res.unknown.length > 0) meta.hasUnresolvedClasses = true;\n    for (const w of res.warnings) {\n      diagnostics.push({\n        code: 'DF_STYLE_CONFLICT_UNRESOLVED',\n        severity: w.severity,\n        message: w.message,\n        nodeId,\n      });\n    }\n    return ctx.normalizer.normalizeStyleMap(res.styles);\n  };\n\n  const splitTokens = (raw: string): string[] => raw.split(/\\s+/).filter((t) => t.length > 0);\n\n  /* ----- child lowering ----- */\n\n  const appendChild = (node: P5Node, parentId: IRNodeId, out: IRNodeId[]): void => {\n    const name = node.nodeName;\n    if (name === '#text') {\n      const value = node.value ?? '';\n      const id = doc.alloc.next();\n      const loc = node.sourceCodeLocation ?? null;\n      doc.nodes.set(\n        id,\n        createText(id, value, {\n          parent: parentId,\n          span: loc ? span(loc.startOffset, loc.endOffset) : null,\n          collapsible: /^\\s*$/.test(value),\n        }),\n      );\n      out.push(id);\n      return;\n    }\n    if (name === '#comment') {\n      const id = doc.alloc.next();\n      const loc = node.sourceCodeLocation ?? null;\n      doc.nodes.set(\n        id,\n        createComment(id, node.data ?? '', {\n          parent: parentId,\n          span: loc ? span(loc.startOffset, loc.endOffset) : null,\n        }),\n      );\n      out.push(id);\n      return;\n    }\n    if (name === '#documentType') return; // doctype stays verbatim in source (never represented)\n    if (name.startsWith('#')) {\n      // #document / #document-fragment — a container with no element identity: hoist its children.\n      for (const c of node.childNodes ?? []) appendChild(c, parentId, out);\n      return;\n    }\n    out.push(buildElement(node, parentId));\n  };\n\n  /* ----- element lowering ----- */\n\n  const buildElement = (node: P5Node, parentId: IRNodeId): IRNodeId => {\n    const id = doc.alloc.next();\n    const tag = (node.tagName ?? node.nodeName).toLowerCase();\n    const loc: P5Location | null = node.sourceCodeLocation ?? null;\n    const attrsArr: readonly P5Attr[] = node.attrs ?? [];\n\n    const opaqueSubtree = isOpaqueSubtreeTag(tag);\n    const synthetic = loc == null; // auto-inserted <html>/<head>/<body>\n    const opaque = opaqueSubtree || synthetic || elementIsOpaque(attrsArr);\n\n    const meta: NodeMeta = defaultMeta();\n    meta.hasEventHandlers = hasEventHandler(attrsArr);\n    // Opaque nodes get floor 0 (any op above lint is refused by the applier); optimizable nodes get\n    // floor 3 (fully open — the pattern predicates + flatten classifier are the real gate).\n    meta.safetyFloor = opaque ? 0 : 3;\n\n    // Split attributes: `class` → ClassList; everything else → AttrMap entries (so flatten's\n    // `hasOwnAttrs` guard sees id/data-*/… and refuses to unwrap the element).\n    let classes: ClassList = emptyClassList();\n    let classTokens: string[] = [];\n    const entries = new Map<string, AttrValue>();\n    const order: string[] = [];\n\n    for (const a of attrsArr) {\n      if (a.name.toLowerCase() === 'class') {\n        classTokens = splitTokens(a.value);\n        const valueSpan = classValueSpan(loc, code);\n        const clAttr = attrsLocOf(loc)?.['class'];\n        const seg: ClassSegment = {\n          kind: 'static',\n          span: valueSpan ?? undefined,\n          tokens: classTokens.map((value) => ({ value })),\n        };\n        classes = {\n          form: 'string-literal',\n          segments: [seg],\n          valueSpan,\n          attrSpan: clAttr ? span(clAttr.startOffset, clAttr.endOffset) : undefined,\n          hasDynamic: false,\n          opaque: false,\n          rewritable: valueSpan != null,\n        };\n        continue;\n      }\n      const v = a.value;\n      entries.set(a.name, { kind: 'static', value: v === '' ? true : v });\n      order.push(a.name);\n    }\n\n    const attrs: AttrMap = { entries, spreads: [], order };\n    const computed = resolveComputed(classTokens, tag, id, meta);\n\n    // Children — opaque-subtree elements are NOT descended into; their inner bytes survive verbatim.\n    const children: IRNodeId[] = [];\n    if (!opaqueSubtree) {\n      for (const c of node.childNodes ?? []) appendChild(c, id, children);\n    }\n\n    const el: IRElement = createElement(id, {\n      tag,\n      namespace: 'html',\n      isComponent: false,\n      selfClosing: loc ? loc.endTag == null : false,\n      classes,\n      computed,\n      attrs,\n      children,\n      parent: parentId,\n      span: loc ? span(loc.startOffset, loc.endOffset) : null,\n      meta,\n    });\n    doc.nodes.set(id, el);\n\n    // Backref (surgical-edit anchors) — only for elements with a real source location. Synthetic\n    // wrappers get none, so the backend never tries to move/remove their bytes.\n    if (loc) {\n      backref.set(id, {\n        nodeId: id,\n        span: span(loc.startOffset, loc.endOffset),\n        openTagSpan: loc.startTag ? span(loc.startTag.startOffset, loc.startTag.endOffset) : null,\n        closeTagSpan: loc.endTag ? span(loc.endTag.startOffset, loc.endTag.endOffset) : null,\n        innerSpan: null,\n        selfClosing: loc.endTag == null,\n      });\n    }\n    return id;\n  };\n\n  /* ----- attach top-level nodes under the root fragment ----- */\n\n  const rootFrag = doc.nodes.get(doc.root) as IRFragment;\n  appendChild(document, doc.root, rootFrag.children);\n\n  return { doc, diagnostics };\n}\n","/**\n * @domflax/frontend-html — pure parse5 interop, constants, and opacity/span helpers.\n *\n * Stateless building blocks shared by the HTML parse pass: the minimal parse5 node/location shapes\n * this frontend reads (parse5 ships its own types, but the frontend requires it LAZILY as `unknown`,\n * so it re-declares only the slice it touches), the fixed constants, the opacity classification\n * predicates (which elements/subtrees must never be flattened or rewritten), and the source-span\n * helpers that turn parse5 location info into {@link SourceSpan}s for surgical codegen.\n *\n * No closure state, no document mutation, no third-party imports — only the `@domflax/core` type\n * contract.\n */\n\nimport type { FileKind, SourceFileId, SourceSpan } from '@domflax/core';\n\n/** Languages this frontend claims. HTML only; JSX/TSX is owned by a sibling frontend. */\nexport const HTML_LANGS: readonly FileKind[] = ['html'];\n\n/** The single registered source file id (one parse == one document). */\nexport const FILE_ID = 1 as SourceFileId;\n\n/* ───────────────────────── parse5 minimal shapes (lazy-required as unknown) ───────────────────────── */\n\n/** A `{ startOffset, endOffset }` byte range parse5 records for a node/tag/attribute. */\nexport interface P5Range {\n  readonly startOffset: number;\n  readonly endOffset: number;\n}\n\n/** parse5 element start-tag location (parse5 v7 nests per-attribute ranges under `startTag.attrs`). */\nexport interface P5TagLoc extends P5Range {\n  readonly attrs?: Readonly<Record<string, P5Range>>;\n}\n\n/** parse5 element source-code location. `attrs` may live at the top level (v6) or under `startTag` (v7). */\nexport interface P5Location extends P5Range {\n  readonly startTag?: P5TagLoc | null;\n  readonly endTag?: P5Range | null;\n  readonly attrs?: Readonly<Record<string, P5Range>>;\n}\n\nexport interface P5Attr {\n  readonly name: string;\n  readonly value: string;\n}\n\nexport interface P5Node {\n  readonly nodeName: string;\n  readonly tagName?: string;\n  readonly value?: string; // #text\n  readonly data?: string; // #comment\n  readonly attrs?: readonly P5Attr[];\n  readonly childNodes?: readonly P5Node[];\n  readonly sourceCodeLocation?: P5Location | null;\n}\n\n/** The tiny slice of the parse5 module surface the frontend calls. */\nexport interface Parse5Module {\n  parse(html: string, opts: { readonly sourceCodeLocationInfo: boolean }): P5Node;\n}\n\n/* ───────────────────────── HTML detection ───────────────────────── */\n\n/** Lightweight heuristic: does this source id / code look like HTML we can own? */\nexport function looksLikeHtml(id: string, code: string): boolean {\n  if (/\\.html?$/i.test(id)) return true;\n  const head = code.slice(0, 256).trimStart().toLowerCase();\n  return head.startsWith('<!doctype html') || head.startsWith('<html') || head.startsWith('<');\n}\n\n/* ───────────────────────── opacity classification ───────────────────────── */\n\n/**\n * Tags whose ENTIRE subtree is opaque — never descended into, flattened, or rewritten. Raw-text /\n * embedded-content / whitespace-significant elements whose inner bytes must survive verbatim:\n * `<script>`/`<style>` (raw text + JS/CSS), `<template>` (inert content), `<svg>` (foreign markup),\n * `<pre>`/`<textarea>` (whitespace-significant).\n */\nexport const OPAQUE_SUBTREE_TAGS: ReadonlySet<string> = new Set([\n  'script',\n  'style',\n  'template',\n  'svg',\n  'pre',\n  'textarea',\n]);\n\nexport function isOpaqueSubtreeTag(tag: string): boolean {\n  return OPAQUE_SUBTREE_TAGS.has(tag);\n}\n\n/**\n * Element-level opacity: an `id` (JS may `querySelector`/anchor-link it), any inline `on*=` event\n * handler, or `contenteditable` pins the element's identity/behaviour — it must never be flattened or\n * rewritten (its subtree may still be optimized).\n */\nexport function elementIsOpaque(attrs: readonly P5Attr[]): boolean {\n  for (const a of attrs) {\n    const n = a.name.toLowerCase();\n    if (n === 'id' || n === 'contenteditable') return true;\n    if (n.startsWith('on')) return true;\n  }\n  return false;\n}\n\n/** True when the element carries any inline `on*=` event handler. */\nexport function hasEventHandler(attrs: readonly P5Attr[]): boolean {\n  for (const a of attrs) if (/^on/i.test(a.name)) return true;\n  return false;\n}\n\n/* ───────────────────────── source-span helpers ───────────────────────── */\n\n/** A {@link SourceSpan} over `[start, end)` in the single source file. */\nexport function span(start: number, end: number): SourceSpan {\n  return { file: FILE_ID, start, end };\n}\n\n/** The per-attribute location map, tolerating both the v6 (top-level) and v7 (`startTag`) layouts. */\nexport function attrsLocOf(loc: P5Location | null | undefined): Readonly<Record<string, P5Range>> | undefined {\n  if (!loc) return undefined;\n  return loc.startTag?.attrs ?? loc.attrs;\n}\n\n/**\n * The VALUE span (quotes included) of the `class` attribute — the splice target the backend overwrites\n * to rewrite the class list in place. Derived from the whole-attribute range (`class=\"…\"`) by skipping\n * past the name and `=`; returns null when there is no class attribute or it has no value.\n */\nexport function classValueSpan(loc: P5Location | null | undefined, source: string): SourceSpan | null {\n  const attrsLoc = attrsLocOf(loc);\n  const cl = attrsLoc?.['class'];\n  if (!cl) return null;\n  const text = source.slice(cl.startOffset, cl.endOffset);\n  const eq = text.indexOf('=');\n  if (eq === -1) return null; // bare `class` with no value\n  let i = eq + 1;\n  while (i < text.length && /\\s/.test(text[i]!)) i += 1;\n  if (i >= text.length) return null;\n  return span(cl.startOffset + i, cl.endOffset);\n}\n","/**\n * @domflax/frontend-jsx — Babel JSX/TSX → IR frontend.\n *\n * Walks a Babel AST (`@babel/parser` → `@babel/traverse`) and lowers JSXElement /\n * JSXFragment / JSXText / JSXExpressionContainer / JSXSpreadChild nodes into the\n * `@domflax/core` IR. ALL dynamic JavaScript stays out of the structural IR: every\n * expression container, spread, and dynamic className/child is interned into the\n * document's {@link ExprRegistry} as an opaque {@link ExprRef} (with its verbatim source\n * slice as payload), and only its source span survives in the tree.\n *\n * Static `class`/`className` literals are split into {@link ClassToken}s on a static\n * {@link ClassSegment}; a non-string-literal className becomes a single dynamic segment\n * (opaque, never optimized). Static classes are resolved through the supplied\n * {@link StyleResolver} + {@link StyleNormalizer} into `element.computed` so downstream\n * patterns can match on resolved style.\n *\n * NodeMeta opacity barriers populated here: hasRef (`ref=`), hasEventHandlers (`on*=`),\n * hasKey (`key=`), hasSpreadAttrs (`{...x}`), hasDangerousHtml\n * (`dangerouslySetInnerHTML=`), hasDynamicChildren (any expression / spread child),\n * isComponent (capitalized / member tag). \"hasDynamicClasses\" is carried on the\n * {@link ClassList} itself (`hasDynamic` / `opaque`), not on NodeMeta.\n *\n * The pure AST/classification helpers live in `./frontend-ast`; the parse pass itself\n * lives in `./frontend-parse`. This module is the public assembly point.\n */\n\nimport type { Frontend, FrontendParseContext, ParseResult } from '@domflax/core';\n\nimport { JSX_LANGS, looksLikeJsx } from './frontend-ast';\nimport { doParse } from './frontend-parse';\n\nexport const jsxFrontend: Frontend = {\n  name: 'babel-jsx',\n  langs: JSX_LANGS,\n  canParse(id: string, code: string): boolean {\n    return looksLikeJsx(id, code);\n  },\n  parse(code: string, ctx: FrontendParseContext): ParseResult {\n    return doParse(code, ctx);\n  },\n};\n\n/** Factory mirror — returns a fresh handle to the (stateless) JSX frontend. */\nexport function createJsxFrontend(): Frontend {\n  return jsxFrontend;\n}\n","/**\n * @domflax/frontend-jsx — AST interop, constants, and pure classification helpers.\n *\n * Stateless building blocks shared by the JSX parse pass: the `@babel/traverse`\n * default-export normalization, the frontend's fixed constants, and the pure\n * name/classification/JSX-discovery helpers (no closure state, no document mutation).\n */\n\nimport babelTraverse from '@babel/traverse';\nimport type {\n  JSXAttribute,\n  JSXElement,\n  JSXFragment,\n  JSXIdentifier,\n  JSXMemberExpression,\n  JSXNamespacedName,\n  Node as BabelNode,\n} from '@babel/types';\n\nimport type { ClassListForm, ExprKind, FileKind, SourceFileId } from '@domflax/core';\n\n/* ───────────────────────── @babel/traverse interop ───────────────────────── */\n\n// `@babel/traverse` is published as CJS (`module.exports = traverse; exports.default = traverse`).\n// Under an ESM default import the value may be the function OR `{ default: fn }` depending on the\n// interop layer (Node ESM vs. esbuild vs. tsup), so normalize defensively.\nexport const traverse = (\n  typeof babelTraverse === 'function'\n    ? babelTraverse\n    : (babelTraverse as unknown as { default: typeof babelTraverse }).default\n) as typeof babelTraverse;\n\n/** Languages this frontend claims. JSX/TSX only; HTML is owned by a sibling frontend. */\nexport const JSX_LANGS: readonly FileKind[] = ['jsx', 'tsx'];\n\n/** The single registered source file id (one parse == one module). */\nexport const FILE_ID = 1 as SourceFileId;\n\n/** Marker payload stored for every interned expression so the backend can re-print it. */\nexport interface ExprPayload {\n  readonly text: string;\n  readonly spread: boolean;\n}\n\n/* ───────────────────────── name + classification helpers ───────────────────────── */\n\nexport type JSXName = JSXIdentifier | JSXMemberExpression | JSXNamespacedName;\n\nexport function jsxName(node: JSXName): string {\n  switch (node.type) {\n    case 'JSXIdentifier':\n      return node.name;\n    case 'JSXMemberExpression':\n      return `${jsxName(node.object)}.${node.property.name}`;\n    case 'JSXNamespacedName':\n      return `${node.namespace.name}:${node.name.name}`;\n  }\n}\n\n/** Component vs. intrinsic: capitalized identifier or member expression ⇒ component. */\nexport function isComponentName(node: JSXName): boolean {\n  if (node.type === 'JSXMemberExpression') return true;\n  if (node.type === 'JSXNamespacedName') return false;\n  return /^[A-Z]/.test(node.name);\n}\n\nexport function attrName(name: JSXAttribute['name']): string {\n  return name.type === 'JSXNamespacedName'\n    ? `${name.namespace.name}:${name.name.name}`\n    : name.name;\n}\n\nexport function exprKind(node: BabelNode): ExprKind {\n  switch (node.type) {\n    case 'CallExpression':\n    case 'OptionalCallExpression':\n      return 'call';\n    case 'MemberExpression':\n    case 'OptionalMemberExpression':\n      return 'member';\n    case 'ConditionalExpression':\n    case 'LogicalExpression':\n      return 'conditional';\n    case 'TemplateLiteral':\n    case 'TaggedTemplateExpression':\n      return 'template';\n    case 'Identifier':\n      return 'identifier';\n    case 'SpreadElement':\n      return 'spread';\n    default:\n      return 'other';\n  }\n}\n\n/** Map a dynamic className expression to the closest {@link ClassListForm}. */\nexport function classFormOf(node: BabelNode): ClassListForm {\n  switch (node.type) {\n    case 'TemplateLiteral':\n    case 'TaggedTemplateExpression':\n      return 'template-literal';\n    case 'CallExpression':\n    case 'OptionalCallExpression':\n      return 'call';\n    case 'ConditionalExpression':\n    case 'LogicalExpression':\n      return 'conditional';\n    case 'MemberExpression':\n    case 'OptionalMemberExpression':\n    case 'Identifier':\n      return 'member';\n    default:\n      return 'call';\n  }\n}\n\n/**\n * Find the OUTERMOST JSXElement/JSXFragment nodes that a dynamic expression renders, so the frontend\n * can lower JSX nested inside `{…}` holes — `.map`/`.filter`/`.forEach((x) => <jsx/>)` callbacks,\n * `&&`/`||` logical expressions, ternaries, and parenthesized/cast wrappers — into REAL IR element\n * nodes. The dynamic scaffolding around them (the call itself, the conditions, `{expr}` holes) stays\n * opaque; only the renderable JSX is surfaced so the pass manager descends into and optimizes it.\n *\n * Only the outermost JSX is collected: `buildElement`/`buildFragment` recurse into the\n * descendants themselves, so we must NOT descend past a JSX boundary here (that would double-register\n * inner elements).\n */\nexport function findNestedJsxRoots(root: BabelNode): (JSXElement | JSXFragment)[] {\n  const out: (JSXElement | JSXFragment)[] = [];\n  const seen = new Set<BabelNode>();\n\n  const visit = (n: BabelNode | null | undefined): void => {\n    if (!n || seen.has(n)) return;\n    seen.add(n);\n    switch (n.type) {\n      case 'JSXElement':\n      case 'JSXFragment':\n        out.push(n); // outermost renderable JSX — buildElement/buildFragment recurse from here\n        return;\n      case 'ParenthesizedExpression':\n      case 'TSNonNullExpression':\n      case 'TSAsExpression':\n      case 'TSSatisfiesExpression':\n      case 'TSTypeAssertion':\n        visit(n.expression);\n        return;\n      case 'LogicalExpression':\n        visit(n.left);\n        visit(n.right);\n        return;\n      case 'ConditionalExpression':\n        visit(n.consequent);\n        visit(n.alternate);\n        return;\n      case 'SequenceExpression':\n        for (const e of n.expressions) visit(e);\n        return;\n      case 'CallExpression':\n      case 'OptionalCallExpression':\n        // `.map`/`.filter`/`.forEach(cb)` etc. — descend into the call arguments (the callbacks),\n        // never the callee (that is the `items.map` member access, which renders nothing).\n        for (const a of n.arguments) visit(a as BabelNode);\n        return;\n      case 'ArrowFunctionExpression':\n      case 'FunctionExpression':\n        visit(n.body);\n        return;\n      case 'BlockStatement':\n        for (const s of n.body) visit(s);\n        return;\n      case 'ReturnStatement':\n        visit(n.argument);\n        return;\n      case 'IfStatement':\n        visit(n.consequent);\n        visit(n.alternate);\n        return;\n      case 'ArrayExpression':\n        for (const el of n.elements) visit(el as BabelNode);\n        return;\n      default:\n        return;\n    }\n  };\n\n  visit(root);\n  return out;\n}\n\nexport function looksLikeJsx(id: string, code: string): boolean {\n  if (/\\.[jt]sx$/i.test(id)) return true;\n  return /<\\/?[A-Za-z][\\w.-]*|<>/.test(code);\n}\n","/**\n * @domflax/frontend-jsx — the JSX/TSX → IR parse pass.\n *\n * Walks a Babel AST (`@babel/parser` → `@babel/traverse`) and lowers JSXElement /\n * JSXFragment / JSXText / JSXExpressionContainer / JSXSpreadChild nodes into the\n * `@domflax/core` IR. ALL dynamic JavaScript stays out of the structural IR: every\n * expression container, spread, and dynamic className/child is interned into the\n * document's {@link ExprRegistry} as an opaque {@link ExprRef} (with its verbatim source\n * slice as payload), and only its source span survives in the tree.\n *\n * Static `class`/`className` literals are split into {@link ClassToken}s on a static\n * {@link ClassSegment}; a non-string-literal className becomes a single dynamic segment\n * (opaque, never optimized). Static classes are resolved through the supplied\n * {@link StyleResolver} + {@link StyleNormalizer} into `element.computed` so downstream\n * patterns can match on resolved style.\n *\n * NodeMeta opacity barriers populated here: hasRef (`ref=`), hasEventHandlers (`on*=`),\n * hasKey (`key=`), hasSpreadAttrs (`{...x}`), hasDangerousHtml\n * (`dangerouslySetInnerHTML=`), hasDynamicChildren (any expression / spread child),\n * isComponent (capitalized / member tag). \"hasDynamicClasses\" is carried on the\n * {@link ClassList} itself (`hasDynamic` / `opaque`), not on NodeMeta.\n */\n\nimport { parse as babelParse } from '@babel/parser';\nimport type { NodePath } from '@babel/traverse';\nimport type {\n  Expression,\n  JSXAttribute,\n  JSXElement,\n  JSXEmptyExpression,\n  JSXFragment,\n  JSXOpeningElement,\n  Node as BabelNode,\n} from '@babel/types';\n\nimport type {\n  AttrMap,\n  AttrValue,\n  ClassList,\n  ClassSegment,\n  ClassToken,\n  Diagnostic,\n  ExprRef,\n  FrontendParseContext,\n  IRDocument,\n  IRElement,\n  IRFragment,\n  IRNamespace,\n  IRNodeId,\n  MutableBackrefTable,\n  NodeMeta,\n  ParseResult,\n  SourceFile,\n  SourceSpan,\n  StyleMap,\n} from '@domflax/core';\nimport {\n  createDocument,\n  createElement,\n  createExpr,\n  createFragment,\n  createText,\n  defaultMeta,\n  emptyClassList,\n  emptyStyleMap,\n} from '@domflax/core';\n\nimport type { ExprPayload } from './frontend-ast';\nimport {\n  FILE_ID,\n  attrName,\n  classFormOf,\n  exprKind,\n  findNestedJsxRoots,\n  isComponentName,\n  jsxName,\n  traverse,\n} from './frontend-ast';\n\nexport function doParse(code: string, ctx: FrontendParseContext): ParseResult {\n  const diagnostics: Diagnostic[] = [];\n  const doc: IRDocument = createDocument('jsx');\n  const backref = doc.backref as MutableBackrefTable;\n\n  const ast = babelParse(code, {\n    sourceType: 'module',\n    plugins: ['jsx', 'typescript'],\n  });\n\n  const eol: '\\n' | '\\r\\n' = code.includes('\\r\\n') ? '\\r\\n' : '\\n';\n  const sourceFile: SourceFile = {\n    id: FILE_ID,\n    path: ctx.id,\n    text: code,\n    frontend: 'jsx',\n    eol,\n    indentUnit: '  ',\n    native: ast,\n  };\n  doc.sources.set(FILE_ID, sourceFile);\n\n  /* ----- span helpers (close over `code`) ----- */\n\n  const spanOf = (node: BabelNode): SourceSpan | null => {\n    if (node.start == null || node.end == null) return null;\n    const span: SourceSpan = {\n      file: FILE_ID,\n      start: node.start,\n      end: node.end,\n      startLoc: node.loc\n        ? { line: node.loc.start.line, column: node.loc.start.column }\n        : undefined,\n      endLoc: node.loc ? { line: node.loc.end.line, column: node.loc.end.column } : undefined,\n    };\n    return span;\n  };\n\n  const sliceOf = (node: BabelNode): string =>\n    node.start == null || node.end == null ? '' : code.slice(node.start, node.end);\n\n  /** Intern an expression as an opaque ExprRef, recording its verbatim source slice. */\n  const internExpr = (node: Expression | JSXEmptyExpression, spread: boolean): ExprRef => {\n    const payload: ExprPayload = { text: sliceOf(node), spread };\n    return doc.exprs.intern({\n      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },\n      kind: exprKind(node),\n      payload,\n    });\n  };\n\n  /* ----- class list ----- */\n\n  const splitTokens = (raw: string): ClassToken[] =>\n    raw\n      .split(/\\s+/)\n      .filter((t) => t.length > 0)\n      .map((value) => ({ value }) as ClassToken);\n\n  const buildClassList = (attr: JSXAttribute): ClassList => {\n    const attrSpan = spanOf(attr) ?? undefined;\n    const v = attr.value;\n\n    const staticList = (tokens: ClassToken[], valueSpan: SourceSpan | null): ClassList => {\n      const seg: ClassSegment = { kind: 'static', span: valueSpan ?? undefined, tokens };\n      return {\n        form: 'string-literal',\n        segments: [seg],\n        valueSpan,\n        attrSpan,\n        hasDynamic: false,\n        opaque: false,\n        rewritable: true,\n      };\n    };\n\n    if (v == null) return staticList([], null);\n\n    if (v.type === 'StringLiteral') {\n      return staticList(splitTokens(v.value), spanOf(v));\n    }\n\n    if (v.type === 'JSXExpressionContainer') {\n      const expr = v.expression;\n      // `className={\"a b\"}` is still a static string literal.\n      if (expr.type === 'StringLiteral') {\n        return staticList(splitTokens(expr.value), spanOf(expr));\n      }\n      if (expr.type === 'JSXEmptyExpression') return staticList([], null);\n      const ref = internExpr(expr, false);\n      const valueSpan = spanOf(expr);\n      const seg: ClassSegment = { kind: 'dynamic', span: valueSpan ?? undefined, expr: ref };\n      return {\n        form: classFormOf(expr),\n        segments: [seg],\n        valueSpan,\n        attrSpan,\n        hasDynamic: true,\n        opaque: true,\n        rewritable: false,\n      };\n    }\n\n    return emptyClassList();\n  };\n\n  const staticTokensOf = (classes: ClassList): string[] => {\n    const out: string[] = [];\n    for (const seg of classes.segments) {\n      if (seg.kind === 'static') for (const t of seg.tokens) out.push(t.value);\n    }\n    return out;\n  };\n\n  /* ----- attribute value ----- */\n\n  const buildAttrValue = (attr: JSXAttribute): AttrValue => {\n    const v = attr.value;\n    if (v == null) return { kind: 'static', value: true, span: spanOf(attr) ?? undefined };\n    if (v.type === 'StringLiteral') {\n      return { kind: 'static', value: v.value, span: spanOf(v) ?? undefined };\n    }\n    if (v.type === 'JSXExpressionContainer') {\n      if (v.expression.type === 'JSXEmptyExpression') {\n        return { kind: 'static', value: true, span: spanOf(v) ?? undefined };\n      }\n      return { kind: 'dynamic', expr: internExpr(v.expression, false), span: spanOf(v) ?? undefined };\n    }\n    // JSXElement / JSXFragment used as an attribute value → opaque expression.\n    return { kind: 'dynamic', expr: internExpr(v as Expression, false), span: spanOf(v) ?? undefined };\n  };\n\n  /* ----- node builders ----- */\n\n  const buildNestedRoot = (jsx: JSXElement | JSXFragment, parentId: IRNodeId): IRNodeId =>\n    jsx.type === 'JSXFragment' ? buildFragment(jsx, parentId) : buildElement(jsx, parentId);\n\n  /** Lower a single JSX child, appending the resulting IR node id(s) onto `out`. */\n  const appendChild = (\n    node: JSXElement['children'][number],\n    parentId: IRNodeId,\n    out: IRNodeId[],\n  ): void => {\n    switch (node.type) {\n      case 'JSXText': {\n        const id = doc.alloc.next();\n        doc.nodes.set(\n          id,\n          createText(id, node.value, {\n            parent: parentId,\n            span: spanOf(node),\n            collapsible: /^\\s*$/.test(node.value),\n          }),\n        );\n        out.push(id);\n        return;\n      }\n      case 'JSXExpressionContainer': {\n        const expr = node.expression;\n        if (expr.type === 'JSXEmptyExpression') return; // `{/* comment */}`\n        // A container whose WHOLE expression is a JSX node (`{<X/>}`) renders that node directly —\n        // lower it as a real element so passes can optimize it (no opaque wrapper needed).\n        if (expr.type === 'JSXElement' || expr.type === 'JSXFragment') {\n          out.push(buildNestedRoot(expr, parentId));\n          return;\n        }\n        // Otherwise the expression itself stays OPAQUE — the `.map`/condition/`{expr}` hole is\n        // interned and preserved verbatim by the backend …\n        const id = doc.alloc.next();\n        const ref = internExpr(expr, false);\n        doc.nodes.set(id, createExpr(id, ref, { parent: parentId, span: spanOf(node) }));\n        out.push(id);\n        // … but any JSX nested INSIDE it (map/filter callbacks, `&&`/`||`, ternary, parens) is\n        // lowered to real element nodes (with their true source spans) so the pass manager descends\n        // into and optimizes them too.\n        for (const jsx of findNestedJsxRoots(expr)) out.push(buildNestedRoot(jsx, parentId));\n        return;\n      }\n      case 'JSXSpreadChild': {\n        const id = doc.alloc.next();\n        const ref = internExpr(node.expression, true);\n        doc.nodes.set(id, createExpr(id, ref, { parent: parentId, span: spanOf(node) }));\n        out.push(id);\n        for (const jsx of findNestedJsxRoots(node.expression)) {\n          out.push(buildNestedRoot(jsx, parentId));\n        }\n        return;\n      }\n      case 'JSXElement':\n        out.push(buildElement(node, parentId));\n        return;\n      case 'JSXFragment':\n        out.push(buildFragment(node, parentId));\n        return;\n      default:\n        return;\n    }\n  };\n\n  const buildFragment = (node: JSXFragment, parentId: IRNodeId): IRNodeId => {\n    const id = doc.alloc.next();\n    const children: IRNodeId[] = [];\n    for (const c of node.children) appendChild(c, id, children);\n    doc.nodes.set(id, createFragment(id, { children, parent: parentId, span: spanOf(node) }));\n    backref.set(id, {\n      nodeId: id,\n      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },\n      openTagSpan: spanOf(node.openingFragment),\n      closeTagSpan: spanOf(node.closingFragment),\n      innerSpan: null,\n      selfClosing: false,\n    });\n    return id;\n  };\n\n  const buildElement = (node: JSXElement, parentId: IRNodeId): IRNodeId => {\n    const id = doc.alloc.next();\n    const opening: JSXOpeningElement = node.openingElement;\n    const tag = jsxName(opening.name);\n    const component = isComponentName(opening.name);\n\n    const meta: NodeMeta = defaultMeta();\n    meta.isComponent = component;\n\n    let classes: ClassList = emptyClassList();\n    const entries = new Map<string, AttrValue>();\n    const order: string[] = [];\n    const spreads: ExprRef[] = [];\n\n    for (const attr of opening.attributes) {\n      if (attr.type === 'JSXSpreadAttribute') {\n        spreads.push(internExpr(attr.argument, true));\n        meta.hasSpreadAttrs = true;\n        continue;\n      }\n      const name = attrName(attr.name);\n      if (name === 'className' || name === 'class') {\n        classes = buildClassList(attr);\n        continue;\n      }\n      if (name === 'ref') meta.hasRef = true;\n      else if (name === 'key') meta.hasKey = true;\n      else if (name === 'dangerouslySetInnerHTML') meta.hasDangerousHtml = true;\n      else if (/^on[A-Z]/.test(name)) meta.hasEventHandlers = true;\n      entries.set(name, buildAttrValue(attr));\n      order.push(name);\n    }\n\n    const attrs: AttrMap = { entries, spreads, order };\n\n    const children: IRNodeId[] = [];\n    for (const c of node.children) appendChild(c, id, children);\n    for (const cid of children) {\n      const cn = doc.nodes.get(cid);\n      if (cn && cn.kind === 'expr') {\n        meta.hasDynamicChildren = true;\n        break;\n      }\n    }\n\n    // Resolve static classes (+ tag) into computed style via the injected resolver/normalizer.\n    let computed: StyleMap = emptyStyleMap();\n    if (!classes.hasDynamic) {\n      const tokens = staticTokensOf(classes);\n      if (tokens.length > 0) {\n        const res = ctx.resolver.resolve({\n          classes: tokens,\n          element: { tagName: tag, namespace: component ? undefined : 'html' },\n        });\n        computed = ctx.normalizer.normalizeStyleMap(res.styles);\n        // SAFETY (Layer 2): a token the resolver could not resolve leaves the element's true style\n        // UNKNOWN → mark it opaque for flatten (never unwrap it as inert). Distinct from a token that\n        // resolved to no paint (which keeps the element flatten-eligible).\n        if (res.unknown.length > 0) meta.hasUnresolvedClasses = true;\n        for (const w of res.warnings) {\n          diagnostics.push({\n            code: 'DF_STYLE_CONFLICT_UNRESOLVED',\n            severity: w.severity,\n            message: w.message,\n            nodeId: id,\n          });\n        }\n      }\n    }\n\n    const namespace: IRNamespace = component ? 'component' : 'html';\n    const el: IRElement = createElement(id, {\n      tag,\n      namespace,\n      isComponent: component,\n      selfClosing: opening.selfClosing,\n      classes,\n      computed,\n      attrs,\n      children,\n      parent: parentId,\n      span: spanOf(node),\n      meta,\n    });\n    doc.nodes.set(id, el);\n\n    const inner =\n      children.length > 0\n        ? spanOf(node.children[0]! as BabelNode) && spanOf(node.children.at(-1)! as BabelNode)\n          ? {\n              file: FILE_ID,\n              start: spanOf(node.children[0]! as BabelNode)!.start,\n              end: spanOf(node.children.at(-1)! as BabelNode)!.end,\n            }\n          : null\n        : null;\n    backref.set(id, {\n      nodeId: id,\n      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },\n      openTagSpan: spanOf(opening),\n      closeTagSpan: node.closingElement ? spanOf(node.closingElement) : null,\n      innerSpan: inner,\n      selfClosing: opening.selfClosing,\n    });\n    return id;\n  };\n\n  /* ----- collect the outermost JSX islands and attach them to the root fragment ----- */\n\n  const roots: (JSXElement | JSXFragment)[] = [];\n  traverse(ast, {\n    JSXElement(path: NodePath<JSXElement>) {\n      roots.push(path.node);\n      path.skip();\n    },\n    JSXFragment(path: NodePath<JSXFragment>) {\n      roots.push(path.node);\n      path.skip();\n    },\n  });\n\n  const rootFrag = doc.nodes.get(doc.root) as IRFragment;\n  for (const r of roots) {\n    const id = r.type === 'JSXFragment' ? buildFragment(r, doc.root) : buildElement(r, doc.root);\n    rootFrag.children.push(id);\n  }\n\n  return { doc, diagnostics };\n}\n","/**\n * @domflax/frontend-jsx — IR → JSX/TSX backend (SURGICAL, full-module round-trip).\n *\n * The pass manager mutates a tree of JSX *islands* that were lowered from a complete module\n * (imports, `export default function`, hooks, `return (…)`, `{expr}` holes, comments, …). The\n * backend's job is to emit a COMPLETE, valid module — not just the JSX subtree. It does this by\n * starting from the element's ORIGINAL verbatim source (retained on {@link SourceFile.text}) and\n * applying ONLY the diffs the passes produced, via `magic-string`:\n *\n *   • CLASS CHANGE — for every surviving element whose static class list differs from its source\n *     text, overwrite just the `class`/`className` attribute VALUE span (quotes included) with the\n *     new tokens. If the element gained classes but had no class attribute, insert one on the\n *     opening tag.\n *   • UNWRAP (flatten) — when a wrapper element/fragment was removed but its children survived,\n *     delete ONLY the wrapper's open- and close-tag spans; the children (and their entire subtrees,\n *     including dynamic `{expr}` holes and `key=`) are preserved verbatim.\n *   • FULL REMOVAL — when a node was removed with no surviving descendant, delete its whole span.\n *\n * Every other byte — imports, exports, function declarations, returns, hooks, `{expr}` holes,\n * whitespace, comments, attribute ordering — is left exactly as authored. Output is\n * `magicString.toString()`: a complete module.\n *\n * Fallback: a document with no retained source (e.g. a hand-synthesized IR) cannot be spliced, so\n * it falls back to a clean structural re-print ({@link rePrint}).\n */\n\nimport MagicString from 'magic-string';\n\nimport type {\n  AttrValue,\n  Backend,\n  BackendContext,\n  Backref,\n  ClassList,\n  CodegenResult,\n  EditPlan,\n  ExprRef,\n  FileKind,\n  IRDocument,\n  IRElement,\n  IRNode,\n  IRNodeId,\n  SourceFile,\n  SourceSpan,\n} from '@domflax/core';\n\nconst JSX_LANGS: readonly FileKind[] = ['jsx', 'tsx'];\n\ninterface ExprPayload {\n  readonly text: string;\n  readonly spread: boolean;\n}\n\n/* ───────────────────────── shared expr/class helpers ───────────────────────── */\n\n/** Recover an interned expression's source text (payload first, span-slice fallback). */\nfunction exprText(doc: IRDocument, ref: ExprRef): ExprPayload {\n  const rec = doc.exprs.get(ref);\n  const payload = rec?.payload as Partial<ExprPayload> | undefined;\n  if (payload && typeof payload.text === 'string') {\n    return { text: payload.text, spread: payload.spread === true };\n  }\n  if (rec) {\n    const sf = doc.sources.get(rec.span.file);\n    if (sf) return { text: sf.text.slice(rec.span.start, rec.span.end), spread: false };\n  }\n  return { text: '', spread: false };\n}\n\n/** All static class tokens of a {@link ClassList}, in order. */\nfunction staticTokensOf(classes: ClassList): string[] {\n  const out: string[] = [];\n  for (const seg of classes.segments) {\n    if (seg.kind === 'static') for (const t of seg.tokens) out.push(t.value);\n  }\n  return out;\n}\n\n/* ───────────────────────── surgical (magic-string) codegen ───────────────────────── */\n\n/** Pick the single retained source file this document was parsed from (if any). */\nfunction primarySource(doc: IRDocument): SourceFile | null {\n  for (const sf of doc.sources.values()) {\n    if (typeof sf.text === 'string' && sf.text.length > 0) return sf;\n  }\n  return null;\n}\n\n/** Collect every node reachable from the root of the (mutated) tree. */\nfunction collectKept(doc: IRDocument): IRNode[] {\n  const out: IRNode[] = [];\n  const seen = new Set<IRNodeId>();\n  const visit = (id: IRNodeId): void => {\n    if (seen.has(id)) return;\n    seen.add(id);\n    const n = doc.nodes.get(id);\n    if (!n) return;\n    out.push(n);\n    if (n.kind === 'element' || n.kind === 'fragment') for (const c of n.children) visit(c);\n  };\n  visit(doc.root);\n  return out;\n}\n\n/** Span `a` strictly contains span `b` (same file, b nested inside, not identical). */\nfunction strictlyContains(a: SourceSpan, b: SourceSpan): boolean {\n  if (a.file !== b.file) return false;\n  if (a.start <= b.start && b.end <= a.end) return !(a.start === b.start && a.end === b.end);\n  return false;\n}\n\ninterface RemovedRegion {\n  readonly backref: Backref;\n  /** A surviving node nested inside this region ⇒ this was an UNWRAP (keep inner, drop tags). */\n  readonly unwrapped: boolean;\n}\n\n/**\n * Apply the class-list diff for a single surviving element. Returns true if an edit was made.\n */\nfunction editClasses(ms: MagicString, doc: IRDocument, sf: SourceFile, el: IRElement): boolean {\n  const classes = el.classes;\n  // Wholly dynamic / opaque class lists are never rewritten by the passes — leave verbatim.\n  if (classes.hasDynamic || classes.opaque) return false;\n\n  const tokens = staticTokensOf(classes);\n  const valueSpan = classes.valueSpan;\n\n  if (valueSpan && valueSpan.file === sf.id) {\n    const current = sf.text.slice(valueSpan.start, valueSpan.end);\n    // Preserve the original quote style; default to double quotes when we can't detect one.\n    const quote = current.startsWith(\"'\") ? \"'\" : '\"';\n    const next = `${quote}${tokens.join(' ')}${quote}`;\n    if (current !== next) {\n      ms.overwrite(valueSpan.start, valueSpan.end, next);\n      return true;\n    }\n    return false;\n  }\n\n  // No class attribute originally, but the passes added classes ⇒ insert one on the opening tag.\n  if (tokens.length === 0) return false;\n  if (el.isComponent) return false; // never synthesize className onto an opaque component\n  const back = doc.backref.get(el.id);\n  const openTag = back?.openTagSpan;\n  if (!openTag || openTag.file !== sf.id) return false;\n  // Insert immediately after the tag name: `<tag‸ …`.\n  const insertAt = openTag.start + 1 + el.tag.length;\n  ms.appendLeft(insertAt, ` className=\"${tokens.join(' ')}\"`);\n  return true;\n}\n\n/**\n * Extract a `key=…` attribute (verbatim, e.g. `key={f.id}` or `key=\"row\"`) from an opening-tag's\n * source text, or null when the tag carries no key. Brace/quote-aware so `key={f.id}` with nested\n * braces is captured whole. Requires whitespace before `key` so `data-key=` / `aria-keyshortcuts=`\n * never false-match.\n */\nfunction extractKeyAttr(openTag: string): string | null {\n  const m = /(^|\\s)key\\s*=\\s*/.exec(openTag);\n  if (!m) return null;\n  const keyStart = m.index + m[1].length;\n  let i = m.index + m[0].length;\n  const ch = openTag[i];\n  if (ch === '{') {\n    let depth = 0;\n    for (; i < openTag.length; i += 1) {\n      const c = openTag[i];\n      if (c === '{') depth += 1;\n      else if (c === '}') {\n        depth -= 1;\n        if (depth === 0) {\n          i += 1;\n          break;\n        }\n      }\n    }\n  } else if (ch === '\"' || ch === \"'\") {\n    const q = ch;\n    i += 1;\n    for (; i < openTag.length; i += 1) {\n      if (openTag[i] === q) {\n        i += 1;\n        break;\n      }\n    }\n  } else {\n    for (; i < openTag.length; i += 1) {\n      if (/[\\s>/]/.test(openTag[i]!)) break;\n    }\n  }\n  return openTag.slice(keyStart, i);\n}\n\n/**\n * KEY SAFETY: when an UNWRAPPED wrapper carried a React `key`, that key must not vanish with the\n * deleted tags. If the wrapper had exactly one surviving (maximal) element child and that child has\n * no key of its own, transfer the wrapper's `key=…` verbatim onto the survivor's opening tag.\n * Conservative: anything ambiguous (no surviving element child, multiple survivors, child already\n * keyed) is left untouched (the flatten pattern is expected to have refused such a case).\n */\nfunction transferKeyOnUnwrap(\n  ms: MagicString,\n  doc: IRDocument,\n  sf: SourceFile,\n  region: Backref,\n  kept: readonly IRNode[],\n): void {\n  const open = region.openTagSpan;\n  if (!open || open.file !== sf.id) return;\n  const keyAttr = extractKeyAttr(sf.text.slice(open.start, open.end));\n  if (!keyAttr) return;\n\n  const inside: IRElement[] = [];\n  for (const n of kept) {\n    if (n.kind !== 'element' || !n.span || n.span.file !== sf.id) continue;\n    if (strictlyContains(region.span, n.span)) inside.push(n);\n  }\n  // Keep only the topmost survivors (not nested inside another survivor of this region).\n  const maximal = inside.filter(\n    (n) => !inside.some((o) => o !== n && o.span && n.span && strictlyContains(o.span, n.span)),\n  );\n  if (maximal.length !== 1) return;\n\n  const child = maximal[0]!;\n  const childOpen = doc.backref.get(child.id)?.openTagSpan;\n  if (!childOpen || childOpen.file !== sf.id) return;\n  if (extractKeyAttr(sf.text.slice(childOpen.start, childOpen.end))) return; // already keyed\n\n  // Insert immediately after the child's tag name: `<tag‸ …`.\n  ms.appendLeft(childOpen.start + 1 + child.tag.length, ` ${keyAttr}`);\n}\n\n/** Surgical full-module codegen. Returns null when the document has no retained source. */\nfunction surgicalPrint(doc: IRDocument): string | null {\n  const sf = primarySource(doc);\n  if (!sf) return null;\n\n  const ms = new MagicString(sf.text);\n\n  const kept = collectKept(doc);\n  const keptSpans: SourceSpan[] = [];\n  for (const n of kept) if (n.span && n.span.file === sf.id) keptSpans.push(n.span);\n\n  // 1) Structural removals. A node present in the backref table but absent from the live node map\n  //    was removed by the passes. Classify each as an UNWRAP (a surviving node nests inside it) or\n  //    a FULL removal (nothing survived inside).\n  const removed: RemovedRegion[] = [];\n  for (const id of backrefIds(doc)) {\n    if (doc.nodes.has(id)) continue; // still live\n    const back = doc.backref.get(id);\n    if (!back || back.span.file !== sf.id) continue;\n    const unwrapped = keptSpans.some((k) => strictlyContains(back.span, k));\n    removed.push({ backref: back, unwrapped });\n  }\n\n  // Skip any removed region nested inside a FULL-removal region (its bytes are already deleted by\n  // the ancestor) — this keeps every delete disjoint, which magic-string requires.\n  const fullRemovals = removed.filter((r) => !r.unwrapped).map((r) => r.backref.span);\n  for (const r of removed) {\n    const span = r.backref.span;\n    const coveredByFull = fullRemovals.some((f) => f !== span && strictlyContains(f, span));\n    if (coveredByFull) continue;\n\n    if (r.unwrapped) {\n      // KEY SAFETY: salvage a `key=…` off the wrapper onto its surviving child before deleting tags.\n      transferKeyOnUnwrap(ms, doc, sf, r.backref, kept);\n      // Delete only the wrapper's tags; keep its (surviving) inner content verbatim.\n      const open = r.backref.openTagSpan;\n      const close = r.backref.closeTagSpan;\n      if (open && open.file === sf.id && open.end > open.start) ms.remove(open.start, open.end);\n      if (close && close.file === sf.id && close.end > close.start) {\n        ms.remove(close.start, close.end);\n      }\n    } else {\n      ms.remove(span.start, span.end);\n    }\n  }\n\n  // 2) Class-list diffs on every surviving element.\n  for (const n of kept) {\n    if (n.kind === 'element') editClasses(ms, doc, sf, n);\n  }\n\n  return ms.toString();\n}\n\n/** All ids the backref table knows about (every originally-parsed element / fragment). */\nfunction backrefIds(doc: IRDocument): IRNodeId[] {\n  // The backref table is shared verbatim from parse time; collect ids by scanning original spans we\n  // recorded for live + removed nodes. We don't have a public iterator, so reconstruct the universe\n  // from the live nodes plus their (now-removed) original ancestry isn't possible directly — instead\n  // ask the table for each id we can reach. The table exposes `get`; the set of candidate ids is the\n  // contiguous allocation range [1, alloc.peek). Scanning that range is O(n) and dependency-free.\n  const out: IRNodeId[] = [];\n  const max = doc.alloc.peek as unknown as number;\n  for (let i = 1; i < max; i += 1) {\n    const id = i as IRNodeId;\n    if (doc.backref.get(id)) out.push(id);\n  }\n  return out;\n}\n\n/* ───────────────────────── structural re-print (fallback) ───────────────────────── */\n\n/** Re-build the `className=…` attribute (or null when the element has no class list). */\nfunction classText(doc: IRDocument, classes: ClassList): string | null {\n  if (classes.form === 'absent' || classes.segments.length === 0) return null;\n\n  const dynamic = classes.segments.find((s) => s.kind === 'dynamic');\n  if (dynamic && dynamic.kind === 'dynamic') {\n    return `className={${exprText(doc, dynamic.expr).text}}`;\n  }\n\n  const tokens = staticTokensOf(classes);\n  return `className=\"${tokens.join(' ')}\"`;\n}\n\nfunction attrText(doc: IRDocument, name: string, value: AttrValue): string {\n  if (value.kind === 'static') {\n    if (value.value === true) return name;\n    if (value.value === false) return '';\n    return `${name}=\"${String(value.value)}\"`;\n  }\n  return `${name}={${exprText(doc, value.expr).text}}`;\n}\n\nfunction printElement(doc: IRDocument, el: IRElement): string {\n  const parts: string[] = [];\n\n  const cls = classText(doc, el.classes);\n  if (cls !== null) parts.push(cls);\n\n  for (const name of el.attrs.order) {\n    const v = el.attrs.entries.get(name);\n    if (!v) continue;\n    const text = attrText(doc, name, v);\n    if (text.length > 0) parts.push(text);\n  }\n\n  for (const ref of el.attrs.spreads) parts.push(`{...${exprText(doc, ref).text}}`);\n\n  const attrStr = parts.length > 0 ? ` ${parts.join(' ')}` : '';\n  const tag = el.tag;\n\n  if (el.children.length === 0) {\n    return el.selfClosing ? `<${tag}${attrStr} />` : `<${tag}${attrStr}></${tag}>`;\n  }\n\n  const inner = el.children.map((c) => printNode(doc, c)).join('');\n  return `<${tag}${attrStr}>${inner}</${tag}>`;\n}\n\nfunction printNode(doc: IRDocument, id: IRNodeId): string {\n  const node = doc.nodes.get(id);\n  if (!node) return '';\n  switch (node.kind) {\n    case 'text':\n      return node.value;\n    case 'comment':\n      return `{/*${node.value}*/}`;\n    case 'expr': {\n      const { text, spread } = exprText(doc, node.expr);\n      return spread ? `{...${text}}` : `{${text}}`;\n    }\n    case 'fragment':\n      return `<>${node.children.map((c) => printNode(doc, c)).join('')}</>`;\n    case 'element':\n      return printElement(doc, node);\n  }\n}\n\nfunction rePrint(doc: IRDocument): string {\n  const root = doc.nodes.get(doc.root);\n  if (!root || root.kind !== 'fragment') return printNode(doc, doc.root);\n  return root.children.map((c) => printNode(doc, c)).join('');\n}\n\n/* ───────────────────────── public backend ───────────────────────── */\n\nfunction doPrint(doc: IRDocument): string {\n  const surgical = surgicalPrint(doc);\n  return surgical ?? rePrint(doc);\n}\n\nexport const jsxBackend: Backend = {\n  name: 'babel-jsx',\n  langs: JSX_LANGS,\n  print(doc: IRDocument, _plan: EditPlan, _ctx: BackendContext): CodegenResult {\n    const code = doPrint(doc);\n    return { code, map: null, edits: [], diagnostics: [] };\n  },\n};\n\n/** Factory mirror — returns a fresh handle to the (stateless) JSX backend. */\nexport function createJsxBackend(): Backend {\n  return jsxBackend;\n}\n","/**\n * @domflax/frontend-jsx — Babel JSX ⇄ IR frontend + backend (TYPED STUB, Stage 1).\n *\n * Public surface:\n *   • {@link jsxFrontend} / {@link createJsxFrontend} — Frontend (JSX/TSX → IR).\n *   • {@link jsxBackend}  / {@link createJsxBackend}  — Backend  (IR → JSX/TSX).\n *\n * Both define the SHAPE only: `parse`/`print` throw NotImplemented; the cheap\n * routing predicates (`canParse`, `langs`, `name`) are real.\n */\n\nexport { jsxFrontend, createJsxFrontend } from './frontend';\nexport { jsxBackend, createJsxBackend } from './backend';\n"],"mappings":"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","names":["asEl","declaresCustomProperties","targetedByStructuralPseudo","isComponentNode","metaOf","hasSpreadAttrs","isComponentNode","hasOwnAttrs","targetedByStructuralPseudo","asEl","metaOf","establishesContext","hasSpreadAttrs","isComponentNode","hasOwnAttrs","targetedByStructuralPseudo","DISPLAY","path","path","cover","LEGACY_PSEUDO_ELEMENTS","createRequire","path","moduleBase","readFileSync","path","readFileSync","LEGACY_PSEUDO_ELEMENTS","createRequire","createRequire","FILE_ID","doParse","FILE_ID","span","staticTokensOf","path","doParse","MagicString","JSX_LANGS","staticTokensOf","primarySource","collectKept","strictlyContains","editClasses","surgicalPrint","backrefIds","span","doPrint"]}