Revert "Styled markdown, with a few tweaks (#51928)

KristofferC · KristofferC · commit 5a007712554c · 2025-04-03T14:32:27.000+02:00
diff --git a/doc/Manifest.toml b/doc/Manifest.toml
@@ -148,7 +148,7 @@ uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
 version = "1.11.0"
 
 [[deps.Markdown]]
-deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"]
+deps = ["Base64"]
 uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
 version = "1.11.0"
 
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
@@ -139,7 +139,7 @@ uuid = "3a97d323-0669-5f0c-9066-3539efd106a3"
 version = "4.2.1+1"
 
 [[deps.Markdown]]
-deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"]
+deps = ["Base64"]
 uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
 version = "1.11.0"
 
diff --git a/stdlib/Markdown/Project.toml b/stdlib/Markdown/Project.toml
@@ -4,8 +4,6 @@ version = "1.11.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
-JuliaSyntaxHighlighting = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011"
-StyledStrings = "f489334b-da3d-4c2e-b8f0-e476e12c162b"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/Markdown/src/Common/block.jl b/stdlib/Markdown/src/Common/block.jl
@@ -39,7 +39,7 @@ end
 # Headers
 # –––––––
 
-mutable struct Header{level} <: MarkdownElement
+mutable struct Header{level}
     text
 end
 
diff --git a/stdlib/Markdown/src/Common/inline.jl b/stdlib/Markdown/src/Common/inline.jl
@@ -4,7 +4,7 @@
 # Emphasis
 # ––––––––
 
-mutable struct Italic <: MarkdownElement
+mutable struct Italic
     text
 end
 
@@ -20,7 +20,7 @@ function underscore_italic(stream::IO, md::MD)
     return result === nothing ? nothing : Italic(parseinline(result, md))
 end
 
-mutable struct Bold <: MarkdownElement
+mutable struct Bold
     text
 end
 
@@ -66,7 +66,7 @@ end
 # Images & Links
 # ––––––––––––––
 
-mutable struct Image <: MarkdownElement
+mutable struct Image
     url::String
     alt::String
 end
@@ -85,7 +85,7 @@ function image(stream::IO, md::MD)
     end
 end
 
-mutable struct Link <: MarkdownElement
+mutable struct Link
     text
     url::String
 end
@@ -156,7 +156,7 @@ end
 # Punctuation
 # –––––––––––
 
-mutable struct LineBreak <: MarkdownElement end
+mutable struct LineBreak end
 
 @trigger '\\' ->
 function linebreak(stream::IO, md::MD)
diff --git a/stdlib/Markdown/src/GitHub/table.jl b/stdlib/Markdown/src/GitHub/table.jl
@@ -140,15 +140,15 @@ end
 
 function term(io::IO, md::Table, columns)
     margin_str = " "^margin
-    cells = mapmap(x -> annotprint(terminline, x), md.rows)
-    padcells!(cells, md.align, len = textwidth)
+    cells = mapmap(x -> terminline_string(io, x), md.rows)
+    padcells!(cells, md.align, len = ansi_length)
     for i = 1:length(cells)
         print(io, margin_str)
         join(io, cells[i], " ")
         if i == 1
             println(io)
             print(io, margin_str)
-            join(io, ["–"^textwidth(cells[i][j]) for j = 1:length(cells[1])], " ")
+            join(io, ["–"^ansi_length(cells[i][j]) for j = 1:length(cells[1])], " ")
         end
         i < length(cells) && println(io)
     end
diff --git a/stdlib/Markdown/src/Markdown.jl b/stdlib/Markdown/src/Markdown.jl
@@ -9,12 +9,9 @@ literals `md"..."` and `doc"..."`.
 """
 module Markdown
 
-import Base: AnnotatedString, AnnotatedIOBuffer, show, ==, with_output_color, mapany
+import Base: show, ==, with_output_color, mapany
 using Base64: stringmime
 
-using StyledStrings: StyledStrings, Face, addface!, @styled_str, styled
-using JuliaSyntaxHighlighting: highlight, highlight!
-
 # Margin for printing in terminal.
 const margin = 2
 
@@ -37,26 +34,6 @@ export @md_str, @doc_str
 
 public MD, parse
 
-const MARKDOWN_FACES = [
-    :markdown_header => Face(weight=:bold),
-    :markdown_h1 => Face(height=1.25, inherit=:markdown_header),
-    :markdown_h2 => Face(height=1.20, inherit=:markdown_header),
-    :markdown_h3 => Face(height=1.15, inherit=:markdown_header),
-    :markdown_h4 => Face(height=1.12, inherit=:markdown_header),
-    :markdown_h5 => Face(height=1.08, inherit=:markdown_header),
-    :markdown_h6 => Face(height=1.05, inherit=:markdown_header),
-    :markdown_admonition => Face(weight=:bold),
-    :markdown_code => Face(inherit=:code),
-    :markdown_footnote => Face(inherit=:bright_yellow),
-    :markdown_hrule => Face(inherit=:shadow),
-    :markdown_inlinecode => Face(inherit=:markdown_code),
-    :markdown_latex => Face(inherit=:magenta),
-    :markdown_link => Face(underline=:bright_blue),
-    :markdown_list => Face(foreground=:blue),
-]
-
-__init__() = foreach(addface!, MARKDOWN_FACES)
-
 parse(markdown::String; flavor = julia) = parse(IOBuffer(markdown), flavor = flavor)
 
 """
