RubyGems - red_quilt - Versions diffs - 0.7.2 → 0.8.0 - Mend

red_quilt 0.7.2 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +23 -0
data/README.md +38 -0
data/docs/api.md +11 -0
data/lib/red_quilt/arena.rb +96 -0
data/lib/red_quilt/block_parser.rb +22 -384
data/lib/red_quilt/cli.rb +8 -2
data/lib/red_quilt/code_block.rb +139 -0
data/lib/red_quilt/document.rb +18 -4
data/lib/red_quilt/footnote_anchors.rb +24 -0
data/lib/red_quilt/footnote_pass.rb +6 -2
data/lib/red_quilt/frontmatter.rb +54 -0
data/lib/red_quilt/html_block.rb +161 -0
data/lib/red_quilt/indentation.rb +35 -0
data/lib/red_quilt/inline/builder.rb +9 -186
data/lib/red_quilt/inline/emphasis_resolver.rb +184 -0
data/lib/red_quilt/inline/url_sanitizer.rb +64 -0
data/lib/red_quilt/line.rb +6 -1
data/lib/red_quilt/lint_pass.rb +2 -2
data/lib/red_quilt/node_ref.rb +20 -11
data/lib/red_quilt/renderer/html.rb +32 -20
data/lib/red_quilt/renderer/mdast.rb +11 -11
data/lib/red_quilt/table.rb +97 -0
data/lib/red_quilt/version.rb +1 -1
data/lib/red_quilt.rb +19 -4
data/sig/red_quilt.rbs +18 -0
metadata +9 -2

data/lib/red_quilt/document.rb CHANGED Viewed

@@ -2,9 +2,9 @@
 module RedQuilt
   class Document
-    attr_reader :source, :arena, :root_id, :references, :footnotes
+    attr_reader :source, :arena, :root_id, :references, :footnotes, :frontmatter
-    def initialize(source, arena, root_id, allow_html: false, disallow_raw_html: false, references: {}, footnotes: nil)
+    def initialize(source, arena, root_id, allow_html: false, disallow_raw_html: false, references: {}, footnotes: nil, frontmatter: nil)
       @source = source
       @arena = arena
       @root_id = root_id
@@ -12,6 +12,7 @@ module RedQuilt
       @disallow_raw_html = disallow_raw_html
       @references = references
       @footnotes = footnotes
+      @frontmatter = frontmatter
     end
     def allow_html?
@@ -51,11 +52,18 @@ module RedQuilt
     #   `<pre class="mermaid">` containers instead of `<pre><code>`. In
     #   standalone mode the mermaid.js runtime is also loaded from a CDN so
     #   the diagrams render in the browser without further setup.
-    def to_html(standalone: false, title: nil, lang: "en", css: nil, theme: :none, heading_ids: false, mermaid: false)
+    #
+    # When standalone and the document was parsed with `frontmatter: true`,
+    # the frontmatter's `title` / `lang` keys fill in the corresponding
+    # `<title>` / `<html lang>` if no explicit argument was given
+    # (explicit argument > frontmatter > default).
+    def to_html(standalone: false, title: nil, lang: nil, css: nil, theme: :none, heading_ids: false, mermaid: false)
       body = Renderer::HTML.new(self, heading_ids: heading_ids, mermaid: mermaid).render
       return body unless standalone
-      wrap_standalone_html(body, title: title.to_s, lang: lang.to_s, css: css, theme: Theme.css(theme), mermaid: mermaid)
+      effective_title = title || frontmatter_value("title")
+      effective_lang = lang || frontmatter_value("lang") || "en"
+      wrap_standalone_html(body, title: effective_title.to_s, lang: effective_lang.to_s, css: css, theme: Theme.css(theme), mermaid: mermaid)
     end
     def to_ast
@@ -91,6 +99,12 @@ module RedQuilt
     private
+    def frontmatter_value(key)
+      return nil unless @frontmatter.is_a?(Hash)
+      @frontmatter[key]
+    end
     # Self-contained assets embedded in standalone output when mermaid
     # support is enabled. Loads the mermaid.js runtime from a CDN as an ES
     # module, renders every `<pre class="mermaid">` container, then makes

