red_quilt 0.7.0 → 0.7.2

data/docs/commonmark-conformance.md

@@ -0,0 +1,316 @@
+# RedQuilt CommonMark Conformance
+
+## 1. Scope of this document
+
+This document describes how RedQuilt differs from the CommonMark / GFM spec.
+For behavior that follows the spec, refer directly to the spec documents
+(<https://spec.commonmark.org/0.31.2/>, <https://github.github.com/gfm/>); this
+document does not repeat them.
+
+#### What this document covers
+
+- Places where the implementation **narrows** what the spec allows (interpreting
+  or tightening ambiguous areas).
+- Features outside the spec (security, diagnostics, option flags).
+- The extensions that are **enabled** (GFM, etc.) and their opt-in conditions.
+- Unsupported features and known limitations.
+
+#### What this document does not cover
+
+- Descriptions of standard behavior that matches the spec.
+- Design background or data structure choices.
+
+### 1.1 Target versions
+
+- CommonMark: 0.31.2
+- GitHub Flavored Markdown: 0.29-gfm
+
+### 1.2 Implementation assumptions
+
+- Input is a UTF-8 string. Preprocessing such as `force_encoding(Encoding::UTF_8)`
+  is the caller's responsibility.
+- The normalization required by spec §2.3 / §2.4 (NUL -> U+FFFD,
+  `\r\n` / `\r` -> `\n`) and limiting the blank-line definition to space/tab are
+  all implemented. These follow the spec, so this document does not list them
+  individually.
+
+### 1.3 Format of each item
+
+```
+### N.N <Title>
+
+**Spec**: the relevant section and the spec rule (or ambiguity)
+**RedQuilt behavior**: how the implementation behaves / where it narrows or extends
+**Implementation**: file:line / main symbols
+**Test**: spec file / example number
+```
+
+## 2. Points where the spec is tightened
+
+Where the spec wording allows more than one interpretation, or where a "must" is
+left ambiguous, the implementation chooses the stricter side.
+
+### 2.1 URI autolink rejects U+007F (DEL)
+
+**Spec**: §6.5 — a URI autolink does not contain "ASCII control characters,
+space, `<`, `>`". Whether the range of "ASCII control characters" is only
+U+0000–U+001F or also includes U+007F is not stated.
+
+**RedQuilt behavior**: also rejects U+007F.
+
+**Implementation**: `lib/red_quilt/inline/lexer.rb` — `URI_AUTOLINK_RE`
+
+**Test**: `spec/whitespace_strictness_spec.rb` — "URI autolink (CommonMark 6.5)"
+
+### 2.2 Raw HTML tag separators limited to space/tab/CR/LF
+
+**Spec**: §6.6 — defines the separators between attributes and around `=` as
+"whitespace". In the spec's terminology (§2.1), the "whitespace" set is broad and
+includes space / tab / newline / line tabulation (U+000B) / form feed (U+000C) /
+carriage return.
+
+**RedQuilt behavior**: within the tag grammar, only `[ \t\r\n]` is allowed as a
+separator. FF (U+000C) / VT (U+000B) are not included. The same constraint
+applies to inline raw HTML and to HTML block types 1 / 6 / 7.
+
+**Implementation**:
+- Inline: `lib/red_quilt/inline/lexer.rb` — `HTML_OPEN_TAG_RE` /
+  `HTML_CLOSING_TAG_RE`
+- Block: `lib/red_quilt/block_parser.rb` — `HTML_TYPE_7_OPEN_TAG_RE` /
+  `HTML_TYPE_7_CLOSING_TAG_RE` / `HTML_BLOCK_TYPE_6_RE` / type 1 regex
+
+**Test**: `spec/whitespace_strictness_spec.rb` — "raw HTML tag whitespace
+(CommonMark 6.6)"
+
+### 2.3 Inline link tail separators limited to space/tab/at most 1 LF
+
+**Spec**: §6.3 — the link tail (inside `(dest "title")`) is separated by "spaces,
+tabs, and up to one line ending". FF / VT are not mentioned.
+
+**RedQuilt behavior**: within the link tail, only space / tab are separators, and
+a line ending is counted separately, up to one. If FF / VT appears, it does not
+form a link (it is treated as normal paragraph text).
+
+**Implementation**: `lib/red_quilt/inline/link_scanner.rb` —
+`link_tail_whitespace_byte?`, `skip_link_whitespace`, `inline_link`,
+`parse_link_title`
+
+**Test**: `spec/whitespace_strictness_spec.rb` — "inline link tail whitespace
+(CommonMark 6.3)"
+
+### 2.4 Reference definition raw destination validated the same as inline links
+
+**Spec**: §6.3 — the raw form of a link destination is "a nonempty sequence of
+characters that does not start with `<`, does not include ASCII control
+characters or space character, and includes parentheses only if (a) they are
+backslash-escaped or (b) they are part of a balanced pair of unescaped
+parentheses".
+
+**RedQuilt behavior**: validates all of the above for the raw destination of a
+reference definition too. Specifically, it rejects ASCII control
+(U+0000–U+001F) / U+007F (DEL) / space, and tracks the depth of unescaped
+parens, invalidating the definition if they are unbalanced.
+
+**Past behavior**: it accepted destinations with a simple `/\A(\S+)(.*)\z/`, so
+`[x]: foo(bar` or `[x]: foo\bbar` were also accepted as definitions.
+
+**Implementation**: `lib/red_quilt/reference_definition.rb` —
+`parse_raw_destination`, `RAW_DEST_FORBIDDEN_RE`
+
+**Test**: `spec/link_validation_spec.rb` — "reference definition raw destination
+validation"
+
+### 2.5 Apply the 999-character link label limit on all paths
+
+**Spec**: §6.3 — "A link label can have at most 999 characters inside the square
+brackets."
+
+**RedQuilt behavior**: rejects more than 999 characters on both the reference
+definition side and the reference link usage side (shortcut / collapsed / full,
+all of them).
+
+**Implementation**:
+- Constant: `lib/red_quilt/reference_definition.rb` —
+  `LABEL_MAX_LENGTH = 999`, the `label_too_long?` helper
+- Definition side: `match_label` (decides for both single-line and multi-line)
+- Usage side: `lib/red_quilt/inline/builder.rb` — `try_reference_link`,
+  `lib/red_quilt/inline/link_scanner.rb` — `reference_label`
+
+**Test**: `spec/link_validation_spec.rb` — "link label length limit (999
+characters)"
+
+### 2.6 NCR digit limits and U+FFFD replacement of invalid codepoints
+
+**Spec**: §6.4 — a decimal NCR is 1–7 digits, a hex NCR is 1–6 digits. If the
+decode result is U+0000, a surrogate (U+D800–U+DFFF), or out of the Unicode range
+(> U+10FFFF), it is replaced with U+FFFD.
+
+**RedQuilt behavior**: implements all of the above.
+
+**Past behavior**: it delegated to `CGI.unescapeHTML`, so an 8-digit decimal like
+`&#00000065;` or a surrogate like `&#xD800;` would each decode to "A" or raise a
+`RangeError`.
+
+**Implementation**: `lib/red_quilt/inline/html_entities.rb` —
+`Inline.decode_entity`, `Inline::ENTITY_RE`, `decode_numeric_codepoint`. The
+`SURROGATE_RANGE` and `MAX_UNICODE_CODEPOINT` constants.
+
+**Test**: `spec/numeric_character_reference_spec.rb`
+
+### 2.7 GFM table header / delimiter cell-count match requirement
+
+**Spec (GFM §4.10)**: "The header row must match the delimiter row in the number
+of cells. If not, a table will not be recognized."
+
+**RedQuilt behavior**: if the cell count of the header and the delimiter do not
+match, it is not recognized as a table and is treated as a paragraph.
+
+**Implementation**: `lib/red_quilt/block_parser.rb` — `table_start?`
+
+**Test**: `spec/red_quilt_spec.rb` — "table separator validation (GFM spec)"
+
+### 2.8 GFM extended autolink domain underscore constraint
+
+**Spec (GFM §6.9)**: "If the domain name contains an underscore (`_`) in its last
+two segments, it is invalid."
+
+**RedQuilt behavior**: when extended autolinks are enabled, a URL / email whose
+domain has `_` in its last two segments is not linkified.
+
+**Implementation**: `lib/red_quilt/extended_autolink_pass.rb` — `valid_domain?` /
+`extract_domain`
+
+**Test**: `spec/extended_autolink_spec.rb` — "domain validation (GFM spec)"
+
+## 3. Features outside the spec
+
+Features not defined in the spec that RedQuilt provides for safety and
+convenience.
+
+### 3.1 Sanitizing unsafe URL schemes
+
+**RedQuilt behavior**: if the scheme of a link / image destination is not in the
+safe list below, it outputs `href` / `src` as an empty string. At the same time
+it emits an `:unsafe_url` diagnostic as a warning. For CommonMark autolinks
+(`<scheme:...>`), to stay spec-conformant, a denylist is used instead of a safe
+list, and only schemes that could lead to script execution get an empty href.
+
+**Safe schemes**: `http`, `https`, `mailto`, `ftp`, `tel`, `ssh`
+
+**Schemes blocked in autolinks**: `javascript`, `vbscript`, `data`
+
+**Implementation**: `lib/red_quilt/inline/builder.rb` — `SAFE_SCHEMES`,
+`UNSAFE_AUTOLINK_SCHEMES`, `sanitize_destination`, `block_unsafe_autolink`
+
+**Test**: `spec/red_quilt_spec.rb` — "sanitizes unsafe URL schemes"
+
+### 3.2 Diagnostics
+
+**RedQuilt behavior**: suspicious syntax, missing references, and potential
+security events detected during parse / render are accumulated in
+`Document#diagnostics` as `RedQuilt::Diagnostic` objects. Processing is never
+interrupted (a tree and HTML are always returned).
+
+**Rules currently emitted**:
+
+| Rule | Severity | Description |
+|---|---|---|
+| `:missing_reference` | warning | A full reference link `[text][ref]` has no definition. |
+| `:duplicate_reference` | warning | There were multiple reference definitions with the same label (the first one is used). |
+| `:duplicate_footnote` | warning | There were multiple footnote definitions with the same label (the first one is used; only when `footnotes: true`). |
+| `:unsafe_url` | warning | An unsafe URL was replaced with an empty `href` / `src`. |
+| `:empty_link` | warning | The link destination is empty (only when `lint: true`). |
+| `:missing_alt` | info | An image's alt text is empty (only when `lint: true`). |
+| `:heading_level_skip` | info | A heading level jumped by more than one (only when `lint: true`). |
+
+**Implementation**: `lib/red_quilt/diagnostic.rb` (value object),
+`lib/red_quilt/block_parser.rb` (duplicate reference),
+`lib/red_quilt/footnote_definition.rb` (duplicate footnote),
+`lib/red_quilt/inline/builder.rb` (missing / unsafe),
+`lib/red_quilt/lint_pass.rb` (lint rules)
+
+### 3.3 `allow_html` / `disallow_raw_html` flags
+
+**RedQuilt behavior**:
+
+| Flag | Default | Effect |
+|---|---|---|
+| `allow_html` | `false` | When false, raw HTML is fully escaped (turned into `&lt;`). When true, HTML blocks and inline raw HTML are output as-is. |
+| `disallow_raw_html` | `false` | The GFM "Disallowed Raw HTML" extension, enabled under `allow_html: true`. It rewrites `<` to `&lt;` for the specified tags. |
+
+The disallowed tag set defined by GFM: `title`, `textarea`, `style`, `xmp`,
+`iframe`, `noembed`, `noframes`, `script`, `plaintext`
+
+**Implementation**: `lib/red_quilt/document.rb` — `allow_html?` /
+`disallow_raw_html?`
+**Implementation (filter)**: `lib/red_quilt/renderer/html.rb` —
+`DISALLOWED_RAW_TAGS` / `DISALLOWED_RAW_TAG_RE` / `filter_disallowed_raw`
+
+## 4. Enabled extensions
+
+### 4.1 GFM Table
+
+Always enabled. In addition to the spec, the column-count match requirement from
+2.7 is applied.
+
+**Implementation**: `lib/red_quilt/block_parser.rb` — `table_start?` /
+`parse_table`
+
+### 4.2 GFM Strikethrough
+
+Always enabled. Only the double tilde `~~text~~` is supported (matching GFM
+behavior). A single tilde `~text~` is treated as normal text.
+
+**Implementation**: `lib/red_quilt/inline/lexer.rb` (handling of `~` in
+`SPECIAL_BYTES` and `scan_delim_run`), `lib/red_quilt/inline/builder.rb`
+(generating `STRIKETHROUGH` in `process_emphasis`)
+
+### 4.3 GFM Disallowed Raw HTML
+
+Opt-in. It only works when `allow_html: true, disallow_raw_html: true` are used
+together (under `allow_html: false` all HTML is escaped, so it has no effect).
+See 3.3 for details.
+
+### 4.4 GFM Extended Autolink
+
+Opt-in. Specifying `extended_autolinks: true` runs `ExtendedAutolinkPass` as a
+pass that linkifies bare URLs / emails / `www.`-prefixed strings that are not
+wrapped in `<...>`.
+
+**Additional constraint**: implements the domain underscore check from 2.8.
+
+**Implementation**: `lib/red_quilt/extended_autolink_pass.rb`
+
+### 4.5 GFM Footnotes
+
+Opt-in. Specifying `footnotes: true` removes `[^label]: ...` definitions from the
+body flow and converts `[^label]` references into sup links. Only the referenced
+definitions are kept, ordered by first reference, and output as a
+`FOOTNOTES_SECTION` at the end of the root. Unreferenced definitions are not
+output.
+
+**Implementation**: `lib/red_quilt/footnote_definition.rb`,
+`lib/red_quilt/footnote_registry.rb`, `lib/red_quilt/footnote_pass.rb`
+
+## 5. Unsupported / known limitations
+
+- GFM Task List Items (`- [ ]` / `- [x]`) are not supported. They are parsed as
+  normal list items.
+
+## 6. Correspondence with tests
+
+This section collects the spec files that verify the difference items.
+
+| Aspect | Spec file |
+|---|---|
+| Passing the official CommonMark examples | `spec/commonmark_compat_spec.rb` |
+| Input normalization (line endings / NUL / blank line) | `spec/input_normalization_spec.rb` |
+| Whitespace strictness (autolink / raw HTML / link tail) | `spec/whitespace_strictness_spec.rb` |
+| Link / reference validation (label cap / raw dest) | `spec/link_validation_spec.rb` |
+| NCR digit limits and invalid codepoints | `spec/numeric_character_reference_spec.rb` |
+| GFM table column-count match | `spec/red_quilt_spec.rb` — "table separator validation" |
+| GFM extended autolink domain validation | `spec/extended_autolink_spec.rb` |
+| GFM footnotes | `spec/footnotes_spec.rb` |
+| URL scheme sanitization | `spec/red_quilt_spec.rb` — "sanitizes unsafe URL schemes" |
+| Diagnostics / lint diagnostics | `spec/diagnostic_spec.rb` |
+| Disallowed Raw HTML | `spec/red_quilt_spec.rb` — disallow_raw_html cases |