diff --git a/stdlib/Markdown/src/render/html.jl b/stdlib/Markdown/src/render/html.jl
@@ -67,9 +67,6 @@ end
 
 function html(io::IO, code::Code)
     withtag(io, :pre) do
-        if code.language == "styled"
-            code = Code("", String(styled(code.code)))
-        end
         maybe_lang = !isempty(code.language) ? Any[:class=>"language-$(code.language)"] : []
         withtag(io, :code, maybe_lang...) do
             htmlesc(io, code.code)
@@ -137,9 +134,6 @@ function htmlinline(io::IO, content::Vector)
 end
 
 function htmlinline(io::IO, code::Code)
-    if code.language == "styled"
-        code = Code("", String(styled(code.code)))
-    end
     withtag(io, :code) do
         htmlesc(io, code.code)
     end
diff --git a/stdlib/Markdown/src/render/latex.jl b/stdlib/Markdown/src/render/latex.jl
@@ -33,9 +33,6 @@ function latex(io::IO, header::Header{l}) where l
 end
 
 function latex(io::IO, code::Code)
-    if code.language == "styled"
-        code = Code("", String(styled(code.code)))
-    end
     occursin("\\end{verbatim}", code.code) && error("Cannot include \"\\end{verbatim}\" in a latex code block")
     wrapblock(io, "verbatim") do
         println(io, code.code)
diff --git a/stdlib/Markdown/src/render/rst.jl b/stdlib/Markdown/src/render/rst.jl
@@ -23,16 +23,10 @@ end
 function rst(io::IO, code::Code)
     if code.language == "jldoctest"
         println(io, ".. doctest::\n")
-    elseif code.language in ("", "julia", "julia-repl")
+    elseif code.language != "rst"
         println(io, ".. code-block:: julia\n")
-    elseif code.language == "rst"
-    elseif code.language == "styled"
-        code = Code("", String(styled(code.code)))
-        println(io, "::\n")
-    else
-        println(io, "::\n")
     end
-    for l in eachsplit(code.code, '\n')
+    for l in lines(code.code)
         println(io, "    ", l)
     end
 end
@@ -96,7 +90,7 @@ end
 
 function rst(io::IO, l::LaTeX)
     println(io, ".. math::\n")
-    for line in eachsplit(l.formula, '\n')
+    for line in lines(l.formula)
         println(io, "    ", line)
     end
 end
diff --git a/stdlib/Markdown/src/render/terminal/formatting.jl b/stdlib/Markdown/src/render/terminal/formatting.jl
@@ -1,72 +1,71 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-const AnnotIO = Union{AnnotatedIOBuffer, IOContext{AnnotatedIOBuffer}}
+# Wrapping
 
-function annotprint(f::Function, args...)
-    buf = AnnotatedIOBuffer()
-    f(buf, args...)
-    read(seekstart(buf), AnnotatedString)
+function ansi_length(s)
+    replace(s, r"\e\[[0-9]+m" => "") |> textwidth
 end
 