data/lib/red_quilt/footnote_anchors.rb ADDED Viewed

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module RedQuilt
+  # Single source of truth for the HTML element ids used to wire footnote
+  # references to their definitions and back. Both the reference (`<sup>`),
+  # the definition (`<li>`), and the back-reference links must agree on
+  # these strings, so they live in one place rather than being rebuilt at
+  # each call site.
+  module FootnoteAnchors
+    module_function
+    # Id of the definition `<li>` and the target of a reference link.
+    def definition_id(number)
+      "fn-#{number}"
+    end
+    # Id of a reference `<sup>` and the target of a back-reference link.
+    # A repeated reference (occurrence > 1) gets a `-N` suffix so every
+    # back-reference has a unique anchor.
+    def reference_id(number, occurrence)
+      occurrence > 1 ? "fnref-#{number}-#{occurrence}" : "fnref-#{number}"
+    end
+  end
+end

data/lib/red_quilt/footnote_pass.rb CHANGED Viewed

@@ -29,10 +29,14 @@ module RedQuilt
       # Re-append referenced definitions in first-reference order; detaching
       # all current children first means unreferenced definitions are left
-      # orphaned (and so never rendered).
+      # orphaned (and so never rendered). The number and reference count are
+      # materialized onto each definition node so the renderer reads them off
+      # the arena rather than consulting the registry.
       @arena.child_ids(section_id).to_a.each { |child| @arena.detach(child) }
       @registry.referenced_labels.each do |label|
-        @arena.append_child(section_id, @registry.definition_node(label))
+        def_id = @registry.definition_node(label)
+        @arena.resolve_footnote_definition(def_id, @registry.number(label), @registry.occurrences(label))
+        @arena.append_child(section_id, def_id)
       end
     end
   end

data/lib/red_quilt/frontmatter.rb ADDED Viewed

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require "psych"
+require "date"
+module RedQuilt
+  # Extracts a leading YAML frontmatter block from a Markdown source.
+  module Frontmatter
+    # Matches a frontmatter block at the very start of the document.
+    PATTERN = /\A---\n(.*?)\n(?:---|\.\.\.)[ \t]*(?:\n|\z)/m
+    private_constant :PATTERN
+    module_function
+    # Extracts frontmatter from +source+, returning a two-element array:
+    # [data, body]. +data+ is the parsed Hash (or nil when there is no
+    # frontmatter), and +body+ is the source with the frontmatter region
+    # blanked out.
+    #
+    # +diagnostics+ is an optional array; on a YAML syntax error a warning
+    # Diagnostic is appended and +data+ is returned as nil.
+    def extract(source, diagnostics: nil)
+      match = PATTERN.match(source)
+      return [nil, source] unless match
+      data = parse_yaml(match[1], diagnostics: diagnostics)
+      body = blank_out(source, match.end(0))
+      [data, body]
+    end
+    # Parses the YAML body with a restricted loader (no arbitrary object
+    # instantiation; Date / Time permitted for common frontmatter dates).
+    # Returns the parsed value, or nil on a syntax error.
+    def parse_yaml(yaml, diagnostics: nil)
+      Psych.safe_load(yaml, permitted_classes: [Date, Time], aliases: false)
+    rescue Psych::SyntaxError => e
+      diagnostics&.push(
+        Diagnostic.new(
+          severity: :warning,
+          rule: :frontmatter,
+          message: "invalid YAML frontmatter: #{e.message}",
+        ),
+      )
+      nil
+    end
+    # Replaces every character before +offset+ with a blank line for each
+    # consumed source line, keeping later line numbers intact.
+    def blank_out(source, offset)
+      consumed = source[0, offset]
+      ("\n" * consumed.count("\n")) + source[offset..]
+    end
+  end
+end

