tessella 0.3.0

data/lib/tessella/table_cells.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Tessella
+    module Table
+        # Cells as lines (DESIGN.md, "Diagram modules"): a cell's "\n"
+        # splits it into lines within its row, and every cell of a row
+        # is padded with empty lines to the row's tallest, top-aligned.
+        module Cells
+            def self.lines(cell)
+                lines = Table.sanitize(cell.to_s).split("\n", -1)
+                lines.empty? ? [""] : lines
+            end
+
+            def self.grid(rows) = rows.map { |row| row.map { lines(it) } }
+
+            def self.multiline?(grid) = grid.any? { |r| r.any? { it.size > 1 } }
+
+            def self.width(cell_lines) = cell_lines.map { Width.of(it) }.max
+
+            # A title: one line, tabs as blanks.
+            def self.title_text(title)
+                title && Table.sanitize(Compose.text!("title", title, false))
+            end
+
+            # A markdown cell: tabs as blanks, a | escaped, as a GFM pipe
+            # table needs.
+            def self.md_cell(text) = Table.sanitize(text).gsub("|", "\\|")
+
+            # One row of cells (each an Array of lines) as Arrays of
+            # line strings, one Array per output line.
+            def self.rows_of(row)
+                height = row.map(&:size).max
+                (0...height).map { |i| row.map { it[i] || "" } }
+            end
+
+            BOLD = "\e[1m"
+            RESET = "\e[0m"
+
+            def self.bold(cell_lines)
+                cell_lines.map { it.empty? ? it : "#{BOLD}#{it}#{RESET}" }
+            end
+
+            # The header row in bold when colour is on.
+            def self.header(row, color)
+                color && row ? row.map { bold(it) } : row
+            end
+
+            def self.column_widths(grid)
+                grid.transpose.map { |col| col.map { width(it) }.max + 2 }
+            end
+
+            def self.check_markdown!(head, body, fit)
+                return unless fit[:width] ||
+                              multiline?(grid([head, *body].compact))
+
+                raise ArgumentError,
+                      "markdown has no multi-line cells and no width: fitting"
+            end
+        end
+
+        # A framed table's glyphs and widths under the width target:
+        # under :cjk a Unicode glyph takes two columns, so widths go in
+        # whole glyphs and edges are padded to the widest glyph.
+        module Edges
+            # width: as Fit counts it, one column a border glyph: less, under
+            # :cjk, the columns its two-column glyphs and the rounding of
+            # each column to whole glyphs may add.
+            def self.fit_width(fit, g, widths)
+                unit = unit(g)
+                fit[:width] &&
+                    (fit[:width] - (((2 * widths.size) + 1) * (unit - 1)))
+            end
+
+            # The style's glyphs, an edge or joint narrower than the widest
+            # glyph padded to its columns, so a minimal table's blanks and
+            # its narrow ╶ ╷ keep up with its two-column rules under :cjk
+            # (the runs, h and sep_h, are repeated to the column instead).
+            def self.glyphs(style)
+                g = Glyphs.fetch(style)
+                unit = unit(g)
+                g.to_h do |role, glyph|
+                    runs = %i[h sep_h].include?(role)
+                    [role, runs ? glyph : Width.ljust(glyph, unit)]
+                end
+            end
+
+            def self.unit(g) = g.values.map { Width.of(it) }.max
+
+            # The widths, the last column widened when the title would not
+            # fit the span with a blank either side.
+            def self.titled(widths, title, g)
+                return widths unless title
+
+                short = Width.of(title) + 2 - Render.span_width(widths, g[:cs])
+                short.positive? ? [*widths[..-2], widths[-1] + short] : widths
+            end
+        end
+
+        # Fitting a width (width:, min_width:): when the framed table is
+        # wider than width, the widest column narrows by the overflow
+        # and its cells wrap to it -- min_width: one floor for every
+        # column, or an Array of one a column; below them it
+        # is refused, naming the width the table needs at the least.
+        module Fit
+            def self.apply(grid, widths, width, min_width)
+                floors = min_widths!(min_width, widths.size)
+                total = Render.span_width(widths) + 2
+                return [grid, widths] if width.nil? || total <= width
+
+                narrow(grid, widths, total - width, [floors, min_width])
+            end
+
+            # min_width: one floor for every column, or an Array of one a
+            # column; each a positive Integer.
+            def self.min_widths!(min_width, ncols)
+                floors = Array(min_width)
+                floors *= ncols unless min_width.is_a?(Array)
+                good = floors.all? { it.is_a?(Integer) && it.positive? }
+                return floors if good && floors.size == ncols
+
+                raise ArgumentError, "min_width must be a positive Integer " \
+                                     "or #{ncols} of them: #{min_width.inspect}"
+            end
+
+            # Over columns come off the widest column still above its
+            # floor, one at a time, so widths converge downwards and a
+            # narrow column is never narrowed first. A column's floor is
+            # min_width, or its natural width when that is smaller; the
+            # table is refused only when every column is at its floor.
+            def self.narrow(grid, widths, over, mins)
+                per_column, min_width = mins
+                texts = widths.map { it - 2 }
+                floors = texts.zip(per_column).map(&:min)
+                target = texts.sum - over
+                check_room!(floors, target, min_width)
+                fitted = level(texts, floors, target)
+                [grid.map { wrap_columns(it, texts, fitted) },
+                 fitted.map { it + 2 }]
+            end
+
+            def self.level(texts, floors, target)
+                fitted = texts.dup
+                while fitted.sum > target
+                    i = fitted.each_index.select { fitted[it] > floors[it] }
+                              .max_by { fitted[it] }
+                    fitted[i] -= 1
+                end
+                fitted
+            end
+
+            def self.check_room!(floors, target, min_width)
+                return if floors.sum <= target
+
+                least = Render.span_width(floors.map { it + 2 }) + 2
+                raise ArgumentError, "table needs #{least} columns at the " \
+                                     "least (min_width #{min_width})"
+            end
+
+            # Every narrowed column's cells wrapped to its new width.
+            def self.wrap_columns(row, texts, fitted)
+                row.each_with_index.map do |cell, i|
+                    next cell if fitted[i] == texts[i]
+
+                    cell.flat_map { Wrap.line(it, fitted[i]) }
+                end
+            end
+        end
+
+        # Word wrap by display width, ANSI colour kept intact: a word
+        # longer than the column breaks inside, and a colour still open
+        # at a line's end is closed there and reopened on the next line,
+        # so every line stands alone.
+        module Wrap
+            SGR = /\e\[[0-9;]*m/
+            RESETS = ["\e[0m", "\e[m"].freeze
+
+            def self.line(text, cols)
+                return [text] if Width.of(text) <= cols
+
+                recolour(pack(words(text, cols), cols))
+            end
+
+            def self.words(text, cols)
+                text.split.flat_map do |word|
+                    Width.of(word) > cols ? chop(word, cols) : [word]
+                end
+            end
+
+            # A word too long for the column, in pieces of cols columns;
+            # an SGR sequence stays whole, attached to the next glyph.
+            def self.chop(word, cols)
+                glyphs = word.scan(/(?:#{SGR})*(?:.(?:#{SGR})*)/o)
+                glyphs.each_with_object([+""]) do |g, out|
+                    Width.of(out.last + g) > cols ? out << g.dup : out.last << g
+                end
+            end
+
+            def self.pack(words, cols)
+                words.each_with_object([]) do |w, out|
+                    if out.any? && Width.of("#{out.last} #{w}") <= cols
+                        out.last << " " << w
+                    else
+                        out << w.dup
+                    end
+                end
+            end
+
+            def self.recolour(lines)
+                open = []
+                lines.map do |l|
+                    text = open.join + l
+                    open = active(text)
+                    open.empty? ? text : text + Cells::RESET
+                end
+            end
+
+            # The SGR sequences still in effect at the end of text.
+            def self.active(text)
+                text.scan(SGR).each_with_object([]) do |seq, on|
+                    RESETS.include?(seq) ? on.clear : on << seq
+                end
+            end
+        end
+    end
+end

data/lib/tessella/target.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Tessella
+    # Where a figure will be read (DESIGN.md, "Width targets"), which
+    # decides what a glyph's width is and which glyphs are safe:
+    #
+    #   :term  a terminal (the default): ambiguous glyphs -- box
+    #          drawing, blocks, · ● ★, Greek, accented Latin -- one
+    #          column, wide ones two.
+    #   :cjk   a CJK-configured terminal: ambiguous glyphs two columns
+    #          too, so figures draw their structure in ASCII (ascii:
+    #          defaults to true, text stays as given) and measure text
+    #          with ambiguous glyphs as two.
+    #   :web   a browser: as :term, but emoji-capable glyphs (▶ ☀ ✔ ...)
+    #          may turn into wide emoji, so a figure's text carries
+    #          U+FE0E, the text-presentation selector, after each one.
+    #          That keeps it a text glyph, not its width: a glyph the
+    #          viewer's monospace font lacks takes its fallback font's
+    #          advance (▶ two columns, ↗ 1.4 in Chrome on GitHub's font
+    #          stack), so only glyphs that font carries line up.
+    #
+    # The target is set for a block of code (Target.with) or for the
+    # rest of the fiber (Tessella.target=); the command line takes
+    # `tessella --target T COMMAND` or TESSELLA_TARGET.
+    module Target
+        TARGETS = %i[term cjk web].freeze
+        TEXT_STYLE = "\u{FE0E}"
+
+        # Emoji-capable with text-default presentation (Emoji=Yes minus
+        # Emoji_Presentation=Yes, BMP; digits/#/* excluded): one cell in
+        # terminals, but web viewers may substitute the 2-cell emoji
+        # glyph. Generated from Unicode 15.1 emoji-data.txt.
+        EMOJI_RISK = [
+            0x00A9..0x00A9, 0x00AE..0x00AE, 0x203C..0x203C, 0x2049..0x2049,
+            0x2122..0x2122, 0x2139..0x2139, 0x2194..0x2199, 0x21A9..0x21AA,
+            0x2328..0x2328, 0x23CF..0x23CF, 0x23ED..0x23EF, 0x23F1..0x23F2,
+            0x23F8..0x23FA, 0x24C2..0x24C2, 0x25AA..0x25AB, 0x25B6..0x25B6,
+            0x25C0..0x25C0, 0x25FB..0x25FC, 0x2600..0x2604, 0x260E..0x260E,
+            0x2611..0x2611, 0x2618..0x2618, 0x261D..0x261D, 0x2620..0x2620,
+            0x2622..0x2623, 0x2626..0x2626, 0x262A..0x262A, 0x262E..0x262F,
+            0x2638..0x263A, 0x2640..0x2640, 0x2642..0x2642, 0x265F..0x2660,
+            0x2663..0x2663, 0x2665..0x2666, 0x2668..0x2668, 0x267B..0x267B,
+            0x267E..0x267E, 0x2692..0x2692, 0x2694..0x2697, 0x2699..0x2699,
+            0x269B..0x269C, 0x26A0..0x26A0, 0x26A7..0x26A7, 0x26B0..0x26B1,
+            0x26C8..0x26C8, 0x26CF..0x26CF, 0x26D1..0x26D1, 0x26D3..0x26D3,
+            0x26E9..0x26E9, 0x26F0..0x26F1, 0x26F4..0x26F4, 0x26F7..0x26F9,
+            0x2702..0x2702, 0x2708..0x2709, 0x270C..0x270D, 0x270F..0x270F,
+            0x2712..0x2712, 0x2714..0x2714, 0x2716..0x2716, 0x271D..0x271D,
+            0x2721..0x2721, 0x2733..0x2734, 0x2744..0x2744, 0x2747..0x2747,
+            0x2763..0x2764, 0x27A1..0x27A1, 0x2934..0x2935, 0x2B05..0x2B07,
+            0x3030..0x3030, 0x303D..0x303D, 0x3297..0x3297, 0x3299..0x3299
+        ].freeze
+        def self.current = Fiber[:tessella_target] || :term
+        def self.cjk? = current == :cjk
+        def self.web? = current == :web
+
+        # ascii:'s default: true under :cjk, whose terminals give box
+        # drawing two columns.
+        def self.ascii? = cjk?
+
+        # A chart's canvas by default: braille, but quadrant blocks
+        # under :web, where a browser draws braille from a fallback
+        # font a fifth wider than a column (measured in Chrome on
+        # GitHub's code fonts), so a braille chart's rows run unequal.
+        def self.canvas = web? ? :block : :braille
+
+        # Text under ascii: true must be ASCII, except under :cjk,
+        # where ascii: only means the structure.
+        def self.text_free? = cjk?
+
+        def self.check!(target)
+            sym = target.to_s.to_sym
+            return sym if TARGETS.include?(sym)
+
+            raise ArgumentError, "unknown target: #{target.inspect} " \
+                                 "(#{TARGETS.join(", ")})"
+        end
+
+        def self.with(target)
+            before = Fiber[:tessella_target]
+            Fiber[:tessella_target] = check!(target)
+            yield
+        ensure
+            Fiber[:tessella_target] = before
+        end
+
+        def self.emoji_risk?(code) = EMOJI_RISK.any? { it.cover?(code) }
+
+        # Under :web, U+FE0E after every emoji-capable glyph not
+        # already followed by a presentation selector; else as is.
+        def self.adapt(text)
+            return text unless web?
+
+            text.gsub(/(.)(?![\u{FE0E}\u{FE0F}])/) do |ch|
+                emoji_risk?(ch.ord) ? ch + TEXT_STYLE : ch
+            end
+        end
+    end
+
+    def self.target = Target.current
+
+    def self.target=(target)
+        Fiber[:tessella_target] = Target.check!(target)
+    end
+end

data/lib/tessella/text.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Tessella
+    # Text styles (DESIGN.md, "Text styles"): plain letters and digits
+    # to the Unicode forms of a style -- bold, italic, script, fraktur,
+    # double-struck, sans, monospace, small caps, superscript,
+    # subscript, circled, parenthesized, squared, fullwidth -- and back
+    # (style: :plain). A character the style has no form for passes
+    # through unchanged; strict: true refuses the text instead, naming
+    # them. Only letters and digits count as missing: punctuation and
+    # spaces are expected to pass. Small caps keep capitals as they
+    # are; the styles with capitals only use them for small letters
+    # too. Every style is non-ASCII, so ascii: true refuses them all.
+    # The output is text, measured by Width like any other: fullwidth
+    # is two columns a glyph.
+    module Text
+        CAPITALS_ONLY = %i[squared negative_circled negative_squared].freeze
+        STYLES = (FORMS.keys + %i[plain]).freeze
+
+        def self.convert(text, style:, strict: false, ascii: false)
+            name = style!(style)
+            raise ArgumentError, "text styles are not ASCII" if ascii
+
+            missing = unmapped(text, name)
+            if strict && !missing.empty?
+                raise ArgumentError, "no #{dashed(name)} form for: " \
+                                     "#{missing.join(" ")}"
+            end
+            text.to_s.each_char.map { form(it, name) }.join
+        end
+
+        # The letters and digits of text the style has no form for.
+        def self.unmapped(text, style)
+            name = style!(style)
+            return [] if name == :plain
+
+            text.to_s.each_char.select do |ch|
+                ch.match?(/[A-Za-z0-9]/) && form(ch, name) == ch &&
+                    !(name == :small_caps && ch.match?(/[A-Z]/))
+            end.uniq
+        end
+
+        def self.dashed(name) = name.to_s.tr("_", "-")
+
+        def self.style!(style)
+            name = Borders.name(style)
+            return name if STYLES.include?(name)
+
+            raise ArgumentError, "unknown text style: #{style.inspect} " \
+                                 "(#{STYLES.join(", ").tr("_", "-")})"
+        end
+
+        def self.form(char, name)
+            return plain_map.fetch(char, char) if name == :plain
+
+            key = CAPITALS_ONLY.include?(name) ? char.upcase : char
+            map(name).fetch(key, char)
+        end
+
+        def self.map(name)
+            (@maps ||= {})[name] ||= FORMS.fetch(name).then do |form|
+                form[:from].chars.zip(form[:to].chars).to_h
+            end
+        end
+
+        # Every style's forms back to their plain characters.
+        def self.plain_map
+            @plain_map ||= FORMS.keys.each_with_object({}) do |name, back|
+                map(name).each { |plain, styled| back[styled] ||= plain }
+            end
+        end
+    end
+
+    # (text, style:, strict: false, ascii: false) => String.
+    def self.text(text, **) = Text.convert(text, **)
+end

data/lib/tessella/text_forms.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Tessella
+    # Each text style as { from:, to: }: the plain characters it has a
+    # form for, and those forms, in the same order -- generated from
+    # Unicode 16's names and decompositions (<font>, <super>, <sub>,
+    # <circle>, <wide>, <square>), never by code point offsets. The
+    # Mathematical Alphanumeric holes are filled from Letterlike
+    # Symbols (ℎ ℬ ℰ ℱ ℋ ℐ ℒ ℳ ℛ ℯ ℊ ℴ ℭ ℌ ℑ ℜ ℨ ℂ ℍ ℕ ℙ ℚ ℝ ℤ); the
+    # ordinal indicators (ª º) are not superscripts.
+    module Text
+        # The Mathematical Alphanumeric Symbols styles.
+        module MathForms
+            FORMS = {
+                bold: {
+                    from: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcd" \
+                          "efghijklmnopqrstuvwxyz",
+                    to: "𝟎𝟏𝟐𝟑𝟒𝟓𝟔𝟕𝟖𝟗𝐀𝐁𝐂𝐃𝐄𝐅𝐆𝐇𝐈𝐉𝐊𝐋𝐌𝐍𝐎𝐏𝐐𝐑𝐒𝐓𝐔𝐕𝐖𝐗𝐘𝐙𝐚𝐛𝐜𝐝" \
+                        "𝐞𝐟𝐠𝐡𝐢𝐣𝐤𝐥𝐦𝐧𝐨𝐩𝐪𝐫𝐬𝐭𝐮𝐯𝐰𝐱𝐲𝐳"
+                },
+                italic: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn" \
+                          "opqrstuvwxyz",
+                    to: "𝐴𝐵𝐶𝐷𝐸𝐹𝐺𝐻𝐼𝐽𝐾𝐿𝑀𝑁𝑂𝑃𝑄𝑅𝑆𝑇𝑈𝑉𝑊𝑋𝑌𝑍𝑎𝑏𝑐𝑑𝑒𝑓𝑔ℎ𝑖𝑗𝑘𝑙𝑚𝑛" \
+                        "𝑜𝑝𝑞𝑟𝑠𝑡𝑢𝑣𝑤𝑥𝑦𝑧"
+                },
+                bold_italic: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn" \
+                          "opqrstuvwxyz",
+                    to: "𝑨𝑩𝑪𝑫𝑬𝑭𝑮𝑯𝑰𝑱𝑲𝑳𝑴𝑵𝑶𝑷𝑸𝑹𝑺𝑻𝑼𝑽𝑾𝑿𝒀𝒁𝒂𝒃𝒄𝒅𝒆𝒇𝒈𝒉𝒊𝒋𝒌𝒍𝒎𝒏" \
+                        "𝒐𝒑𝒒𝒓𝒔𝒕𝒖𝒗𝒘𝒙𝒚𝒛"
+                },
+                script: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn" \
+                          "opqrstuvwxyz",
+                    to: "𝒜ℬ𝒞𝒟ℰℱ𝒢ℋℐ𝒥𝒦ℒℳ𝒩𝒪𝒫𝒬ℛ𝒮𝒯𝒰𝒱𝒲𝒳𝒴𝒵𝒶𝒷𝒸𝒹ℯ𝒻ℊ𝒽𝒾𝒿𝓀𝓁𝓂𝓃" \
+                        "ℴ𝓅𝓆𝓇𝓈𝓉𝓊𝓋𝓌𝓍𝓎𝓏"
+                },
+                bold_script: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn" \
+                          "opqrstuvwxyz",
+                    to: "𝓐𝓑𝓒𝓓𝓔𝓕𝓖𝓗𝓘𝓙𝓚𝓛𝓜𝓝𝓞𝓟𝓠𝓡𝓢𝓣𝓤𝓥𝓦𝓧𝓨𝓩𝓪𝓫𝓬𝓭𝓮𝓯𝓰𝓱𝓲𝓳𝓴𝓵𝓶𝓷" \
+                        "𝓸𝓹𝓺𝓻𝓼𝓽𝓾𝓿𝔀𝔁𝔂𝔃"
+                },
+                fraktur: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn" \
+                          "opqrstuvwxyz",
+                    to: "𝔄𝔅ℭ𝔇𝔈𝔉𝔊ℌℑ𝔍𝔎𝔏𝔐𝔑𝔒𝔓𝔔ℜ𝔖𝔗𝔘𝔙𝔚𝔛𝔜ℨ𝔞𝔟𝔠𝔡𝔢𝔣𝔤𝔥𝔦𝔧𝔨𝔩𝔪𝔫" \
+                        "𝔬𝔭𝔮𝔯𝔰𝔱𝔲𝔳𝔴𝔵𝔶𝔷"
+                },
+                bold_fraktur: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn" \
+                          "opqrstuvwxyz",
+                    to: "𝕬𝕭𝕮𝕯𝕰𝕱𝕲𝕳𝕴𝕵𝕶𝕷𝕸𝕹𝕺𝕻𝕼𝕽𝕾𝕿𝖀𝖁𝖂𝖃𝖄𝖅𝖆𝖇𝖈𝖉𝖊𝖋𝖌𝖍𝖎𝖏𝖐𝖑𝖒𝖓" \
+                        "𝖔𝖕𝖖𝖗𝖘𝖙𝖚𝖛𝖜𝖝𝖞𝖟"
+                },
+                double_struck: {
+                    from: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcd" \
+                          "efghijklmnopqrstuvwxyz",
+                    to: "𝟘𝟙𝟚𝟛𝟜𝟝𝟞𝟟𝟠𝟡𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ𝕒𝕓𝕔𝕕" \
+                        "𝕖𝕗𝕘𝕙𝕚𝕛𝕜𝕝𝕞𝕟𝕠𝕡𝕢𝕣𝕤𝕥𝕦𝕧𝕨𝕩𝕪𝕫"
+                },
+                sans: {
+                    from: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcd" \
+                          "efghijklmnopqrstuvwxyz",
+                    to: "𝟢𝟣𝟤𝟥𝟦𝟧𝟨𝟩𝟪𝟫𝖠𝖡𝖢𝖣𝖤𝖥𝖦𝖧𝖨𝖩𝖪𝖫𝖬𝖭𝖮𝖯𝖰𝖱𝖲𝖳𝖴𝖵𝖶𝖷𝖸𝖹𝖺𝖻𝖼𝖽" \
+                        "𝖾𝖿𝗀𝗁𝗂𝗃𝗄𝗅𝗆𝗇𝗈𝗉𝗊𝗋𝗌𝗍𝗎𝗏𝗐𝗑𝗒𝗓"
+                },
+                sans_bold: {
+                    from: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcd" \
+                          "efghijklmnopqrstuvwxyz",
+                    to: "𝟬𝟭𝟮𝟯𝟰𝟱𝟲𝟳𝟴𝟵𝗔𝗕𝗖𝗗𝗘𝗙𝗚𝗛𝗜𝗝𝗞𝗟𝗠𝗡𝗢𝗣𝗤𝗥𝗦𝗧𝗨𝗩𝗪𝗫𝗬𝗭𝗮𝗯𝗰𝗱" \
+                        "𝗲𝗳𝗴𝗵𝗶𝗷𝗸𝗹𝗺𝗻𝗼𝗽𝗾𝗿𝘀𝘁𝘂𝘃𝘄𝘅𝘆𝘇"
+                },
+                sans_italic: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn" \
+                          "opqrstuvwxyz",
+                    to: "𝘈𝘉𝘊𝘋𝘌𝘍𝘎𝘏𝘐𝘑𝘒𝘓𝘔𝘕𝘖𝘗𝘘𝘙𝘚𝘛𝘜𝘝𝘞𝘟𝘠𝘡𝘢𝘣𝘤𝘥𝘦𝘧𝘨𝘩𝘪𝘫𝘬𝘭𝘮𝘯" \
+                        "𝘰𝘱𝘲𝘳𝘴𝘵𝘶𝘷𝘸𝘹𝘺𝘻"
+                },
+                sans_bold_italic: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn" \
+                          "opqrstuvwxyz",
+                    to: "𝘼𝘽𝘾𝘿𝙀𝙁𝙂𝙃𝙄𝙅𝙆𝙇𝙈𝙉𝙊𝙋𝙌𝙍𝙎𝙏𝙐𝙑𝙒𝙓𝙔𝙕𝙖𝙗𝙘𝙙𝙚𝙛𝙜𝙝𝙞𝙟𝙠𝙡𝙢𝙣" \
+                        "𝙤𝙥𝙦𝙧𝙨𝙩𝙪𝙫𝙬𝙭𝙮𝙯"
+                },
+                monospace: {
+                    from: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcd" \
+                          "efghijklmnopqrstuvwxyz",
+                    to: "𝟶𝟷𝟸𝟹𝟺𝟻𝟼𝟽𝟾𝟿𝙰𝙱𝙲𝙳𝙴𝙵𝙶𝙷𝙸𝙹𝙺𝙻𝙼𝙽𝙾𝙿𝚀𝚁𝚂𝚃𝚄𝚅𝚆𝚇𝚈𝚉𝚊𝚋𝚌𝚍" \
+                        "𝚎𝚏𝚐𝚑𝚒𝚓𝚔𝚕𝚖𝚗𝚘𝚙𝚚𝚛𝚜𝚝𝚞𝚟𝚠𝚡𝚢𝚣"
+                }
+            }.freeze
+        end
+
+        # Small caps, super/subscripts, enclosed and fullwidth forms.
+        module OtherForms
+            FORMS = {
+                small_caps: {
+                    from: "abcdefghijklmnopqrstuvwyz",
+                    to: "ᴀʙᴄᴅᴇꜰɢʜɪᴊᴋʟᴍɴᴏᴘꞯʀꜱᴛᴜᴠᴡʏᴢ"
+                },
+                superscript: {
+                    from: "0123456789ABCDEFGHIJKLMNOPQRTUVWabcdefgh" \
+                          "ijklmnopqrstuvwxyz",
+                    to: "⁰¹²³⁴⁵⁶⁷⁸⁹ᴬᴮꟲᴰᴱꟳᴳᴴᴵᴶᴷᴸᴹᴺᴼᴾꟴᴿᵀᵁⱽᵂᵃᵇᶜᵈᵉᶠᵍʰ" \
+                        "ⁱʲᵏˡᵐⁿᵒᵖ𐞥ʳˢᵗᵘᵛʷˣʸᶻ"
+                },
+                subscript: {
+                    from: "0123456789aehijklmnoprstuvx",
+                    to: "₀₁₂₃₄₅₆₇₈₉ₐₑₕᵢⱼₖₗₘₙₒₚᵣₛₜᵤᵥₓ"
+                },
+                circled: {
+                    from: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcd" \
+                          "efghijklmnopqrstuvwxyz",
+                    to: "⓪①②③④⑤⑥⑦⑧⑨ⒶⒷⒸⒹⒺⒻⒼⒽⒾⒿⓀⓁⓂⓃⓄⓅⓆⓇⓈⓉⓊⓋⓌⓍⓎⓏⓐⓑⓒⓓ" \
+                        "ⓔⓕⓖⓗⓘⓙⓚⓛⓜⓝⓞⓟⓠⓡⓢⓣⓤⓥⓦⓧⓨⓩ"
+                },
+                negative_circled: {
+                    from: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+                    to: "⓿❶❷❸❹❺❻❼❽❾🅐🅑🅒🅓🅔🅕🅖🅗🅘🅙🅚🅛🅜🅝🅞🅟🅠🅡🅢🅣🅤🅥🅦🅧🅨🅩"
+                },
+                parenthesized: {
+                    from: "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcde" \
+                          "fghijklmnopqrstuvwxyz",
+                    to: "⑴⑵⑶⑷⑸⑹⑺⑻⑼🄐🄑🄒🄓🄔🄕🄖🄗🄘🄙🄚🄛🄜🄝🄞🄟🄠🄡🄢🄣🄤🄥🄦🄧🄨🄩⒜⒝⒞⒟⒠" \
+                        "⒡⒢⒣⒤⒥⒦⒧⒨⒩⒪⒫⒬⒭⒮⒯⒰⒱⒲⒳⒴⒵"
+                },
+                squared: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+                    to: "🄰🄱🄲🄳🄴🄵🄶🄷🄸🄹🄺🄻🄼🄽🄾🄿🅀🅁🅂🅃🅄🅅🅆🅇🅈🅉"
+                },
+                negative_squared: {
+                    from: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+                    to: "🅰🅱🅲🅳🅴🅵🅶🅷🅸🅹🅺🅻🅼🅽🅾🅿🆀🆁🆂🆃🆄🆅🆆🆇🆈🆉"
+                },
+                fullwidth: {
+                    from: "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH" \
+                          "IJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnop" \
+                          "qrstuvwxyz{|}~ ",
+                    to: "！＂＃＄％＆＇（）＊＋，－．／０１２３４５６７８９：；＜＝＞？＠ＡＢＣＤＥＦＧＨ" \
+                        "ＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ［＼］＾＿｀ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐ" \
+                        "ｑｒｓｔｕｖｗｘｙｚ｛｜｝～　"
+                }
+            }.freeze
+        end
+
+        FORMS = MathForms::FORMS.merge(OtherForms::FORMS).freeze
+    end
+end