# Pandoc-native conformance allowlist.
#
# One case ID per line. Matches the directory prefix under
# tests/fixtures/pandoc-conformance/corpus/<NNNN>-<section>-<slug>/.
#
# Append-only in spirit: only remove an entry if you have a concrete reason and
# a follow-up plan. Group entries under their section header. Verify each ID
# appears in the latest tests/pandoc/report.txt before adding.

# inline
1
2
3
4
5
6
7
8
9
10
11
12
25
190
191

# block
13
14
15
16
17
18
19
20
21
22
23
24
188
189
192

# imported (machine-imported via scripts/import-pandoc-conformance-from-parser-fixtures.sh)
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

# html-block
193
194
195
196
197
198
199
200
201
202

# html-inline
203
204
205
206
207
208
209
210

# html-block (sectioning + verbatim — no markdown inside verbatim, simple cases)
211
212
213
214
215
216
217
218
219
220

# html-block (comments + processing instructions)
221
222
223
224
225
230
231

# html-inline (comments + processing instructions)
226
227
228
229
232

# html-block (declarations + CDATA — pandoc-markdown does not recognize these as raw HTML; types 4/5 gated CommonMark-only)
233
234
235
236
237
238

# html-inline (declarations + CDATA — pandoc-markdown does not recognize these as inline raw HTML)
239
240

# html-block (markdown_in_html_blocks — non-sectioning block tags split into per-tag RawBlocks with markdown-parsed content between them)
241
242
243
244
245
246
247
248
249
250

# html-block (nested div — depth-aware close scan, mirrors pandoc's htmlInBalanced)
251
252
253
254

# html-block (div recursive parse — inner heading auto-ids, ref-link defs, footnote defs resolve in inner RefsCtx instead of leaking outer)
255
256
257
258
259
260
261
262
263
264

# html-block (div recursive parse — outer ref-link defs, footnote defs, and heading-slug history inherited into the inner RefsCtx so cross-boundary uses resolve)
265
266
267

# html-block (multi-line div open tag — `<div\n  attrs\n>` with the closing `>` on a separate line; structural HTML_ATTRS exposure across lines so the salsa anchor walk picks up the id)
268

# html-block (div Plain/Para promotion — last block keeps `Para` only when `</div>` sits at column 0 on its own line; demotes to `Plain` when close is butted to content or sits on an indented line; mirrors pandoc's `markdown_in_html_blocks` recursive parse)
269
270
271
272

# html-block / html-inline (Pandoc-specific blockHtmlTags — pandoc-markdown's narrower block-tag set vs CommonMark §4.6 type-6: `dialog`, `legend`, `option`, etc. fall through to inline raw HTML, while `canvas`, `meta`, `hgroup`, `output` open HTML blocks)
273
274
275
276
277
278
279

# html-block (HTML5 sectioning + grouping — header, footer, main, details/summary, figure/figcaption, nav with markdown_in_html_blocks)
280
281
282
283
284
285
286

# html-block (eitherBlockOrInline tags — pandoc's `eitherBlockOrInline` set: at fresh-block positions `<iframe>`, `<button>`, `<video>`, `<del>`, etc. lift to RawBlock+Plain+RawBlock; inside an existing inline run they stay inline as RawInline. The projector tracks `inline_pending` to keep case 0248 and other nested cases inline.)
287
288
289
290
291
292
293
294
295
296
297

# html-block (eitherBlockOrInline void elements — pandoc's void `eitherBlockOrInline` subset: `<embed>`, `<area>`, `<source>`, `<track>` emit a single RawBlock at fresh-block positions; inside a running paragraph they stay inline as RawInline. The parser closes the block on the open-tag line (no closing tag to match), and the projector splits same-line shapes like `<embed src="x"> trailing` via the same `inline_pending` rule. Case 305 tests `<source>` lifted as a separate RawBlock when nested inside a `<video>` matched-pair lift.)
298
299
300
301
302
303
304
305

