diff --git a/README.md b/README.md
index efae63a8..c3ae295b 100644
--- a/README.md
+++ b/README.md
@@ -113,12 +113,13 @@ The renderer targets the subset of CommonMark + GitHub-flavored Markdown that LL
 - [x] Inline LaTeX math via `\( … \)`
 - [x] Display LaTeX math via `$$ … $$`
 - [x] Inline citation pills
+- [x] Inline HTML formatting tags — `<br>`, `<b>`/`<strong>`, `<i>`/`<em>`, `<s>`/`<del>`/`<strike>`, `<u>`/`<ins>`, `<mark>`, `<sub>`/`<sup>`, `<code>`/`<kbd>`/`<samp>`/`<tt>`, `<a href>`, `<wbr>` (comments are dropped; unclosed open tags auto-close like browsers; unsupported or unmatched closing tags render as literal text)
 
 ### Not yet supported
 
 - [ ] Footnotes (`[^1]`)
 - [ ] Highlight (`==text==`), superscript (`^x^`), subscript (`~x~`)
-- [ ] Raw HTML (`<details>`, `<kbd>`, `<aside>`, …) — kept inline as text
+- [ ] Block-level raw HTML (`<details>`, `<aside>`, …) — kept inline as text
 - [ ] GitHub alerts (`> [!NOTE]`) — rendered as plain block quotes
 - [ ] Container directives (`::: warning … :::`) and admonitions (`!!! note`)
 - [ ] Mermaid / PlantUML diagrams — rendered as fenced code
diff --git a/Sources/MarkdownText/Inline/Markdown+InlineConvertible.swift b/Sources/MarkdownText/Inline/Markdown+InlineConvertible.swift
index 952cdf90..e2c9b817 100644
--- a/Sources/MarkdownText/Inline/Markdown+InlineConvertible.swift
+++ b/Sources/MarkdownText/Inline/Markdown+InlineConvertible.swift
@@ -187,6 +187,62 @@ extension Markdown.InlineCode: InlineConvertible {
   }
 }
 
