- ` groups, switching container when ordered-ness flips.
+ /// Nesting is flattened to a single level for v1 (see deviations).
+ private static func renderList(items: [ListItem], ns: NSString) -> String {
+ var out: [String] = []
+ var currentOrdered: Bool?
+ var buffer: [String] = []
+
+ func flush() {
+ guard let ordered = currentOrdered, !buffer.isEmpty else { return }
+ let tag = ordered ? "ol" : "ul"
+ out.append("<\(tag)>\n" + buffer.joined(separator: "\n") + "\n")
+ buffer.removeAll()
+ }
+
+ for item in items {
+ if currentOrdered != item.ordered {
+ flush()
+ currentOrdered = item.ordered
+ }
+ buffer.append(listItem(item, ns: ns))
+ }
+ flush()
+ return out.joined(separator: "\n")
+ }
+
+ private static func listItem(_ item: ListItem, ns: NSString) -> String {
+ let content = renderInlines(item.inlines, ns: ns)
+ if item.checkbox != nil {
+ // GFM task markup so markdown consumers (Obsidian etc.) restore
+ // `- [ ]` on paste. Rich targets get this stripped to a plain
+ // bullet by the pasteboard writer (user's call).
+ let box = item.checked
+ ? " "
+ : " "
+ return "
- \(box)\(content) " + } + return "
- \(content) " + } + + /// Fenced code: drop the opening ```lang / closing ``` fence lines, escape body. + private static func renderCodeBlock(range: NSRange, ns: NSString) -> String { + let raw = ns.substring(with: range) + var lines = raw.components(separatedBy: "\n") + if lines.last == "" { lines.removeLast() } // drop trailing-newline artifact + + let language = fenceLanguage(lines.first ?? "") + var body = Array(lines.dropFirst()) + if let last = body.last, isFenceLine(last) { body.removeLast() } + + let escaped = escape(body.joined(separator: "\n")) + if let language, !language.isEmpty { + return "
\(escaped)\(escaped)\(escape(raw.trimmingCharacters(in: .newlines)))" + } + let head = parsed.header.map { "
\(escape(ns.substring(with: content)))"
+
+ case .emphasis(let kind, _, _, let children):
+ let inner = renderInlines(children, ns: ns)
+ switch kind {
+ case .italic: return "\(inner)"
+ case .bold: return "\(inner)"
+ case .boldItalic: return "\(inner)"
+ }
+
+ case .link(_, _, let url, _, let children):
+ return "\(renderInlines(children, ns: ns))"
+
+ case .image(_, let alt, let url, _):
+ return "`/`` wrappers, mixed-case tags,
+/// and sometimes unclosed elements. This converter does NOT assume well-formed
+/// XML — it runs a tolerant tag scanner with a small nesting stack, unwraps
+/// unknown/styling-only tags, decodes entities, and collapses insignificant
+/// whitespace. It prefers robustness over completeness.
+///
+/// Returns `nil` when the input has no convertible structure (no tags), so the
+/// caller can fall back to the plain-text flavor.
+enum HTMLToMarkdownConverter {
+
+ static func markdown(fromHTML html: String) -> String? {
+ var sawTag = false
+ let root = parse(html, sawTag: &sawTag)
+ guard sawTag else { return nil }
+ let rendered = renderBlocks(root.children).htmlTrimmed
+ return rendered.isEmpty ? nil : rendered
+ }
+
+ // MARK: - DOM
+
+ private final class Node {
+ let name: String // "" for a text node, "#root" for the root
+ var attrs: [String: String]
+ var children: [Node] = []
+ var text: String
+
+ init(name: String, attrs: [String: String] = [:], text: String = "") {
+ self.name = name
+ self.attrs = attrs
+ self.text = text
+ }
+
+ var isText: Bool { name.isEmpty }
+ }
+
+ private static let voidElements: Set = [
+ "br", "hr", "img", "input", "meta", "link", "source",
+ "col", "area", "base", "wbr", "embed", "param", "track"
+ ]
+
+ // MARK: - Lenient parse
+
+ private static func parse(_ html: String, sawTag: inout Bool) -> Node {
+ let root = Node(name: "#root")
+ var stack = [root]
+ let chars = Array(html)
+ let n = chars.count
+ var i = 0
+
+ func top() -> Node { stack[stack.count - 1] }
+ func appendText(_ s: String) {
+ if !s.isEmpty { top().children.append(Node(name: "", text: s)) }
+ }
+
+ while i < n {
+ if chars[i] == "<" {
+ // HTML comment: skip through "-->"
+ if hasPrefix(chars, at: i, "