@apollohg/react-native-rich-text-editor 2.0.3 → 2.0.5

package/ios/EditorStyleSheet.swift

@@ -2,6 +2,34 @@ import UIKit
 
 struct EditorStyleSheet {
     let styles: [String: [String: Any]]
+    let rules: [Rule]
+
+    struct Rule {
+        let path: [String]
+        let style: [String: Any]
+    }
+
+    init(styles: [String: [String: Any]], rules: [Rule] = []) {
+        self.styles = styles
+        self.rules = rules
+    }
+
+    static func decodeRules(_ value: Any?) -> [Rule] {
+        let names: Set<String> = [
+            "content", "text", "paragraph", "h1", "h2", "h3", "h4", "h5", "h6",
+            "blockquote", "codeBlock", "bulletList", "orderedList", "taskList", "listItem",
+            "taskItem", "listMarker", "taskCheckbox", "horizontalRule", "image", "link",
+            "inlineCode", "bold", "italic", "underline", "strike", "mention", "placeholder"
+        ]
+        return (value as? [Any] ?? []).compactMap { entry in
+            guard let entry = entry as? [String: Any],
+                  let rawPath = entry["path"] as? [String], !rawPath.isEmpty,
+                  let style = entry["style"] as? [String: Any] else { return nil }
+            let path = rawPath.map(Self.element)
+            guard path.allSatisfy({ names.contains($0) }) else { return nil }
+            return Rule(path: path, style: style)
+        }
+    }
 
     static func collapsedMargin(_ first: CGFloat, _ second: CGFloat) -> CGFloat {
         max(0, first, second) + min(0, first, second)
@@ -26,7 +54,38 @@ struct EditorStyleSheet {
 
     subscript(_ element: String) -> [String: Any] { styles[Self.element(element)] ?? [:] }
 
+    private func matchingRules(_ element: String, ancestors: [String]) -> [Rule] {
+        let chain = (ancestors + [element]).map(Self.element)
+        return rules.filter { $0.path.count <= chain.count && Array(chain.suffix($0.path.count)) == $0.path }
+    }
+
+    func hasInlineFontRule(_ marks: [Any], ancestors: [String]) -> Bool {
+        marks.contains { mark in
+            guard let rawName = (mark as? String) ?? (mark as? [String: Any])?["type"] as? String else { return false }
+            let name = Self.element(rawName)
+            return Self.inlineMarkNames.contains(name)
+                && matchingRules(name, ancestors: ancestors).contains { $0.style["fontFamily"] is String }
+        }
+    }
+
+    func resolvedValues(_ element: String, ancestors: [String] = []) -> [String: Any] {
+        var values = self[element]
+        for rule in matchingRules(element, ancestors: ancestors) {
+            values.merge(rule.style, uniquingKeysWith: Self.mergeValue)
+        }
+        return values
+    }
+
+    private static func mergeValue(_ current: Any, _ next: Any) -> Any {
+        guard let current = current as? [String: Any], let next = next as? [String: Any] else { return next }
+        return current.merging(next, uniquingKeysWith: Self.mergeValue)
+    }
+
     func box(_ element: String) -> EditorStyleBox {
+        box(element, ancestors: [])
+    }
+
+    func box(_ element: String, ancestors: [String]) -> EditorStyleBox {
         var values: [String: Any] = [:]
         switch Self.element(element) {
         case "codeBlock":
@@ -40,7 +99,7 @@ struct EditorStyleSheet {
         case "horizontalRule": values = ["backgroundColor": UIColor.separator, "marginTop": 12, "marginBottom": 12]
         default: break
         }
-        values.merge(self[element]) { _, new in new }
+        values.merge(resolvedValues(element, ancestors: ancestors)) { _, new in new }
         return EditorStyleBox(values)
     }
 
@@ -53,19 +112,23 @@ struct EditorStyleSheet {
         if name == "codeBlock" { style = style.merged(with: EditorTextStyle(fontFamily: "monospace")) }
         style = style.merged(with: semantic)
         for ancestor in ancestors { style = style.merged(with: EditorTextStyle(dictionary: self[ancestor])) }
-        return style.merged(with: EditorTextStyle(dictionary: self[name]))
+        return style.merged(with: EditorTextStyle(dictionary: resolvedValues(name, ancestors: ancestors)))
     }
 
     func textValues(_ element: String, ancestors: [String] = []) -> [String: Any] {
         let keys = ["letterSpacing", "textAlign", "textDecorationLine", "textDecorationColor", "textDecorationStyle"]
         var result: [String: Any] = [:]
-        for layer in ["text"] + ancestors + [element] {
+        for layer in ["text"] + ancestors {
             for key in keys where self[layer][key] != nil { result[key] = self[layer][key] }
         }
+        let target = resolvedValues(element, ancestors: ancestors)
+        for key in keys where target[key] != nil { result[key] = target[key] }
         return result
     }
 
-    func inlineAttributes(_ marks: [Any], base: [NSAttributedString.Key: Any], scale: CGFloat = 1) -> [NSAttributedString.Key: Any] {
+    private static let inlineMarkNames = ["inlineCode", "bold", "italic", "link", "underline", "strike"]
+
+    func inlineAttributes(_ marks: [Any], base: [NSAttributedString.Key: Any], scale: CGFloat = 1, ancestors: [String] = []) -> [NSAttributedString.Key: Any] {
         var attributes = base
         var byName: [String: [String: Any]] = [:]
         for mark in marks {
@@ -74,7 +137,7 @@ struct EditorStyleSheet {
                 byName[Self.element(name)] = object
             }
         }
-        for name in ["inlineCode", "bold", "italic", "link", "underline", "strike"] where byName[name] != nil {
+        for name in Self.inlineMarkNames where byName[name] != nil {
             var values: [String: Any] = [:]
             switch name {
             case "inlineCode": values = ["fontFamily": "monospace"]
@@ -85,7 +148,7 @@ struct EditorStyleSheet {
             case "strike": values = ["textDecorationLine": "line-through"]
             default: break
             }
-            values.merge(self[name]) { _, new in new }
+            values.merge(resolvedValues(name, ancestors: ancestors)) { _, new in new }
             Self.applyText(values, to: &attributes, scale: scale)
             if name == "link", let href = byName[name]?["href"] as? String {
                 attributes[RenderBridgeAttributes.linkHref] = href
@@ -334,8 +397,10 @@ extension RenderBridge {
         }
         guard start < result.length else { return }
         let range = NSRange(location: start, length: result.length - start)
-        let outer = ancestors.reduce(UIEdgeInsets.zero) { $0.adding(sheet.box($1.nodeType).outerInsets) }
-        var values = sheet.box(context.nodeType).values
+        let outer = ancestors.enumerated().reduce(UIEdgeInsets.zero) { total, entry in
+            total.adding(sheet.box(entry.element.nodeType, ancestors: ancestors.prefix(entry.offset).map(\.nodeType)).outerInsets)
+        }
+        var values = sheet.box(context.nodeType, ancestors: ancestors.map(\.nodeType)).values
         if omitBottomMargin { values["marginBottom"] = 0 }
         let box = EditorStyleBox(values)
         let descriptor = EditorRenderedBox(box: box, depth: ancestors.count, leading: outer.left + box.margin.left, trailing: outer.right + box.margin.right)
@@ -444,10 +509,11 @@ final class EditorStyleBoxView: UIView {
 let editorTaskCheckboxAttribute = NSAttributedString.Key("com.apollohg.editor.taskCheckbox")
 
 extension EditorStyleSheet {
-    func checkbox(checked: Bool) -> EditorStyleBox {
+    func checkbox(checked: Bool, ancestors: [String] = []) -> EditorStyleBox {
         var values: [String: Any] = ["borderWidth": 1.8, "borderColor": "#8e8e93ff", "borderRadius": 5, "size": 24, "gap": 8, "checkColor": "#007affff"]
-        values.merge(self["taskCheckbox"]) { _, new in new }
-        if checked { values.merge(self["taskCheckbox"]["checked"] as? [String: Any] ?? [:]) { _, new in new } }
+        let resolved = resolvedValues("taskCheckbox", ancestors: ancestors)
+        values.merge(resolved) { _, new in new }
+        if checked { values.merge(resolved["checked"] as? [String: Any] ?? [:]) { _, new in new } }
         return EditorStyleBox(values)
     }
 

package/ios/EditorTextView+Commands.swift

@@ -26,7 +26,7 @@ extension EditorTextView {
                     scalarAnchor: selection.anchor,
                     scalarHead: selection.head
                 )
-                : EditorV2Shadow.wrapInListAtSelectionScalar(
+                : EditorV2Shadow.applyListTypeAtSelectionScalar(
                     id: editorId,
                     scalarAnchor: selection.anchor,
                     scalarHead: selection.head,

package/ios/EditorTextView+Selection.swift

@@ -49,7 +49,8 @@ extension EditorTextView {
               prepareForExternalEditorUpdate(),
               let position = closestPosition(to: point)
         else { return false }
-        let offset = self.offset(from: beginningOfDocument, to: position)
+        let caretPosition = autocapitalizationFriendlyEmptyBlockPosition(for: position) ?? position
+        let offset = self.offset(from: beginningOfDocument, to: caretPosition)
         guard !isAtomBoundaryCaretOffset(offset) else { return false }
         _ = becomeFirstResponder()
         logicalSelectionScalarRange = nil
@@ -154,7 +155,9 @@ extension EditorTextView {
            selectedRange.length == 0,
            let point = caretPlacementTapRecognizer.pendingCaretPoint,
            let position = closestPosition(to: point) {
-            let offset = self.offset(from: beginningOfDocument, to: position)
+            // Match empty-block normalization so synchronous callbacks cannot alternate offsets.
+            let caretPosition = autocapitalizationFriendlyEmptyBlockPosition(for: position) ?? position
+            let offset = self.offset(from: beginningOfDocument, to: caretPosition)
             if selectedRange.location != offset, !isAtomBoundaryCaretOffset(offset) {
                 // Correct UIKit's word snap before publishing or drawing the selection.
                 selectedRange = NSRange(location: offset, length: 0)

package/ios/EditorTextView.swift

@@ -97,12 +97,15 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate, UITextDragD
             placeholderLabel.textColor = theme?.placeholderColor ?? .placeholderText
             if let sheet = theme?.styleSheet {
                 var attributes: [NSAttributedString.Key: Any] = [.font: resolvedDefaultFont(), .foregroundColor: theme?.placeholderColor ?? UIColor.placeholderText]
-                EditorStyleSheet.applyText(sheet["placeholder"], to: &attributes)
+                EditorStyleSheet.applyText(sheet.resolvedValues("placeholder", ancestors: []), to: &attributes)
                 placeholderLabel.attributedText = NSAttributedString(string: placeholder, attributes: attributes)
             } else { placeholderLabel.attributedText = nil; placeholderLabel.text = placeholder }
             styleContentView.box = theme?.styleSheet?.box("content")
             backgroundColor = theme?.backgroundColor ?? baseBackgroundColor
-            if let contentInsets = theme?.contentInsets {
+            if let box = theme?.styleSheet?.box("content", ancestors: []) {
+                textContainerInset = box.inset
+                textContainer.lineFragmentPadding = 0
+            } else if let contentInsets = theme?.contentInsets {
                 textContainerInset = UIEdgeInsets(
                     top: contentInsets.top ?? 0,
                     left: contentInsets.left ?? 0,

package/ios/EditorTheme.swift

@@ -398,6 +398,7 @@ struct EditorContentInsets {
 
 struct EditorTheme {
     var styleSheet: EditorStyleSheet?
+    var styleSheetMentionOverrides: [String: Any]?
     var text: EditorTextStyle?
     var paragraph: EditorTextStyle?
     var blockquote: EditorBlockquoteTheme?
@@ -432,7 +433,8 @@ struct EditorTheme {
            dictionary["styles"] == nil || dictionary["styles"] is [String: [String: Any]] {
             let styles = dictionary["styles"] as? [String: [String: Any]] ?? [:]
             self.init(legacyDictionary: Self.legacyProjection(styles: styles, root: dictionary))
-            styleSheet = EditorStyleSheet(styles: styles)
+            styleSheet = EditorStyleSheet(styles: styles, rules: EditorStyleSheet.decodeRules(dictionary["rules"]))
+            styleSheetMentionOverrides = dictionary["mentions"] as? [String: Any]
             return
         }
         self.init(legacyDictionary: dictionary)

package/ios/EditorV2Adapter+Commands.swift

@@ -69,6 +69,16 @@ extension EditorV2Adapter {
         return commandAtSelection(["type": "toggleBlockquote"], anchor: anchor, head: head)
     }
 
+    func applyListType(_ listType: String, anchor: UInt32, head: UInt32) -> String? {
+        guard beginRuntimeOperation() else { return nil }
+        defer { endRuntimeOperation() }
+        return commandAtSelection(
+            ["type": "applyListType", "listType": listType],
+            anchor: anchor,
+            head: head
+        )
+    }
+
     func wrapInList(listType: String, itemType: String, anchor: UInt32, head: UInt32) -> String? {
         guard beginRuntimeOperation() else { return nil }
         defer { endRuntimeOperation() }

package/ios/EditorV2Shadow.swift

@@ -200,6 +200,10 @@ enum EditorV2Shadow {
         return adapter(for: id)?.wrapInList(listType: listType, itemType: itemType, anchor: scalarAnchor, head: scalarHead) ?? "{}"
     }
 
+    static func applyListTypeAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32, listType: String) -> String {
+        adapter(for: id)?.applyListType(listType, anchor: scalarAnchor, head: scalarHead) ?? "{}"
+    }
+
     static func unwrapFromListAtSelectionScalar(id: UInt64, scalarAnchor: UInt32, scalarHead: UInt32) -> String {
         adapter(for: id)?.unwrapFromList(anchor: scalarAnchor, head: scalarHead) ?? "{}"
     }

package/ios/RenderBridge+Atoms.swift

@@ -144,7 +144,8 @@ extension RenderBridge {
         topLevelChildIndex: Int?,
         theme: EditorTheme?,
         atomKey: String,
-        atomConfiguration: AtomRenderConfiguration?
+        atomConfiguration: AtomRenderConfiguration?,
+        ancestors: [String] = []
     ) -> NSAttributedString {
         var attrs = defaultAttributes(baseFont: baseFont, textColor: textColor)
         attrs[RenderBridgeAttributes.voidNodeType] = nodeType
@@ -171,9 +172,9 @@ extension RenderBridge {
         switch nodeType {
         case "horizontalRule", "horizontal_rule":
             let attachment = HorizontalRuleAttachment()
-            attachment.styleBox = theme?.styleSheet?.box("horizontalRule")
-            attachment.lineColor = theme?.horizontalRule?.color ?? textColor.withAlphaComponent(0.3)
-            attachment.lineHeight = theme?.horizontalRule?.thickness ?? LayoutConstants.horizontalRuleHeight
+            attachment.styleBox = theme?.styleSheet?.box("horizontalRule", ancestors: ancestors)
+            attachment.lineColor = attachment.styleBox?.color("backgroundColor") ?? theme?.horizontalRule?.color ?? textColor.withAlphaComponent(0.3)
+            attachment.lineHeight = attachment.styleBox.map { $0.number("height", fallback: 1) } ?? theme?.horizontalRule?.thickness ?? LayoutConstants.horizontalRuleHeight
             attachment.verticalPadding = resolvedHorizontalRuleVerticalMargin(theme: theme)
             let attrStr = NSMutableAttributedString(
                 attachment: attachment
@@ -195,7 +196,7 @@ extension RenderBridge {
                 preferredWidth: jsonCGFloat(elementAttrs["width"]),
                 preferredHeight: jsonCGFloat(elementAttrs["height"])
             )
-            attachment.styleBox = theme?.styleSheet?.box("image")
+            attachment.styleBox = theme?.styleSheet?.box("image", ancestors: ancestors)
             let attrStr = NSMutableAttributedString(attachment: attachment)
             let range = NSRange(location: 0, length: attrStr.length)
             attrStr.addAttributes(attrs, range: range)
@@ -226,7 +227,15 @@ extension RenderBridge {
         attrs[RenderBridgeAttributes.voidNodeType] = nodeType
         attrs[RenderBridgeAttributes.docPos] = docPos
         if nodeType == "mention" {
-            let resolvedMentionTheme = theme?.mentions?.merged(with: mentionTheme) ?? mentionTheme
+            var globalMentionTheme = theme?.mentions
+            if let sheet = theme?.styleSheet, !sheet.rules.isEmpty {
+                let projection = EditorTheme.legacyProjection(
+                    styles: ["mention": sheet.resolvedValues("mention", ancestors: blockStack.map(\.nodeType))],
+                    root: theme?.styleSheetMentionOverrides.map { ["mentions": $0] } ?? [:]
+                )
+                globalMentionTheme = (projection["mentions"] as? [String: Any]).map(EditorMentionTheme.init(dictionary:))
+            }
+            let resolvedMentionTheme = globalMentionTheme?.merged(with: mentionTheme) ?? mentionTheme
             let node = resolvedMentionTheme?.node
             attrs[.foregroundColor] = node?.textColor ?? blockColor
             attrs[.backgroundColor] =

package/ios/RenderBridge+Style.swift

@@ -17,13 +17,38 @@ extension RenderBridge {
         if let sheet = theme?.styleSheet {
             let ancestors = blockStack.dropLast().map(\.nodeType)
             let text = sheet.textStyle(context.nodeType, ancestors: ancestors)
-            let horizontal = blockStack.reduce(UIEdgeInsets.zero) { $0.adding(sheet.box($1.nodeType).outerInsets) }
+            let horizontal = blockStack.enumerated().reduce(UIEdgeInsets.zero) { total, entry in
+                total.adding(sheet.box(entry.element.nodeType, ancestors: blockStack.prefix(entry.offset).map(\.nodeType)).outerInsets)
+            }
             let listName = context.listContext.map { ($0["kind"] as? String) == "task" ? "taskList" : (($0["ordered"] as? NSNumber)?.boolValue == true ? "orderedList" : "bulletList") }
+            let ownerIndex = blockStack.lastIndex { $0.listContext != nil }
+            let markerAncestors = ownerIndex.map { blockStack.prefix($0 + 1).map(\.nodeType) } ?? []
             let list = listName.map { sheet[$0] } ?? [:]
+            var contextualIndent: CGFloat = 0
+            for (listDepth, entry) in blockStack.enumerated().filter({ $0.element.listContext != nil }).enumerated() {
+                let context = entry.element.listContext!
+                let name = (context["kind"] as? String) == "task" ? "taskList" : ((context["ordered"] as? NSNumber)?.boolValue == true ? "orderedList" : "bulletList")
+                let prefix = Array(blockStack.prefix(entry.offset))
+                let containerIndex = prefix.lastIndex { EditorStyleSheet.element($0.nodeType) == name } ?? prefix.count
+                let resolved = sheet.resolvedValues(name, ancestors: prefix.prefix(containerIndex).map(\.nodeType))
+                let base = sheet[name]
+                let resolvedIndent = EditorTheme.cgFloat(resolved["indent"]) ?? LayoutConstants.indentPerDepth
+                let baseIndent = EditorTheme.cgFloat(base["indent"]) ?? LayoutConstants.indentPerDepth
+                let resolvedMultiplier = listDepth == 0 ? EditorTheme.cgFloat(resolved["baseIndentMultiplier"]) ?? 1 : 1
+                let baseMultiplier = listDepth == 0 ? EditorTheme.cgFloat(base["baseIndentMultiplier"]) ?? 1 : 1
+                contextualIndent += resolvedIndent * resolvedMultiplier - baseIndent * baseMultiplier
+            }
             let indent = EditorTheme.cgFloat(list["indent"]) ?? LayoutConstants.indentPerDepth
             let multiplier = EditorTheme.cgFloat(list["baseIndentMultiplier"]) ?? 1
             let listDepth = max(0, blockStack.filter { $0.listContext != nil }.count - 1)
-            let listInset = listName == nil ? 0 : indent * (CGFloat(listDepth) + multiplier) + listMarkerWidth(for: context, theme: theme, baseFont: baseFont)
+            // Preserve the legacy mixed-list baseline, then add each container's rule adjustment.
+            let listInset = listName == nil ? 0 : indent * (CGFloat(listDepth) + multiplier) + contextualIndent + listMarkerWidth(
+                for: context,
+                theme: theme,
+                baseFont: baseFont,
+                nestingDepth: listDepth,
+                ancestors: markerAncestors
+            )
             style.headIndent = horizontal.left + listInset
             style.firstLineHeadIndent = style.headIndent
             style.tailIndent = -horizontal.right
@@ -180,35 +205,45 @@ extension RenderBridge {
             mutableAttrs[RenderBridgeAttributes.listContext] = listContext
         }
         if let markerContext = currentBlock.listMarkerContext {
+            let ownerIndex = blockStack.lastIndex { $0.listContext != nil }
+            let markerAncestors = ownerIndex.map { blockStack.prefix($0 + 1).map(\.nodeType) } ?? []
+            let marker = theme?.styleSheet?.resolvedValues("listMarker", ancestors: markerAncestors)
+            let orderedTheme = (marker?["ordered"] as? [String: Any]).map(EditorOrderedListMarkerTheme.init(dictionary:)) ?? theme?.list?.orderedMarker
             mutableAttrs[RenderBridgeAttributes.listMarkerContext] = markerContext
+            let ordered = (markerContext["ordered"] as? NSNumber)?.boolValue == true
             let visualListDepth = max(0, blockStack.filter { $0.listContext != nil }.count - 1)
             if (markerContext["kind"] as? String) != "task",
-               (markerContext["ordered"] as? NSNumber)?.boolValue == true,
+               ordered,
                let rawIndex = markerContext["index"] as? NSNumber,
                let index = v2ExactUInt32(rawIndex) {
                 mutableAttrs[RenderBridgeAttributes.orderedListMarkerLabel] =
                     OrderedListMarkerFormatter.label(
                         index: index,
                         nestingDepth: visualListDepth,
-                        theme: theme?.list?.orderedMarker
+                        theme: orderedTheme
                     )
             }
-            mutableAttrs[RenderBridgeAttributes.listMarkerColor] = theme?.list?.markerColor
+            mutableAttrs[RenderBridgeAttributes.listMarkerColor] = EditorTheme.color(from: marker?["color"]) ?? theme?.list?.markerColor
             mutableAttrs[RenderBridgeAttributes.listMarkerScale] = theme?.list?.markerScale
             if let sheet = theme?.styleSheet {
-                mutableAttrs[RenderBridgeAttributes.listMarkerScale] = EditorTheme.cgFloat(sheet["listMarker"]["scale"]) ?? ((markerContext["ordered"] as? Bool) == true ? 1 : LayoutConstants.unorderedListMarkerFontScale)
+                mutableAttrs[RenderBridgeAttributes.listMarkerScale] = ordered
+                    ? 1
+                    : EditorTheme.cgFloat(sheet.resolvedValues("listMarker", ancestors: markerAncestors)["scale"])
+                        ?? LayoutConstants.unorderedListMarkerFontScale
             }
-            mutableAttrs[RenderBridgeAttributes.listMarkerGap] = theme?.list?.markerGap
+            mutableAttrs[RenderBridgeAttributes.listMarkerGap] = EditorTheme.cgFloat(marker?["gap"]) ?? theme?.list?.markerGap
             mutableAttrs[RenderBridgeAttributes.listMarkerBaseFont] = paragraphBaseFont
             if let sheet = theme?.styleSheet, (markerContext["kind"] as? String) == "task" {
-                let checkbox = sheet.checkbox(checked: markerContext["checked"] as? Bool == true)
+                let checkbox = sheet.checkbox(checked: markerContext["checked"] as? Bool == true, ancestors: markerAncestors)
                 mutableAttrs[editorTaskCheckboxAttribute] = EditorMentionRenderedBox(box: checkbox)
                 mutableAttrs[RenderBridgeAttributes.listMarkerGap] = checkbox.number("gap", fallback: 8)
             }
             mutableAttrs[RenderBridgeAttributes.listMarkerWidth] = listMarkerWidth(
                 for: currentBlock,
                 theme: theme,
-                baseFont: paragraphBaseFont
+                baseFont: paragraphBaseFont,
+                nestingDepth: visualListDepth,
+                ancestors: markerAncestors
             )
         }
         if currentBlock.nodeType == "codeBlock", theme?.styleSheet == nil {
@@ -267,23 +302,30 @@ extension RenderBridge {
     static func listMarkerWidth(
         for context: BlockContext,
         theme: EditorTheme?,
-        baseFont: UIFont
+        baseFont: UIFont,
+        nestingDepth: Int? = nil,
+        ancestors: [String] = []
     ) -> CGFloat {
         guard let listContext = context.listContext else { return 0 }
         if let sheet = theme?.styleSheet {
             if (listContext["kind"] as? String) == "task" {
-                let box = sheet.checkbox(checked: listContext["checked"] as? Bool == true)
+                let box = sheet.checkbox(checked: listContext["checked"] as? Bool == true, ancestors: ancestors)
                 return box.number("size", fallback: 24) + box.number("gap", fallback: 8)
             }
-            let ordered = (listContext["ordered"] as? Bool) == true
-            let scale = EditorTheme.cgFloat(sheet["listMarker"]["scale"]) ?? (ordered ? 1 : LayoutConstants.unorderedListMarkerFontScale)
-            let gap = EditorTheme.cgFloat(sheet["listMarker"]["gap"]) ?? 8
+            let ordered = (listContext["ordered"] as? NSNumber)?.boolValue == true
+            let scale = ordered
+                ? 1
+                : EditorTheme.cgFloat(sheet.resolvedValues("listMarker", ancestors: ancestors)["scale"])
+                    ?? LayoutConstants.unorderedListMarkerFontScale
+            let gap = EditorTheme.cgFloat(sheet.resolvedValues("listMarker", ancestors: ancestors)["gap"]) ?? 8
             if !ordered {
                 return EditorLayoutManager.unorderedBulletDrawingRect(usedRect: .zero, lineFragmentRect: .zero, markerWidth: 0, baselineY: 0, baseFont: baseFont, markerScale: scale, origin: .zero).width + gap
             }
-            let label = ordered
-                ? OrderedListMarkerFormatter.label(index: jsonUInt32(listContext["index"]) ?? 1, nestingDepth: Int(context.depth), theme: theme?.list?.orderedMarker)
-                : "•"
+            let label = OrderedListMarkerFormatter.label(
+                index: jsonUInt32(listContext["index"]) ?? 1,
+                nestingDepth: nestingDepth ?? Int(context.depth),
+                theme: (sheet.resolvedValues("listMarker", ancestors: ancestors)["ordered"] as? [String: Any]).map(EditorOrderedListMarkerTheme.init(dictionary:)) ?? theme?.list?.orderedMarker
+            )
             return ceil((label as NSString).size(withAttributes: [.font: baseFont.withSize(baseFont.pointSize * scale)]).width) + gap
         }
         return LayoutConstants.listMarkerWidth

package/ios/RenderBridge.swift

@@ -236,20 +236,18 @@ final class RenderBridge {
                 if let sheet = theme?.styleSheet {
                     var base = defaultAttributes(baseFont: blockFont, textColor: blockColor)
                     EditorStyleSheet.applyText(sheet.textValues(blockStack.last?.nodeType ?? "paragraph", ancestors: blockStack.dropLast().map(\.nodeType)), to: &base)
-                    baseAttrs = sheet.inlineAttributes(marks, base: base)
+                    baseAttrs = sheet.inlineAttributes(marks, base: base, ancestors: blockStack.map(\.nodeType))
                 }
                 if isCodeBlock {
-                    // blockFont already carries theme.codeBlock.text. Keep an
-                    // explicit code-block family for ordinary marked text;
-                    // otherwise use the shared monospace resolver. In either
-                    // case, the resolver accepts a face only if it satisfies
-                    // the complete bold/italic request.
+                    // Preserve explicit code families through the final monospace fallback.
                     let resolvedFont = baseAttrs[.font] as? UIFont ?? blockFont
                     let markTraits = resolvedFont.fontDescriptor.symbolicTraits
                         .intersection([.traitBold, .traitItalic])
-                    let themedFamily = theme?.codeBlock?.text?.fontFamily != nil
+                    let codeValues = theme?.styleSheet?.resolvedValues("codeBlock", ancestors: blockStack.dropLast().map(\.nodeType))
+                    let themedFamily = (codeValues?["fontFamily"] as? String) ?? theme?.codeBlock?.text?.fontFamily
+                    let hasInlineFamily = theme?.styleSheet?.hasInlineFontRule(marks, ancestors: blockStack.map(\.nodeType)) == true
                     baseAttrs[.font] = ViewerFontEnvironment.shared.resolveFont(
-                        family: themedFamily ? nil : "monospace",
+                        family: themedFamily != nil || hasInlineFamily ? nil : "monospace",
                         size: resolvedFont.pointSize,
                         fallback: resolvedFont,
                         additionalTraits: markTraits,
@@ -336,21 +334,23 @@ final class RenderBridge {
                     topLevelChildIndex: topLevelChildIndex,
                     theme: theme,
                     atomKey: atomKey,
-                    atomConfiguration: atomConfiguration
+                    atomConfiguration: atomConfiguration,
+                    ancestors: blockStack.map(\.nodeType)
                 )
                 if let sheet = theme?.styleSheet {
                     let styled = NSMutableAttributedString(attributedString: attrStr)
                     styled.addAttribute(editorStyledContentAttribute, value: true, range: NSRange(location: 0, length: styled.length))
                     let context = BlockContext(nodeType: nodeType, depth: blockStack.last?.depth ?? 0, listContext: nil)
                     let style = paragraphStyleForBlock(context, blockStack: blockStack + [context], theme: theme, baseFont: baseFont)
-                    let inset = sheet.box(nodeType).inset
+                    let box = sheet.box(nodeType, ancestors: blockStack.map(\.nodeType))
+                    let inset = box.inset
                     style.headIndent -= inset.left
                     style.firstLineHeadIndent -= inset.left
                     style.tailIndent += inset.right
-                    style.paragraphSpacingBefore = sheet.box(nodeType).margin.top
-                    style.paragraphSpacing = sheet.box(nodeType).margin.bottom
+                    style.paragraphSpacingBefore = box.margin.top
+                    style.paragraphSpacing = box.margin.bottom
                     styled.addAttribute(.paragraphStyle, value: style, range: NSRange(location: 0, length: styled.length))
-                    styled.addAttribute(editorBlockSpacingBoxAttribute, value: EditorRenderedBox(box: sheet.box(nodeType), depth: blockStack.count, leading: 0, trailing: 0), range: NSRange(location: 0, length: styled.length))
+                    styled.addAttribute(editorBlockSpacingBoxAttribute, value: EditorRenderedBox(box: box, depth: blockStack.count, leading: 0, trailing: 0), range: NSRange(location: 0, length: styled.length))
                     result.append(styled)
                 } else { result.append(attrStr) }
                 pendingTrailingParagraphSpacing = theme?.effectiveTextStyle(
@@ -512,7 +512,9 @@ final class RenderBridge {
                 }
 
             case "blockEnd":
-                if let endedBlock = blockStack.popLast() {
+                if let endedBlock = blockStack.last {
+                    let endedAncestors = Array(blockStack.dropLast())
+                    blockStack.removeLast()
                     appendTrailingLineBreakPlaceholderIfNeeded(
                         in: result,
                         endedBlock: endedBlock,
@@ -525,15 +527,16 @@ final class RenderBridge {
                         && blockStack.last?.nodeType == "blockquote"
                         && elements.indices.contains(elementIndex + 1)
                         && elements[elementIndex + 1]["type"] as? String == "blockEnd"
-                    closeStyledBlock(endedBlock, ancestors: blockStack, in: result, theme: theme, baseFont: baseFont, textColor: textColor, omitBottomMargin: omitBottomMargin)
+                    closeStyledBlock(endedBlock, ancestors: endedAncestors, in: result, theme: theme, baseFont: baseFont, textColor: textColor, omitBottomMargin: omitBottomMargin)
                     if EditorStyleSheet.element(endedBlock.nodeType) == "codeBlock", endedBlock.styleStart < result.length {
                         result.addAttribute(editorCodeBlockAttribute, value: EditorCodeBlockPresentation(language: endedBlock.language), range: NSRange(location: endedBlock.styleStart, length: result.length - endedBlock.styleStart))
                     }
                     if theme?.styleSheet != nil, endedBlock.listContext?["isLast"] as? Bool == true,
                        let container = blockStack.last,
                        ["bulletList", "orderedList", "taskList"].contains(container.nodeType) {
+                        let containerAncestors = Array(blockStack.dropLast())
                         blockStack.removeLast()
-                        closeStyledBlock(container, ancestors: blockStack, in: result, theme: theme, baseFont: baseFont, textColor: textColor)
+                        closeStyledBlock(container, ancestors: containerAncestors, in: result, theme: theme, baseFont: baseFont, textColor: textColor)
                     }
                     if endedBlock.listContext != nil, theme?.styleSheet == nil {
                         let spacing = (endedBlock.listContext?["isLast"] as? Bool) == true