-"""
-    with_output_annotations(f::Function, io::AnnotIO, annots::Pair{Symbol, <:Any}...)
+words(s) = split(s, " ")
+lines(s) = split(s, "\n")
 
-Call `f(io)`, and apply `annots` to the output created by doing so.
-"""
-function with_output_annotations(f::Function, io::AnnotIO, annots::Pair{Symbol, <:Any}...)
-    @nospecialize annots
-    aio = if io isa AnnotatedIOBuffer io else io.io end
-    start = position(aio) + 1
-    f(io)
-    stop = position(aio)
-    sortedindex = searchsortedlast(aio.annotations, (region=start:stop,), by=a -> a.region)
-    for (i, annot) in enumerate(annots)
-        insert!(aio.annotations, sortedindex + i, (start:stop, annot...))
-    end
-end
+function wrapped_line(io::IO, s::AbstractString, width, i)
+    ws = words(s)
+    lines = String[]
+    for word in ws
+        word_length = ansi_length(word)
+        word_length == 0 && continue
+        if isempty(lines) || i + word_length + 1 > width
+            i = word_length
+            if length(lines) > 0
+                last_line = lines[end]
+                maybe_underline = findlast(Base.text_colors[:underline], last_line)
+                if !isnothing(maybe_underline)
+                    # disable underline style at end of line if not already disabled.
+                    maybe_disable_underline = max(
+                        last(something(findlast(Base.disable_text_style[:underline], last_line), -1)),
+                        last(something(findlast(Base.text_colors[:normal], last_line), -1)),
+                    )
 
-"""
-    wraplines(content::AnnotatedString, width::Integer = 80, column::Integer = 0)
+                    if maybe_disable_underline < 0 || maybe_disable_underline < last(maybe_underline)
 
-Wrap `content` into a vector of lines of at most `width` (according to
-`textwidth`), with the first line starting at `column`.
-"""
-function wraplines(content::Union{Annot, SubString{<:Annot}}, width::Integer = 80, column::Integer = 0) where { Annot <: AnnotatedString}
-    s, lines = String(content), SubString{Annot}[]
-    i, lastwrap, slen = firstindex(s), 0, ncodeunits(s)
-    most_recent_break_opportunity = 1
-    while i < slen
-        if isspace(s[i]) && s[i] != '\n'
-            most_recent_break_opportunity = i
-        elseif s[i] == '\n'
-            push!(lines, content[nextind(s, lastwrap):prevind(s, i)])
-            lastwrap = i
-            column = 0
-        elseif column >= width && most_recent_break_opportunity > 1
-            if lastwrap == most_recent_break_opportunity
-                nextbreak = findfirst(isspace, @view s[nextind(s, lastwrap):end])
-                if isnothing(nextbreak)
-                    break
-                else
-                    most_recent_break_opportunity = lastwrap + nextbreak
+                        lines[end] = last_line * Base.disable_text_style[:underline]
+                        word = Base.text_colors[:underline] * word
+                    end
                 end
-                i = most_recent_break_opportunity
-            else
-                i = nextind(s, most_recent_break_opportunity)
             end
-            push!(lines, content[nextind(s, lastwrap):prevind(s, most_recent_break_opportunity)])
-            lastwrap = most_recent_break_opportunity
-            column = 0
+            push!(lines, word)
+        else
+            i += word_length + 1
+            lines[end] *= " " * word   # this could be more efficient
         end
-        column += textwidth(s[i])
-        i = nextind(s, i)
     end
-    if lastwrap < slen
-        push!(lines, content[nextind(s, lastwrap):end])
+    return i, lines
+end
+
+function wrapped_lines(io::IO, s::AbstractString; width = 80, i = 0)
+    ls = String[]
+    for ss in lines(s)
+        i, line = wrapped_line(io, ss, width, i)
+        append!(ls, line)
+    end
+    return ls
+end
+
+wrapped_lines(io::IO, f::Function, args...; width = 80, i = 0) =
+    wrapped_lines(io, sprint(f, args...; context=io), width = width, i = 0)
+
+function print_wrapped(io::IO, s...; width = 80, pre = "", i = 0)
+    lines = wrapped_lines(io, s..., width = width, i = i)
+    isempty(lines) && return 0, 0
+    print(io, lines[1])
+    for line in lines[2:end]
+        print(io, '\n', pre, line)
     end
-    lines
+    length(lines), length(pre) + ansi_length(lines[end])
 end
 
+print_wrapped(f::Function, io::IO, args...; kws...) = print_wrapped(io, f, args...; kws...)
 # Print horizontal lines between each docstring if there are multiple docs
 function insert_hlines(docs)
     if !isa(docs, MD) || !haskey(docs.meta, :results) || isempty(docs.meta[:results])
diff --git a/stdlib/Markdown/src/render/terminal/render.jl b/stdlib/Markdown/src/render/terminal/render.jl
diff --git a/stdlib/Markdown/test/runtests.jl b/stdlib/Markdown/test/runtests.jl
diff --git a/test/precompile.jl b/test/precompile.jl
