markbridge 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa422d5e0a05eee7f32524e42823d02a552111132025fd9ede1fc5045a79412e
-  data.tar.gz: cc7af6319a7c9dde74a764dc9edaab186ef2cca92bc6fabd842a147216adaec0
+  metadata.gz: e9a481ff76e961a6f9c93e9cea998a6cdbe02ee46000c3acfba4e00023c12fd4
+  data.tar.gz: ffcc31afdae7383a83a2a51a26bfacfcd1c482dd5e779144cb6263b8547ed63c
 SHA512:
-  metadata.gz: 2eb57814326cf0fbaf2e356290d962a0a9e8bf2b9c38aa4e41ad7526d9494574162fc5384473b15c833b4e34bd7f322bf464098337bf9d535662f615590c19e4
-  data.tar.gz: d4fc22c47cc54ab91a0d29b140bf69317c5c10aae3358758b0036b213f96ddca9318d723016854819a8a80dcf03ea5f66180eaccc8df2d550d06ab69b8f25a87
+  metadata.gz: 46ba479a92c780d448385002567fea76f51478d18af74b6e7675bf916d01e5bbf61d56fd4f6b9f8ce1fd702662a9d41f15f1d43d86ec605e62604f2171b17795
+  data.tar.gz: 1eb764723017c5ca0afefb538945b37343dddf9aefb891947a7c3357451078bea5b045588c66275e517a95343ebef0a9bb9bfaef17639ded233333a819af0c9f

data/lib/markbridge/ast/image.rb

@@ -9,6 +9,9 @@ module Markbridge
     #
     # @example Image with dimensions
     #   image = AST::Image.new(src: "https://example.com/img.png", width: 100, height: 100)
+    #
+    # @example Image with alternative text
+    #   image = AST::Image.new(src: "https://example.com/img.png", alt: "a cat")
     class Image < Element
       # @return [String, nil] the image source URL
       attr_reader :src
@@ -19,16 +22,21 @@ module Markbridge
       # @return [Integer, nil] the image height
       attr_reader :height
 
+      # @return [String, nil] the alternative text
+      attr_reader :alt
+
       # Create a new Image element.
       #
       # @param src [String, nil] the image source URL
       # @param width [Integer, nil] the image width
       # @param height [Integer, nil] the image height
-      def initialize(src: nil, width: nil, height: nil)
+      # @param alt [String, nil] the alternative text
+      def initialize(src: nil, width: nil, height: nil, alt: nil)
         super()
         @src = src
         @width = width
         @height = height
+        @alt = alt
       end
     end
   end

data/lib/markbridge/ast/url.rb

@@ -12,6 +12,10 @@ module Markbridge
     #   url = AST::Url.new(href: "https://example.com")
     #   url << AST::Text.new("https://example.com")
     class Url < Element
+      # Whitespace at the start or at the end of the text.
+      EDGE_SPACE = /\A[[:space:]]+|[[:space:]]+\z/
+      private_constant :EDGE_SPACE
+
       # @return [String, nil] the URL/href for this link
       attr_reader :href
 
@@ -24,18 +28,39 @@ module Markbridge
       end
 
       # Whether this link is "bare" — it has no link text of its own:
-      # either no children, or a single Text child whose content is
-      # exactly the href (how parsers model a URL that stands for
-      # itself). Consumers that record or rewrite links need this
+      # either no children, or a single Text child whose content is the
+      # href (how parsers model a URL that stands for itself).
+      # Whitespace at the edges of the text and line breaks in front of
+      # it or after it don't count: forum posts often have
+      # `[url] https://example.com [/url]` or a line break right after
+      # `[url]`. Consumers that record or rewrite links need this
       # judgment too (a bare URL must stay bare to keep autolinking
       # and oneboxing working), so it lives on the node rather than
       # in the renderer.
       #
       # @return [Boolean]
+      # @example
+      #   url = AST::Url.new(href: "https://example.com")
+      #   url << AST::LineBreak.new << AST::Text.new(" https://example.com ")
+      #   url.bare? # => true
       def bare?
         return true if children.empty?
 
-        children.size == 1 && children.first.instance_of?(Text) && children.first.text == href
+        bare_text = nil
+        children.each do |child|
+          if child.instance_of?(Text)
+            return false if bare_text
+
+            bare_text = child.text
+          elsif !child.instance_of?(LineBreak)
+            return false
+          end
+        end
+        return false if bare_text.nil?
+        # Most bare links have no whitespace to take off.
+        return true if bare_text == href
+
+        bare_text.gsub(EDGE_SPACE, "") == href
       end
     end
   end