data/lib/red_quilt/html_block.rb ADDED Viewed

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+module RedQuilt
+  # CommonMark HTML-block classification (spec 4.6). Pure functions over a
+  # line's text: given the raw line they decide whether it opens an HTML
+  # block and of which of the seven types. No arena or parser state is
+  # involved, so this lives apart from BlockParser's node construction.
+  module HtmlBlock
+    module_function
+    # True when `text` opens an HTML block (any of the 7 types). Indented
+    # code (4+ leading spaces) takes precedence and is never an HTML block.
+    def start?(text)
+      return false if text.start_with?("    ")
+      !type(text).nil?
+    end
+    # The HTML block type (1..7) opened by `text`, or nil if it opens none.
+    def type(text)
+      # Fast reject: every HTML block starts with `<`. lstrip strips
+      # 0-3 indent spaces (more would already be indented code), so peek
+      # the leading non-space byte before doing any allocations.
+      i = 0
+      # CommonMark: HTML block lines may have 0-3 spaces of indent.
+      while i < 3 && i < text.length && text.getbyte(i) == 0x20
+        i += 1
+      end
+      return nil unless i < text.length && text.getbyte(i) == 0x3C
+      stripped = i.zero? ? text : text[i..]
+      # Type 1: <script|pre|style|textarea (case-insensitive) followed by
+      # space/tab/end-of-line or `>`. CommonMark restricts the separator
+      # to space, tab, or a line ending (not any whitespace class).
+      return 1 if stripped.match?(%r{\A<(script|pre|style|textarea)(?:[ \t]|>|$)}i)
+      # Type 2: <!--
+      return 2 if stripped.start_with?("<!--")
+      # Type 3: <?
+      return 3 if stripped.start_with?("<?")
+      # Type 4: <! followed by uppercase ASCII letter
+      return 4 if stripped.match?(%r{\A<![A-Z]})
+      # Type 5: <![CDATA[
+      return 5 if stripped.start_with?("<![CDATA[")
+      # Type 6: line opens with one of the listed block-level tags.
+      return 6 if stripped.match?(TYPE_6_RE)
+      # Type 7: a complete open or closing tag spanning the line.
+      return 7 if valid_tag?(stripped)
+      nil
+    end
+    TYPE_6_NAMES = %w[
+      address article aside base basefont blockquote body caption center
+      col colgroup dd details dialog dir div dl dt fieldset figcaption
+      figure footer form frame frameset h1 h2 h3 h4 h5 h6 head header
+      hr html iframe legend li link main menu menuitem nav noframes ol
+      optgroup option p param search section summary table tbody td
+      tfoot th thead title tr track ul
+    ].freeze
+    TYPE_6_RE = %r{\A</?(?:#{TYPE_6_NAMES.join('|')})(?:[ \t]|>|/>|\z)}i
+    private_constant :TYPE_6_NAMES, :TYPE_6_RE
+    # Type 7: a complete open or closing tag on its own line.
+    # Closing tags must not have attributes.
+    #
+    # HTML tag separators per CommonMark 6.6 are space, tab, or up to one
+    # line ending -- not the broader \s class (which would include form
+    # feed and vertical tab).
+    TYPE_7_OPEN_TAG_RE = %r{
+      \A
+      <[A-Za-z][A-Za-z0-9-]*
+      (?:[ \t\r\n]+[A-Za-z_:][A-Za-z0-9_.:-]*(?:[ \t\r\n]*=[ \t\r\n]*(?:"[^"\n]*"|'[^'\n]*'|[^ \t\r\n"'=<>`]+))?)*
+      [ \t\r\n]*/?>
+      \z
+    }x
+    TYPE_7_CLOSING_TAG_RE = %r{\A</[A-Za-z][A-Za-z0-9-]*[ \t\r\n]*>\z}
+    private_constant :TYPE_7_OPEN_TAG_RE, :TYPE_7_CLOSING_TAG_RE
+    def valid_tag?(text)
+      # Fast reject: every type-7 tag must begin with `<`.
+      return false unless text.start_with?("<")
+      TYPE_7_OPEN_TAG_RE.match?(text) || TYPE_7_CLOSING_TAG_RE.match?(text)
+    end
+    # Closing-condition strings for HTML block types 2-5 (types 1, 6, 7 use
+    # dynamic / blank-line termination).
+    FIXED_TERMINATORS = { 2 => "-->", 3 => "?>", 4 => ">", 5 => "]]>" }.freeze
+    private_constant :FIXED_TERMINATORS
+    # Cached collaborator for BlockParser. A single instance is created in
+    # BlockParser#initialize and reused; per-call state lives in method
+    # locals so reentrant calls are safe.
+    class Parser
+      def initialize(block_parser)
+        @arena = block_parser.arena
+      end
+      # Parses the HTML block starting at lines[index] (its type already
+      # confirmed by HtmlBlock.start?). Returns the index past the block.
+      def parse(parent_id, lines, index)
+        start_index = index
+        type = HtmlBlock.type(lines[index].content)
+        end_index = locate_end(lines, index, type)
+        start_byte = lines[start_index].start_byte
+        end_byte = lines[end_index].end_byte
+        html_lines = (start_index..end_index).map { |i| lines[i].content }
+        html_id = @arena.add_node(NodeType::HTML_BLOCK,
+                                  source_start: start_byte,
+                                  source_len: end_byte - start_byte,
+                                  str1: html_lines.join("\n"))
+        @arena.append_child(parent_id, html_id)
+        end_index + 1
+      end
+      private
+      def locate_end(lines, index, type)
+        terminator = terminator_for(type, lines[index].content)
+        if terminator
+          case_insensitive = (type == 1)
+          while index < lines.length
+            line = lines[index].content
+            haystack = case_insensitive ? line.downcase : line
+            return index if haystack.include?(terminator)
+            index += 1
+          end
+          lines.length - 1
+        else
+          # Types 6 & 7: terminated by blank line (or end of input)
+          index += 1 while index < lines.length && !lines[index].blank
+          index - 1
+        end
+      end
+      def terminator_for(type, first_line)
+        case type
+        when 1
+          "</#{closing_tag_name(first_line)}>"
+        when 2..5
+          FIXED_TERMINATORS[type]
+        end
+      end
+      def closing_tag_name(text)
+        match = /\A<(script|pre|style|textarea)/i.match(text)
+        match ? match[1].downcase : "script"
+      end
+    end
+  end
+end

data/lib/red_quilt/indentation.rb CHANGED Viewed

@@ -57,6 +57,41 @@ module RedQuilt
       end
     end
+    # Strips up to `max` leading 0x20 (space) bytes from `text`, returning
+    # the rest. Unlike #strip_columns this is a plain byte strip (tabs are
+    # not expanded); used where the spec counts literal spaces, e.g. a
+    # fenced code block stripping its own opening indent. No-alloc return
+    # when `text` already starts at a non-space byte.
+    def strip_leading_spaces(text, max)
+      return text if max <= 0
+      bytes = text.bytesize
+      i = 0
+      while i < max && i < bytes && text.getbyte(i) == 0x20
+        i += 1
+      end
+      return text if i.zero?
+      text.byteslice(i..)
+    end
+    # Strips all leading 0x20 / 0x09 bytes from `text` (spaces and tabs,
+    # no column cap). Same no-alloc return as #strip_leading_spaces when
+    # `text` already starts at a non-whitespace byte.
+    def strip_leading_whitespace(text)
+      bytes = text.bytesize
+      i = 0
+      while i < bytes
+        b = text.getbyte(i)
+        break unless b == 0x20 || b == 0x09
+        i += 1
+      end
+      return text if i.zero?
+      text.byteslice(i..)
+    end
     # Bytes of literal leading 0x20 / 0x09 in `text`.
     def leading_ws_bytes(text)
       i = 0

data/lib/red_quilt/inline/builder.rb CHANGED Viewed

@@ -9,22 +9,10 @@ module RedQuilt
     #   1. linear_pass — code spans, brackets (link/image), autolinks,
     #      HTML, simple inlines. Emphasis delimiter runs are added as
     #      provisional TEXT nodes and pushed onto a delimiter stack.
-    #   2. process_emphasis — CommonMark spec 6.2 algorithm pairs up
-    #      delimiter stack entries into EMPHASIS / STRONG nodes.
+    #   2. EmphasisResolver#resolve — CommonMark spec 6.2 algorithm pairs
+    #      up delimiter stack entries into EMPHASIS / STRONG nodes
+    #      (delegated to Inline::EmphasisResolver).
     class Builder
-      SAFE_SCHEMES = %w[http https mailto ftp tel ssh].freeze
-      # Autolinks (`<scheme:...>`) are not run through the SAFE_SCHEMES
-      # allowlist: CommonMark permits arbitrary schemes there (e.g.
-      # `<made-up-scheme://x>`), and an allowlist would break that
-      # conformance. Only the schemes that execute script when the link
-      # is navigated are denied.
-      UNSAFE_AUTOLINK_SCHEMES = %w[javascript vbscript data].freeze
-      # `count` is the CommonMark delimiter-run length; a Delimiter is
-      # never enumerated, so shadowing Struct#count (from Enumerable) is
-      # intentional rather than a footgun.
-      Delimiter = Struct.new(:node_id, :char, :count, :can_open, :can_close) # rubocop:disable Lint/StructNewOverride
       Bracket = Struct.new(:token_id, :node_id, :image, :active, :delim_stack_size)
       # track_source: when true, arena nodes carry the byte ranges supplied
@@ -49,6 +37,7 @@ module RedQuilt
         @diagnostics = diagnostics
         @footnotes = footnotes
         @link_scanner = LinkScanner.new(source)
+        @emphasis = EmphasisResolver.new(arena, track_source: track_source)
       end
       def build(parent_id, tokens)
@@ -58,7 +47,7 @@ module RedQuilt
         @bracket_stack = []
         @provisional_nodes = {}
         linear_pass
-        process_emphasis(@delimiter_stack)
+        @emphasis.resolve(@delimiter_stack, @provisional_nodes)
       end
       private
@@ -228,29 +217,12 @@ module RedQuilt
         link_id = add_arena_node(
           NodeType::LINK,
           @tokens.start_byte(id), @tokens.end_byte(id),
-          str1: block_unsafe_autolink(@link_scanner.normalize_uri(destination)),
+          str1: UrlSanitizer.block_unsafe_autolink(@link_scanner.normalize_uri(destination), @diagnostics),
         )
         @arena.append_child(@parent_id, link_id)
         @arena.append_child(link_id, @arena.add_node(NodeType::TEXT, str1: label))
       end
-      # Returns "" (blocking the href) for autolink destinations whose
-      # scheme executes script on navigation; otherwise the destination
-      # is returned unchanged. Unlike sanitize_destination this is a
-      # denylist, to stay CommonMark-conformant for benign custom schemes.
-      def block_unsafe_autolink(destination)
-        scheme = destination[%r{\A([a-zA-Z][a-zA-Z0-9+\-.]*):}, 1]
-        return destination if scheme.nil?
-        return destination unless UNSAFE_AUTOLINK_SCHEMES.include?(scheme.downcase)
-        report_diagnostic(
-          severity: :warning,
-          rule: :unsafe_url,
-          message: "Unsafe URL scheme #{scheme.downcase.inspect} blocked",
-        )
-        ""
-      end
       # --------------------------- code spans -----------------------------
       # Find the closing backtick run for a code span by scanning the
@@ -400,7 +372,7 @@ module RedQuilt
         link_kind = opener.image ? NodeType::IMAGE : NodeType::LINK
         link_id = add_arena_node(
           link_kind, opener_start, match[:end_byte],
-          str1: sanitize_destination(match[:destination]),
+          str1: UrlSanitizer.sanitize_destination(match[:destination], @diagnostics),
           str2: match[:title],
         )
@@ -416,7 +388,7 @@ module RedQuilt
         @arena.detach(opener.node_id)
         inner_delims = @delimiter_stack.slice!(opener.delim_stack_size..) || []
-        process_emphasis(inner_delims)
+        @emphasis.resolve(inner_delims, @provisional_nodes)
         @bracket_stack.delete_at(opener_index)
@@ -489,22 +461,6 @@ module RedQuilt
         last
       end
-      def sanitize_destination(destination)
-        return "" if destination.nil?
-        return destination if destination.start_with?("/", "#")
-        scheme = destination[%r{\A([a-zA-Z][a-zA-Z0-9+\-.]*):}, 1]
-        return destination if scheme.nil?
-        return destination if SAFE_SCHEMES.include?(scheme.downcase)
-        report_diagnostic(
-          severity: :warning,
-          rule: :unsafe_url,
-          message: "Unsafe URL scheme #{scheme.downcase.inspect} blocked",
-        )
-        ""
-      end
       def report_diagnostic(severity:, rule:, message:, source_span: nil)
         return unless @diagnostics
@@ -530,145 +486,12 @@ module RedQuilt
         @arena.append_child(@parent_id, node_id)
         @provisional_nodes[node_id] = true
-        @delimiter_stack << Delimiter.new(
+        @delimiter_stack << EmphasisResolver::Delimiter.new(
           node_id, char, count,
           (flags & 0b10) != 0,
           (flags & 0b01) != 0,
         )
       end
-      def process_emphasis(stack)
-        # NB: the CommonMark spec describes an `openers_bottom`
-        # optimization keyed by closer character / length / flanking
-        # flags. Implementing that correctly is subtle (a single
-        # per-character bottom blocks valid matches like
-        # `*foo**bar**baz*`), so the implementation here just walks
-        # back to the start of the stack for every closer. This is
-        # O(stack^2) in the worst case but stacks are tiny in practice.
-        closer_idx = 0
-        while closer_idx < stack.length
-          closer = stack[closer_idx]
-          unless closer.can_close
-            closer_idx += 1
-            next
-          end
-          opener_idx = closer_idx - 1
-          found = false
-          while opener_idx >= 0
-            opener = stack[opener_idx]
-            if opener.can_open && opener.char == closer.char
-              skip = false
-              if (opener.can_close || closer.can_open) &&
-                 ((opener.count + closer.count) % 3).zero? &&
-                 !((opener.count % 3).zero? && (closer.count % 3).zero?)
-                skip = true
-              end
-              unless skip
-                found = true
-                break
-              end
-            end
-            opener_idx -= 1
-          end
-          unless found
-            unless closer.can_open
-              @provisional_nodes.delete(closer.node_id)
-              stack.delete_at(closer_idx)
-            end
-            closer_idx += 1
-            next
-          end
-          opener = stack[opener_idx]
-          strength = [opener.count, closer.count].min >= 2 ? 2 : 1
-          if closer.char == "~"
-            # GFM strikethrough only forms on `~~` runs. A single `~`
-            # leaves the delimiter as text; advance the cursor so future
-            # `~~` pairs can still match.
-            if strength < 2
-              closer_idx += 1
-              next
-            end
-            kind = NodeType::STRIKETHROUGH
-          else
-            kind = strength == 2 ? NodeType::STRONG : NodeType::EMPHASIS
-          end
-          # CommonMark spec: any delimiters strictly between this opener and
-          # closer can't open or close anything in this scope, so drop them
-          # from the stack before we rebuild the tree. Their arena nodes
-          # stay where they are (they'll be reparented into the new emphasis
-          # alongside the surrounding content), but they must no longer be
-          # candidates for future iterations. Without this, the next
-          # iteration would try to pair stranded delimiters that have
-          # already been moved into a different parent, which corrupts the
-          # sibling chain (Arena#reparent walks into @parent[-1]).
-          if closer_idx > opener_idx + 1
-            removed = stack.slice!((opener_idx + 1)...closer_idx)
-            removed.each { |e| @provisional_nodes.delete(e.node_id) }
-            closer_idx = opener_idx + 1
-            closer = stack[closer_idx]
-          end
-          opener_node = opener.node_id
-          closer_node = closer.node_id
-          if @track_source
-            opener_match_start = @arena.source_end(opener_node) - strength
-            closer_match_end = @arena.source_start(closer_node) + strength
-          else
-            opener_match_start = -1
-            closer_match_end = 0
-          end
-          emphasis_id = add_arena_node(kind, opener_match_start, closer_match_end)
-          first_inside = @arena.raw_next_sibling_id(opener_node)
-          last_inside = @arena.raw_prev_sibling_id(closer_node)
-          if first_inside != -1 && last_inside != -1 &&
-             first_inside != closer_node && last_inside != opener_node
-            @arena.reparent(emphasis_id, first_inside, last_inside)
-          end
-          parent_id = @arena.raw_parent_id(opener_node)
-          @arena.insert_before(parent_id, closer_node, emphasis_id)
-          if opener.count == strength
-            @provisional_nodes.delete(opener_node)
-            @arena.detach(opener_node)
-            stack.delete_at(opener_idx)
-            closer_idx -= 1
-          else
-            opener.count -= strength
-            str = @arena.str1(opener_node)
-            @arena.update_str1(opener_node, str[0...-strength])
-            if @track_source
-              new_end = @arena.source_end(opener_node) - strength
-              @arena.update_span(opener_node, @arena.source_start(opener_node), new_end)
-            end
-          end
-          if closer.count == strength
-            @provisional_nodes.delete(closer_node)
-            @arena.detach(closer_node)
-            stack.delete_at(closer_idx)
-          else
-            closer.count -= strength
-            str = @arena.str1(closer_node)
-            @arena.update_str1(closer_node, str[strength..])
-            if @track_source
-              new_start = @arena.source_start(closer_node) + strength
-              new_end = @arena.source_end(closer_node)
-              @arena.update_span(closer_node, new_start, new_end)
-            end
-          end
-        end
-        stack.each { |e| @provisional_nodes.delete(e.node_id) }
-        stack.clear
-      end
     end
   end
 end