+extension Markdown.InlineAttributes: InlineConvertible {
+
+  /// Attribute keys this renderer understands inside `attributes`. Produced by
+  /// `InlineHTMLRewriter` for tags that have no dedicated Markdown node
+  /// (`<u>`/`<ins>`, `<mark>`, `<sub>`, `<sup>`).
+  private static let enabledKeyRegex = try? Regex(#"(?:^|[,{}\s])([a-zA-Z]+)\s*:\s*true\b"#)
+
+  private var enabledKeys: Set<String> {
+    guard let regex = Self.enabledKeyRegex else { return [] }
+    var keys = Set<String>()
+    for match in attributes.matches(of: regex) {
+      if let key = match.output[1].substring {
+        keys.insert(String(key))
+      }
+    }
+    return keys
+  }
+
+  func convert(attributeContainer: NSAttributeContainer, config: MarkdownRenderConfig) -> NSMutableAttributedString {
+    var container = attributeContainer
+    let font = attributeContainer[.font] as? MDFont ?? config.paragraphStyle.textFonts.normal
+    let keys = enabledKeys
+    if keys.contains("subscript") {
+      container[.baselineOffset] = -font.pointSize * 0.2
+    }
+    if keys.contains("superscript") {
+      container[.baselineOffset] = font.pointSize * 0.35
+    }
+    if keys.contains("underline") {
+      container[.underlineStyle] = NSUnderlineStyle.single.rawValue
+      container[.underlineColor] = container[.foregroundColor]
+    }
+    if keys.contains("highlight") {
+      container[.backgroundColor] = MDColor.systemYellow.withAlphaComponent(0.45)
+    }
+    let str = NSMutableAttributedString()
+    self.inlineConvertibleChildren.forEach { convertible in
+      str.append(convertible.convert(attributeContainer: container, config: config))
+    }
+    if keys.contains("subscript") || keys.contains("superscript") {
+      // Scale the produced runs rather than the container font: inner
+      // converters (`Strong`, `Emphasis`, `InlineCode`) overwrite `.font`
+      // with their own variants, which would leave e.g. `<sup><b>x</b></sup>`
+      // at full size.
+      var scaled: [(NSRange, MDFont)] = []
+      str.enumerateAttribute(.font, in: NSRange(location: 0, length: str.length)) { value, range, _ in
+        scaled.append((range, (value as? MDFont) ?? font))
+      }
+      for (range, base) in scaled {
+        str.addAttribute(.font, value: base.scaled(by: 0.75), range: range)
+      }
+    }
+    return str
+  }
+}
+
 extension Markdown.Table.Cell: InlineConvertible {
 
   func convert(attributeContainer: NSAttributeContainer, config: MarkdownRenderConfig) -> NSMutableAttributedString {
diff --git a/Sources/MarkdownText/Parser/MarkdownParserImpl.swift b/Sources/MarkdownText/Parser/MarkdownParserImpl.swift
index 433c0ac1..8b22cc60 100644
--- a/Sources/MarkdownText/Parser/MarkdownParserImpl.swift
+++ b/Sources/MarkdownText/Parser/MarkdownParserImpl.swift
@@ -13,6 +13,8 @@ public final class MarkdownParserImpl: MarkdownParser {
     PartialTableMarkupPostParsingRewriter()
   ]
 
+  private let inlineHTMLRewriter = InlineHTMLMarkupPostParsingRewriter()
+
   private let imageBlockRewriter = ImageBlockMarkupPostParsingRewriter()
 
   private let latexPreprocessor: LaTexPreProcessor
@@ -39,6 +41,13 @@ public final class MarkdownParserImpl: MarkdownParser {
       }
     }
 
+    if let rewrittenDoc = inlineHTMLRewriter.rewriteIfApplicable(document: result.document) {
+      result = MarkdownParseResult(
+        document: rewrittenDoc,
+        speculativeRewritten: result.speculativeRewritten
+      )
+    }
+
     if option.imageSupport {
       if let rewrittenDoc = imageBlockRewriter.rewriteIfApplicable(document: result.document) {
         result = MarkdownParseResult(
diff --git a/Sources/MarkdownText/Parser/Rewriters/InlineHTMLRewriter.swift b/Sources/MarkdownText/Parser/Rewriters/InlineHTMLRewriter.swift
new file mode 100644
index 00000000..5c867293
--- /dev/null
+++ b/Sources/MarkdownText/Parser/Rewriters/InlineHTMLRewriter.swift
@@ -0,0 +1,408 @@
+//
+//  Copyright (c) Microsoft Corporation. All rights reserved.
+//  Licensed under the MIT License. See LICENSE in the project root for license information.
+//
+
+import Markdown
+
+/// Rewrites supported inline raw-HTML tags into their Markdown equivalents so
+/// they render instead of being dropped by inline conversion.
+///
+/// Supported mappings:
+/// - `<br>` / `<br/>` → line break, `<wbr>` → zero-width space
+/// - `<b>` / `<strong>` → strong, `<i>` / `<em>` → emphasis
+/// - `<s>` / `<del>` / `<strike>` → strikethrough
+/// - `<u>` / `<ins>` → underline, `<mark>` → highlight
+/// - `<sub>` / `<sup>` → sub/superscript
+/// - `<code>` / `<kbd>` / `<samp>` / `<tt>` → inline code
+/// - `<a href="…">` → link
+///
+/// Comments are dropped. Unsupported or unmatched tags render as literal text
+/// so their source stays visible. An open tag with no matching close applies
+/// to the rest of the inline container (browser-style auto-close), which keeps
+/// streamed documents sensible while a tag is still arriving.
+///
+/// Standalone-line tags are parsed by cmark as `HTMLBlock` rather than
+/// `InlineHTML`; those blocks are converted to literal paragraphs so their
+/// text is never silently dropped.
+final class InlineHTMLRewriter: MarkupRewriter {
+
+  /// Maximum tag-pair nesting depth processed before the remainder of a
+  /// container is emitted literally. Bounds recursion and the per-open
+  /// closing-tag scan on adversarial inputs like thousands of unclosed tags.
+  private static let maxDepth = 64
+
+  private enum Tag {
+    case open(name: String, attributes: String)
+    case close(name: String)
+    case comment
+    case other
+  }
+
+  private static let pairedTags: Set<String> = [
+    "b", "strong", "i", "em", "s", "del", "strike",
+    "u", "ins", "mark", "sub", "sup",
+    "code", "kbd", "samp", "tt", "a"
+  ]
+
+  /// Whitespace cmark accepts inside a tag (`spacechar` in the HTML scanners).
+  private static let htmlWhitespace: Set<Character> = [" ", "\t", "\n", "\r", "\u{0B}", "\u{0C}"]
+
+  /// `HTMLBlock` nodes have no renderable representation; without this they
+  /// would be dropped, losing their text entirely. Render the source verbatim
+  /// so `<details>` and friends degrade to readable text. Comments,
+  /// processing instructions, and declarations are dropped like their inline
+  /// counterparts rather than surfacing as visible text.
+  func visitHTMLBlock(_ htmlBlock: HTMLBlock) -> Markup? {
+    let raw = htmlBlock.rawHTML.trimmingCharacters(in: .whitespacesAndNewlines)
+    if raw.hasPrefix("<!--") || raw.hasPrefix("<?") || raw.hasPrefix("<!") {
+      return nil
+    }
+    return Paragraph([Text(htmlBlock.rawHTML)])
+  }
+
+  func visitParagraph(_ paragraph: Paragraph) -> Markup? { rewriteInlineChildren(paragraph) }
+  func visitHeading(_ heading: Heading) -> Markup? { rewriteInlineChildren(heading) }
+  func visitTableCell(_ tableCell: Table.Cell) -> Markup? { rewriteInlineChildren(tableCell) }
+  func visitEmphasis(_ emphasis: Emphasis) -> Markup? { rewriteInlineChildren(emphasis) }
+  func visitStrong(_ strong: Strong) -> Markup? { rewriteInlineChildren(strong) }
+  func visitStrikethrough(_ strikethrough: Strikethrough) -> Markup? { rewriteInlineChildren(strikethrough) }
+  func visitLink(_ link: Link) -> Markup? { rewriteInlineChildren(link) }
+  func visitInlineAttributes(_ attributes: InlineAttributes) -> Markup? { rewriteInlineChildren(attributes) }
+  func visitImage(_ image: Image) -> Markup? { rewriteInlineChildren(image) }
+
+  /// Recursively visits the container's children first, then rewrites the tag
+  /// sequences at this level. Containers without `InlineHTML` are returned
+  /// unchanged so untouched subtrees keep their identity.
+  private func rewriteInlineChildren<Container: InlineContainer & Markup>(_ container: Container) -> Markup? {
+    guard Self.containsInlineHTML(container) else { return container }
+    // `defaultVisit` is `mutating` on the non-class-bound visitor protocol, so
+    // it must be called through a variable; `self` is a class reference here.
+    var mutableSelf = self
+    guard var visited = mutableSelf.defaultVisit(container) as? Container else { return container }
+    var children = process(Array(visited.children))
+    // `Link`, `Image`, and `InlineAttributes` only allow `RecurringInlineMarkup`
+    // children; degraded nodes keep their text as a literal fallback.
+    if visited is Link || visited is Image || visited is InlineAttributes {
+      children = children.map { $0 as? (any RecurringInlineMarkup) ?? Text($0.plainText) }
+    }
+    visited.setInlineChildren(children)
+    return visited
+  }
+
+  /// Whether the subtree contains any `InlineHTML` or `HTMLBlock` node. Used
+  /// to prune containers (and whole documents) that need no rewriting.
+  static func containsInlineHTML(_ markup: Markup) -> Bool {
+    markup.children.contains {
+      $0 is InlineHTML || $0 is HTMLBlock || containsInlineHTML($0)
+    }
+  }
+
+  private func process(_ input: [Markup], depth: Int = 0) -> [InlineMarkup] {
+    // At the depth cap, emit everything verbatim: `InlineHTML` becomes literal
+    // text and other nodes pass through. This bounds recursion and the
+    // per-open scan on inputs like thousands of unclosed `<b>` tags.
+    if depth >= Self.maxDepth {
+      return input.compactMap { markup in
+        guard let html = markup as? InlineHTML else { return markup as? InlineMarkup }
+        if case .comment = classify(html) { return nil }
+        return Text(html.rawHTML)
+      }
+    }
+    var output: [InlineMarkup] = []
+    var index = 0
+    while index < input.count {
+      guard let html = input[index] as? InlineHTML else {
+        if let markup = input[index] as? InlineMarkup {
+          output.append(markup)
+        }
+        index += 1
+        continue
+      }
+      switch classify(html) {
+      case .comment:
+        index += 1
+      case .close("br"):
+        // `</br>` is a parse error that browsers treat as `<br>`.
+        output.append(LineBreak())
+        index += 1
+      case .other, .close:
+        output.append(Text(html.rawHTML))
+        index += 1
+      case .open(let name, let attributes):
+        if name == "br" {
+          output.append(LineBreak())
+          index += 1
+          continue
+        }
+        if name == "wbr" {
+          output.append(Text("\u{200B}"))
+          index += 1
+          continue
+        }
+        guard Self.pairedTags.contains(name) else {
+          output.append(Text(html.rawHTML))
+          index += 1
+          continue
+        }
+        if let closeIndex = findClosingIndex(named: name, in: input, from: index + 1) {
+          let inner = process(Array(input[(index + 1)..<closeIndex]), depth: depth + 1)
+          output.append(contentsOf: wrapOrLiteral(open: html, close: input[closeIndex], name: name, attributes: attributes, inner: inner))
+          index = closeIndex + 1
+        } else {
+          let inner = process(Array(input[(index + 1)...]), depth: depth + 1)
+          output.append(contentsOf: wrapOrLiteral(open: html, close: nil, name: name, attributes: attributes, inner: inner))
+          index = input.count
+        }
+      }
+    }
+    return output
+  }
+
+  /// Returns the wrapped pair, or the literal open tag + inner nodes + literal
+  /// close tag when the pair can't be represented.
+  private func wrapOrLiteral(open: InlineHTML, close: Markup?, name: String, attributes: String, inner: [InlineMarkup]) -> [InlineMarkup] {
+    if let wrapped = wrapPair(name: name, attributes: attributes, inner: inner) {
+      return wrapped
+    }
+    var literal: [InlineMarkup] = [Text(open.rawHTML)]
+    literal.append(contentsOf: inner)
+    if let close = close as? InlineHTML {
+      literal.append(Text(close.rawHTML))
+    }
+    return literal
+  }
+
+  private func classify(_ html: InlineHTML) -> Tag {
+    let raw = html.rawHTML.trimmingCharacters(in: .whitespaces)
+    if raw.hasPrefix("<!--") { return .comment }
+    guard raw.count > 2, raw.hasPrefix("<"), raw.hasSuffix(">") else { return .other }
+    var inner = String(raw.dropFirst().dropLast())
+    if inner.hasPrefix("/") {
+      inner.removeFirst()
+      let name = inner.split(whereSeparator: { Self.htmlWhitespace.contains($0) || $0 == "/" }).first.map(String.init) ?? ""
+      return name.first?.isLetter == true ? .close(name: name.lowercased()) : .other
+    }
+    // A trailing "/" does not close non-void elements in HTML5, so `<b/>x`
+    // behaves like `<b>x`; the tag is still treated as an open.
+    if inner.hasSuffix("/") { inner = String(inner.dropLast()) }
+    guard let nameEnd = inner.firstIndex(where: { Self.htmlWhitespace.contains($0) }) else {
+      let name = inner.lowercased()
+      return name.first?.isLetter == true ? .open(name: name, attributes: "") : .other
+    }
+    let name = String(inner[..<nameEnd]).lowercased()
+    guard name.first?.isLetter == true else { return .other }
+    return .open(name: name, attributes: String(inner[nameEnd...]))
+  }
+
+  /// Finds the matching `</name>` for an open tag at `start - 1`, counting
+  /// nested same-name tags. Other tags do not affect depth, matching how
+  /// browsers auto-close interleaved markup (the stray closer then renders
+  /// literally at the outer level).
+  private func findClosingIndex(named name: String, in input: [Markup], from start: Int) -> Int? {
+    var depth = 0
+    for index in start..<input.count {
+      guard let html = input[index] as? InlineHTML else { continue }
+      switch classify(html) {
+      case .open(let tagName, _) where tagName == name:
+        depth += 1
+      case .close(let tagName) where tagName == name:
+        if depth == 0 { return index }
+        depth -= 1
+      default:
+        continue
+      }
+    }
+    return nil
+  }
+
+  /// Wraps the processed children of a matched tag pair, or returns `nil` when
+  /// the pair cannot be represented (the caller then renders it literally).
+  private func wrapPair(name: String, attributes: String, inner: [InlineMarkup]) -> [InlineMarkup]? {
+    switch name {
+    case "b", "strong":
+      return splitOnImages(inner) { Strong($0) }
+    case "i", "em":
+      return splitOnImages(inner) { Emphasis($0) }
+    case "s", "del", "strike":
+      return splitOnImages(inner) { Strikethrough($0) }
+    case "u", "ins":
+      return attributeWrap("underline", inner)
+    case "mark":
+      return attributeWrap("highlight", inner)
+    case "sub":
+      return attributeWrap("subscript", inner)
+    case "sup":
+      return attributeWrap("superscript", inner)
+    case "code", "kbd", "samp", "tt":
+      return [InlineCode(inner.map { ($0 as? InlineCode)?.code ?? $0.plainText }.joined())]
+    case "a":
+      guard let href = hrefValue(in: attributes),
+            let children = linkChildren(inner) else { return nil }
+      return [Link(destination: href, children)]
+    default:
+      return nil
+    }
+  }
+
+  /// Splits a basic wrapper run around `Image` children: images must reach
+  /// paragraph level for `ImageBlockRewriter` to hoist them into blocks —
+  /// an `Image` nested inside `Strong` would be dropped at conversion.
+  private func splitOnImages(_ inner: [InlineMarkup], wrap: ([InlineMarkup]) -> InlineMarkup) -> [InlineMarkup] {
+    var output: [InlineMarkup] = []
+    var run: [InlineMarkup] = []
+    for markup in inner {
+      if markup is Image {
+        if !run.isEmpty {
+          output.append(wrap(run))
+          run = []
+        }
+        output.append(markup)
+      } else {
+        run.append(markup)
+      }
+    }
+    if !run.isEmpty { output.append(wrap(run)) }
+    return output
+  }
+
+  /// `InlineAttributes` children must be `RecurringInlineMarkup`. Stacked
+  /// attribute tags (`<u><sup>x</sup></u>`) merge into a single node; other
+  /// non-recurring children (`Link`, `Image`) split the attribute run so the
+  /// surrounding text still gets the style instead of the whole pair going
+  /// literal.
+  private func attributeWrap(_ key: String, _ inner: [InlineMarkup]) -> [InlineMarkup] {
+    var output: [InlineMarkup] = []
+    var run: [any RecurringInlineMarkup] = []
+
+    func flushRun() {
+      guard !run.isEmpty else { return }
+      output.append(InlineAttributes(attributes: "{\(key):true}", run))
+      run = []
+    }
+
+    for markup in inner {
+      if let attributes = markup as? InlineAttributes {
+        // Nested attribute tags merge keys: `<u><sup>x</sup></u>` keeps both
+        // underline and superscript. Children that can't rebuild the node
+        // degrade to the unmerged original.
+        flushRun()
+        if let children = recurring(Array(attributes.children)) {
+          output.append(InlineAttributes(attributes: mergedAttributes(attributes.attributes, key: key), children))
+        } else {
+          output.append(attributes)
+        }
+      } else if let recurring = markup as? (any RecurringInlineMarkup) {
+        run.append(recurring)
+      } else {
+        // Non-recurring nodes (`Link`, `Image`) end the run but stay in the
+        // output, so `<u>text <a>x</a> more</u>` underlines both text parts.
+        flushRun()
+        output.append(markup)
+      }
+    }
+    flushRun()
+    return output
+  }
+
+  /// Attributes produced by this rewriter always end in `}`; attribute nodes
+  /// from other sources keep their original string, dropping the new key —
+  /// graceful degradation rather than a malformed merge.
+  private func mergedAttributes(_ attributes: String, key: String) -> String {
+    guard attributes.hasSuffix("}") else { return attributes }
+    return String(attributes.dropLast()) + ",\(key):true}"
+  }
+
+  /// `Link` children must be `RecurringInlineMarkup`; `InlineAttributes` nodes
+  /// inside an anchor are flattened to their children (the link wins over the
+  /// inner styling, which is the more useful behavior).
+  private func linkChildren(_ inner: [InlineMarkup]) -> [any RecurringInlineMarkup]? {
+    var children: [any RecurringInlineMarkup] = []
+    for markup in inner {
+      if let attributes = markup as? InlineAttributes {
+        guard let nested = recurring(Array(attributes.children)) else { return nil }
+        children.append(contentsOf: nested)
+      } else if let recurring = markup as? (any RecurringInlineMarkup) {
+        children.append(recurring)
+      } else {
+        return nil
+      }
+    }
+    return children
+  }
+
+  private func recurring(_ inner: [Markup]) -> [any RecurringInlineMarkup]? {
+    let children = inner.compactMap { $0 as? (any RecurringInlineMarkup) }
+    return children.count == inner.count ? children : nil
+  }
+
+  /// Extracts the `href` value from a tag's attribute string with a
+  /// quote-aware scan: attribute names are matched case-insensitively on a
+  /// whitespace boundary, and quoted values are skipped rather than scanned,
+  /// so `data-href` or `title="a href='b'"` can't produce a link.
+  private func hrefValue(in attributes: String) -> String? {
+    var index = attributes.startIndex
+    var previousWasBoundary = true
+    while index < attributes.endIndex {
+      let character = attributes[index]
+      if character == "\"" || character == "'" {
+        // Skip a quoted attribute value entirely.
+        index = attributes[index...].dropFirst().firstIndex(of: character) ?? attributes.endIndex
+        if index < attributes.endIndex { index = attributes.index(after: index) }
+        previousWasBoundary = false
+        continue
+      }
+      defer { index = attributes.index(after: index) }
+      if character == "h" || character == "H", previousWasBoundary {
+        let rest = attributes[index...]
+        if rest.prefix(4).lowercased() == "href" {
+          var cursor = rest.index(rest.startIndex, offsetBy: 4)
+          while cursor < attributes.endIndex, Self.htmlWhitespace.contains(attributes[cursor]) {
+            cursor = attributes.index(after: cursor)
+          }
+          if cursor < attributes.endIndex, attributes[cursor] == "=" {
+            cursor = attributes.index(after: cursor)
+            while cursor < attributes.endIndex, Self.htmlWhitespace.contains(attributes[cursor]) {
+              cursor = attributes.index(after: cursor)
+            }
+            return decodeEntities(attributeValue(in: attributes, from: &cursor))
+          }
+        }
+      }
+      previousWasBoundary = Self.htmlWhitespace.contains(character)
+    }
+    return nil
+  }
+
+  /// Reads one attribute value: quoted, or unquoted until whitespace/`>`.
+  private func attributeValue(in attributes: String, from cursor: inout String.Index) -> String {
+    guard cursor < attributes.endIndex else { return "" }
+    let quote = attributes[cursor]
+    if quote == "\"" || quote == "'" {
+      let valueStart = attributes.index(after: cursor)
+      let valueEnd = attributes[valueStart...].firstIndex(of: quote) ?? attributes.endIndex
+      cursor = valueEnd < attributes.endIndex ? attributes.index(after: valueEnd) : attributes.endIndex
+      return String(attributes[valueStart..<valueEnd])
+    }
+    var end = cursor
+    while end < attributes.endIndex, !Self.htmlWhitespace.contains(attributes[end]), attributes[end] != ">" {
+      end = attributes.index(after: end)
+    }
+    defer { cursor = end }
+    return String(attributes[cursor..<end])
+  }
+
+  /// Decodes the common named and numeric entities found in attribute values
+  /// (cmark decodes `Text` nodes but never sees attribute contents).
+  private func decodeEntities(_ value: String) -> String {
+    guard value.contains("&") else { return value }
+    var result = value
+    result = result.replacingOccurrences(of: "&quot;", with: "\"")
+    result = result.replacingOccurrences(of: "&#39;", with: "'")
+    result = result.replacingOccurrences(of: "&#x27;", with: "'")
+    result = result.replacingOccurrences(of: "&lt;", with: "<")
+    result = result.replacingOccurrences(of: "&gt;", with: ">")
+    result = result.replacingOccurrences(of: "&amp;", with: "&")
+    return result
+  }
+}
diff --git a/Sources/MarkdownText/Parser/Scanners/MarkupPostParsingRewriter.swift b/Sources/MarkdownText/Parser/Scanners/MarkupPostParsingRewriter.swift
index b4321860..7c9ece7e 100644
--- a/Sources/MarkdownText/Parser/Scanners/MarkupPostParsingRewriter.swift
+++ b/Sources/MarkdownText/Parser/Scanners/MarkupPostParsingRewriter.swift
@@ -52,6 +52,18 @@ final class PartialTableMarkupPostParsingRewriter: MarkupPostParsingRewriter {
   }
 }
 
+/// Rewrites supported inline raw-HTML tags into Markdown equivalents. See
+/// `InlineHTMLRewriter`. Runs unconditionally: it only touches subtrees that
+/// contain `InlineHTML` nodes and is not a speculative repair.
+final class InlineHTMLMarkupPostParsingRewriter: MarkupPostParsingRewriter {
+
+  func rewriteIfApplicable(document: Document) -> Document? {
+    guard InlineHTMLRewriter.containsInlineHTML(document) else { return nil }
+    var rewriter = InlineHTMLRewriter()
+    return rewriter.visit(document) as? Document
+  }
+}
+
 /// Splits paragraphs that contain images into block-level image-only
 /// paragraphs. See `ImageBlockRewriter`.
 ///
diff --git a/Sources/MarkdownText/Utilities/MDFont.swift b/Sources/MarkdownText/Utilities/MDFont.swift
index 679963b8..b6990eb5 100644
--- a/Sources/MarkdownText/Utilities/MDFont.swift
+++ b/Sources/MarkdownText/Utilities/MDFont.swift
@@ -12,3 +12,14 @@ import AppKit
 /// Cross-platform font type. Resolves to `UIFont` on UIKit platforms and `NSFont` on AppKit platforms.
 public typealias MDFont = NSFont
 #endif
+
+extension MDFont {
+  /// Returns a copy of the font scaled by `factor`.
+  func scaled(by factor: CGFloat) -> MDFont {
+    #if canImport(UIKit)
+    return withSize(pointSize * factor)
+    #else
+    return NSFont(descriptor: fontDescriptor, size: pointSize * factor) ?? self
+    #endif
+  }
+}
diff --git a/Tests/MarkdownTextTests/InlineHTMLRewriterTests.swift b/Tests/MarkdownTextTests/InlineHTMLRewriterTests.swift
new file mode 100644
index 00000000..516de303
--- /dev/null
+++ b/Tests/MarkdownTextTests/InlineHTMLRewriterTests.swift
@@ -0,0 +1,260 @@
+//
+//  Copyright (c) Microsoft Corporation. All rights reserved.
+//  Licensed under the MIT License. See LICENSE in the project root for license information.
+//
+
+@testable import SwiftStreamingMarkdown
+import Markdown
+import XCTest
+
+final class InlineHTMLRewriterTests: XCTestCase {
+
+  private let parser = MarkdownParserImpl()
+
+  /// Parses `text` through the full pipeline and returns the rendered
+  /// paragraph's attributed content.
+  private func renderedParagraph(_ text: String) async -> NSMutableAttributedString? {
+    let renderables = await renderables(text)
+    guard case .paragraph(_, let content) = renderables.first else { return nil }
+    return content
+  }
+
+  private func renderables(_ text: String) async -> [MarkdownRenderable] {
+    await parser.parse(text: text, config: .default).renderables
+  }
+
+  // MARK: - Inline containers
+
+  func test_bold_tag_renders_strong() async {
+    let content = await renderedParagraph("a <b>bold</b> c")
+    XCTAssertEqual(content?.string, "a bold c")
+    let boldFont = content?.attribute(.font, at: 2, effectiveRange: nil) as? MDFont
+    let plainFont = content?.attribute(.font, at: 0, effectiveRange: nil) as? MDFont
+    XCTAssertNotNil(boldFont)
+    XCTAssertNotEqual(boldFont, plainFont)
+  }
+
+  func test_italic_tag_renders_emphasis() async {
+    let content = await renderedParagraph("a <i>x</i>")
+    XCTAssertEqual(content?.string, "a x")
+  }
+
+  func test_strikethrough_tag_adds_strike_attribute() async {
+    let content = await renderedParagraph("a <s>gone</s>")
+    XCTAssertEqual(content?.string, "a gone")
+    let strike = content?.attribute(.strikethroughStyle, at: 2, effectiveRange: nil) as? Int
+    XCTAssertEqual(strike, NSUnderlineStyle.single.rawValue)
+  }
+
+  func test_br_tag_renders_line_break() async {
+    let content = await renderedParagraph("one<br>two")
+    XCTAssertEqual(content?.string, "one\ntwo")
+  }
+
+  func test_kbd_tag_renders_inline_code() async {
+    let content = await renderedParagraph("press <kbd>Cmd</kbd>")
+    XCTAssertEqual(content?.string, "press Cmd")
+    let background = content?.attribute(.backgroundColor, at: 6, effectiveRange: nil)
+    XCTAssertNotNil(background)
+  }
+
+  func test_sub_and_sup_tags_set_baseline_offsets() async {
+    let content = await renderedParagraph("H<sub>2</sub>O x<sup>2</sup>")
+    XCTAssertEqual(content?.string, "H2O x2")
+    let sub = content?.attribute(.baselineOffset, at: 1, effectiveRange: nil) as? CGFloat
+    XCTAssertNotNil(sub)
+    XCTAssertLessThan(sub ?? 0, 0)
+    let sup = content?.attribute(.baselineOffset, at: 5, effectiveRange: nil) as? CGFloat
+    XCTAssertNotNil(sup)
+    XCTAssertGreaterThan(sup ?? 0, 0)
+  }
+
+  func test_u_tag_underlines() async {
+    let content = await renderedParagraph("a <u>under</u>")
+    let underline = content?.attribute(.underlineStyle, at: 2, effectiveRange: nil) as? Int
+    XCTAssertEqual(underline, NSUnderlineStyle.single.rawValue)
+  }
+
+  func test_mark_tag_highlights() async {
+    let content = await renderedParagraph("a <mark>hi</mark>")
+    let background = content?.attribute(.backgroundColor, at: 2, effectiveRange: nil) as? MDColor
+    XCTAssertNotNil(background)
+  }
+
+  func test_anchor_tag_renders_link() async {
+    let content = await renderedParagraph("see <a href=\"https://example.com\">site</a>")
+    XCTAssertEqual(content?.string, "see site")
+    let link = content?.attribute(.link, at: 4, effectiveRange: nil) as? URL
+    XCTAssertEqual(link?.absoluteString, "https://example.com")
+  }
+
+  func test_nested_attribute_tags_compose() async {
+    let content = await renderedParagraph("a <u><sup>x</sup></u>")
+    let underline = content?.attribute(.underlineStyle, at: 2, effectiveRange: nil) as? Int
+    XCTAssertEqual(underline, NSUnderlineStyle.single.rawValue)
+    let sup = content?.attribute(.baselineOffset, at: 2, effectiveRange: nil) as? CGFloat
+    XCTAssertGreaterThan(sup ?? 0, 0)
+  }
+
+  func test_tag_inside_strong_keeps_bold() async {
+    let content = await renderedParagraph("**<u>x</u>**")
+    XCTAssertEqual(content?.string, "x")
+    let underline = content?.attribute(.underlineStyle, at: 0, effectiveRange: nil) as? Int
+    XCTAssertEqual(underline, NSUnderlineStyle.single.rawValue)
+  }
+
+  // MARK: - Graceful degradation
+
+  func test_unclosed_tag_applies_to_end_of_container() async {
+    let content = await renderedParagraph("a <b>bold")
+    XCTAssertEqual(content?.string, "a bold")
+  }
+
+  func test_stray_close_tag_renders_literally() async {
+    let content = await renderedParagraph("a </b> c")
+    XCTAssertEqual(content?.string, "a </b> c")
+  }
+
+  func test_unknown_tag_renders_literally() async {
+    let content = await renderedParagraph("a <span>x</span> b")
+    XCTAssertEqual(content?.string, "a <span>x</span> b")
+  }
+
+  func test_comment_is_dropped() async {
+    let content = await renderedParagraph("a <!-- hidden --> b")
+    XCTAssertEqual(content?.string, "a  b")
+  }
+
+  func test_anchor_without_href_renders_literally() async {
+    let content = await renderedParagraph("a <a>x</a>")
+    XCTAssertEqual(content?.string, "a <a>x</a>")
+  }
+
+  func test_data_href_does_not_produce_a_link() async {
+    let content = await renderedParagraph("a <a data-href=\"https://evil.example\">x</a>")
+    XCTAssertEqual(content?.string, "a <a data-href=\"https://evil.example\">x</a>")
+    let link = content?.attribute(.link, at: 2, effectiveRange: nil)
+    XCTAssertNil(link)
+  }
+
+  func test_uppercase_href_produces_link() async {
+    let content = await renderedParagraph("a <a HREF=\"https://example.com\">x</a>")
+    XCTAssertEqual(content?.string, "a x")
+    let link = content?.attribute(.link, at: 2, effectiveRange: nil) as? URL
+    XCTAssertEqual(link?.absoluteString, "https://example.com")
+  }
+
+  func test_quoted_attribute_containing_href_is_skipped() async {
+    let content = await renderedParagraph("a <a title=\"v href='x'\" href=\"https://real.example\">x</a>")
+    let link = content?.attribute(.link, at: 2, effectiveRange: nil) as? URL
+    XCTAssertEqual(link?.absoluteString, "https://real.example")
+  }
+
+  func test_href_entities_are_decoded() async {
+    let content = await renderedParagraph("a <a href=\"https://x.example?a=1&amp;b=2\">x</a>")
+    let link = content?.attribute(.link, at: 2, effectiveRange: nil) as? URL
+    XCTAssertEqual(link?.absoluteString, "https://x.example?a=1&b=2")
+  }
+
+  func test_stray_br_close_tag_renders_line_break() async {
+    let content = await renderedParagraph("a</br>b")
+    XCTAssertEqual(content?.string, "a\nb")
+  }
+
+  func test_standalone_tag_block_renders_literally() async {
+    // `<b>` on its own line is an HTML block (cmark type 7); it must not lose text.
+    let renderables = await renderables("intro\n\n<b>\nHello world\n</b>\n\noutro")
+    let allText = renderables.compactMap { renderable -> String? in
+      guard case .paragraph(_, let content) = renderable else { return nil }
+      return content.string
+    }.joined()
+    XCTAssertTrue(allText.contains("Hello world"))
+    XCTAssertTrue(allText.contains("intro"))
+  }
+
+  func test_underline_wraps_text_around_a_link() async {
+    let content = await renderedParagraph("<u>before <a href=\"https://x.example\">mid</a> after</u>")
+    XCTAssertEqual(content?.string, "before mid after")
+    let underlineBefore = content?.attribute(.underlineStyle, at: 0, effectiveRange: nil) as? Int
+    XCTAssertEqual(underlineBefore, NSUnderlineStyle.single.rawValue)
+    let link = content?.attribute(.link, at: 7, effectiveRange: nil) as? URL
+    XCTAssertEqual(link?.absoluteString, "https://x.example")
+    let underlineAfter = content?.attribute(.underlineStyle, at: 10, effectiveRange: nil) as? Int
+    XCTAssertEqual(underlineAfter, NSUnderlineStyle.single.rawValue)
+  }
+
+  func test_link_wraps_attribute_styled_text() async {
+    let content = await renderedParagraph("<a href=\"https://x.example\"><u>x</u></a>")
+    XCTAssertEqual(content?.string, "x")
+    let link = content?.attribute(.link, at: 0, effectiveRange: nil) as? URL
+    XCTAssertEqual(link?.absoluteString, "https://x.example")
+  }
+
+  func test_sup_tag_scales_bold_text_either_nesting_order() async {
+    // Inner converters overwrite `.font` with their own variants, so the
+    // shrink must be applied to the produced runs — `<sup><b>` used to stay
+    // full-size.
+    for input in ["a <sup><b>x</b></sup>", "a <b><sup>x</sup></b>"] {
+      let content = await renderedParagraph(input)
+      XCTAssertEqual(content?.string, "a x")
+      let innerFont = (content?.attribute(.font, at: 2, effectiveRange: nil) as? MDFont)?.pointSize
+      let plainFont = (content?.attribute(.font, at: 0, effectiveRange: nil) as? MDFont)?.pointSize
+      XCTAssertNotNil(innerFont)
+      XCTAssertNotNil(plainFont)
+      XCTAssertLessThan(innerFont ?? .infinity, plainFont ?? 0)
+    }
+  }
+
+  func test_code_tag_flattens_nested_inline_code() async {
+    let content = await renderedParagraph("<code>a `b` c</code>")
+    XCTAssertEqual(content?.string, "a b c")
+  }
+
+  func test_block_comment_is_dropped() async {
+    let renderables = await renderables("intro\n\n<!-- note -->\n\noutro")
+    let allText = renderables.compactMap { renderable -> String? in
+      guard case .paragraph(_, let content) = renderable else { return nil }
+      return content.string
+    }.joined()
+    XCTAssertFalse(allText.contains("note"))
+    XCTAssertTrue(allText.contains("intro"))
+    XCTAssertTrue(allText.contains("outro"))
+  }
+
+  func test_image_inside_bold_tag_stays_at_paragraph_level() async {
+    // With image support enabled, `![x](u)` inside `<b>` must not be swallowed.
+    let document = await parser.parse(
+      text: "a <b>![alt](https://x.example/i.png) after</b>",
+      config: .default.withImageConfig(ImageConfig(enabled: true, allowedImageTypes: [.remote(allowedDomains: [])]))
+    )
+    XCTAssertTrue(document.renderables.contains { renderable in
+      if case .image = renderable { return true }
+      return false
+    })
+  }
+
+  func test_nested_link_inside_link_loses_inner_link_keeps_text() async {
+    let content = await renderedParagraph("[a <a href=\"https://inner.example\">inner</a>](https://outer.example)")
+    XCTAssertEqual(content?.string, "a inner")
+  }
+
+  func test_deeply_unclosed_tags_do_not_crash() async {
+    let opens = String(repeating: "<b>", count: 500)
+    let content = await renderedParagraph("a \(opens)x")
+    XCTAssertNotNil(content?.string)
+  }
+
+  // MARK: - Non-regression
+
+  func test_document_without_html_is_untouched() async {
+    let renderables = await renderables("plain **bold** text")
+    guard case .paragraph = renderables.first else {
+      return XCTFail("expected paragraph")
+    }
+  }
+
+  func test_html_inside_code_span_is_not_rewritten() async {
+    let content = await renderedParagraph("`<b>x</b>`")
+    XCTAssertEqual(content?.string, "<b>x</b>")
+  }
+}