etassia 0.1.0

data/lib/etassia/parser/grammars/kanban.rb

@@ -0,0 +1,417 @@
+# frozen_string_literal: true
+
+require_relative "common"
+require_relative "../atoms/greedy_run"
+require_relative "../atoms/joined"
+
+module Etassia
+  module Parser
+    module Grammars
+      # Parslet grammar for Kanban diagrams
+      class Kanban < Common
+        rule(:diagram) do
+          space_run >>
+            header >>
+            content_line.repeat(0).as(:lines) >>
+            line_space_run
+        end
+
+        rule(:header) do
+          str("kanban") >> (newline | eof)
+        end
+
+        # Nothing but blank and comment lines up to the end of the source.
+        rule(:blank_lines_left) do
+          (newline >> blank_text_run.maybe >> line_space_run >> eof) | eof
+        end
+
+        # The lines that capture nothing, taken as ONE slice. Parslet folds a
+        # repetition of plain slices with `Slice#+`, which is quadratic, so
+        # every repetition of such lines goes through `Joined`. A line that
+        # captures (an item or a modifier) breaks the run and is never joined.
+        rule(:blank_run) do
+          Atoms::Joined.new(
+            (empty_line | comment_line | no_op_modifier_line).repeat(1),
+          )
+        end
+
+        # Only blank and comment lines: an empty `:::` is not one of them, and
+        # `empty_class_modifier` looks ahead through this rule.
+        rule(:blank_text_run) do
+          Atoms::Joined.new((empty_line | comment_line).repeat(1))
+        end
+
+        rule(:content_line) do
+          blank_run | modifier_line | item_line
+        end
+
+        rule(:empty_line) do
+          line_space_run >> newline
+        end
+
+        # Overrides Common's char-at-a-time `comment` with the bounded
+        # `GreedyRun` scan (see atoms/greedy_run.rb) so a long `%%` line
+        # cannot hang this grammar; `.maybe` covers the empty-body `%%` case,
+        # since GreedyRun itself errors on a zero-length match.
+        #
+        # The body stops at U+2028/U+2029, where mermaid's lexer `.*` stops.
+        # Carriage returns never reach the grammar: the parser turns them
+        # into line feeds first, as mermaid does.
+        rule(:comment) do
+          str("%%") >> Atoms::GreedyRun.new('[^\n\u2028\u2029]').maybe
+        end
+
+        # A line holding only a `%%` comment (corpus 032). Mermaid strips
+        # such a line, up to its line feed, before lexing - so unlike a
+        # trailing comment, its body runs through U+2028/U+2029 too. It
+        # captures nothing, the same way empty_line doesn't -
+        # Builders::Kanban's `rule(lines: subtree(:lines))` filters any
+        # non-Hash entry out of the lines array.
+        rule(:comment_line) do
+          line_space_run >> str("%%") >> str("{").absent? >>
+            Atoms::GreedyRun.new('[^\n]').maybe >> (newline | eof)
+        end
+
+        # How every item and modifier line ends: optional
+        # whitespace, an optional trailing `%%` comment, then the line
+        # break. After a closing delimiter (`]`, `)`, `}`) the comment needs
+        # no space (`root[Root]%% c`); after a bare id `%%` is part of the
+        # label, which `bare_item` refuses. Whitespace is mermaid's `\s`,
+        # not Common's ASCII `space`.
+        rule(:line_end) do
+          (hspace_run >> comment >> comment_end) |
+            (line_space_run >> (newline | eof))
+        end
+
+        # The comment body stops at U+2028/U+2029. Mermaid refuses one
+        # unless only blanks and comments follow it to the end of the input.
+        rule(:comment_end) do
+          newline | eof |
+            (line_sep >> line_space_run >>
+              (blank_lines_left | (comment_line_start >> blank_lines_left)))
+        end
+
+        rule(:comment_line_start) do
+          str("%%") >> str("{").absent? >>
+            Atoms::GreedyRun.new('[^\n]').maybe
+        end
+
+        rule(:item_line) do
+          Atoms::GreedyRun.new("[ ]", min: 0).as(:indent) >>
+            item >>
+            line_end
+        end
+
+        # An empty `::icon()` decorates nothing and may sit anywhere. An
+        # empty `:::` swallows its own line break in mermaid's lexer, so the
+        # next item would be joined onto it: it is accepted only when
+        # nothing but blank or comment lines follow (measured against mmdc
+        # 11.12.0).
+        rule(:no_op_modifier_line) do
+          space_run >>
+            ((icon_keyword >> str(")") >> line_end) | empty_class_modifier)
+        end
+
+        rule(:empty_class_modifier) do
+          str(":::") >> blank_lines_left.present?
+        end
+
+        # A standalone `::icon(...)` or `:::classes` line applies to the
+        # PREVIOUS item rather than declaring one of its own - mermaid's
+        # kanban shorthand for attaching an icon or classes without going
+        # through `@{ ... }` metadata. Mirrors mindmap.rb's
+        # `node_with_icon` / `node_with_class`, the existing precedent for
+        # this exact shorthand in this grammar family; `Builders::Kanban`
+        # applies it to the last item the same way mindmap's `TreeBuilder`
+        # applies it to the last node.
+        rule(:modifier_line) do
+          space_run.as(:indent) >> (icon_modifier | class_modifier) >> line_end
+        end
+
+        rule(:icon_keyword) do
+          str("::") >> match["iI"] >> match["cC"] >> match["oO"] >>
+            match["nN"] >> str("(")
+        end
+
+        rule(:icon_modifier) do
+          icon_keyword >>
+            Atoms::GreedyRun.new("[^)]").as(:icon) >>
+            str(")")
+        end
+
+        # The body stops where mermaid's `.+` does, at a line break or
+        # U+2028/U+2029; `%%` inside it is class text.
+        rule(:class_modifier) do
+          str(":::") >>
+            Atoms::GreedyRun.new('[^\n\u2028\u2029]').as(:classes)
+        end
+
+        # An item can be either a column or a card. The label is optional:
+        # mermaid accepts a bare id, with or without trailing metadata.
+        #
+        # Named alternation branches rather than folding the bracket label
+        # into one rule as a `.maybe`.
+        # `bare_item` is the most permissive branch and must stay last, or a
+        # later branch that also starts with an identifier would never be
+        # reached. `shaped_item` and `labelled_item` both require a specific
+        # delimiter (`(` or `[`) right after the id, so their relative order
+        # does not matter - Parslet fails one and tries the next without
+        # consuming input. `unlabelled_shaped_item` opens on `(`, something
+        # an identifier can never start with, so it stays reachable
+        # wherever it sits. Naming the branches keeps the order explicit
+        # rather than implied, which is how the other grammars in this
+        # directory are written - see `mindmap.rb`'s `node` rule.
+        rule(:item) do
+          reserved_token.absent? >>
+            (labelled_item | shaped_item | unlabelled_shaped_item |
+              bare_item) >>
+            metadata.maybe.as(:metadata)
+        end
+
+        # `kanban` is the diagram's own header token, and mermaid reserves it
+        # as a node name: it refuses `kanban`, `Kanban` and `KANBAN`, bare or
+        # carrying a bracket label, as a column or as a card. Only the whole
+        # word is taken - `kanbanBoard` and `mykanban` are legal ids. Measured
+        # against mmdc 11.12.0.
+        #
+        # No other keyword is reserved. The tokens checked are listed once,
+        # in the spec that pins them - see the 'reserves no other keyword'
+        # example in spec/etassia/parser/kanban_spec.rb.
+        rule(:reserved_token) do
+          kanban_keyword >> match["a-zA-Z0-9_"].absent?
+        end
+
+        # Parslet's `str` is case-sensitive and it offers no case-insensitive
+        # literal, so the keyword is spelled out character by character.
+        rule(:kanban_keyword) do
+          match["kK"] >> match["aA"] >> match["nN"] >>
+            match["bB"] >> match["aA"] >> match["nN"]
+        end
+
+        # Common's `identifier` repeats a one-character match, which Parslet
+        # folds with `Slice#+`: quadratic in the length of the id.
+        rule(:identifier) do
+          match["a-zA-Z_"] >> Atoms::GreedyRun.new("[a-zA-Z0-9_]", min: 0)
+        end
+
+        rule(:labelled_item) do
+          identifier.as(:id) >>
+            lbracket >>
+            labelled_item_text >>
+            rbracket
+        end
+
+        # Try the quoted form first: a quoted bracket label may contain `[`/`]`
+        # literally, so the unquoted fallback below (which stops at the first
+        # `]`) must not run against a quoted body. A markdown-string body
+        # (`"`text`"`) is refused in both alternatives, as `round_text` does:
+        # mermaid renders it as markdown and Etassia has no markdown renderer.
+        rule(:labelled_item_text) do
+          empty_quoted_fragments >>
+            ((str('"') >> markdown_string_body.absent? >>
+              Atoms::GreedyRun.new('[^"]').as(:text) >> str('"')) |
+              ((str('"') >> markdown_string_body).absent? >>
+                Atoms::GreedyRun.new('[^\]]').as(:text))) >>
+            empty_quoted_fragments
+        end
+
+        # mermaid's lexer drops an empty quoted fragment (`""` or an empty
+        # markdown string) beside the label text: `root[""a]` and
+        # `root["a"""]` are both `a`, while `root[""]` with no text-bearing
+        # fragment is refused.
+        rule(:empty_quoted_fragment) do
+          str('"``"') | str('""')
+        end
+
+        rule(:empty_quoted_fragments) do
+          Atoms::Joined.new(empty_quoted_fragment.repeat)
+        end
+
+        # Round shape with an id: id(text) - mermaid's rounded-node syntax,
+        # the same shorthand flowchart's `shape_rounded` parses. Etassia's
+        # kanban renderer always draws a rounded rect for every item
+        # regardless of source syntax (see Renderer::Kanban#render_column
+        # and #render_card), so the delimiter is parsed only to recover the
+        # label - no separate shape field is modeled, matching how the
+        # bracket label above works.
+        rule(:shaped_item) do
+          identifier.as(:id) >>
+            lparen >>
+            round_text >>
+            rparen
+        end
+
+        # Round shape with no id: (text). Mermaid auto-assigns an id here;
+        # BoardBuilder does too, deterministically - see
+        # Builders::Kanban::BoardBuilder#resolve_id.
+        rule(:unlabelled_shaped_item) do
+          lparen >>
+            round_text >>
+            rparen
+        end
+
+        # Text inside a round shape - id(text) or (text). A quoted body is
+        # tried first so it can contain an unescaped `)`, mermaid's own
+        # rule for `Todo (urgent)`, and the surrounding quotes are excluded
+        # from the capture rather than kept as literal characters - mermaid
+        # strips them too. Falls back to the plain, unquoted body when the
+        # first character isn't a `"`. Mirrors `square_shape` in
+        # mindmap.rb, the existing precedent for quoted content inside a
+        # bracketed shape in this grammar family.
+        #
+        # The unquoted body excludes `(`, `)`, `]` and `}` - mermaid's own
+        # lexer treats all four as node-shape delimiters even unquoted
+        # mid-label, and rejects a body carrying one (measured against mmdc
+        # 11.12.0). `[` and `{` are not delimiters to it there and stay
+        # literal, so they are not excluded - both parse in mermaid.
+        #
+        # A quoted body that itself opens and closes with a backtick -
+        # `"`text`"` - is mermaid's separate markdown-string syntax: it
+        # strips the backtick pair and renders the content through
+        # markdown, formatting included (`col("`Hi **urgent**`")` draws
+        # `Hi <strong>urgent</strong>` in mmdc 11.12.0). Etassia has no
+        # markdown renderer anywhere in the codebase, so matching this as
+        # an ordinary quoted body would keep the backticks as literal text
+        # and silently draw something mermaid does not. Refused instead,
+        # the same way an empty or unterminated quoted body is refused
+        # below, rather than half-supporting a shape nothing here
+        # understands.
+        rule(:round_text) do
+          empty_quoted_fragments >>
+            ((str('"') >> markdown_string_body.absent? >>
+              Atoms::GreedyRun.new('[^"]').as(:text) >> str('"')) |
+              (str('"').absent? >>
+                Atoms::GreedyRun.new('[^()\]}]').as(:text))) >>
+            empty_quoted_fragments
+        end
+
+        rule(:markdown_string_body) do
+          str("`") >> Atoms::GreedyRun.new('[^"`]', min: 0) >>
+            str("`") >> str('"')
+        end
+
+        # Deliberately just an identifier. Mermaid also accepts a bare label
+        # containing spaces, but widening this to free text would swallow
+        # `root(Root)` and `:::hot` as literal labels, turning unsupported
+        # constructs into silently wrong output instead of parse failures.
+        # `identifier` also refuses a leading digit, so `1col` fails to parse
+        # while `col1` and `_col` are accepted.
+        # Trailing `%%`, or trailing JavaScript whitespace beyond space and
+        # tab, is part of a bare id's literal label in mermaid, so it is
+        # refused here rather than dropped by `line_end`.
+        rule(:bare_item) do
+          identifier.as(:id) >>
+            (space_run >> (str("%%") | line_space)).absent?
+        end
+
+        LINE_SPACE_CHARS = '\t\v\f\x20\u00A0\u1680' \
+                           '\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF'
+        HSPACE_CHARS = '\t\v\f\x20\u00A0\u1680' \
+                       '\u2000-\u200A\u202F\u205F\u3000\uFEFF'
+        private_constant :LINE_SPACE_CHARS, :HSPACE_CHARS
+
+        rule(:line_space) { match[LINE_SPACE_CHARS] }
+        rule(:line_sep) { match['\u2028\u2029'] }
+
+        # Whitespace runs go through `GreedyRun`: Parslet's own
+        # `line_space.repeat` is quadratic in the length of the run.
+        rule(:line_space_run) do
+          Atoms::GreedyRun.new("[#{LINE_SPACE_CHARS}]", min: 0)
+        end
+
+        rule(:space_run) { Atoms::GreedyRun.new("[ \\t]", min: 0) }
+
+        rule(:hspace_run) do
+          Atoms::GreedyRun.new("[#{HSPACE_CHARS}]", min: 0)
+        end
+
+        # Metadata: @{ key: 'value', key2: 'value2' } - or newline-separated
+        # with no commas (corpus 038). The body is captured RAW, as
+        # `flowchart.rb`'s `node_metadata` does, and handed to a YAML engine
+        # in the builder (`MetadataYaml`): a grammar rule cannot express
+        # "block vs flow, decided by whether a newline appears ANYWHERE in
+        # the body" without reimplementing a YAML lexer.
+        #
+        # `metadata_entries` is the grammar seam: its default is that raw
+        # capture, and a subclass that overrides it controls the tree
+        # `metadata` holds. The builder reads only `:body` from it, so an
+        # override that drops `:body` gives the item no metadata.
+        rule(:metadata) do
+          str("@") >> space_run >> lbrace >> metadata_entries >> rbrace
+        end
+
+        # An unmatched `"` is not body text - mermaid's lexer stays in its
+        # string state to the end of the block and refuses the source.
+        # A caret is not body text either: mermaid takes the run between
+        # the braces with `[^}^"]+`, so a `^` outside a quoted value ends
+        # the block early.
+        rule(:metadata_body) do
+          Atoms::Joined.new(
+            (Atoms::GreedyRun.new('[^"}^\n]') | blank_line_run |
+              metadata_comment_line | metadata_quoted | newline).repeat,
+          )
+        end
+
+        # Every line break that another one follows; the last stays for
+        # `metadata_comment_line`, which opens on a line break.
+        rule(:blank_line_run) do
+          Atoms::GreedyRun.new('\r?\n(?=\r?\n)')
+        end
+
+        # Mermaid strips comment lines before the metadata lexer sees them.
+        rule(:metadata_comment_line) do
+          newline >> line_space_run >> str("%%") >> str("{").absent? >>
+            Atoms::GreedyRun.new('[^\r\n]')
+        end
+
+        # A double-quoted run is skipped whole so a brace inside it is text,
+        # mirroring flowchart.rb's `metadata_quoted`. A comment line inside
+        # it is still a comment: mermaid strips those before lexing.
+        rule(:metadata_quoted) do
+          str('"') >>
+            (metadata_comment_line | Atoms::GreedyRun.new('[^"\n]') |
+              newline).repeat >>
+            str('"')
+        end
+
+        # The next 5 rules are public methods released in etassia 0.1.0: do
+        # not delete or rename them outside a major version. Only
+        # `metadata_entries` is on the parse path; the other four are
+        # building blocks a subclass may use inside its own override.
+        rule(:metadata_entries) do
+          metadata_body.as(:body)
+        end
+
+        rule(:metadata_entry) do
+          metadata_key.as(:key) >>
+            space_run >>
+            colon >>
+            space_run >>
+            metadata_value.as(:value)
+        end
+
+        rule(:metadata_key) do
+          match["a-zA-Z_"] >> Atoms::GreedyRun.new("[a-zA-Z0-9_]", min: 0)
+        end
+
+        rule(:metadata_value) do
+          quoted_string | single_quoted_string | unquoted_value
+        end
+
+        # Captured as :unquoted, not :string, so an override of
+        # `metadata_entries` can tell an unquoted scalar from a quoted one.
+        #
+        # `.`, `+` and `~` are in the set because js-yaml reads them and
+        # mermaid draws them: `0.0`, `+0`, `~` and `.nan` are values it
+        # resolves falsy, and `1.5` and `+7` values it keeps. Without them
+        # the whole line failed to parse. None of the three ends a value -
+        # a comma or a closing brace does - so the rule stays unambiguous.
+        rule(:unquoted_value) do
+          Atoms::GreedyRun.new('[a-zA-Z0-9_\-.+~]').as(:unquoted)
+        end
+
+        root(:diagram)
+      end
+    end
+  end
+end