data/lib/red_quilt/browser_launcher.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module RedQuilt
+  # Opens a local HTML file in the OS default browser when `--open` is set.
+  # Best-effort: unsupported platforms or spawn failures are logged but
+  # never abort the CLI.
+  class BrowserLauncher
+    def initialize(err:)
+      @err = err
+    end
+
+    def launch(path)
+      command = platform_command
+      unless command
+        @err.puts "redquilt: --open is not supported on this platform; skipping."
+        return
+      end
+
+      pid = Process.spawn(*command, path, in: :close, out: File::NULL, err: File::NULL)
+      Process.detach(pid)
+    rescue StandardError => e
+      @err.puts "redquilt: failed to open browser: #{e.message}"
+    end
+
+    private
+
+    def platform_command
+      case RbConfig::CONFIG["host_os"]
+      when /darwin/ then ["open"]
+      when /linux|bsd/ then ["xdg-open"]
+      when /mswin|mingw|cygwin/ then ["cmd.exe", "/c", "start", ""]
+      end
+    end
+  end
+end

data/lib/red_quilt/cli.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "optparse"
+require "tmpdir"
 require "red_quilt"
+require "red_quilt/browser_launcher"
 
 module RedQuilt
   # Entry point for the `redquilt` executable. Defined as a module-level