data/lib/markbridge/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Markbridge
+  # Raised when a post holds something whose output depends on a plugin
+  # of the target site and the renderer was not told whether the site
+  # has it. See the +features:+ option of {Markbridge.discourse_renderer}.
+  class UndecidedFeatureError < StandardError
+  end
+end

data/lib/markbridge/parsers/bbcode/handler_registry.rb

@@ -32,8 +32,13 @@ module Markbridge
         def register(tag_names, handler)
           element_class = handler.element_class
           Array(tag_names).each { |tag_name| @handlers[tag_name.to_s.downcase] = handler }
-          @element_handlers[element_class] = handler
+          # The conditional write goes first. Both writes are independent and
+          # keyed by element_class, so the order makes no difference to a
+          # successful register. On a frozen registry it decides which
+          # collection raises, and only a write that can be skipped lets a
+          # spec reach the one behind it.
           @auto_closeable_elements << element_class if handler.auto_closeable?
+          @element_handlers[element_class] = handler
           self
         end
 

data/lib/markbridge/parsers/bbcode/handlers/image_handler.rb

@@ -10,6 +10,7 @@ module Markbridge
         # - [img=100x100]url[/img]
         # - [img width=100]url[/img]
         # - [img width=100 height=50]url[/img]
+        # - [img alt="a cat"]url[/img]
         class ImageHandler < RawHandler
           def initialize
             super(AST::Image)
@@ -19,7 +20,7 @@ module Markbridge
 
           def create_element(token:, content:)
             width, height = extract_dimensions(token)
-            AST::Image.new(src: content, width:, height:)
+            AST::Image.new(src: content, width:, height:, alt: token.attrs[:alt])
           end
 
           OPTION_DIMENSIONS_PATTERN = /\A(?<width>\d+)(?:x(?<height>\d+))?\z/i

data/lib/markbridge/parsers/bbcode/handlers/url_handler.rb

@@ -5,6 +5,9 @@ module Markbridge
     module BBCode
       module Handlers
         # Handler for URL tags
+        # Supports:
+        # - [url=https://example.com]text[/url]
+        # - [url]https://example.com[/url], where the text is the href
         class UrlHandler < BaseHandler
           def initialize
             @element_class = AST::Url
@@ -12,11 +15,32 @@ module Markbridge
 
           def on_open(token:, context:, registry:, tokens: nil)
             href = token.attrs[:href] || token.attrs[:url] || token.attrs[:option]
-            element = AST::Url.new(href:)
-            context.push(element, token:)
+            content = href ? nil : content_href(token:, tokens:)
+            return context.push(AST::Url.new(href:), token:) unless content
+
+            # The text and the closing tag that content_href looked at.
+            tokens.next
+            tokens.next
+            context.add_child(AST::Url.new(href: content) << AST::Text.new(content))
           end
 
           attr_reader :element_class
+
+          private
+
+          # [url]https://example.com[/url] has its href in the text. Only
+          # plain text followed by the closing tag counts: with tags inside
+          # the text is no URL, and the element keeps a nil href.
+          #
+          # @return [String, nil]
+          def content_href(token:, tokens:)
+            text, close = tokens&.peek_ahead(2)
+            return unless text.instance_of?(TextToken) && close.instance_of?(TagEndToken)
+            return unless close.tag == token.tag
+
+            href = text.text.strip
+            href unless href.empty?
+          end
         end
       end
     end

data/lib/markbridge/parsers/html/handlers/image_handler.rb

@@ -14,8 +14,11 @@ module Markbridge
             src = element["src"]
             width = sanitize_dimension(element["width"])
             height = sanitize_dimension(element["height"])
+            # An empty alt attribute means "no text", the same as a missing one.
+            alt = element["alt"]
+            alt = nil if alt&.empty?
 
-            ast_element = AST::Image.new(src:, width:, height:)
+            ast_element = AST::Image.new(src:, width:, height:, alt:)
             parent << ast_element
 
             # Return nil to signal: don't process children (void element)

data/lib/markbridge/parsers/html/parser.rb

@@ -70,9 +70,21 @@ module Markbridge
           # a <pre> keep their semantics.
           @preserve_depth = initial_preserve_depth(doc)
 
