diff --git a/docs/changelog.md b/docs/changelog.md
index 7926ab4aa..81368a191 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -14,6 +14,28 @@ See the [Contributing Guide](contributing.md) for details.
 
 ## Unreleased
 
+### Added
+
+* Add the `finish` and `end_blocks` methods to `BlockProcessor`, which the
+  block parser calls when its outermost call is done and when a nested call is
+  done. A block processor which holds on to blocks until a later call to the
+  parser must release them there. Content held for a nested block, such as an
+  unclosed raw HTML block in a list item, may be added to it after the call to
+  `parseChunk` which parsed it has returned.
+
+### Changed
+
+* Recognize raw HTML blocks nested in a list item, definition, blockquote,
+  admonition or footnote as at the top level of the document, rather than
+  parsing them as Markdown and splitting them into paragraphs at blank lines
+  (#1096). As at the top level, Markdown is no longer parsed within such a
+  block, unless the `md_in_html` extension is enabled and the element has a
+  `markdown` attribute, which is now supported in those places too. Unlike at
+  the top level, a nested raw HTML block must start a block of its own and
+  cannot interrupt a paragraph, and an unclosed tag runs to the end of the
+  nesting block rather than of the document. See
+  [Raw HTML Blocks](index.md#differences) for details.
+
 ### Fixed
 
 * Fix for complex cases in new emphasis handling where text could be unexpectedly
diff --git a/docs/extensions/api.md b/docs/extensions/api.md
index 4822bbc2b..3fc2c91a6 100644
--- a/docs/extensions/api.md
+++ b/docs/extensions/api.md
@@ -114,6 +114,33 @@ processor.  There are three methods:
 For perspective, Markdown calls `parseDocument` which calls `parseChunk` which calls `parseBlocks` which calls your
 block processor, which, in turn, might call one of these routines.
 
+#### Holding Blocks Across Calls
+
+A block which contains other blocks, such as a list item or an admonition, hands its content to the parser a block at a
+time, in a call for each. A block processor which needs to see a later block before it knows what to do with an
+earlier one may hold on to blocks across those calls, but must release them once no more are coming. The built-in
+processor for raw HTML blocks nested in other blocks does this for a raw HTML block with a blank line in it. Two
+methods of `BlockProcessor`, which do nothing unless overridden, are called for that:
+
+* [`end_blocks`][markdown.blockprocessors.BlockProcessor.end_blocks] is called with `parent` when a nested call to
+  the parser, which parsed blocks into `parent`, is done. The caller may do as it likes with `parent` once the call
+  returns, so anything held which no call still in progress can be counted on to hand more blocks to must be
+  released here.
+* [`finish`][markdown.blockprocessors.BlockProcessor.finish] is called when the outermost call to the parser is done.
+  Anything still held must be released here.
+
+This affects a block processor which calls the parser itself. If it parses into an element of its own, which is not in
+the tree being parsed (to move what is parsed somewhere else, for example), everything parsed is in that element by
+the time the call returns. If it parses into an element at the end of the tree being parsed, which a later call may
+hand more blocks to (as a list item is), what is held for that element may be added to it after the call returns: once
+a later block closes it, or once the outermost call is done.
+
+!!! warning
+
+    The parser calls these methods from [`parseBlocks`][markdown.blockparser.BlockParser.parseBlocks]. A subclass of
+    `BlockParser` which overrides `parseBlocks` must call the parent class's `parseBlocks` to parse the blocks.
+    Otherwise, blocks held by a block processor are never released, and their content is lost from the output.
+
 #### Example
 
 This example calls out important paragraphs by giving them a border.  It looks for a fence line of exclamation points
@@ -198,6 +225,7 @@ Some block processors in the Markdown source tree include:
 | [`HashHeaderProcessor`][markdown.blockprocessors.HashHeaderProcessor]            | built-in  |  Title hashes (`#`), which may split blocks |
 | [`HRProcessor`][markdown.blockprocessors.HRProcessor]                            | built-in  |  Horizontal lines, e.g., `---`              |
 | [`OListProcessor`][markdown.blockprocessors.OListProcessor]                      | built-in  |  Ordered lists; complex and using `state`   |
+| [`RawHtmlBlockProcessor`][markdown.blockprocessors.RawHtmlBlockProcessor]        | built-in  |  Nested raw HTML; holds blocks across calls |
 | [`AdmonitionProcessor`][markdown.extensions.admonition.AdmonitionProcessor]      | extension |  Render each [Admonition][] in a new `div`  |
 | [`FootnoteBlockProcessor`][markdown.extensions.footnotes.FootnoteBlockProcessor] | extension | Find footnote definitions and store for later use. |
 
diff --git a/docs/extensions/md_in_html.md b/docs/extensions/md_in_html.md
index 13a9a88b3..224ab70cd 100644
--- a/docs/extensions/md_in_html.md
+++ b/docs/extensions/md_in_html.md
@@ -170,6 +170,27 @@ behavior. However, if the value of an element's `markdown` attribute is the same
 parent, the the child element's behavior is observed. For example, a `block` element may contain either `block`
 elements or `span` elements as children and each element will be parsed using the specified behavior.
 
+### In Lists and Other Blocks
+
+A raw HTML block nested in a list item, definition, blockquote, admonition or footnote may have a `markdown`
+attribute as well. Its content is parsed as it would be at the top level of the document, whatever block it is nested
+in. For example, a paragraph within it is wrapped in a `<p>` tag even in a tight list item, whose own text is not.
+
+``` md-render
+---
+extensions: [md_in_html]
+---
+* <div markdown="1">This is a *Markdown* paragraph.</div>
+* A tight list item.
+* Another list item.
+
+    <div markdown="1">
+    This is a *Markdown* paragraph too.
+    </div>
+```
+
+See [Raw HTML Blocks](../index.md#differences) for where a raw HTML block is recognized in nested content.
+
 ### Tag Normalization
 
 While the default behavior is for Markdown to not alter raw HTML, as this extension is parsing the content of raw HTML elements, it will do some normalization of the tags of block-level elements. For example:
diff --git a/docs/index.md b/docs/index.md
index 7912d2361..357b7ab56 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -118,6 +118,35 @@ are summarized below:
     foreseeable future. That said, the [Sane List Extension](extensions/sane_lists.md)
     is available to provide a less surprising behavior.
 
+* __Raw HTML Blocks__
+
+    The [syntax rules](https://daringfireball.net/projects/markdown/syntax#html)
+    state that a block-level HTML element must be separated from surrounding
+    content by blank lines, and that its start and end tags should not be
+    indented. At the top level of a document, Python-Markdown is more lenient: a
+    line which starts with a block-level tag, or with a comment, processing
+    instruction, `CDATA` section or declaration, indented by no more than three
+    spaces, starts a raw HTML block, even when it directly follows a line of a
+    paragraph. The block continues, across blank lines, until its tags are closed,
+    and a tag which is never closed runs to the end of the document. Markdown is
+    not parsed within a raw HTML block (the
+    [Markdown in HTML Extension](extensions/md_in_html.md) can change that).
+
+    Nested in a list item, definition, blockquote, admonition or footnote, a raw
+    HTML block follows the same rules once the indentation of the nesting (or the
+    `>` of a blockquote) is removed, with two differences:
+
+    1. A raw HTML block must start a block of its own: after a blank line, right
+       after a list marker or the `:` of a definition, or on the first line of
+       the nested content. A block-level tag on a later line of a paragraph,
+       including a lazy continuation line, remains part of that paragraph. A
+       fenced code block is not recognized in nested content by the
+       [Fenced Code Blocks Extension](extensions/fenced_code_blocks.md), so
+       without this rule, the HTML of a code example in a list item would be
+       rendered rather than shown.
+    2. A tag which is never closed runs to the end of the list item (or other
+       nesting block) rather than to the end of the document.
+
 * __Automatic Links__
 
     Automatic links recognize URL schemes followed by `://`, including schemes
diff --git a/markdown/blockparser.py b/markdown/blockparser.py
index 549c9ecd5..60a1c621d 100644
--- a/markdown/blockparser.py
+++ b/markdown/blockparser.py
@@ -96,6 +96,8 @@ def __init__(self, md: Markdown):
         self.blockprocessors: util.Registry[BlockProcessor] = util.Registry()
         self.state = State()
         self.md = md
+        # The parent of each call to `parseBlocks` in progress, outermost first.
+        self._frames: list[etree.Element] = []
 
     def parseDocument(self, lines: Iterable[str]) -> etree.ElementTree:
         """ Parse a Markdown document into an `ElementTree`.
@@ -113,6 +115,7 @@ def parseDocument(self, lines: Iterable[str]) -> etree.ElementTree:
             An element tree.
         """
         # Create an `ElementTree` from the lines
+        self._frames = []
         self.root = etree.Element(self.md.doc_tag)
         self.parseChunk(self.root, '\n'.join(lines))
         return etree.ElementTree(self.root)
@@ -147,14 +150,33 @@ def parseBlocks(self, parent: etree.Element, blocks: list[str]) -> None:
         additional `BlockProcessors` which call this method to recursively
         parse a nested block.
 
+        Once the blocks are parsed, this calls each processor's
+        [`end_blocks`][markdown.blockprocessors.BlockProcessor.end_blocks] (for a
+        nested call) or [`finish`][markdown.blockprocessors.BlockProcessor.finish]
+        (for the outermost call), so that a processor can release blocks it holds.
+        A subclass which overrides this method must call it to parse the blocks;
+        otherwise, held blocks are never released and their content is lost.
+
         Arguments:
             parent: The parent element.
             blocks: The blocks of text to parse.
 
         """
-        while blocks:
+        self._frames.append(parent)
+        try:
+            while blocks:
+                for processor in self.blockprocessors:
+                    if processor.test(parent, blocks[0]):
+                        if processor.run(parent, blocks) is not False:
+                            # run returns True or None
+                            break
+        finally:
+            self._frames.pop()
+        if self._frames:
+            # The caller may do as it likes with `parent` from here on.
+            for processor in self.blockprocessors:
+                processor.end_blocks(parent)
+        else:
+            # The outermost call is done, so nothing more will be handed to a processor for these parents.
             for processor in self.blockprocessors:
-                if processor.test(parent, blocks[0]):
-                    if processor.run(parent, blocks) is not False:
-                        # run returns True or None
-                        break
+                processor.finish()
diff --git a/markdown/blockprocessors.py b/markdown/blockprocessors.py
index 4465ce472..9e1d63459 100644
--- a/markdown/blockprocessors.py
+++ b/markdown/blockprocessors.py
@@ -43,6 +43,7 @@ def build_block_parser(md: Markdown, **kwargs: Any) -> BlockParser:
     """ Build the default block parser used by Markdown. """
     parser = BlockParser(md)
     parser.blockprocessors.register(EmptyBlockProcessor(parser), 'empty', 100)
+    parser.blockprocessors.register(RawHtmlBlockProcessor(parser), 'rawhtml', 95)
     parser.blockprocessors.register(ListIndentProcessor(parser), 'indent', 90)
     parser.blockprocessors.register(CodeBlockProcessor(parser), 'code', 80)
     parser.blockprocessors.register(HashHeaderProcessor(parser), 'hashheader', 70)
@@ -149,6 +150,239 @@ def run(self, parent: etree.Element, blocks: list[str]) -> bool | None:
         """
         pass  # pragma: no cover
 
+    def finish(self) -> None:
+        """ Called when the outermost call to the parser is done. Does nothing unless overridden.
+
+        A processor which holds on to blocks, to decide what to do with them once it has seen the next, must
+        release them here: this is the last the parser will hand it for the parents involved.
+        """
+        pass
+
+    def end_blocks(self, parent: etree.Element) -> None:
+        """ Called when a nested call to the parser that parsed blocks into `parent` is done. Does nothing unless
+        overridden.
+
+        The caller may do as it likes with `parent` and what was parsed into it once the call returns. A processor
+        which holds on to blocks until a later call, and can not be sure there will be one, must release them here.
+        """
+        pass
+
+
+class HeldBlocks(list):
+    """
+    Blocks which are held back until it is known whether they are raw HTML, the parser state they are in, and what
+    ends the construct they start.
+    """
+
+    def __init__(self, blocks: list[str], state: list, terminator: re.Pattern[str]):
+        super().__init__(blocks)
+        self.state = list(state)
+        self.terminator = terminator
+
+
+class RawHtmlBlockProcessor(BlockProcessor):
+    """
+    Extract raw HTML blocks nested in a container.
+
+    The preprocessor can only extract a raw block that is at the start of a line. Within a container (a list item,
+    an admonition, a blockquote, etc.) the block is indented or quoted, which can not be told apart from an indented
+    code block or a paragraph until the container has removed its indentation or markers. At that point the block
+    starts a block of text and is extracted here.
+
+    Containers pass their content on a block at a time, so a raw block with blank lines in it is collected across
+    calls until it is closed. Anything still open when the parser is done is handled in
+    [`finish`][markdown.blockprocessors.RawHtmlBlockProcessor.finish].
+    """
+
+    START_RE = re.compile(r'^[ ]{0,3}(?:<!--|<\?|<![A-Za-z\[]|<([A-Za-z][\w:-]*))')
+    # Constructs which the extractor can not be given a piece at a time: a comment, processing instruction, `CDATA`
+    # section or declaration, and what ends each of them.
+    UNTERMINATED_RE = re.compile(r'^[ ]{0,3}(?:(<!--)|(<\?)|(<!\[CDATA\[)|(<![A-Za-z\[]))')
+    TERMINATORS = (re.compile(r'--!?>'), re.compile(r'>'), re.compile(r']]>'), re.compile(r'>'))
+
+    def __init__(self, parser: BlockParser):
+        super().__init__(parser)
+        self.extractor = None
+        # Per container: the extractor of a raw block that is still open, or the blocks of a comment that is.
+        self.open: dict[etree.Element, Any] = {}
+        self.flushing = False
+        self._root: etree.Element | None = None
+        # Per container with an open block: the index, in the parser's calls in progress, of the outermost call
+        # parsing into an element the container is on the last-child path of. The block is held until that call is
+        # done. See [`end_blocks`][markdown.blockprocessors.RawHtmlBlockProcessor.end_blocks].
+        self.anchors: dict[etree.Element, int] = {}
+
+    def get_extractor(self):
+        """ Get an extractor to collect a raw block with. """
+        from .htmlparser import HTMLExtractor
+        return (self.extractor or HTMLExtractor)(self.parser.md)
+
+    def starts_raw(self, block: str) -> bool:
+        """ Does `block` start with something the HTML extractor treats as a raw block? """
+        m = self.START_RE.match(block)
+        return bool(m) and (m.group(1) is None or self.parser.md.is_block_level(m.group(1).lower()))
+
+    def test(self, parent: etree.Element, block: str) -> bool:
+        """ Is this the start of a raw block, or a block of one that is still open in `parent`? """
+        if self.flushing:
+            return False
+        root = getattr(self.parser, 'root', None)
+        if self._root is not root:
+            # A new document. Discard anything a document that failed to parse left behind.
+            self._root = root
+            self.open = {}
+            self.anchors = {}
+        if parent in self.open:
+            return True
+        # What follows the marker of a list item or definition is no different: a raw block there is extracted
+        # like one in any later block of the item.
+        return self.starts_raw(block)
+
+    def unterminated(self, text: str) -> re.Pattern[str] | None:
+        """
+        If `text` starts a comment, processing instruction, `CDATA` section or declaration it does not end, get
+        what would end it.
+        """
+        m = self.UNTERMINATED_RE.match(text)
+        if m is None:
+            return None
+        terminator = self.TERMINATORS[m.lastindex - 1]
+        return None if terminator.search(text, m.end()) else terminator
+
+    @staticmethod
+    def closed(extractor) -> bool:
+        """ Has the extractor closed everything it has been fed? """
+        return not extractor.inraw and not getattr(extractor, 'mdstack', None)
+
+    def run(self, parent: etree.Element, blocks: list[str]) -> bool | None:
+        """ Feed the block to the extractor and, once the raw block is closed, replace it with its placeholder. """
+        block = blocks.pop(0)
+        original = [block]
+        extractor = self.open.get(parent)
+        # A line split off from the block it is in, rather than a block of its own.
+        line = False
+        if parent.tag == 'li' and (self.parser.state.isstate('list') or self.parser.state.isstate('looselist')):
+            # The first block of a list item is handed on as it is, without the indent of the lines after the first
+            # removed as it is from the item's later blocks, and with each indented nested item split off from it.
+            line = extractor is not None and block.startswith(' ' * self.tab_length)
+            block = self.looseDetab(block)
+        if isinstance(extractor, HeldBlocks):
+            # A comment (or similar) with a blank line in it. The extractor is given nothing until it is closed.
+            if line:
+                extractor[-1] += '\n' + block
+            else:
+                extractor.append(block)
+            # No terminator has a newline in it, so one can not span blocks: only the new block needs searching.
+            # Searching (or joining) everything held for each block would take quadratic time.
+            if not extractor.terminator.search(block):
+                return True
+            original = list(extractor)
+            block = '\n\n'.join(original)
+            del self.open[parent]
+            self.anchors.pop(parent, None)
+            extractor = None
+        elif extractor is None and parent is not self.parser.root:
+            terminator = self.unterminated(block)
+            if terminator is not None:
+                self.open[parent] = HeldBlocks(original, self.parser.state, terminator)
+                return True
+        if extractor is None:
+            extractor = self.get_extractor()
+            feed = block
+        else:
+            feed = ('\n' if line else '\n\n') + block
+        extractor.feed(feed)
+        if not self.closed(extractor):
+            self.open[parent] = extractor
+            return True
+        self.open.pop(parent, None)
+        self.anchors.pop(parent, None)
+        result = self.collect(extractor)
+        if result == block.strip('\n').split('\n\n'):
+            # Not something the extractor treats as raw HTML (a bogus comment, for example)
+            blocks[0:0] = original
+            return False
+        for i in range(1, len(result)):
+            if result[i][:1] in (' ', '\t') and util.HTML_PLACEHOLDER_RE.search(result[i - 1]):
+                # Text on the line a raw block ends on keeps the whitespace before it. At the top of the document
+                # its paragraph strips that, but the text of a tight list item is not a paragraph, so strip it here.
+                # Text on a later line (which starts with a newline) is left alone: it may be an indented code block.
+                result[i] = result[i].lstrip(' \t')
+        blocks[0:0] = result
+        return True
+
+    @staticmethod
+    def collect(extractor) -> list[str]:
+        """ Get the blocks that replace the text fed to the extractor. """
+        extractor.close()
+        return ''.join(extractor.cleandoc).strip('\n').split('\n\n')
+
+    def anchor(self, parent: etree.Element) -> int | None:
+        """
+        Find the outermost call in progress which a later call can be counted on to hand `parent` more blocks for:
+        one parsing into an element `parent` is on the last-child path of. A container that will be handed more
+        blocks is at the end of what has been parsed so far, so it is on that path for every call it is nested in.
+        An element an extension parses into on its own (to move what is parsed somewhere else, for example) is only
+        on it for the calls the extension makes.
+        """
+        for index, el in enumerate(self.parser._frames):
+            while True:
+                if el is parent:
+                    return index
+                if not len(el):
+                    break
+                el = el[-1]
+        return None
+
+    def end_blocks(self, parent: etree.Element) -> None:
+        """ Release each open block which no call still in progress can be counted on to hand more blocks to. """
+        if self.flushing or not self.open:
+            return
+        depth = len(self.parser._frames)
+        for container in list(self.open):
+            index = self.anchors.get(container)
+            if index is None or index >= depth:
+                # Not anchored yet, or anchored to a call which is done: look again among the calls in progress.
+                index = self.anchor(container)
+            if index is not None:
+                self.anchors[container] = index
+                continue
+            # The caller may do anything with what this call parsed once it returns, so the content must be in place
+            # by then. The block was held for the container this call parsed into, in the state it is still in.
+            self.anchors.pop(container, None)
+            self.flush(container, self.open.pop(container), keep_state=container is parent)
+
+    def flush(self, parent: etree.Element, item: Any, keep_state: bool = False) -> None:
+        """ Parse a raw block which was never closed, or a comment which was not, into `parent`. """
+        state = self.parser.state
+        self.flushing = True
+        try:
+            if isinstance(item, HeldBlocks) and not keep_state:
+                # Parse the blocks as they would have been had they never been held. A list item hands the
+                # blocks of its content on one at a time, each in its own `detabbed` state, so they are not
+                # parsed in that state all at once.
+                saved = list(state)
+                state[:] = [name for name in item.state if name != 'detabbed']
+                try:
+                    self.parser.parseBlocks(parent, list(item))
+                finally:
+                    state[:] = saved
+            elif isinstance(item, HeldBlocks):
+                self.parser.parseBlocks(parent, list(item))
+            else:
+                self.parser.parseBlocks(parent, self.collect(item))
+        finally:
+            self.flushing = False
+
+    def finish(self) -> None:
+        """ Parse what is left in each container: a raw block which was never closed, or a comment which was not. """
+        if not self.open:
+            return
+        pending, self.open = self.open, {}
+        self.anchors = {}
+        for parent, item in pending.items():
+            self.flush(parent, item)
+
 
 class ListIndentProcessor(BlockProcessor):
     """ Process children of list items.
diff --git a/markdown/extensions/md_in_html.py b/markdown/extensions/md_in_html.py
index 1a4ec0e2b..be233a91b 100644
--- a/markdown/extensions/md_in_html.py
+++ b/markdown/extensions/md_in_html.py
@@ -341,7 +341,16 @@ def parse_element_content(self, element: etree.Element) -> None:
             if element.text:
                 block = element.text.rstrip('\n')
                 element.text = ''
-                self.parser.parseBlocks(element, block.split('\n\n'))
+                # Parse the content as it would be at the top of the document, whatever container the element
+                # is in: the state of a list item (a `list` item's text has no `p`, for example) does not carry
+                # over into the element.
+                state = self.parser.state
+                saved = list(state)
+                state[:] = []
+                try:
+                    self.parser.parseBlocks(element, block.split('\n\n'))
+                finally:
+                    state[:] = saved
 
         elif md_attr == 'span':
             # Span elements need to be recursively processed for block elements and raw HTML
@@ -446,6 +455,7 @@ def extendMarkdown(self, md):
         # flake8: noqa: E501 429-433
         # Replace raw HTML preprocessor
         md.preprocessors.register(HtmlBlockPreprocessor(md), 'html_block', 20)
+        md.parser.blockprocessors['rawhtml'].extractor = HTMLExtractorExtra
         # Add `blockprocessor` which handles the placeholders for `etree` elements
         md.parser.blockprocessors.register(
             MarkdownInHtmlProcessor(md.parser), 'markdown_block', 105
diff --git a/tests/test_syntax/blocks/test_indented_html_blocks.py b/tests/test_syntax/blocks/test_indented_html_blocks.py
new file mode 100644
index 000000000..3bbcc6ad5
--- /dev/null
+++ b/tests/test_syntax/blocks/test_indented_html_blocks.py
@@ -0,0 +1,4138 @@
+# -*- coding: utf-8 -*-
+"""
+Python Markdown
+
+A Python implementation of John Gruber's Markdown.
+
+Documentation: https://python-markdown.github.io/
+GitHub: https://github.com/Python-Markdown/markdown/
+PyPI: https://pypi.org/project/Markdown/
+
+Started by Manfred Stienstra (http://www.dwerg.net/).
+Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
+Currently maintained by Waylan Limberg (https://github.com/waylan),
+Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
+
+Copyright 2007-2023 The Python Markdown Project (v. 1.7 and later)
+Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
+Copyright 2004 Manfred Stienstra (the original version)
+
+License: BSD (see LICENSE.md for details).
+"""
+
+import xml.etree.ElementTree as etree
+
+from markdown.blockprocessors import BlockProcessor
+from markdown.extensions import Extension
+from markdown.test_tools import TestCase
+
+
+class TestIndentedHTMLBlocks(TestCase):
+    """
+    Raw HTML blocks which start on a line indented by more than `tab_length` spaces.
+
+    Within a containing block (a list item, an admonition, etc.) such a block is raw HTML. Where it can not be
+    (an indented code block, or a paragraph which it cannot interrupt), the document must render as it always has.
+    """
+
+    def test_mdih_admonition_markdown_attr(self):
+        """
+        Under md_in_html the extractor stores an `etree` Element, not `IndentedRawHtml`, and the element text
+        keeps the 4-space indent, so `**test**` becomes an indented code block. Intended change: a raw block
+        in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+
+                !!! note "Title"
+                    <div markdown>
+                    **test**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                <p><strong>test</strong></p>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_admonition_markdown_1(self):
+        """Same as above with markdown='1'. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div markdown="1">
+                    **test**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                <p><strong>test</strong></p>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_admonition_markdown_block_blank_lines(self):
+        """markdown='block' with blank lines inside the element. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div markdown="block">
+
+                    **test**
+
+                    - a
+                    - b
+
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                <p><strong>test</strong></p>
+                <ul>
+                <li>a</li>
+                <li>b</li>
+                </ul>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_admonition_markdown_span(self):
+        """markdown='span' inside an admonition. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div markdown="span">
+                    **test**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                <strong>test</strong>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_admonition_nested_markdown(self):
+        """
+        Nested md_in_html elements: inner indentation relative to the outer start tag must survive. Intended
+        change: a raw block in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div markdown>
+                    <div markdown>
+                    **test**
+                    </div>
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                <div>
+                <p><strong>test</strong></p>
+                </div>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_admonition_markdown_deeper_content(self):
+        """
+        Content indented deeper than the start tag: that part is a real indented code block. Intended
+        change: a raw block in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div markdown>
+                        code
+
+                    **test**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                <pre><code>code
+                </code></pre>
+                <p><strong>test</strong></p>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_list_item_markdown(self):
+        """md_in_html element inside a list item. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+
+                    <div markdown>
+                    **test**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>item</p>
+                <div>
+                <p><strong>test</strong></p>
+                </div>
+                </li>
+                </ul>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_admonition_raw_div(self):
+        """
+        No `markdown` attribute: raw, content must stay literal. Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div>
+                    **test**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                **test**
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_code_block_root(self):
+        """
+        an indented code block containing `<div markdown>` must stay escaped code. Regression: renders as it
+        always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text
+
+                    <div markdown>
+                    **x**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>text</p>
+                <pre><code>&lt;div markdown&gt;
+                **x**
+                &lt;/div&gt;
+                </code></pre>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_code_block_root_blank_lines(self):
+        """Same with blank lines inside the element. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text
+
+                    <div markdown>
+
+                    **x**
+
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>text</p>
+                <pre><code>&lt;div markdown&gt;
+
+                **x**
+
+                &lt;/div&gt;
+                </code></pre>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_code_block_in_list(self):
+        """
+        Code block (8 spaces) in a list item containing `<div markdown>`. Regression: renders as it always
+        has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+
+                        <div markdown>
+                        **x**
+                        </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>item<pre><code>&lt;div markdown&gt;
+                **x**
+                &lt;/div&gt;
+                </code></pre>
+                </li>
+                </ul>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_code_block_in_admonition(self):
+        """
+        Code block (8 spaces) in an admonition containing `<div markdown>`. Regression: renders as it always
+        has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                        <div markdown>
+                        **x**
+                        </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <pre><code>&lt;div markdown&gt;
+                **x**
+                &lt;/div&gt;
+                </code></pre>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_code_block_with_more_code(self):
+        """
+        Code after the element in the same code block must not gain blank lines. Regression: renders as it
+        always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text
+
+                    <div markdown>
+                    **x**
+                    </div>
+                    more code
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>text</p>
+                <pre><code>&lt;div markdown&gt;
+                **x**
+                &lt;/div&gt;
+                more code
+                </code></pre>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_unclosed(self):
+        """
+        Unclosed `markdown` element in a container (source no longer available at close()). Intended change:
+        a raw block in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div markdown>
+                    **test**
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                <p><strong>test</strong></p>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_unclosed_in_code_block(self):
+        """
+        Unclosed `markdown` element inside an indented code block must show its source as written (no
+        `markdown='block'`, no double escaping, no invented </div>). Regression: renders as it always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text
+
+                    <div markdown>
+                    **x** & <b>y</b>
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>text</p>
+                <pre><code>&lt;div markdown&gt;
+                **x** &amp; &lt;b&gt;y&lt;/b&gt;
+                </code></pre>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_unclosed_nested_in_code_block(self):
+        """Same with an unclosed nested element. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text
+
+                    <div markdown>
+                    <p markdown>
+                    **x**
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>text</p>
+                <pre><code>&lt;div markdown&gt;
+                &lt;p markdown&gt;
+                **x**
+                </code></pre>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_unclosed_in_admonition_code_block(self):
+        """Same inside an admonition (8 spaces). Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                        <div markdown>
+                        **x**
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <pre><code>&lt;div markdown&gt;
+                **x**
+                </code></pre>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_mdih_tail_text(self):
+        """Text after the closing tag on the same line. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div markdown>
+                    **test**
+                    </div> tail
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                <p><strong>test</strong></p>
+                </div>
+                <p>tail</p>
+                <p>after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_admonition_div(self):
+        """ Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div>
+                    **test**
+                    </div>
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                **test**
+                </div>
+                <p>after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_admonition_div_blank_lines(self):
+        """ Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div>
+
+                    **test**
+
+                    </div>
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+
+                **test**
+
+                </div>
+                <p>after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_list_item_div(self):
+        """
+        raw block in a list item should not be split at blank lines. Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+
+                    <div>
+
+                    **test**
+
+                    </div>
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>item</p>
+                <div>
+
+                **test**
+
+                </div>
+                <p>after</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_nested_admonition_div(self):
+        """Two levels of containers; indent of the tag is 8. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Outer"
+                    !!! note "Inner"
+                        <div>
+                        **test**
+                        </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Outer</p>
+                <div class="admonition note">
+                <p class="admonition-title">Inner</p>
+                <div>
+                **test**
+                </div>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_admonition_div_deeper_lines(self):
+        """
+        Lines inside the raw block indented deeper than the start tag must keep the extra indent. Intended
+        change: a raw block in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div>
+                        <p>deeper</p>
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                    <p>deeper</p>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_admonition_pre(self):
+        """Whitespace-sensitive <pre> in a container. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <pre>
+                      keep
+                        this
+                    </pre>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <pre>
+                  keep
+                    this
+                </pre>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_admonition_script(self):
+        """<script> in a container. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <script>
+                    var x = "**no**";
+                    </script>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <script>
+                var x = "**no**";
+                </script>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_admonition_comment(self):
+        """
+        Indented HTML comment (handled by handle_empty_tag / parse_comment path). Regression: renders as it
+        always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <!-- a **comment** -->
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <!-- a **comment** -->
+                <p>after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_admonition_unclosed_div(self):
+        """
+        Unclosed raw block at end of document (flush in close()). Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div>
+                    **test**
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                **test**
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_paragraph_continuation_div(self):
+        """
+        An indented line directly after paragraph text is a paragraph continuation, not code. Regression:
+        renders as it always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                some text
+                    <div>x</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>some text
+                    <div>x</div></p>
+                '''
+            )
+        )
+
+    def test_paragraph_continuation_div_multiline(self):
+        """Same, multi-line raw block. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                some text
+                    <div>
+                    **x**
+                    </div>
+                more text
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>some text
+                    <div>
+                    <strong>x</strong>
+                    </div>
+                more text</p>
+                '''
+            )
+        )
+
+    def test_paragraph_chain_with_text(self):
+        """
+        Blocks that start where the last one ended, mid-paragraph, then text. Must stay one inline run.
+        Regression: renders as it always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                some text
+                    <div>a</div><div>b</div> trailing
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>some text
+                    <div>a</div><div>b</div> trailing</p>
+                '''
+            )
+        )
+
+    def test_paragraph_chain_with_more_lines(self):
+        """
+        Same with an indented continuation line and a following paragraph. Regression: renders as it always
+        has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                some text
+                    <div>a</div><div>b</div> trailing
+                    more
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>some text
+                    <div>a</div><div>b</div> trailing
+                    more</p>
+                <p>after</p>
+                '''
+            )
+        )
+
+    def test_paragraph_chain_of_three(self):
+        """Three blocks in a row. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                some text
+                    <div>a</div><div>b</div><div>c</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>some text
+                    <div>a</div><div>b</div><div>c</div></p>
+                '''
+            )
+        )
+
+    def test_paragraph_chain_multiline(self):
+        """ Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                some text
+                    <div>
+                    a
+                    </div><div>
+                    b
+                    </div> trailing
+                more
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>some text
+                    <div>
+                    a
+                    </div><div>
+                    b
+                    </div> trailing
+                more</p>
+                '''
+            )
+        )
+
+    def test_paragraph_chain_multiline_indented(self):
+        """Same with the continuation line indented. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                some text
+                    <div>
+                    a
+                    </div><div>
+                    b
+                    </div> trailing
+                    more
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>some text
+                    <div>
+                    a
+                    </div><div>
+                    b
+                    </div> trailing
+                    more</p>
+                '''
+            )
+        )
+
+    def test_code_chain_blocks(self):
+        """ Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text
+
+                    <div>a</div><div>b</div><div>c</div> trailing
+                    more
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>text</p>
+                <pre><code>&lt;div&gt;a&lt;/div&gt;&lt;div&gt;b&lt;/div&gt;&lt;div&gt;c&lt;/div&gt; trailing
+                more
+                </code></pre>
+                '''
+            )
+        )
+
+    def test_code_chain_multiline(self):
+        """Same, multi-line blocks. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text
+
+                    <div>
+                    a
+                    </div><div>
+                    b
+                    </div> trailing
+                    more
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>text</p>
+                <pre><code>&lt;div&gt;
+                a
+                &lt;/div&gt;&lt;div&gt;
+                b
+                &lt;/div&gt; trailing
+                more
+                </code></pre>
+                '''
+            )
+        )
+
+    def test_list_lazy_chain(self):
+        """ Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+                    <div>a</div><div>b</div> trailing
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>item
+                    <div>a</div><div>b</div> trailing</li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_list_lazy_div_next_item(self):
+        """
+        Indented div on a lazy line of a list item, followed by another item. Both items must stay tight (no
+        <p>): nothing may be inserted between the placeholder and the next item. Regression: renders as it
+        always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+                    <div>x</div>
+                - b
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>item
+                    <div>x</div></li>
+                <li>b</li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_list_lazy_tail_next_item(self):
+        """
+        Same with text after the closing tag. The next item must not be swallowed into the paragraph.
+        Regression: renders as it always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+                    <div>x</div> trailing
+                - b
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>item
+                    <div>x</div> trailing</li>
+                <li>b</li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_list_lazy_tail_next_item_ordered(self):
+        """Same in an ordered list. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                1. item
+                    <div>x</div> trailing
+                2. b
+                '''
+            ),
+            self.dedent(
+                '''
+                <ol>
+                <li>item
+                    <div>x</div> trailing</li>
+                <li>b</li>
+                </ol>
+                '''
+            )
+        )
+
+    def test_paragraph_tail_then_code(self):
+        """
+        Text after the closing tag in a paragraph, then a blank line and an indented code block. The code
+        block must stay a code block. Regression: renders as it always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                some text
+                    <div>x</div> trailing
+
+                    code
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>some text
+                    <div>x</div> trailing</p>
+                <pre><code>code
+                </code></pre>
+                '''
+            )
+        )
+
+    def test_fn_div_blank_lines(self):
+        """Raw HTML with blank lines in a footnote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Text[^1]
+
+                [^1]:
+                    <div>
+
+                    **x**
+
+                    </div>
+
+                    after
+                '''
+            ),
+            '<p>Text<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<div>\n'
+            '\n'
+            '**x**\n'
+            '\n'
+            '</div>\n'
+            '<p>after&#160;<a class="footnote-backref" href="#fnref:1" title="Jump'
+            ' back to footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes']
+        )
+
+    def test_fn_text_then_div(self):
+        """Raw HTML after the text of a footnote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Text[^1]
+
+                [^1]: Note text.
+
+                    <div>
+                    **x**
+                    </div>
+
+                    after
+                '''
+            ),
+            '<p>Text<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<p>Note text.</p>\n'
+            '<div>\n'
+            '**x**\n'
+            '</div>\n'
+            '<p>after&#160;<a class="footnote-backref" href="#fnref:1" title="Jump'
+            ' back to footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes']
+        )
+
+    def test_fn_lazy_div(self):
+        """
+        Indented HTML on a lazy line of a footnote is part of the paragraph. Regression: renders as it
+        always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Text[^1]
+
+                [^1]: Note text.
+                    <div>x</div>
+                '''
+            ),
+            '<p>Text<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<p>Note text.\n'
+            '<div>x</div>&#160;<a class="footnote-backref" href="#fnref:1"'
+            ' title="Jump back to footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes']
+        )
+
+    def test_fn_code_with_html(self):
+        """Indented code with HTML in a footnote. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Text[^1]
+
+                [^1]: Note.
+
+                        <div>
+
+                        code
+                        </div>
+                '''
+            ),
+            '<p>Text<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<p>Note.</p>\n'
+            '<pre><code>&lt;div&gt;\n'
+            '\n'
+            'code\n'
+            '&lt;/div&gt;\n'
+            '</code></pre>\n'
+            '<p><a class="footnote-backref" href="#fnref:1" title="Jump back to'
+            ' footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes']
+        )
+
+    def test_fn_mdhtml(self):
+        """A `markdown` element with blank lines in a footnote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Text[^1]
+
+                [^1]:
+                    <div markdown>
+
+                    **x**
+
+                    </div>
+                '''
+            ),
+            '<p>Text<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<div>\n'
+            '<p><strong>x</strong></p>\n'
+            '</div>\n'
+            '<p><a class="footnote-backref" href="#fnref:1" title="Jump back to'
+            ' footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes', 'md_in_html']
+        )
+
+    def test_fn_unclosed(self):
+        """An unclosed raw block in a footnote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Text[^1]
+
+                [^1]:
+                    <div>
+
+                    **x**
+                '''
+            ),
+            '<p>Text<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<p><div>\n'
+            '\n'
+            '**x**&#160;<a class="footnote-backref" href="#fnref:1" title="Jump'
+            ' back to footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes']
+        )
+
+    def test_dl_div_blank_lines(self):
+        """Raw HTML with blank lines in a definition. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Term
+                :   para
+
+                    <div>
+
+                    **x**
+
+                    </div>
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>
+                <p>para</p>
+                <div>
+
+                **x**
+
+                </div>
+                <p>after</p>
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_dl_div_after_definition(self):
+        """Raw HTML after the text of a definition. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Term
+                :   definition
+
+                    <div>
+                    **x**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>
+                <p>definition</p>
+                <div>
+                **x**
+                </div>
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_dl_lazy_div(self):
+        """
+        Indented HTML on a lazy line of a definition is part of the paragraph. Regression: renders as it
+        always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Term
+                :   definition
+                    <div>x</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>definition
+                <div>x</div></dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_dl_code_with_html(self):
+        """Indented code with HTML in a definition. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Term
+                :   definition
+
+                        <div>
+
+                        code
+                        </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>definition<pre><code>&lt;div&gt;
+
+                code
+                &lt;/div&gt;
+                </code></pre>
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_dl_mdhtml(self):
+        """A `markdown` element with blank lines in a definition. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Term
+                :   para
+
+                    <div markdown>
+
+                    **x**
+
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>
+                <p>para</p>
+                <div>
+                <p><strong>x</strong></p>
+                </div>
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list', 'md_in_html']
+        )
+
+    def test_dl_unclosed(self):
+        """An unclosed raw block in a definition. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Term
+                :   para
+
+                    <div>
+
+                    **x**
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>
+                <p>para</p>
+                <div>
+
+                **x**
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_adm_in_footnote(self):
+        """Raw HTML in an admonition in a footnote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Text[^1]
+
+                [^1]:
+                    !!! note
+                        <div>
+
+                        **x**
+
+                        </div>
+                '''
+            ),
+            '<p>Text<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<div class="admonition note">\n'
+            '<p class="admonition-title">Note</p>\n'
+            '<div>\n'
+            '\n'
+            '**x**\n'
+            '\n'
+            '</div>\n'
+            '</div>\n'
+            '<p><a class="footnote-backref" href="#fnref:1" title="Jump back to'
+            ' footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes', 'admonition']
+        )
+
+    def test_list_in_admonition(self):
+        """Raw HTML with blank lines in a list in an admonition. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    - item
+
+                        <div>
+
+                        **x**
+
+                        </div>
+
+                        after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <ul>
+                <li>
+                <p>item</p>
+                <div>
+
+                **x**
+
+                </div>
+                <p>after</p>
+                </li>
+                </ul>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_admonition_in_list_in_definition(self):
+        """Three levels of containers. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Term
+                :   - item
+
+                        !!! note
+                            <div>
+
+                            **x**
+
+                            </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>
+                <ul>
+                <li>
+                <p>item</p>
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <div>
+
+                **x**
+
+                </div>
+                </div>
+                </li>
+                </ul>
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list', 'admonition']
+        )
+
+    def test_admonition_in_blockquote(self):
+        """
+        An admonition in a blockquote is a container, so its indented HTML is raw. Intended change: a raw
+        block in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > !!! note
+                >     <div>
+                >     **x**
+                >     </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <div>
+                **x**
+                </div>
+                </div>
+                </blockquote>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_blockquote_in_admonition(self):
+        """A blockquote is a container too, so HTML in one is raw. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    > <div>
+                    > **x**
+                    > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <blockquote>
+                <div>
+                **x**
+                </div>
+                </blockquote>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_blockquote_div(self):
+        """A block of HTML in a blockquote is raw. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>
+                > **x**
+                > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>
+                **x**
+                </div>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_div_blank_lines(self):
+        """Blank lines in the raw block do not end it. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>
+                >
+                > **x**
+                >
+                > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>
+
+                **x**
+
+                </div>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_div_after_paragraph(self):
+        """Raw block after a paragraph in a blockquote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > para
+                >
+                > <div>
+                > **x**
+                > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <p>para</p>
+                <div>
+                **x**
+                </div>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_div_then_paragraph(self):
+        """A paragraph follows the raw block. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>
+                > x
+                > </div>
+                >
+                > after
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>
+                x
+                </div>
+                <p>after</p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_text_after_close(self):
+        """
+        Text after the end of the raw block starts its own paragraph. Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>x</div>
+                > more
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>x</div>
+                <p>more</p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_two_blocks(self):
+        """Two raw blocks in a blockquote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>a</div>
+                >
+                > <div>b</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>a</div>
+                <div>b</div>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_chained_blocks(self):
+        """Raw blocks that start where the last one ended. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>a</div><div>b</div> tail
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>a</div>
+                <div>b</div>
+                <p>tail</p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_lazy_line_in_html(self):
+        """A lazy line inside the raw block belongs to it. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>
+                lazy
+                > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>
+                lazy
+                </div>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_lazy_line_after_html(self):
+        """
+        A lazy line after the raw block is a paragraph in the blockquote. Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>x</div>
+                lazy
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>x</div>
+                <p>lazy</p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_unclosed_html(self):
+        """
+        A raw block that is never closed ends with the blockquote. Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div>
+                > x
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>
+                x
+                </blockquote>
+                <p>after</p>
+                '''
+            )
+        )
+
+    def test_blockquote_nested(self):
+        """Raw block in a nested blockquote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > > <div>
+                > > **x**
+                > > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <blockquote>
+                <div>
+                **x**
+                </div>
+                </blockquote>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_nested_after_text(self):
+        """Raw block in a blockquote nested after text. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > text
+                > > <div>
+                > > x
+                > > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <p>text</p>
+                <blockquote>
+                <div>
+                x
+                </div>
+                </blockquote>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_in_list(self):
+        """Raw block in a blockquote in a list item. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+
+                    > <div>
+                    > **x**
+                    > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>item</p>
+                <blockquote>
+                <div>
+                **x**
+                </div>
+                </blockquote>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_blockquote_on_list_marker(self):
+        """Raw block in a blockquote on the line of a list marker. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - > <div>
+                  > **x**
+                  > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <blockquote>
+                <div>
+                **x**
+                </div>
+                </blockquote>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_blockquote_comment(self):
+        """A comment in a blockquote is raw. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <!-- c -->
+                > text
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <!-- c -->
+                <p>text</p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_pre_blank_line(self):
+        """A blank line in a raw block does not split it. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <pre>
+                > a
+                >
+                > b
+                > </pre>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <pre>
+                a
+
+                b
+                </pre>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_script(self):
+        """The content of a raw block is not escaped. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <script>
+                > var a = 1 < 2;
+                > </script>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <script>
+                var a = 1 < 2;
+                </script>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_table(self):
+        """A table in a blockquote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <table>
+                > <tr><td>x</td></tr>
+                > </table>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <table>
+                <tr><td>x</td></tr>
+                </table>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_md_in_html(self):
+        """A `markdown` attribute works in a blockquote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div markdown>
+                > **x**
+                > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>
+                <p><strong>x</strong></p>
+                </div>
+                </blockquote>
+                '''
+            ),
+            extensions=['md_in_html']
+        )
+
+    def test_blockquote_md_in_html_block(self):
+        """A `markdown` attribute with blank lines. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <div markdown="block">
+                >
+                > **x**
+                >
+                > </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <div>
+                <p><strong>x</strong></p>
+                </div>
+                </blockquote>
+                '''
+            ),
+            extensions=['md_in_html']
+        )
+
+    def test_blockquote_in_footnote(self):
+        """Raw block in a blockquote in a footnote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text[^1]
+
+                [^1]:
+                    > <div>
+                    > x
+                    > </div>
+                '''
+            ),
+            '<p>text<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<blockquote>\n'
+            '<div>\n'
+            'x\n'
+            '</div>\n'
+            '</blockquote>\n'
+            '<p><a class="footnote-backref" href="#fnref:1" title="Jump back to'
+            ' footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes']
+        )
+
+    def test_blockquote_paragraph_continuation(self):
+        """A raw block can not interrupt a paragraph in a blockquote. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > a
+                > <div>x</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <p>a
+                <div>x</div></p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_inline_tag(self):
+        """An inline tag in a blockquote is not a raw block. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <span>x</span> text
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <p><span>x</span> text</p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_code_block(self):
+        """An indented code block in a blockquote is code. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                >     <div>
+                >     x
+                >     </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <pre><code>&lt;div&gt;
+                x
+                &lt;/div&gt;
+                </code></pre>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_fenced_code(self):
+        """HTML in a fenced code block in a blockquote is code. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > ```
+                > <div>
+                > ```
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <p><code>&lt;div&gt;</code></p>
+                </blockquote>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def test_blockquote_list_marker_html(self):
+        """
+        What follows a list marker in a blockquote is parsed as it always has been. Regression: renders as
+        it always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > - <div>x</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <ul>
+                <li><div>x</div></li>
+                </ul>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_blockquote_invalid_declaration(self):
+        """
+        Something the extractor does not treat as a raw block is left alone. Regression: renders as it
+        always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <!invalid>
+                > text
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <p>&lt;!invalid&gt;
+                text</p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_comment_blank_line_admonition(self):
+        """A comment with a blank line in it is one raw block. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!--
+                    c
+
+                    -->
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <!--
+                c
+
+                -->
+                <p>text</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_blank_line_list(self):
+        """A comment with a blank line in a list item. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - a
+
+                    <!--
+                    c
+
+                    -->
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>a</p>
+                <!--
+                c
+
+                -->
+                <p>text</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_comment_blank_line_definition(self):
+        """A comment with a blank line in a definition. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                Term
+                :   a
+
+                    <!--
+                    c
+
+                    -->
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>
+                <p>a</p>
+                <!--
+                c
+
+                -->
+                <p>text</p>
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_comment_blank_line_blockquote(self):
+        """A comment with a blank line in a blockquote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <!--
+                > c
+                >
+                > -->
+                > text
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <!--
+                c
+
+                -->
+                <p>text</p>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_comment_blank_line_blockquote_in_list(self):
+        """
+        A comment with a blank line in a blockquote in a list item. Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - a
+
+                    > <!--
+                    > c
+                    >
+                    > -->
+                    > text
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>a</p>
+                <blockquote>
+                <!--
+                c
+
+                -->
+                <p>text</p>
+                </blockquote>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_comment_blank_line_footnote(self):
+        """A comment with a blank line in a footnote. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                x[^1]
+
+                [^1]:
+                    <!--
+                    c
+
+                    -->
+                    text
+                '''
+            ),
+            '<p>x<sup id="fnref:1"><a class="footnote-ref" href="#fn:1">1</a></sup></p>\n'
+            '<div class="footnote">\n'
+            '<hr />\n'
+            '<ol>\n'
+            '<li id="fn:1">\n'
+            '<!--\n'
+            'c\n'
+            '\n'
+            '-->\n'
+            '<p>text&#160;<a class="footnote-backref" href="#fnref:1" title="Jump'
+            ' back to footnote 1 in the text">&#8617;</a></p>\n'
+            '</li>\n'
+            '</ol>\n'
+            '</div>',
+            extensions=['footnotes']
+        )
+
+    def test_comment_many_blank_lines(self):
+        """A comment with several blank lines in it. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!--
+                    a
+
+                    b
+
+                    c
+                    -->
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <!--
+                a
+
+                b
+
+                c
+                -->
+                <p>text</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_blank_line_then_div(self):
+        """A raw block follows a comment with a blank line. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!--
+                    a
+
+                    -->
+
+                    <div>x</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <!--
+                a
+
+                -->
+                <div>x</div>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_blank_line_two_comments(self):
+        """Two comments with blank lines in them. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!--
+                    a
+
+                    -->
+
+                    <!--
+                    b
+
+                    -->
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <!--
+                a
+
+                -->
+                <!--
+                b
+
+                -->
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_blank_line_after_paragraph(self):
+        """A comment with a blank line after a paragraph. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    para
+
+                    <!--
+                    c
+
+                    -->
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <p>para</p>
+                <!--
+                c
+
+                -->
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_blank_line_div_after_close(self):
+        """A raw block starts on the line where the comment ends. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!--
+                    c
+
+                    --> <div>x</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <!--
+                c
+
+                -->
+                <div>x</div>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_blank_line_md_in_html(self):
+        """
+        A `markdown` attribute after a comment with a blank line. Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!--
+                    c
+
+                    -->
+                    <div markdown>
+                    **x**
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <!--
+                c
+
+                -->
+                <div>
+                <p><strong>x</strong></p>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition', 'md_in_html']
+        )
+
+    def test_processing_instruction_blank_line(self):
+        """A processing instruction with a blank line in it. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <?php
+                    c
+
+                    ?>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <?php
+                c
+
+                ?>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_processing_instruction_blank_line_blockquote(self):
+        """
+        A processing instruction with a blank line in a blockquote. Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <?php
+                > c
+                >
+                > ?>
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <?php
+                c
+
+                ?>
+                </blockquote>
+                '''
+            )
+        )
+
+    def test_cdata_blank_line(self):
+        """A `CDATA` section with a blank line in it. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <![CDATA[
+                    c
+
+                    ]]>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <![CDATA[
+                c
+
+                ]]>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_declaration_blank_line(self):
+        """A declaration with a blank line in it. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!DOCTYPE
+                    c
+
+                    html>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <!DOCTYPE
+                c
+
+                html>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_unclosed_admonition(self):
+        """A comment which is never closed is text. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!--
+                    a
+
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <p>&lt;!--
+                a</p>
+                <p>text</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_unclosed_list(self):
+        """
+        What follows a comment which is never closed is parsed as it always has been. Regression: renders as
+        it always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+
+                    <!--
+                    a
+
+                    - nested
+                    - list
+
+                    para
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>item</p>
+                <p>&lt;!--
+                a</p>
+                <ul>
+                <li>nested</li>
+                <li>list</li>
+                </ul>
+                <p>para</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_comment_unclosed_list_item(self):
+        """
+        A comment which is never closed does not change the list around it. Regression: renders as it always
+        has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - a
+                - b
+
+                    <!-- x
+
+                    more
+                - c
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>a</li>
+                <li>
+                <p>b</p>
+                <p>&lt;!-- x</p>
+                <p>more
+                - c</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_comment_unclosed_blockquote(self):
+        """A comment which is never closed in a blockquote is text. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                > <!-- x
+                >
+                > more
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <blockquote>
+                <p>&lt;!-- x</p>
+                <p>more</p>
+                </blockquote>
+                <p>after</p>
+                '''
+            )
+        )
+
+    def test_comment_unclosed_root(self):
+        """A comment which is never closed at the root is text. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                <!-- x
+
+                more
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>&lt;!-- x</p>
+                <p>more</p>
+                '''
+            )
+        )
+
+    def test_comment_closed_then_unclosed(self):
+        """Only the comment that is closed is raw. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!-- a -->
+
+                    <!-- b
+
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <!-- a -->
+                <p>&lt;!-- b</p>
+                <p>text</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_comment_in_text_line(self):
+        """A comment that does not start a block is text. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    text <!--
+                    c
+
+                    --> more
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <p>text &lt;!--
+                c</p>
+                <p>--&gt; more</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_processing_instruction_unclosed(self):
+        """A processing instruction which is never closed is text. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <?php
+                    c
+
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <p>&lt;?php
+                c</p>
+                <p>text</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_cdata_unclosed(self):
+        """A `CDATA` section which is never closed is text. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <![CDATA[
+                    c
+
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <p>&lt;![CDATA[
+                c</p>
+                <p>text</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_cdata_spaced_close(self):
+        """A `CDATA` section is closed by `]]>` only. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <![CDATA[
+                    c
+
+                    ] ]>
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <p>&lt;![CDATA[
+                c</p>
+                <p>] ]&gt;
+                after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_declaration_unclosed(self):
+        """A declaration which is never closed is text. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note
+                    <!DOCTYPE
+                    c
+
+                    text
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Note</p>
+                <p>&lt;!DOCTYPE
+                c</p>
+                <p>text</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_list_lazy_continuation_div(self):
+        """Indented div right after a list item line (no blank line). Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+                    <div>x</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>item
+                    <div>x</div></li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_code_block_in_list(self):
+        """
+        Code block (8 spaces) inside a list item containing HTML with blank lines. Regression: renders as it
+        always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+
+                        <div>
+
+                        code
+                        </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>item<pre><code>&lt;div&gt;
+
+                code
+                &lt;/div&gt;
+                </code></pre>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_code_block_in_admonition(self):
+        """Code block (8 spaces) inside an admonition containing HTML. Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                        <div>
+                        code
+                        </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <pre><code>&lt;div&gt;
+                code
+                &lt;/div&gt;
+                </code></pre>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_trailing_text_after_close(self):
+        """
+        Text on the same line after the closing tag. Text after a block starts its own paragraph (as at the
+        root). Intended change: a raw block in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div>x</div> trailing
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>x</div>
+                <p>trailing</p>
+                <p>after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_trailing_text_multiline_block(self):
+        """
+        Multi-line block followed by text on the closing line, then a lazy continuation line. Intended
+        change: a raw block in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div>
+                    **x**
+                    </div> trailing
+                    more
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>
+                **x**
+                </div>
+                <p>trailing
+                more</p>
+                <p>after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_trailing_text_chained_blocks(self):
+        """
+        A second block starts on the closing line of the first, followed by text. Intended change: a raw
+        block in a container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <div>a</div><div>b</div> trailing
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <div>a</div>
+                <div>b</div>
+                <p>trailing</p>
+                <p>after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_trailing_text_after_comment(self):
+        """
+        Text after an indented comment on the same line (empty-tag path). Intended change: a raw block in a
+        container.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                    <!-- c --> trailing
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <!-- c -->
+                <p>trailing</p>
+                <p>after</p>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_trailing_text_in_list(self):
+        """Text after the closing tag inside a list item. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                - item
+
+                    <div>x</div> trailing
+
+                    after
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>item</p>
+                <div>x</div>
+                <p>trailing</p>
+                <p>after</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_trailing_text_in_code_block(self):
+        """
+        Indented CODE with HTML followed by text on the same line must stay one code line. Regression:
+        renders as it always has.
+        """
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                text
+
+                    <div>x</div> trailing
+                    more code
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>text</p>
+                <pre><code>&lt;div&gt;x&lt;/div&gt; trailing
+                more code
+                </code></pre>
+                '''
+            )
+        )
+
+    def test_trailing_text_in_code_block_in_admonition(self):
+        """Same inside an admonition (8 spaces). Regression: renders as it always has."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Title"
+                        <p>x</p> trailing
+                        more code
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Title</p>
+                <pre><code>&lt;p&gt;x&lt;/p&gt; trailing
+                more code
+                </code></pre>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+    def test_trailing_text_nested_admonition(self):
+        """Two container levels. Intended change: a raw block in a container."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                R'''
+                !!! note "Outer"
+                    !!! note "Inner"
+                        <div>x</div> trailing
+
+                        after
+                '''
+            ),
+            self.dedent(
+                '''
+                <div class="admonition note">
+                <p class="admonition-title">Outer</p>
+                <div class="admonition note">
+                <p class="admonition-title">Inner</p>
+                <div>x</div>
+                <p>trailing</p>
+                <p>after</p>
+                </div>
+                </div>
+                '''
+            ),
+            extensions=['admonition']
+        )
+
+
+class SectionProcessor(BlockProcessor):
+    """
+    Parse the indented blocks after `::: section` into an element of its own, then move what was parsed into a
+    `section`. The element parsed into is never part of the document and is not handed anything more once the call
+    to the parser returns.
+    """
+
+    def test(self, parent, block):
+        return block.split('\n', 1)[0] == '::: section'
+
+    def run(self, parent, blocks):
+        chunks = [blocks.pop(0).split('\n', 1)[1]]
+        while blocks and blocks[0].startswith('    '):
+            chunks.append(blocks.pop(0))
+        temp = etree.Element('div')
+        self.parser.parseChunk(temp, '\n'.join(line[4:] for line in '\n\n'.join(chunks).split('\n')))
+        section = etree.SubElement(parent, 'section')
+        for el in list(temp):
+            section.append(el)
+
+
+class SectionExtension(Extension):
+    def extendMarkdown(self, md):
+        md.parser.blockprocessors.register(SectionProcessor(md.parser), 'section', 105)
+
+
+class TestTemporaryParent(TestCase):
+    """
+    A raw block held open in an element an extension parses into on its own must be written out before the call to
+    the parser returns. Holding it until the end of the document puts it in an element nothing refers to by then.
+    """
+
+    def test_unclosed_raw_block(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ::: section
+                    <div>
+                    unclosed
+
+                    kept
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <section>
+                <div>
+                unclosed
+
+                kept
+                </section>
+                <p>after</p>
+                '''
+            ),
+            extensions=[SectionExtension()]
+        )
+
+    def test_unterminated_comment(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ::: section
+                    <!-- open
+
+                    kept
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <section>
+                <p>&lt;!-- open</p>
+                <p>kept</p>
+                </section>
+                <p>after</p>
+                '''
+            ),
+            extensions=[SectionExtension()]
+        )
+
+    def test_closed_raw_block_with_blank_line(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ::: section
+                    <div>
+                    one
+
+                    two
+                    </div>
+
+                    para
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <section>
+                <div>
+                one
+
+                two
+                </div>
+                <p>para</p>
+                </section>
+                <p>after</p>
+                '''
+            ),
+            extensions=[SectionExtension()]
+        )
+
+    def test_nested_list_raw_block_with_blank_line(self):
+        """A list item in the element is handed its blocks a call at a time; the raw block is collected across them."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ::: section
+                    - one
+
+                        <div>
+                        a
+
+                        b
+                        </div>
+
+                    - two
+
+                        text
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <section>
+                <ul>
+                <li>
+                <p>one</p>
+                <div>
+                a
+
+                b
+                </div>
+                </li>
+                <li>
+                <p>two</p>
+                <p>text</p>
+                </li>
+                </ul>
+                </section>
+                <p>after</p>
+                '''
+            ),
+            extensions=[SectionExtension()]
+        )
+
+    def test_nested_list_unclosed_raw_block(self):
+        """Held for the list item until the call parsing into the element is done, then written out in it."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ::: section
+                    - item
+
+                        <div>
+                        unclosed
+
+                        kept
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <section>
+                <ul>
+                <li>
+                <p>item</p>
+                <div>
+                unclosed
+
+                kept
+                </li>
+                </ul>
+                </section>
+                <p>after</p>
+                '''
+            ),
+            extensions=[SectionExtension()]
+        )
+
+    def test_nested_list_unterminated_comment(self):
+        """Held for the list item until the call parsing into the element is done, then parsed in the list item."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ::: section
+                    - item
+
+                        <!-- open
+
+                        kept
+
+                after
+                '''
+            ),
+            self.dedent(
+                '''
+                <section>
+                <ul>
+                <li>
+                <p>item</p>
+                <p>&lt;!-- open</p>
+                <p>kept</p>
+                </li>
+                </ul>
+                </section>
+                <p>after</p>
+                '''
+            ),
+            extensions=[SectionExtension()]
+        )
+
+
+class TestHeldConstructs(TestCase):
+    """
+    A comment, processing instruction, `CDATA` section or declaration with a blank line in it is held a block at a
+    time until it is ended. No terminator has a newline in it, so only each new block is searched for one.
+    """
+
+    def test_comment_ended_blocks_later(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - item
+
+                    <!-- a
+
+                    b
+
+                    c --> after
+
+                    para
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>item</p>
+                <!-- a
+
+                b
+
+                c -->
+                <p>after</p>
+                <p>para</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_processing_instruction_ended_blocks_later(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - item
+
+                    <?php a
+
+                    b ?>
+
+                    para
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>item</p>
+                <?php a
+
+                b ?>
+                <p>para</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_many_blocks_in_unterminated_comment(self):
+        """
+        Each block held for an unterminated comment should only be searched for a terminator itself, as searching
+        everything held so far for each block takes quadratic time.
+        """
+        count = 5000
+        self.assertMarkdownRenders(
+            '- item\n\n    <!--\n\n' + '    para\n\n' * count,
+            '<ul>\n<li>\n<p>item</p>\n<p>&lt;!--</p>\n' + '<p>para</p>\n' * count + '</li>\n</ul>'
+        )
+
+
+class TestListItemFirstBlock(TestCase):
+    """
+    A raw block right after the marker of a list item, or the colon of a definition, is extracted like one in any
+    later block of the item.
+    """
+
+    def test_tight_list_item(self):
+        """A raw block right after the marker of a tight list item."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <div>*x*</div>
+                - two
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li><div>*x*</div></li>
+                <li>two</li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_loose_list_item(self):
+        """A raw block right after the marker of a loose list item."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <div>*x*</div>
+
+                - two
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <div>*x*</div>
+                </li>
+                <li>
+                <p>two</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_ordered_list_item(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                1. <p>*x*</p>
+                2. two
+                '''
+            ),
+            self.dedent(
+                '''
+                <ol>
+                <li><p>*x*</p></li>
+                <li>two</li>
+                </ol>
+                '''
+            )
+        )
+
+    def test_nested_list_item(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - a
+                    - <div>*x*</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>a<ul>
+                <li><div>*x*</div></li>
+                </ul>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_text_after_raw_block(self):
+        """Text after the raw block on its line is parsed as Markdown, as in any other block."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <div>a</div> tail *em*
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li><div>a</div>
+                tail <em>em</em></li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_code_block_after_raw_block(self):
+        """Only text on the line the raw block ends on loses the whitespace before it: an indented line is code."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - a
+
+                    <div>a</div>
+                        code
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <p>a</p>
+                <div>a</div>
+                <pre><code>code
+                </code></pre>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_same_as_later_block(self):
+        """The first block of an item gives the same raw block as a later block of it."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <div>a</div>
+
+                    <div>b</div>
+
+                    para *x*
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <div>a</div>
+                <div>b</div>
+                <p>para <em>x</em></p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_blank_line_in_raw_block(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <div>
+
+                    *x*
+
+                    </div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <div>
+
+                *x*
+
+                </div>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_indent_removed_from_lines_after_first(self):
+        """The lines after the first lose the indent of the item, as those of a later block do."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <pre>
+                    code
+                      more
+                    </pre>
+
+                    <pre>
+                    code
+                      more
+                    </pre>
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <pre>
+                code
+                  more
+                </pre>
+                <pre>
+                code
+                  more
+                </pre>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_nested_item_line_in_comment(self):
+        """An indented nested item line is split off from the block, but rejoined to the comment it is in."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <!-- a
+                    - b
+
+                    c -->
+
+                - d
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <!-- a
+                - b
+
+                c -->
+                </li>
+                <li>
+                <p>d</p>
+                </li>
+                </ul>
+                '''
+            )
+        )
+
+    def test_definition(self):
+        """A raw block right after the colon of a definition."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                Term
+                :   <div>*x*</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd><div>*x*</div></dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_loose_definition(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                Term
+
+                :   <div>*x*</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>
+                <div>*x*</div>
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_definition_indent(self):
+        """The rest of a definition is already detabbed, so the indent is removed only once."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                Term
+                :   <pre>
+                    code
+                      more
+                    </pre>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd><pre>
+                code
+                  more
+                </pre></dd>
+                </dl>
+                '''
+            ),
+            extensions=['def_list']
+        )
+
+    def test_md_in_html_tight_list_item(self):
+        """Parsed as it would be at the top of the document: a tight item's text has no `p`, but this does."""
+
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <div markdown="1">*x*</div>
+                - two
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <div>
+                <p><em>x</em></p>
+                </div>
+                </li>
+                <li>two</li>
+                </ul>
+                '''
+            ),
+            extensions=['md_in_html']
+        )
+
+    def test_md_in_html_indented_content(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                - <div markdown="1">
+                    *x*
+
+                    para
+                    </div>
+
+                - two
+                '''
+            ),
+            self.dedent(
+                '''
+                <ul>
+                <li>
+                <div>
+                <p><em>x</em></p>
+                <p>para</p>
+                </div>
+                </li>
+                <li>
+                <p>two</p>
+                </li>
+                </ul>
+                '''
+            ),
+            extensions=['md_in_html']
+        )
+
+    def test_md_in_html_definition(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                Term
+                :   <div markdown="1">*x*</div>
+                '''
+            ),
+            self.dedent(
+                '''
+                <dl>
+                <dt>Term</dt>
+                <dd>
+                <div>
+                <p><em>x</em></p>
+                </div>
+                </dd>
+                </dl>
+                '''
+            ),
+            extensions=['md_in_html', 'def_list']
+        )