@@ -34,6 +36,9 @@ module RedQuilt
       lang: "en",
       css: nil,
       theme: :default,
+      output: nil,
+      open: false,
+      mermaid: false,
     }.freeze
 
     THEMES = %i[none default].freeze
@@ -44,6 +49,13 @@ module RedQuilt
       options = parse_options(argv, stderr: stderr)
       return options if options.is_a?(Integer)
 
+      if options[:open] && options[:format] != :html
+        stderr.puts "redquilt: --open requires --format html"
+        return 1
+      end
+      options[:standalone] = true if options[:open]
+
+      source_path = argv.first
       source = read_source(argv, stdin: stdin, stderr: stderr)
       return 1 unless source
 
@@ -54,15 +66,7 @@ module RedQuilt
                            lint: options[:lint])
 
       unless options[:diagnostics_only]
-        case options[:format]
-        when :html
-          stdout.write(render_html(doc, options))
-        when :ast
-          require "pp"
-          PP.pp(doc.to_ast, stdout)
-        when :json
-          stdout.puts doc.to_json
-        end
+        emit_output(doc, options, source_path: source_path, stdout: stdout, stderr: stderr)
       end
 
       if options[:diagnostics] || options[:diagnostics_only]
@@ -72,6 +76,35 @@ module RedQuilt
       doc.diagnostics.any? { |d| d.severity == :error } ? 1 : 0
     end
 