# html-block (incomplete open tag — pandoc treats `<embed`, `<div`, `<table`, `<iframe` etc. with no `>` anywhere as paragraph text rather than RawBlock. Recognizing them as HTML blocks made the projector reparse the same bytes and infinite-recurse; the parser now rejects open tags that never close in `pandoc_html_open_tag_closes`.)
306
307
308
309

# html-block (multi-line void open tag — `<embed\n  src="x">`, `<area\n  href="x">`, `<source\n  src="x.mp3">`, `<track\n  src="t.vtt">` and three-line variants; the parser captures all open-tag lines in a single HTML_BLOCK_TAG so the projector emits one RawBlock matching pandoc-native instead of splitting the open tag across paragraphs. Generalized `find_multiline_open_end` over tag name; void path emits simple TEXT+NEWLINE per line — no HTML_ATTRS structural node is needed since the projector doesn't read attributes for void tags.)
310
311
312
313
314

# html-block (inline-block matched-pair lift abandons when interior starts with a void block tag — `<video>\n<source>...\nfallback\n</video>` projects as separate RawBlocks for `<video>` and `<source>` plus a Para[fallback, SoftBreak, RawInline</video>] (per pandoc-native), instead of the prior lift that demoted to Plain[fallback] and emitted `</video>` as RawBlock. Closing forms of inline-block / void tags (`</video>`, `</button>`, `</embed>`, ...) now also start a single-line RawBlock at fresh-block positions, fixing standalone-close-tag recursion and matching pandoc's `htmlBlock` behavior. Cases 316–318 cover the standalone-close + open-without-close shapes.)
315
316
317
318

# html-block (strict-block + verbatim closing forms — standalone `</p>`, `</nav>`, `</section>`, `</pre>` etc. emit as single-line RawBlock under Pandoc, mirroring pandoc-native's `htmlBlock isBlockTag` accept-both-directions rule. Unlike inline-block / void closes, these CAN interrupt a running paragraph (no `cannot_interrupt` in the dispatcher); the projector's existing `is_pandoc_block_tag_name` arm in `split_html_block_by_tags` already splits trailing same-line text into a separate Para, so `</p> bar` projects as [RawBlock</p>, Para[bar]]. Para→Plain demotion when a strict-close interrupts a running paragraph (`foo\n</p>` → `[Plain[foo], RawBlock</p>]` per pandoc) is a separate gap shared with strict-block opens; not addressed here.)
319
320
321
322
323
324

# html-block (paragraph PARAGRAPH→PLAIN demotion when interrupted by HTML strict-block / verbatim — `foo\n<p>` and `foo\n</p>` and `foo\n<div>...</div>` and `foo\n<pre>...</pre>` all project as `[Plain[foo], …]` per pandoc, not `[Para[foo], …]`. Parser-side decision: at `BlockDetectionResult::YesCanInterrupt` for an HTML BlockTag under Pandoc dialect, retag the closing PARAGRAPH wrapper as PLAIN. Inline-block / void / comment paths take `cannot_interrupt` and stay inside Para. Replicates the 2026-05-10-reverted projector demotion as a parser decision.)
325
326
327
328
329

# html-block (`<style>` and processing instructions cannot interrupt a paragraph under Pandoc — `foo\n<style>x</style>` and `foo\n<?pi?>` stay as a single Para with the tag(s) as RawInline, matching pandoc-native. The real reason is pandoc's `isInlineTag` predicate (`Readers/HTML.hs`): `<style>` open and close are SPECIAL-CASED to always be inline (commit fixing issue #10643), and PIs match `T.take 1 name == "?"`. `<style>` and `<textarea>` are BOTH in pandoc's `blockHtmlTags`, but only `<style>` gets the `isInlineTag` override — that's why `<pre>`, `<script>` open, `<textarea>` interrupt while `<style>` does not. Parser-side: extend `cannot_interrupt` in `HtmlBlockParser::detect_prepared` to include `HtmlBlockType::ProcessingInstruction` and `BlockTag { tag_name == "style" }` under Pandoc dialect.)
330
331
332