+          # Whitespace collapsing follows the browser rule (CSS Text
+          # §4.1.1): a collapsible space is dropped at the start of a
+          # line, at the end of a line, and right after another
+          # collapsible space — wherever the inline boundaries fall, so
+          # `<b>a </b> b` keeps one space and `<p><b>x </b></p>` none.
+          # A line starts at the parse root and on every block-level tag
+          # boundary. @space_tail is the element whose last child is a
+          # collapsible Text ending in a space (the candidate for the
+          # end-of-line trim), or nil.
+          @line_start = true
+          @space_tail = nil
+
           # Process all nodes
           children.each { |node| process_node(node, document) }
-          trim_trailing_whitespace(document)
+          end_line
 
           document
         end
@@ -117,17 +129,27 @@ module Markbridge
 
           if @preserve_depth.positive?
             parent << AST::Text.new(text)
+            # Preserved whitespace is content: it neither starts a line
+            # nor collapses against a space that follows it.
+            @line_start = false
+            @space_tail = nil
             return
           end
 
-          text = text.gsub(WHITESPACE_RUN, " ") if text.match?(COLLAPSIBLE_WHITESPACE)
-          # Drop leading whitespace at the start of an element's content,
-          # matching the browser rule that whitespace at the beginning of a
-          # block (or before any inline content) is collapsed away.
-          text = text.lstrip if parent.children.empty?
+          text = collapse_whitespace(text)
+          text = text.lstrip if @line_start || @space_tail
           return if text.empty?
 
           parent << AST::Text.new(text)
+          @line_start = false
+          @space_tail = (parent if text.end_with?(" "))
+        end
+
+        # Collapse runs of whitespace to a single space.
+        # @param text [String]
+        # @return [String]
+        def collapse_whitespace(text)
+          text.match?(COLLAPSIBLE_WHITESPACE) ? text.gsub(WHITESPACE_RUN, " ") : text
         end
 
         # Process an element node
@@ -137,19 +159,21 @@ module Markbridge
           tag_name = node.name
           return if IGNORED_TAGS.include?(tag_name)
 
-          # Drop whitespace that sits between content and the start of a
-          # block-level tag, matching browser behavior where such whitespace
-          # collapses against the block boundary. Applies whether or not a
-          # handler is registered, so unknown tags like <div> or <section>
-          # still collapse the whitespace before them.
-          trim_trailing_whitespace(parent) if @handlers.block_level_tags.include?(tag_name)
+          # A block-level tag ends the line before it and the line inside
+          # it, matching browser behavior where whitespace collapses
+          # against the block boundary. Applies whether or not a handler
+          # is registered, so unknown tags like <div> or <section> still
+          # end lines.
+          block = @handlers.block_level_tags.include?(tag_name)
+          end_line if block
 
           preserving = @handlers.whitespace_preserving_tags.include?(tag_name)
           @preserve_depth += 1 if preserving
 
-          dispatch_element(node, tag_name, parent, preserving)
+          dispatch_element(node, tag_name, parent)
 
           @preserve_depth -= 1 if preserving
+          end_line if block
         end
 
         # Dispatch an element to its handler (or the unknown-tag path) and
@@ -157,18 +181,22 @@ module Markbridge
         # @param node [Nokogiri::XML::Element]
         # @param tag_name [String]
         # @param parent [AST::Element]
-        # @param preserving [Boolean] whether this tag preserves whitespace
-        def dispatch_element(node, tag_name, parent, preserving)
+        def dispatch_element(node, tag_name, parent)
           handler = @handlers[tag_name]
           return handle_unknown_tag(node, parent) unless handler
 
           # Handler returns element if children should be processed, nil otherwise
+          size = parent.children.size
           ast_element = handler.process(element: node, parent:)
 
-          return unless ast_element
-
-          process_children(node, ast_element)
-          trim_trailing_whitespace(ast_element) unless preserving
+          if ast_element
+            process_children(node, ast_element)
+          elsif parent.children.size > size
+            # The handler appended a leaf (image, line break, ...), which
+            # is content on the current line like a word.
+            @line_start = false
+            @space_tail = nil
+          end
         end
 
         # Handle unknown tag by tracking it and ignoring the wrapper
@@ -180,6 +208,16 @@ module Markbridge
           process_children(node, parent)
         end
 