+    def self.emit_output(doc, options, source_path:, stdout:, stderr:)
+      destination = output_destination(options, source_path)
+
+      case options[:format]
+      when :html
+        html = render_html(doc, options)
+        if destination
+          File.write(destination, html)
+        else
+          stdout.write(html)
+        end
+      when :ast
+        require "pp"
+        PP.pp(doc.to_ast, stdout)
+      when :json
+        stdout.puts doc.to_json
+      end
+
+      BrowserLauncher.new(err: stderr).launch(destination) if options[:open] && destination
+    end
+
+    def self.output_destination(options, source_path)
+      return options[:output] if options[:output]
+      return nil unless options[:open]
+
+      base = source_path ? File.basename(source_path, ".*") : "stdin"
+      File.join(Dir.tmpdir, "redquilt-#{base}.html")
+    end
+
     def self.parse_options(argv, stderr:)
       options = DEFAULTS.dup
       parser = OptionParser.new do |opts|
@@ -115,6 +148,17 @@ module RedQuilt
                 "Embedded stylesheet: default (the default) or none (bare HTML)") do |t|
           options[:theme] = t
         end
+        opts.on("-o", "--output FILE", "Write HTML to FILE instead of stdout") do |f|
+          options[:output] = f
+        end
+        opts.on("--open",
+                "Write HTML to a file and open it in the default browser (forces --standalone)") do
+          options[:open] = true
+        end
+        opts.on("--mermaid",
+                "Render `mermaid` code blocks as diagrams (loads mermaid.js from a CDN in standalone output)") do
+          options[:mermaid] = true
+        end
         opts.on("--diagnostics", "Also print diagnostics to stderr") do
           options[:diagnostics] = true
         end