# html-block (`</script>` close cannot interrupt a paragraph under Pandoc — `foo\n</script>\n` stays as `Para[foo, SoftBreak, RawInline</script>]` matching pandoc-native. Pandoc's `isInlineTag` SPECIAL-CASES `</script>` (close form) to always be inline, regardless of `<script>` open being a block start. Parser-side: added `is_closing: bool` field to `HtmlBlockType::BlockTag`; `cannot_interrupt` matches `is_closing && tag_name == "script"`.)
333

# citation (bracketed citation prefix may contain ordinary parens and `\@`-escaped at-signs without aborting citation detection; matches pandoc's NormalCitation with the prefix captured as ordinary inlines, e.g. `[see (Smith 1999) and @doe99]` and `[see \@ref(svm) and @bischl_applied_2024]`)
334

# html-block (`<script type="math/tex…">` open cannot interrupt a paragraph under Pandoc — `foo\n<script type="math/tex">x</script>\nbar\n` stays as a single `Para[foo, SoftBreak, RawInline<script…>, Str x, RawInline</script>, SoftBreak, bar]` matching pandoc-native. Pandoc's `isInlineTag` SPECIAL-CASES `<script>` open with a `type` attribute whose value has the `math/tex` prefix (case-insensitive, e.g. `math/tex`, `math/tex; mode=display`) to always be inline; every other `<script>` open is a `RawBlock` start (`<pre>`, `<textarea>`, `<script>` without math/tex DO interrupt). Parser-side: `cannot_interrupt` in `HtmlBlockParser::detect_prepared` consults `is_math_tex_script_open(ctx.content)`, which parses the open tag's attributes via `parse_html_tag_attributes` and matches `type` values that start with `math/tex` (case-insensitive prefix). At fresh-block positions (`<script type="math/tex">…</script>` alone, or after a blank line) the tag still lifts to `RawBlock` per pandoc-native; only the mid-paragraph case takes the inline path.)
335

# html-block (HTML blocks inside a blockquote — `> <div>...`, `> <p>...`, `> <pre>...`, `> <video>...` etc. project with the BLOCK_QUOTE wrapping a single Div/RawBlock(s) matching pandoc-native. The parser keeps BLOCK_QUOTE_MARKER + WHITESPACE prefix tokens inside the HTML_BLOCK_CONTENT and the close HTML_BLOCK_TAG (lossless CST). The projector strips those marker pairs via `collect_html_block_text_skip_bq_markers` before feeding the bytes to `try_div_html_block` / `split_html_block_by_tags` / `flush_html_block_text` / `extract_div_inner_and_butted` / `parse_pandoc_blocks`; without the strip the inner reparse re-recognizes the `> ` prefixes as a nested blockquote (or a verbatim RawBlock includes literal `>` characters). Applied uniformly in `html_div_block` and `emit_html_block`. Handles arbitrary nesting depth (`> > <div>`); div attributes on the open tag remain accessible via the existing `cst_div_open_tag_attr` walk because the open-tag's leading marker is consumed by the outer BLOCK_QUOTE wrapper, not by HTML_BLOCK_DIV / HTML_BLOCK.)
336
337
338
339
340
341

# html-block (empty `<div></div>` / `<div>\n</div>` / `<div>\n\n</div>` projects to `Div ("",[],[]) []` matching pandoc-native. Parser already lifts the shape into clean `HTML_BLOCK_TAG` + (optional `BLANK_LINE`s) + `HTML_BLOCK_TAG` children with no `HTML_BLOCK_CONTENT`; the projector's `div_has_structural_inner` predicate was relaxed from "requires a non-(TAG/BLANK_LINE/CONTENT) body child" to "no `HTML_BLOCK_CONTENT` children", which trusts the parser-side lift even when the body is empty or blank-only. Bq-wrapped divs still carry `HTML_BLOCK_CONTENT` for the bq-prefixed body lines and continue to fall through to the byte-reparse path.)
342
343
344

