get rid of the label highlight, and emit special wbr and span indent markers to perform signature linebreaking. also make linebreaking only apply to the multiline css style, and apply that style if the signature is more than 80 characters long

Author: tayloraswift

Assets/css/Main.css

@@ -56,7 +56,7 @@ extension MarkdownBytecode
         case type
         case `typealias`
         /// New in 8.0.
-        case label
+        case indent
 
         //  Section elements.
         case parameters = 0xC0

Assets/css/Main.css.map

@@ -1,5 +1,8 @@
 extension MarkdownBytecode
 {
+    /// Markers inhabit the unassigned codepoints of the UTF-8 encoding.
+    ///
+    /// https://en.wikipedia.org/wiki/UTF-8
     @frozen public
     enum Marker:UInt8, Equatable, Hashable, Sendable
     {

Sources/MarkdownABI/Bytecode/MarkdownBytecode.Context.swift

@@ -23,40 +23,44 @@ extension Signature.Abridged
     @usableFromInline internal
     init(utf8:[UInt8], actor:Bool = false)
     {
-        let regions:SignatureSyntax = utf8.withUnsafeBufferPointer(SignatureSyntax.init)
+        let signature:SignatureSyntax = utf8.withUnsafeBufferPointer(SignatureSyntax.init)
         let bytecode:MarkdownBytecode = .init
         {
-            for token:SignatureSyntax.Token? in regions.tokens
+            for span:SignatureSyntax.Span in signature.elements
             {
-                guard let token:SignatureSyntax.Token
-                else
+                switch span
                 {
+                case .wbr(indent: false):
                     $0[.wbr]
-                    continue
-                }
 
-                let text:String = .init(decoding: utf8[token.range], as: Unicode.UTF8.self)
+                case .wbr(indent: true):
+                    $0[.indent]
 
-                if  actor,
-                    case (.keyword, "class") = (token.color, text)
-                {
-                    $0 += "actor"
-                    continue
-                }
+                case .text(let range, nil, _):
+                    $0 += utf8[range]
 
-                switch  (token.color, text)
-                {
-                case    (.identifier, _),
-                        (.keyword, "init"),
-                        (.keyword, "deinit"),
-                        (.keyword, "subscript"):
-                    $0[.identifier] = text
+                case .text(let range, let color?, let depth):
+                    let text:String = .init(decoding: utf8[range], as: Unicode.UTF8.self)
+                    switch  (color, text, depth)
+                    {
+                    case    (.keyword, "subscript", .toplevel?),
+                            (.keyword, "deinit", .toplevel?),
+                            (.keyword, "init", .toplevel?),
+                            (.identifier, _, _):
+                        $0[.identifier] = text
+
+                    case    (.keyword, "class", .toplevel?):
+                        guard actor
+                        else
+                        {
+                            fallthrough
+                        }
 
-                case    (.label, _):
-                    $0[.label] = text
+                        $0 += "actor"
 
-                case    _:
-                    $0 += text
+                    case    (_, _, _):
+                        $0 += text
+                    }
                 }
             }
         }

Sources/MarkdownABI/Bytecode/MarkdownBytecode.Marker.swift

@@ -46,60 +46,67 @@ extension Signature.Expanded
     @inlinable internal
     init(utf8:[UInt8], keywords:inout InterestingKeywords, symbols:inout [Int: Scalar])
     {
-        let regions:SignatureSyntax = utf8.withUnsafeBufferPointer(SignatureSyntax.init)
+        let signature:SignatureSyntax = utf8.withUnsafeBufferPointer(SignatureSyntax.init)
         var references:[Scalar: Int] = [:]
         var referents:[Scalar] = []
 
         let bytecode:MarkdownBytecode = .init
         {
-            for token:SignatureSyntax.Token? in regions.tokens
+            for span:SignatureSyntax.Span in signature.elements
             {
-                guard let token:SignatureSyntax.Token
-                else
+                switch span
                 {
+                case .wbr(indent: false):
                     $0[.wbr]
-                    continue
-                }
 
-                let text:String = .init(decoding: utf8[token.range], as: Unicode.UTF8.self)
+                case .wbr(indent: true):
+                    $0[.indent]
 
-                guard let color:MarkdownBytecode.Context = token.color
-                else
-                {
-                    $0 += text
-                    continue
-                }
+                case .text(let range, nil, _):
+                    $0 += utf8[range]
 
-                if  case .keyword = color
-                {
-                    switch text
+                case .text(let range, let color?, .toplevel?):
+                    if  case .keyword = color
                     {
-                    case "actor":   keywords.actor = true
-                    case "class":   keywords.class = true
-                    default:        break
+                        //  The `actor` and `async` keywords are contextual; there is no
+                        //  other way to detect them besides inspecting token text!
+                        switch String.init(decoding: utf8[range], as: Unicode.UTF8.self)
+                        {
+                        case "actor":   keywords.actor = true
+                        case "class":   keywords.class = true
+                        default:        break
+                        }
                     }
-                }
 
-                $0[color]
-                {
-                    if  let referent:Scalar = symbols.removeValue(forKey: token.start)
+                    fallthrough
+
+                case .text(let range, let color?, _):
+
+                    $0[color]
                     {
-                        $0[.href] =
+                        if  let referent:Scalar = symbols.removeValue(forKey: range.lowerBound)
                         {
-                            if  let reference:Int = $0
-                            {
-                                return reference
-                            }
-                            else
+                            $0[.href] =
                             {
-                                let next:Int = referents.endIndex
-                                referents.append(referent)
-                                $0 = next
-                                return next
-                            }
-                        } (&references[referent])
+                                if  let reference:Int = $0
+                                {
+                                    return reference
+                                }
+                                else
+                                {
+                                    let next:Int = referents.endIndex
+                                    referents.append(referent)
+                                    $0 = next
+                                    return next
+                                }
+                            } (&references[referent])
+                        }
                     }
-                } = text
+                    content:
+                    {
+                        $0 += utf8[range]
+                    }
+                }
             }
         }
 

Sources/MarkdownPluginSwift/Signature.Abridged (ext).swift

@@ -0,0 +1,8 @@
+extension SignatureSyntax.Span
+{
+    @frozen @usableFromInline internal
+    enum Depth
+    {
+        case toplevel
+    }
+}

Sources/MarkdownPluginSwift/Signature.Expanded (ext).swift

@@ -0,0 +1,11 @@
+import MarkdownABI
+
+extension SignatureSyntax
+{
+    @frozen @usableFromInline internal
+    enum Span
+    {
+        case text(Range<Int>, MarkdownBytecode.Context? = nil, Depth? = nil)
+        case wbr(indent:Bool)
+    }
+}