+        # End the current line: the collapsible space that closed it goes,
+        # and the next collapsible space starts a line. @space_tail is
+        # not cleared here: the trim is idempotent, so a stale tail is
+        # harmless until the next text or leaf on the new line resets it,
+        # and @line_start already covers the lstrip.
+        def end_line
+          trim_trailing_whitespace(@space_tail) if @space_tail
+          @line_start = true
+        end
+
         # Number of whitespace-preserving elements enclosing the parse
         # root, the root itself included. Computed once per parse; from
         # there the counter is maintained during descent. Documents and

data/lib/markbridge/parsers/text_formatter/handlers/attachment_handler.rb

@@ -21,8 +21,9 @@ module Markbridge
               )
             parent << node
 
-            # Return node to signal: process children into this node
-            node
+            # The content is only fallback text (the filename), so there are
+            # no children to process.
+            nil
           end
 
           attr_reader :element_class

data/lib/markbridge/parsers/text_formatter/handlers/image_handler.rb

@@ -17,11 +17,13 @@ module Markbridge
                 src: attrs[:src],
                 width: attrs[:width]&.to_i,
                 height: attrs[:height]&.to_i,
+                alt: attrs[:alt],
               )
             parent << node
 
-            # Return node to signal: process children into this node
-            node
+            # The content is only fallback text (the URL), so there are
+            # no children to process.
+            nil
           end
 
           attr_reader :element_class

data/lib/markbridge/parsers/text_formatter/parser.rb

@@ -9,6 +9,12 @@ module Markbridge
       # - Plain text: <t>text content</t>
       # - Rich text: <r><B>bold</B> <URL url="...">link</URL></r>
       # - Markup preservation: <s> and <e> elements (ignored during parsing)
+      # - Ignored text: <i> (lowercase) holds text s9e did not use, like the
+      #   newline after [list] or a stray [/b]. It is skipped too; <I> is italic.
+      # - Line breaks: <br/> followed by a newline in the next text node. The
+      #   newline is only source formatting, like any whitespace at the start
+      #   of a line, because phpBB renders the XML as HTML. Inside <CODE> the
+      #   text is kept as it is.
       #
       # This format is used by phpBB 3.2+ and other forum software.
       #
@@ -36,6 +42,12 @@ module Markbridge
               handlers || HandlerRegistry.shared_default
             end
           @unknown_tags = Hash.new(0)
+          # Whether an AST class is one of the BLOCK_NODES, computed once
+          # per class, so an inline element doesn't check all of them.
+          @block_classes =
+            Hash.new do |block_class_cache, klass|
+              block_class_cache[klass] = BLOCK_NODES.any? { klass <= _1 }
+            end
         end
 
         # Parse s9e/TextFormatter XML into an AST.
@@ -49,11 +61,13 @@ module Markbridge
         # @return [AST::Document]
         def parse(input)
           @unknown_tags.clear
+          @line_start = true
 
           if input.is_a?(Nokogiri::XML::Node)
             root = input.is_a?(Nokogiri::XML::Document) ? input.root : input
             document = AST::Document.new
             process_node(root, document) if root
+            flush_line_break
             return document
           end
 
@@ -70,17 +84,38 @@ module Markbridge
 
           document = AST::Document.new
           process_node(root, document)
+          flush_line_break
           document
         rescue Nokogiri::XML::SyntaxError
           AST::Document.new << AST::Text.new(input)
         end
 
-        # <s>/<e> hold the original BBCode markup for unparsing; <t>/<r>
-        # are the plain-text/rich-text roots. Frozen constants — the
-        # membership checks run once per element node.
-        MARKUP_PRESERVATION_TAGS = %w[s e].freeze
+        # <s>/<e> hold the original BBCode markup for unparsing, <i> holds
+        # text that s9e ignored; <t>/<r> are the plain-text/rich-text roots.
+        # Frozen constants — the membership checks run once per element
+        # node. The check is case-sensitive: <I> is italic.
+        MARKUP_PRESERVATION_TAGS = %w[s e i].freeze
         ROOT_TAGS = %w[t r].freeze