# html-block (Fix #4 strict-block body structural lift — `<section>foo\n\nbar\n</section>` and friends project as `RawBlock + Para + Plain + RawBlock` with the trailing paragraph demoted to Plain when no blank line precedes the close, matching pandoc's `markdown_in_html_blocks` adjacency rule. Parser now lifts the inner body of clean multi-line non-div Pandoc strict-block tags (`PANDOC_BLOCK_TAGS` minus verbatim / inline-block / void / `<div>`) into structural CST children (PARAGRAPH/PLAIN/HEADING/LIST/...) when (a) outside any blockquote, (b) open tag is on its own line with no trailing content after `>`, (c) close tag is on its own line with at most whitespace indent, (d) no multi-line open. Same-line / open-trailing / butted-close / BQ-wrapped shapes stay opaque and fall through to the projector byte walker. PARAGRAPH→PLAIN retag at parse time follows the `LastParaDemote::OnlyIfLast` rule — demote only when no trailing `BLANK_LINE` separates the last paragraph from the close tag. Projector adds `html_block_has_structural_lift` + `emit_html_block_structural` to walk the lifted children directly (open `HTML_BLOCK_TAG` → RawBlock, body children → collect_block, close `HTML_BLOCK_TAG` → RawBlock), avoiding the byte-reparse path that would re-disambiguate heading auto-ids against a fresh inner `RefsCtx`. `html_block_open_tag_is_clean` predicate loosened from "TEXT exactly equal to `>`" to "TEXT ending in `>`" so it accepts both `<div>`'s split-`>` emission and non-div's whole-line TEXT.)
345
346
347

# html-block (non-div strict-block butted-close / open-trailing / same-line shapes — `<form>\nfoo</form>`, `<form>foo\nbar\n</form>`, `<form>foo</form>` now lift to structural CST children matching pandoc's `RawBlock + Plain + RawBlock` projection. Parser extends Fix #4's clean-multi-line strict-block lift to the remaining shape variants: open-trailing captures bytes after `>` into `pre_content` via `emit_open_tag_tokens` (generalized from div's same helper); butted-close removes the leading-whitespace gate on `try_split_close_line` since `LastParaDemote::OnlyIfLast` already handles non-blank-terminated demotion; same-line reuses the existing div same-line lift path (`pre_content` splits at `</tag>`) gated on a new `same_line_strict_lift_safe` check that reuses the generalized `probe_same_line_lift(line, tag_name)`. CST gain: open tags split into `TEXT("<form") + (WHITESPACE + HTML_ATTRS{TEXT(attrs)})? + TEXT(">")` so `AttributeNode::cast(HTML_ATTRS)` finds non-div strict-block ids too. Multi-line open tags and bq-wrapped non-div shapes still fall through to opaque `HTML_BLOCK_CONTENT` + projector byte walker.)
348
349
350

# html-block (non-div strict-block multi-line open tag — `<form\n  id="x"\n  class="y">…</form>`, `<section\n  id="intro">…</section>` etc. now lift to structural CST children with `HTML_ATTRS` exposure on each attribute line, matching pandoc-native's `RawBlock + body + RawBlock` projection. Parser extends `find_multiline_open_end` recognition to Pandoc-lift-eligible strict-block tags (`is_pandoc_lift_eligible_strict_block_tag` predicate), reuses the generalized `emit_multiline_open_tag_with_attrs(tag_name)` (renamed from `emit_multiline_div_open_tag`) for both div and non-div strict-block multi-line opens. The `strict_block_lift` gate accepts `multiline_open_end.is_some()` directly because `find_multiline_open_end` already verified the open tag closes with a quote-aware `>` somewhere downstream. Salsa's existing `AttributeNode` descendants walk picks up multi-line `<section id="intro">` ids as anchor declarations. Projector adds `open_tag_raw_block_text` helper in `pandoc_ast.rs` to canonicalize the open-tag `RawBlock` text to pandoc's single-line `<tag attr1 attr2 ...>` form when structural `HTML_ATTRS` regions are present (multi-line collapses to one line; inter-attribute whitespace normalizes to a single space); without canonicalization the projector emitted literal `<form\n  id="x"\n  class="y">` bytes which diverged from pandoc-native's `<form id="x" class="y">` since `normalize_native` preserves whitespace inside string literals.)
351
352