@@ -167,6 +211,7 @@ module RedQuilt
         lang: options[:lang],
         css: options[:css],
         theme: options[:theme],
+        mermaid: options[:mermaid],
       )
     end
 

data/lib/red_quilt/document.rb

@@ -47,11 +47,15 @@ module RedQuilt
     #   (an external stylesheet link) is independent and may be combined.
     # heading_ids: when true, every heading gets a slugified `id` (Unicode
     #   preserving, deduplicated within the document) for anchor links.
-    def to_html(standalone: false, title: nil, lang: "en", css: nil, theme: :none, heading_ids: false)
-      body = Renderer::HTML.new(self, heading_ids: heading_ids).render
+    # mermaid: when true, fenced code blocks tagged `mermaid` render as
+    #   `<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)
+      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))
+      wrap_standalone_html(body, title: title.to_s, lang: lang.to_s, css: css, theme: Theme.css(theme), mermaid: mermaid)
     end
 
     def to_ast
@@ -87,7 +91,68 @@ module RedQuilt
 
     private
 
-    def wrap_standalone_html(body, title:, lang:, css:, theme:)
+    # 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
+    # each diagram interactive with svg-pan-zoom (also from a CDN): mouse
+    # wheel zooms, drag pans, and a small control panel offers +/-/reset.
+    MERMAID_SCRIPT = <<~HTML
+      <style>
+      .rq-mermaid-pz {
+        /* Break out of the body's max-width column so the viewport isn't a
+           narrow peephole: span most of the viewport width, centered. */
+        width: 80vw;
+        margin-left: calc(50% - 40vw);
+        height: 80vh;
+        border: 1px solid #d0d7de;
+        border-radius: 6px;
+        overflow: hidden;
+      }
+      .rq-mermaid-pz svg {
+        width: 100%;
+        height: 100%;
+        max-width: none;
+        display: block;
+        cursor: grab;
+      }
+      @media (prefers-color-scheme: dark) {
+        .rq-mermaid-pz { border-color: #30363d; }
+      }
+      </style>
+      <script type="module">
+      import mermaid from "https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.esm.min.mjs";
+      import svgPanZoom from "https://cdn.jsdelivr.net/npm/svg-pan-zoom@3.6.1/+esm";
+      mermaid.initialize({ startOnLoad: false });
+      await mermaid.run();
+
+      for (const pre of document.querySelectorAll("pre.mermaid")) {
+        const svg = pre.querySelector("svg");
+        if (!svg) continue;
+        // Drop mermaid's inline max-width and let the SVG fill a sized box so
+        // svg-pan-zoom has room to zoom/pan. The whole viewBox scales as one,
+        // so every element stays aligned.
+        svg.removeAttribute("style");
+        svg.setAttribute("width", "100%");
+        svg.setAttribute("height", "100%");
+        const box = document.createElement("div");
+        box.className = "rq-mermaid-pz";
+        pre.replaceWith(box);
+        box.appendChild(svg);
+        svgPanZoom(svg, {
+          zoomEnabled: true,
+          controlIconsEnabled: true,
+          fit: true,
+          center: true,
+          zoomScaleSensitivity: 0.3,
+          minZoom: 0.2,
+          maxZoom: 20,
+        });
+      }
+      </script>
+    HTML
+    private_constant :MERMAID_SCRIPT
+
+    def wrap_standalone_html(body, title:, lang:, css:, theme:, mermaid: false)
       out = +"<!DOCTYPE html>\n"
       out << %(<html lang="#{html_escape_attr(lang)}">\n)
       out << "<head>\n"
@@ -97,6 +162,7 @@ module RedQuilt
       out << "<style>\n#{theme}</style>\n" if theme
       out << "</head>\n<body>\n"
       out << body
+      out << MERMAID_SCRIPT if mermaid
       out << "</body>\n</html>\n"
       out
     end

data/lib/red_quilt/renderer/html.rb

@@ -3,11 +3,12 @@
 module RedQuilt
   module Renderer
     class HTML
-      def initialize(document, heading_ids: false)
+      def initialize(document, heading_ids: false, mermaid: false)
         @document = document
         @arena = document.arena
         @out = +""
         @slugger = Slug::Counter.new if heading_ids
+        @mermaid = mermaid
       end
 
       def render
@@ -73,12 +74,21 @@ module RedQuilt
           render_list_item(node_id)
           @out << "</li>\n"
         when NodeType::CODE_BLOCK
-          @out << "<pre><code"
           info_word = @arena.str2(node_id).to_s.split.first.to_s
-          @out << %( class="language-#{escape_html(info_word)}") unless info_word.empty?
-          @out << ">"
-          @out << escape_html(@arena.text(node_id).to_s)
-          @out << "</code></pre>\n"
+          if @mermaid && info_word == "mermaid"
+            # Emit a container mermaid.js recognizes via class="mermaid".
+            # The diagram source is still HTML-escaped; the browser decodes
+            # the entities back into textContent, which is what mermaid reads.
+            @out << %(<pre class="mermaid">)
+            @out << escape_html(@arena.text(node_id).to_s)
+            @out << "</pre>\n"
+          else
+            @out << "<pre><code"
+            @out << %( class="language-#{escape_html(info_word)}") unless info_word.empty?
+            @out << ">"
+            @out << escape_html(@arena.text(node_id).to_s)
+            @out << "</code></pre>\n"
+          end
         when NodeType::HTML_BLOCK
           render_raw_html(@arena.text(node_id).to_s, block: true)
         when NodeType::TABLE

data/lib/red_quilt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RedQuilt
-  VERSION = "0.7.0"
+  VERSION = "0.7.2"
 end

data/lib/red_quilt.rb

@@ -57,13 +57,13 @@ module RedQuilt
       document
     end
 
-    def render_html(source, allow_html: false, disallow_raw_html: false, extended_autolinks: false, footnotes: false, lint: false, heading_ids: false)
+    def render_html(source, allow_html: false, disallow_raw_html: false, extended_autolinks: false, footnotes: false, lint: false, heading_ids: false, mermaid: false)
       parse(source,
             allow_html: allow_html,
             disallow_raw_html: disallow_raw_html,
             extended_autolinks: extended_autolinks,
             footnotes: footnotes,
-            lint: lint).to_html(heading_ids: heading_ids)
+            lint: lint).to_html(heading_ids: heading_ids, mermaid: mermaid)
     end
 
     private

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: red_quilt
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.2
 platform: ruby
 authors:
 - takahashim
 bindir: exe
 cert_chain: []
-date: 2026-05-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A modern Markdown document processor in pure Ruby, with an arena-style
   AST and full CommonMark spec test suite compliance.
@@ -26,13 +26,17 @@ files:
 - Rakefile
 - docs/api.md
 - docs/architecture.ja.md
+- docs/architecture.md
 - docs/arena-usage.ja.md
+- docs/arena-usage.md
 - docs/commonmark-conformance.ja.md
+- docs/commonmark-conformance.md
 - exe/redquilt
 - lib/red_quilt.rb
 - lib/red_quilt/arena.rb
 - lib/red_quilt/block_parser.rb
 - lib/red_quilt/blockquote.rb
+- lib/red_quilt/browser_launcher.rb
 - lib/red_quilt/cli.rb
 - lib/red_quilt/diagnostic.rb
 - lib/red_quilt/document.rb
@@ -90,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: CommonMark-based Markdown processor written in pure Ruby
 test_files: []