-        private_constant :MARKUP_PRESERVATION_TAGS, :ROOT_TAGS
+
+        # AST nodes that phpBB shows as blocks. A new line starts before and
+        # after them, so whitespace at the start of their content and of the
+        # text after them is not visible.
+        BLOCK_NODES = [
+          AST::Align,
+          AST::Code,
+          AST::Details,
+          AST::Heading,
+          AST::HorizontalRule,
+          AST::List,
+          AST::ListItem,
+          AST::Paragraph,
+          AST::Quote,
+          AST::Spoiler,
+          AST::Table,
+          AST::TableCell,
+          AST::TableRow,
+        ].freeze
+        private_constant :MARKUP_PRESERVATION_TAGS, :ROOT_TAGS, :BLOCK_NODES
 
         # Process children of an XML element (public for handler access)
         # @param element [Nokogiri::XML::Element]
@@ -114,33 +149,91 @@ module Markbridge
           # Handle root nodes
           return process_children(element, ast_parent) if ROOT_TAGS.include?(tag_name)
 
-          # Handle line breaks
-          if tag_name == "br"
-            ast_parent << AST::LineBreak.new
-            return
-          end
+          return process_line_break(ast_parent) if tag_name == "br"
 
           # Process element with registered handler
           # Handler returns element if children should be processed, nil otherwise
+          flush_line_break
           result_element = @handlers.process_element(element, ast_parent, self)
 
           if result_element
             # Handler succeeded and returned element - process children into it
-            process_children(element, result_element)
-          elsif !@handlers.has_handler?(tag_name)
+            process_handled_children(element, result_element)
+          elsif @handlers.has_handler?(tag_name)
+            # The handler returned nil intentionally: a leaf like an image
+            # or an attachment, whose content is only fallback text. It is
+            # visible, so the text after it is no longer at the line start.
+            @line_start = false
+          else
             # No handler found - track as unknown and process children directly
             @unknown_tags[tag_name] += 1
             process_children(element, ast_parent)
           end
-          # else: handler returned nil intentionally (no children to process)
+        end
+
+        # Two line breaks in a row are an empty line in phpBB. In Markdown
+        # that is a paragraph break, so a line break waits in
+        # +@pending_break+ until something visible follows it. When the
+        # next line break comes first, the two become a blank line. A
+        # third one comes after the blank line and is not visible.
+        #
+        # @param ast_parent [AST::Element]
+        def process_line_break(ast_parent)
+          if @pending_break.equal?(ast_parent)
+            @pending_break = nil
+            ast_parent << AST::Text.new("\n\n")
+          else
+            flush_line_break
+            @pending_break = ast_parent
+          end
+          @line_start = true
+        end
+
+        # Adds the line break that waits, if there is one, before anything
+        # visible is added after it.
+        def flush_line_break
+          @pending_break&.<<(AST::LineBreak.new)
+          @pending_break = nil
+        end
+
+        # @param element [Nokogiri::XML::Element]
+        # @param ast_element [AST::Element]
+        def process_handled_children(element, ast_element)
+          if @block_classes[ast_element.class]
+            @line_start = true
+            process_children(element, ast_element)
+            @line_start = true
+          else
+            process_children(element, ast_element)
+          end
         end
 
         # Process text node
+        #
+        # Outside of code, whitespace at the start of a line is not visible
+        # in phpBB, but in Markdown a newline after a line break would end
+        # the paragraph and four spaces would start a code block, so it is
+        # removed. Whitespace-only text between two inline elements (the
+        # space in "<B>a</B> <I>b</I>") is kept; with a newline in it, it
+        # is only formatting between blocks.
+        #
         # @param text_node [Nokogiri::XML::Text]
         # @param ast_parent [AST::Element]
         def process_text(text_node, ast_parent)
           text = text_node.content
-          ast_parent << AST::Text.new(text) if text.match?(/\S/)
+
+          if ast_parent.is_a?(AST::Code)
+            ast_parent << AST::Text.new(text) if text.match?(/\S/)
+          elsif @line_start
+            text = text.lstrip
+            return if text.empty?
+
+            @line_start = false
+            flush_line_break
+            ast_parent << AST::Text.new(text)
+          elsif text.match?(/\S/) || !text.include?("\n")
+            ast_parent << AST::Text.new(text)
+          end
         end
       end
     end

data/lib/markbridge/renderers/discourse/html_block.rb

@@ -11,15 +11,21 @@ module Markbridge
       # renders into such a block therefore picks one of two forms:
       #
       # 1. raw HTML — an HTML equivalent of the tag's Markdown, spliced
-      #    into the block as it is;
+      #    into the block as it is, with no blank line in it;
       # 2. a Markdown island — the tag's normal Markdown surrounded by