data/lib/etassia/parser/grammars/mermaid_unicode_text.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Parser
+    module Grammars
+      # The characters mermaid lexes as UNICODE_TEXT — the letters a
+      # flowchart id may hold outside ASCII.
+      #
+      # Copied from the flowchart lexer in mmdc 11.12.0, the pinned
+      # oracle, where it is a table frozen at Unicode 6.1. It is one
+      # character class body, ready to hand to `match[]`. The source
+      # spells it as 61 alternated classes; they are flattened into one
+      # here and nothing else is changed. To regenerate against a newer
+      # mmdc, read mermaid/dist/mermaid.js, find the regexp literal
+      # holding \u00AA, and flatten its alternatives the same way.
+      #
+      # Ruby's \p{L} is not a stand-in for it. Comparing the two over
+      # the BMP, \p{L} takes hundreds of codepoints this table does not —
+      # `ࢳ` arrived in Unicode 8 and `ᲀ` in Unicode 9 — and refuses 2
+      # that it does, U+1885 and U+1886. The count moves with Ruby's
+      # Unicode version; those two exceptions do not.
+      MERMAID_UNICODE_TEXT =
+        '\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1' \
+        '\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376' \
+        '\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1' \
+        '\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559' \
+        '\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E' \
+        '\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF' \
+        '\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1' \
+        '\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824' \
+        '\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D' \
+        '\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C' \
+        '\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9' \
+        '\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1' \
+        '\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32' \
+        '\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E' \
+        '\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8' \
+        '\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0' \
+        '\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30' \
+        '\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61' \
+        '\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99' \
+        '\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA' \
+        '\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28' \
+        '\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61' \
+        '\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3' \
+        '\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2' \
+        '\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60' \
+        '\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB' \
+        '\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46' \
+        '\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97' \
+        '\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB' \
+        '\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6' \
+        '\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C' \
+        '\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065' \
+        '\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7' \
+        '\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256' \
+        '\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0' \
+        '\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6' \
+        '\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F' \
+        '\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A' \
+        '\u16A0-\u16EA\u1700-\u170C\u170E-\u1711\u1720-\u1731' \
+        '\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7' \
+        '\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5' \
+        '\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB' \
+        '\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33' \
+        '\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5' \
+        '\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC' \
+        '\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15' \
+        '\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59' \
+        '\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE' \
+        '\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB' \
+        '\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F' \
+        '\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D' \
+        '\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F' \
+        '\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E' \
+        '\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27' \
+        '\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6' \
+        '\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6' \
+        '\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006' \
+        '\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F' \
+        '\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E' \
+        '\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC' \
+        '\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A' \
+        '\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F' \
+        '\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA' \
+        '\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822' \
+        '\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925' \
+        '\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28' \
+        '\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF' \
+        '\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD' \
+        '\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E' \
+        '\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2' \
+        '\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D' \
+        '\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28' \
+        '\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44' \
+        '\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7' \
+        '\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A' \
+        '\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF' \
+        '\uFFD2-\uFFD7\uFFDA-\uFFDC'
+
+      # Read unqualified from `Grammars::Flowchart`, which this module
+      # lexically encloses, so marking it private costs that reader
+      # nothing. `mermaid_shapes.rb:104` does the same with its own
+      # mmdc-derived table.
+      private_constant :MERMAID_UNICODE_TEXT
+    end
+  end
+end