-      #    blank lines, which end the block and start it again:
+      #    blank lines, which end the block, and a line that opens it
+      #    again after them:
       #
       #        <div align="center">
       #
       #        [a link](https://example.com)
       #
       #        </div>
+      #
+      # Inside an HTML block the island is always in a `<div>`
+      # (.enclosed_island, which a tag reaches through
+      # RenderingInterface#markdown_island). After a bare island the rest
+      # of the cell would be Markdown too.
       module HtmlBlock
         # Tag names that start a type 6 HTML block when a line begins
         # with `<name` or `</name` followed by a space, a tab, `>`, `/>`
@@ -94,6 +100,10 @@ module Markbridge
         # are item content that the list builder has not indented yet.
         OPENER = %r{\A[ \t]*</?(?:#{Regexp.union(BLOCK_TAGS).source})(?:[ \t>]|/>|\z)}i
 
+        # The newline in front of a line that holds nothing but spaces and
+        # tabs: with the line it makes a blank line.
+        BLANK_LINE_NEWLINE = /\n(?=[ \t]*\n)/
+
         # Markdown sigils that would surface as literal text inside an
         # HTML block: emphasis (`*`, `_`, `~`) and link middles (`](`).
         MARKDOWN_SIGILS = /[*_~]|\]\(/
@@ -102,7 +112,7 @@ module Markbridge
         # content line keeps its own indentation, e.g. a nested `  - a`.
         BLANK_EDGES = /\A(?:[ \t]*\n)+|(?:\n[ \t]*)+\z/
 
-        private_constant :BLOCK_TAGS, :OPENER, :MARKDOWN_SIGILS, :BLANK_EDGES
+        private_constant :BLOCK_TAGS, :OPENER, :BLANK_LINE_NEWLINE, :MARKDOWN_SIGILS, :BLANK_EDGES
 
         # Whether +line+ starts an HTML block. A closing tag such as
         # `</div>` starts one too. The block runs until the next blank
@@ -124,17 +134,50 @@ module Markbridge
           "\n\n#{markdown.gsub(BLANK_EDGES, "")}\n\n"
         end
 
-        # Whether a fragment can be spliced into an HTML block: raw HTML
-        # or plain text without Markdown sigils, or an island.
+        # An island for the inside of an HTML block, in a `<div>`. After
+        # a bare island what follows on the same lines is Markdown until
+        # a line opens an HTML block again, so text after it in a table
+        # cell would get Markdown meaning; the `</div>` line opens the
+        # block again. A `div` is a block in the HTML as well, so the
+        # island shows as a paragraph of its own, like a bare island
+        # does.
+        # @param markdown [String]
+        # @return [String]
+        # @example
+        #   HtmlBlock.enclosed_island("![a](b)") # => "<div>\n\n![a](b)\n\n</div>"
+        def self.enclosed_island(markdown)
+          "<div>#{island(markdown)}</div>"
+        end
+
+        # Text for the inside of an HTML block, with no blank line in it:
+        # a blank line ends the block, and what follows is Markdown
+        # again. The newline that would start a blank line is written as
+        # the entity, which the HTML parser reads back as a newline.
+        # @param text [String] text or HTML, already escaped
+        # @return [String]
+        # @example
+        #   HtmlBlock.without_blank_lines("a\n\nb") # => "a&#10;\nb"
+        def self.without_blank_lines(text)
+          return text unless text.include?("\n")
+
+          text.gsub(BLANK_LINE_NEWLINE, "&#10;")
+        end
+
+        # Whether a fragment can be spliced into an HTML block: an island
+        # in a `<div>`, or raw HTML or plain text without Markdown sigils
+        # and without a blank line. A blank line anywhere else ends the
+        # block, and what follows it is Markdown until a line opens a
+        # block again; a bare island, `\n\n…\n\n`, is not accepted for
+        # that reason.
         #
         # Used by the html_mode contract check that ships in
         # +markbridge/rspec+ and by this repo's own contract spec.
         # @param output [String] a tag's html_mode render result
         # @return [Boolean]
         def self.safe?(output)
-          return true if output.start_with?("\n\n") && output.end_with?("\n\n")
+          return true if output.start_with?("<div>\n\n") && output.end_with?("\n\n</div>")
 
-          !output.match?(MARKDOWN_SIGILS)
+          !output.match?(MARKDOWN_SIGILS) && !output.match?(BLANK_LINE_NEWLINE)
         end
       end
     end