react-native-markdown-native 1.0.0

package/ios/MarkdownView.swift

@@ -0,0 +1,771 @@
+import UIKit
+import React
+
+@available(iOS 15.0, *)
+class MarkdownView: UITextView {
+    
+    @objc var onNativeSizeChange: RCTDirectEventBlock?
+    
+    @objc var markdownText: String = "" {
+        didSet { renderContent() }
+    }
+    
+    @objc var markdownFontSize: CGFloat = 16.0 {
+        didSet { renderContent() }
+    }
+    
+    @objc var markdownColor: String = "" {
+        didSet { renderContent() }
+    }
+    
+    @objc var markdownFontFamily: String = "" {
+        didSet { renderContent() }
+    }
+    
+    @objc var markdownSelectionColor: String = "" {
+        didSet { updateSelectionColor() }
+    }
+    
+    @objc var markdownScrollEnabled: Bool = false {
+        didSet { self.isScrollEnabled = markdownScrollEnabled }
+    }
+    
+    @objc var markdownSelectable: Bool = true {
+        didSet { self.isSelectable = markdownSelectable }
+    }
+    
+    // Customization props
+    @objc var markdownLinkColor: String = "" {
+        didSet { 
+            renderContent()
+            updateLinkAttributes()
+        }
+    }
+    
+    @objc var markdownLineSpacing: CGFloat = 0.0 {
+        didSet { renderContent() }
+    }
+    
+    @objc var markdownParagraphSpacing: CGFloat = 0.0 {
+        didSet { renderContent() }
+    }
+    
+    @objc var markdownBulletIndent: CGFloat = 0.0 {
+        didSet { renderContent() }
+    }
+    
+    // List styling props
+    @objc var markdownListLeftInset: CGFloat = 0.0 {
+        didSet { renderContent() }
+    }
+    
+    @objc var markdownListSpacingBefore: CGFloat = 0.0 {
+        didSet { renderContent() }
+    }
+    
+    @objc var markdownListSpacingAfter: CGFloat = 0.0 {
+        didSet { renderContent() }
+    }
+    
+    // New rules-based styling system
+    @objc var markdownRulesJson: String = "" {
+        didSet { parseAndApplyRules() }
+    }
+    
+    // Parsed rules storage
+    private var parsedRules: [String: [String: Any]] = [:]
+    
+    // MARK: - Initialization
+    
+    override init(frame: CGRect, textContainer: NSTextContainer?) {
+        super.init(frame: frame, textContainer: textContainer)
+        setupView()
+    }
+    
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupView()
+    }
+    
+    private func setupView() {
+        self.backgroundColor = .clear
+        self.isEditable = false
+        self.isScrollEnabled = false
+        self.isSelectable = true
+        self.textContainerInset = .zero
+        self.textContainer.lineFragmentPadding = 0
+        self.clipsToBounds = false
+        
+        self.clipsToBounds = false
+        
+        self.dataDetectorTypes = [.link]
+        self.isUserInteractionEnabled = true
+        updateLinkAttributes()
+    }
+    
+    private func updateLinkAttributes() {
+        let linkColor = resolveColor(markdownLinkColor) ?? UIColor.systemBlue
+        self.linkTextAttributes = [
+            .foregroundColor: linkColor,
+            .underlineStyle: NSUnderlineStyle.single.rawValue
+        ]
+    }
+    
+    // MARK: - Rendering
+    
+    private func renderContent() {
+        guard !markdownText.isEmpty else {
+            self.attributedText = nil
+            notifySizeChange()
+            return
+        }
+        
+
+        
+        let textColor = resolveColor(markdownColor) ?? UIColor.black
+        let fontSize = markdownFontSize > 0 ? markdownFontSize : 16.0
+        let font = resolveFont(markdownFontFamily, size: fontSize)
+        let boldFont = UIFont.boldSystemFont(ofSize: fontSize)
+        let italicFont = UIFont.italicSystemFont(ofSize: fontSize)
+        
+
+        
+        let attributedString = parseMarkdownManually(
+            markdownText,
+            font: font,
+            boldFont: boldFont,
+            italicFont: italicFont,
+            color: textColor,
+            fontSize: fontSize
+        )
+        
+        self.attributedText = attributedString
+        self.textColor = textColor
+        
+        updateSelectionColor()
+        
+        updateSelectionColor()
+        
+        self.setNeedsLayout()
+        self.layoutIfNeeded()
+        notifySizeChange()
+    }
+    
+    private func parseMarkdownManually(_ text: String, font: UIFont, boldFont: UIFont, italicFont: UIFont, color: UIColor, fontSize: CGFloat) -> NSAttributedString {
+        let result = NSMutableAttributedString()
+        
+
+        
+        let lines = text.components(separatedBy: "\n")
+        
+        for (index, line) in lines.enumerated() {
+            let isEmpty = line.trimmingCharacters(in: .whitespaces).isEmpty
+            let isListItem = isListLine(line)
+                        
+            let isNextNonEmptyLineList = isNextNonEmptyList(lines: lines, currentIndex: index)
+            
+            if isEmpty {
+                if index < lines.count - 1 {
+                    result.append(NSAttributedString(string: "\n"))
+                }
+                continue
+            }
+            
+
+            
+            var spacingAfter: CGFloat = markdownParagraphSpacing
+            
+            if !isListItem && isNextNonEmptyLineList {
+                spacingAfter = markdownListSpacingBefore
+            } else if isListItem && !isNextNonEmptyLineList {
+                spacingAfter = markdownListSpacingAfter
+            } else if isListItem && isNextNonEmptyLineList {
+                spacingAfter = markdownParagraphSpacing
+            }
+            
+            let processedLine = processLine(
+                line, 
+                font: font, 
+                boldFont: boldFont, 
+                italicFont: italicFont, 
+                color: color, 
+                fontSize: fontSize,
+                spacingBefore: 0,
+                spacingAfter: spacingAfter
+            )
+            result.append(processedLine)
+            
+
+            
+            if index < lines.count - 1 {
+                result.append(NSAttributedString(string: "\n"))
+            }
+        }
+        
+        return result
+    }
+    
+    private func isNextNonEmptyList(lines: [String], currentIndex: Int) -> Bool {
+        for i in (currentIndex + 1)..<lines.count {
+            let line = lines[i].trimmingCharacters(in: .whitespaces)
+            if !line.isEmpty {
+                return isListLine(lines[i])
+            }
+        }
+        return false
+    }
+    
+    private func isPrevNonEmptyList(lines: [String], currentIndex: Int) -> Bool {
+        for i in stride(from: currentIndex - 1, through: 0, by: -1) {
+            let line = lines[i].trimmingCharacters(in: .whitespaces)
+            if !line.isEmpty {
+                return isListLine(lines[i])
+            }
+        }
+        return false
+    }
+    
+    private func isListLine(_ line: String) -> Bool {
+
+        if line.range(of: "^\\d+\\.\\s+", options: .regularExpression) != nil {
+            return true
+        }
+        if line.range(of: "^[-*+]\\s+", options: .regularExpression) != nil {
+            return true
+        }
+        return false
+    }
+    
+    private func processLine(_ line: String, font: UIFont, boldFont: UIFont, italicFont: UIFont, color: UIColor, fontSize: CGFloat, spacingBefore: CGFloat, spacingAfter: CGFloat) -> NSAttributedString {
+        var text = line
+        
+        let baseParagraphStyle = NSMutableParagraphStyle()
+        baseParagraphStyle.lineSpacing = markdownLineSpacing
+        baseParagraphStyle.paragraphSpacing = spacingAfter
+        baseParagraphStyle.paragraphSpacingBefore = spacingBefore
+        
+        var attributes: [NSAttributedString.Key: Any] = [
+            .font: font,
+            .foregroundColor: color,
+            .paragraphStyle: baseParagraphStyle
+        ]
+        
+        
+        if let headerMatch = text.range(of: "^#{1,6}\\s+", options: .regularExpression) {
+            let headerLevel = text[headerMatch].filter { $0 == "#" }.count
+            text = String(text[headerMatch.upperBound...])
+            
+            // Determine element type based on header level
+            let headerType: String
+            switch headerLevel {
+            case 1: headerType = "heading1"
+            case 2: headerType = "heading2"
+            case 3: headerType = "heading3"
+            case 4: headerType = "heading4"
+            case 5: headerType = "heading5"
+            case 6: headerType = "heading6"
+            default: headerType = "heading6"
+            }
+            
+            // Apply rules if available, otherwise use defaults
+            let headerFont = applyRulesToFont(headerType, baseSize: fontSize * (headerLevel == 1 ? 2.0 : headerLevel == 2 ? 1.5 : headerLevel == 3 ? 1.25 : headerLevel == 4 ? 1.1 : 1.0))
+            let headerColor = applyRulesToColor(headerType, defaultColor: color)
+            
+            let headerParagraph = NSMutableParagraphStyle()
+            headerParagraph.paragraphSpacingBefore = getRuleValue(headerType, "marginTop", defaultValue: 8)
+            headerParagraph.paragraphSpacing = getRuleValue(headerType, "marginBottom", defaultValue: 4)
+            headerParagraph.lineSpacing = markdownLineSpacing
+            
+            attributes[.font] = headerFont
+            attributes[.foregroundColor] = headerColor
+            attributes[.paragraphStyle] = headerParagraph
+            
+            return applyInlineFormatting(to: text, baseAttributes: attributes, boldFont: headerFont, italicFont: UIFont.italicSystemFont(ofSize: headerFont.pointSize))
+        }
+        
+        // Blockquote handling (> text)
+        if text.hasPrefix("> ") || text.hasPrefix(">") {
+            let content = text.hasPrefix("> ") ? String(text.dropFirst(2)) : String(text.dropFirst(1))
+            
+            let quoteFont = applyRulesToFont("blockquote", baseSize: fontSize)
+            let quoteColor = applyRulesToColor("blockquote", defaultColor: color)
+            
+            let quoteParagraph = NSMutableParagraphStyle()
+            quoteParagraph.paragraphSpacingBefore = getRuleValue("blockquote", "marginTop", defaultValue: 8)
+            quoteParagraph.paragraphSpacing = getRuleValue("blockquote", "marginBottom", defaultValue: 8)
+            quoteParagraph.lineSpacing = markdownLineSpacing
+            
+            // Apply left border effect with padding
+            let leftInset: CGFloat = getRuleValue("blockquote", "paddingLeft", defaultValue: 12)
+            let marginLeft: CGFloat = getRuleValue("blockquote", "marginLeft", defaultValue: 16)
+            quoteParagraph.firstLineHeadIndent = marginLeft + leftInset
+            quoteParagraph.headIndent = marginLeft + leftInset
+            
+            attributes[.font] = quoteFont
+            attributes[.foregroundColor] = quoteColor
+            attributes[.paragraphStyle] = quoteParagraph
+            
+            // Background color for blockquote
+            if let bgColorStr: String = getRuleValue("blockquote", "backgroundColor", defaultValue: nil),
+               let bgColor = resolveColor(bgColorStr) {
+                attributes[.backgroundColor] = bgColor
+            }
+            
+            return applyInlineFormatting(to: content, baseAttributes: attributes, boldFont: boldFont, italicFont: italicFont)
+        }
+        
+        // Horizontal rule handling (---, ***, ___)
+        if text.range(of: "^[-*_]{3,}$", options: .regularExpression) != nil {
+            let hrParagraph = NSMutableParagraphStyle()
+            hrParagraph.paragraphSpacingBefore = getRuleValue("hr", "marginTop", defaultValue: 16)
+            hrParagraph.paragraphSpacing = getRuleValue("hr", "marginBottom", defaultValue: 16)
+            
+            attributes[.paragraphStyle] = hrParagraph
+            
+            // Create a visual line
+            let lineText = "─────────────────────────────────────"
+            let lineColor = getRuleValue("hr", "borderBottomColor", defaultValue: "#CCCCCC")
+            if let color = resolveColor(lineColor) {
+                attributes[.foregroundColor] = color
+            }
+            
+            return NSAttributedString(string: lineText, attributes: attributes)
+        }
+        
+        
+        if let listMatch = text.range(of: "^\\d+\\.\\s+", options: .regularExpression) {
+            let prefix = String(text[listMatch])
+            let content = String(text[listMatch.upperBound...])
+            
+            // Apply rules for ordered list items
+            let itemFont = applyRulesToFont("orderedListItem", baseSize: fontSize)
+            let itemColor = applyRulesToColor("orderedListItem", defaultColor: color)
+            
+            let prefixSize = (prefix as NSString).size(withAttributes: [.font: itemFont])
+            let bulletIndent = getRuleValue("orderedListItem", "bulletIndent", defaultValue: markdownBulletIndent > 0 ? markdownBulletIndent : prefixSize.width)
+            let leftInset = getRuleValue("orderedListItem", "listLeftInset", defaultValue: markdownListLeftInset)
+            
+            let listParagraph = NSMutableParagraphStyle()
+            listParagraph.headIndent = leftInset + bulletIndent
+            listParagraph.firstLineHeadIndent = leftInset
+            listParagraph.paragraphSpacing = getRuleValue("orderedListItem", "marginBottom", defaultValue: spacingAfter)
+            listParagraph.paragraphSpacingBefore = spacingBefore
+            listParagraph.lineSpacing = getRuleValue("orderedListItem", "lineHeight", defaultValue: markdownLineSpacing)
+            
+            attributes[.font] = itemFont
+            attributes[.foregroundColor] = itemColor
+            attributes[.paragraphStyle] = listParagraph
+            
+            let result = NSMutableAttributedString(string: prefix, attributes: attributes)
+            result.append(applyInlineFormatting(to: content, baseAttributes: attributes, boldFont: boldFont, italicFont: italicFont))
+            return result
+        }
+        
+
+        
+        if let bulletMatch = text.range(of: "^[-*+]\\s+", options: .regularExpression) {
+            let content = String(text[bulletMatch.upperBound...])
+            
+            // Apply rules for list items
+            let itemFont = applyRulesToFont("listItem", baseSize: fontSize)
+            let itemColor = applyRulesToColor("listItem", defaultColor: color)
+            
+            let bulletPrefix = "• "
+            
+            let bulletSize = (bulletPrefix as NSString).size(withAttributes: [.font: itemFont])
+            let bulletIndent = getRuleValue("listItem", "bulletIndent", defaultValue: markdownBulletIndent > 0 ? markdownBulletIndent : bulletSize.width)
+            let leftInset = getRuleValue("listItem", "listLeftInset", defaultValue: markdownListLeftInset)
+            
+            let bulletParagraph = NSMutableParagraphStyle()
+            bulletParagraph.headIndent = leftInset + bulletIndent
+            bulletParagraph.firstLineHeadIndent = leftInset
+            bulletParagraph.paragraphSpacing = getRuleValue("listItem", "marginBottom", defaultValue: spacingAfter)
+            bulletParagraph.paragraphSpacingBefore = spacingBefore
+            bulletParagraph.lineSpacing = getRuleValue("listItem", "lineHeight", defaultValue: markdownLineSpacing)
+            
+            attributes[.font] = itemFont
+            attributes[.foregroundColor] = itemColor
+            attributes[.paragraphStyle] = bulletParagraph
+            
+            let result = NSMutableAttributedString(string: bulletPrefix, attributes: attributes)
+            result.append(applyInlineFormatting(to: content, baseAttributes: attributes, boldFont: boldFont, italicFont: italicFont))
+            return result
+        }
+        
+        return applyInlineFormatting(to: text, baseAttributes: attributes, boldFont: boldFont, italicFont: italicFont)
+    }
+    
+    private func applyInlineFormatting(to text: String, baseAttributes: [NSAttributedString.Key: Any], boldFont: UIFont, italicFont: UIFont) -> NSAttributedString {
+        let result = NSMutableAttributedString(string: text, attributes: baseAttributes)
+        
+        // Apply link patterns first (they need special handling)
+        applyLinkPattern(to: result, baseAttributes: baseAttributes)
+        
+        // Apply bold formatting using rules
+        let strongFont = applyRulesToFont("strong", baseSize: boldFont.pointSize)
+        let strongColor = applyRulesToColor("strong", defaultColor: baseAttributes[.foregroundColor] as? UIColor ?? UIColor.black)
+        applyPatternWithColor("\\*\\*(.+?)\\*\\*|__(.+?)__", to: result, font: strongFont, color: strongColor)
+        
+        // Apply italic formatting using rules
+        let emFont = applyRulesToFont("em", baseSize: italicFont.pointSize)
+        let emColor = applyRulesToColor("em", defaultColor: baseAttributes[.foregroundColor] as? UIColor ?? UIColor.black)
+        applyPatternWithColor("(?<!\\*)\\*(?!\\*)(.+?)(?<!\\*)\\*(?!\\*)|(?<!_)_(?!_)(.+?)(?<!_)_(?!_)", to: result, font: emFont, color: emColor)
+        
+        // Apply strikethrough formatting using rules (~~text~~)
+        let strikeColor = applyRulesToColor("strikethrough", defaultColor: baseAttributes[.foregroundColor] as? UIColor ?? UIColor.black)
+        applyStrikethroughPattern("~~(.+?)~~", to: result, color: strikeColor)
+        
+        // Apply inline code formatting using rules
+        let codeFont = applyRulesToFont("codeInline", baseSize: (baseAttributes[.font] as? UIFont)?.pointSize ?? 16)
+        let codeColor = applyRulesToColor("codeInline", defaultColor: UIColor.black)
+        let codeBgColor = getRuleValue("codeInline", "backgroundColor", defaultValue: "#F5F5F5")
+        applyCodePattern("`(.+?)`", to: result, font: codeFont, color: codeColor, backgroundColor: codeBgColor)
+    
+        return result
+    }
+    
+    private func applyLinkPattern(to attributedString: NSMutableAttributedString, baseAttributes: [NSAttributedString.Key: Any]) {
+
+        let linkPattern = "\\[([^\\]]+)\\]\\(([^)]+)\\)"
+        guard let regex = try? NSRegularExpression(pattern: linkPattern, options: []) else { return }
+        
+        let fullRange = NSRange(location: 0, length: attributedString.length)
+        let matches = regex.matches(in: attributedString.string, options: [], range: fullRange)
+        
+
+        
+        let linkColor = resolveColor(markdownLinkColor) ?? UIColor.systemBlue
+        
+        for match in matches.reversed() {
+            guard match.numberOfRanges >= 3 else { continue }
+            
+            let textRange = match.range(at: 1)
+            let urlRange = match.range(at: 2)
+            
+            guard textRange.location != NSNotFound, urlRange.location != NSNotFound else { continue }
+            
+            let linkText = (attributedString.string as NSString).substring(with: textRange)
+            let urlString = (attributedString.string as NSString).substring(with: urlRange)
+            
+
+            
+            var linkAttributes = baseAttributes
+            linkAttributes[.foregroundColor] = linkColor
+            linkAttributes[.underlineStyle] = NSUnderlineStyle.single.rawValue
+            
+            if let url = URL(string: urlString) {
+                linkAttributes[.link] = url
+            }
+            
+            let formattedLink = NSAttributedString(string: linkText, attributes: linkAttributes)
+            
+
+            
+            attributedString.replaceCharacters(in: match.range, with: formattedLink)
+        }
+    }
+    
+    private func applyPattern(_ pattern: String, to attributedString: NSMutableAttributedString, attribute: NSAttributedString.Key, value: Any) {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return }
+        
+        let fullRange = NSRange(location: 0, length: attributedString.length)
+        let matches = regex.matches(in: attributedString.string, options: [], range: fullRange)
+        
+        // Process in reverse to preserve ranges
+        for match in matches.reversed() {
+            // Find the actual content (first non-nil group)
+            var contentRange: NSRange?
+            for i in 1..<match.numberOfRanges {
+                let range = match.range(at: i)
+                if range.location != NSNotFound {
+                    contentRange = range
+                    break
+                }
+            }
+            
+            guard let actualContentRange = contentRange else { continue }
+            
+            // Get the content without markers
+            let content = (attributedString.string as NSString).substring(with: actualContentRange)
+            
+            // Create new attributed string with the formatting
+            var newAttributes = attributedString.attributes(at: actualContentRange.location, effectiveRange: nil)
+            newAttributes[attribute] = value
+            
+            let formattedContent = NSAttributedString(string: content, attributes: newAttributes)
+            
+            // Replace the entire match (including markers) with just the formatted content
+            attributedString.replaceCharacters(in: match.range, with: formattedContent)
+        }
+    }
+    
+    private func applyPatternWithColor(_ pattern: String, to attributedString: NSMutableAttributedString, font: UIFont, color: UIColor) {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return }
+        
+        let fullRange = NSRange(location: 0, length: attributedString.length)
+        let matches = regex.matches(in: attributedString.string, options: [], range: fullRange)
+        
+        for match in matches.reversed() {
+            var contentRange: NSRange?
+            for i in 1..<match.numberOfRanges {
+                let range = match.range(at: i)
+                if range.location != NSNotFound {
+                    contentRange = range
+                    break
+                }
+            }
+            
+            guard let actualContentRange = contentRange else { continue }
+            
+            let content = (attributedString.string as NSString).substring(with: actualContentRange)
+            
+            var newAttributes = attributedString.attributes(at: actualContentRange.location, effectiveRange: nil)
+            newAttributes[.font] = font
+            newAttributes[.foregroundColor] = color
+            
+            let formattedContent = NSAttributedString(string: content, attributes: newAttributes)
+            attributedString.replaceCharacters(in: match.range, with: formattedContent)
+        }
+    }
+    
+    private func applyCodePattern(_ pattern: String, to attributedString: NSMutableAttributedString, font: UIFont, color: UIColor, backgroundColor: String?) {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return }
+        
+        let fullRange = NSRange(location: 0, length: attributedString.length)
+        let matches = regex.matches(in: attributedString.string, options: [], range: fullRange)
+        
+        for match in matches.reversed() {
+            var contentRange: NSRange?
+            for i in 1..<match.numberOfRanges {
+                let range = match.range(at: i)
+                if range.location != NSNotFound {
+                    contentRange = range
+                    break
+                }
+            }
+            
+            guard let actualContentRange = contentRange else { continue }
+            
+            let content = (attributedString.string as NSString).substring(with: actualContentRange)
+            
+            var newAttributes = attributedString.attributes(at: actualContentRange.location, effectiveRange: nil)
+            newAttributes[.font] = font
+            newAttributes[.foregroundColor] = color
+            
+            if let bgColorStr = backgroundColor, let bgColor = resolveColor(bgColorStr) {
+                newAttributes[.backgroundColor] = bgColor
+            }
+            
+            let formattedContent = NSAttributedString(string: content, attributes: newAttributes)
+            attributedString.replaceCharacters(in: match.range, with: formattedContent)
+        }
+    }
+    
+    private func applyStrikethroughPattern(_ pattern: String, to attributedString: NSMutableAttributedString, color: UIColor) {
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return }
+        
+        let fullRange = NSRange(location: 0, length: attributedString.length)
+        let matches = regex.matches(in: attributedString.string, options: [], range: fullRange)
+        
+        for match in matches.reversed() {
+            var contentRange: NSRange?
+            for i in 1..<match.numberOfRanges {
+                let range = match.range(at: i)
+                if range.location != NSNotFound {
+                    contentRange = range
+                    break
+                }
+            }
+            
+            guard let actualContentRange = contentRange else { continue }
+            
+            let content = (attributedString.string as NSString).substring(with: actualContentRange)
+            
+            var newAttributes = attributedString.attributes(at: actualContentRange.location, effectiveRange: nil)
+            newAttributes[.strikethroughStyle] = NSUnderlineStyle.single.rawValue
+            newAttributes[.foregroundColor] = color
+            
+            let formattedContent = NSAttributedString(string: content, attributes: newAttributes)
+            attributedString.replaceCharacters(in: match.range, with: formattedContent)
+        }
+    }
+    
+    private func resolveColor(_ hex: String) -> UIColor? {
+        guard !hex.isEmpty else { return nil }
+        
+        let start = hex.hasPrefix("#") ? hex.index(hex.startIndex, offsetBy: 1) : hex.startIndex
+        let hexColor = String(hex[start...])
+        
+        guard hexColor.count == 6 || hexColor.count == 8 else { return nil }
+        
+        var hexNumber: UInt64 = 0
+        guard Scanner(string: hexColor).scanHexInt64(&hexNumber) else { return nil }
+        
+        if hexColor.count == 6 {
+            return UIColor(
+                red: CGFloat((hexNumber & 0xff0000) >> 16) / 255,
+                green: CGFloat((hexNumber & 0x00ff00) >> 8) / 255,
+                blue: CGFloat(hexNumber & 0x0000ff) / 255,
+                alpha: 1.0
+            )
+        } else {
+            return UIColor(
+                red: CGFloat((hexNumber & 0xff000000) >> 24) / 255,
+                green: CGFloat((hexNumber & 0x00ff0000) >> 16) / 255,
+                blue: CGFloat((hexNumber & 0x0000ff00) >> 8) / 255,
+                alpha: CGFloat(hexNumber & 0x000000ff) / 255
+            )
+        }
+    }
+    
+    private func resolveFont(_ familyName: String, size: CGFloat) -> UIFont {
+        if !familyName.isEmpty, let customFont = UIFont(name: familyName, size: size) {
+            return customFont
+        }
+        return UIFont.systemFont(ofSize: size)
+    }
+    
+    private func updateSelectionColor() {
+        if let color = resolveColor(markdownSelectionColor) {
+            self.tintColor = color
+        }
+    }
+    
+    private var lastSize: CGSize = .zero
+    
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        // Force size notification after layout
+        DispatchQueue.main.async { [weak self] in
+            self?.notifySizeChange()
+        }
+    }
+    
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        // Trigger size calculation when view is added to window
+        if window != nil {
+            DispatchQueue.main.async { [weak self] in
+                self?.notifySizeChange()
+            }
+        }
+    }
+    
+    private func notifySizeChange() {
+        var boundingWidth = self.bounds.width
+        if boundingWidth <= 0 {
+            boundingWidth = self.superview?.bounds.width ?? UIScreen.main.bounds.width
+        }
+        
+        let size = self.sizeThatFits(CGSize(width: boundingWidth, height: .greatestFiniteMagnitude))
+        
+        let minHeight = markdownFontSize * 1.5
+        let finalHeight = max(size.height, minHeight)
+        
+        if abs(finalHeight - lastSize.height) > 0.5 || abs(size.width - lastSize.width) > 0.5 {
+            lastSize = CGSize(width: size.width, height: finalHeight)
+            onNativeSizeChange?(["width": size.width, "height": finalHeight])
+            self.invalidateIntrinsicContentSize()
+        }
+    }
+    
+    override var intrinsicContentSize: CGSize {
+        var width = self.bounds.width
+        if width <= 0 {
+            width = self.superview?.bounds.width ?? UIScreen.main.bounds.width
+        }
+        let size = self.sizeThatFits(CGSize(width: width, height: .greatestFiniteMagnitude))
+        let minHeight = markdownFontSize * 1.5
+        return CGSize(width: size.width, height: max(size.height, minHeight))
+    }
+    
+    // MARK: - Rules Parsing and Application
+    
+    private func parseAndApplyRules() {
+        guard !markdownRulesJson.isEmpty else {
+            parsedRules = [:]
+            return
+        }
+        
+        guard let data = markdownRulesJson.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: [String: Any]] else {
+            parsedRules = [:]
+            return
+        }
+        
+        parsedRules = json
+        renderContent()
+    }
+    
+    private func getRuleValue<T>(_ elementType: String, _ key: String, defaultValue: T) -> T {
+        guard let rule = parsedRules[elementType],
+              let value = rule[key] as? T else {
+            return defaultValue
+        }
+        return value
+    }
+    
+    private func applyRulesToFont(_ elementType: String, baseSize: CGFloat) -> UIFont {
+        let fontSize: CGFloat = getRuleValue(elementType, "fontSize", defaultValue: baseSize)
+        let fontFamily: String? = getRuleValue(elementType, "fontFamily", defaultValue: nil as String?)
+        let fontWeight: String? = getRuleValue(elementType, "fontWeight", defaultValue: nil as String?)
+        let fontStyle: String? = getRuleValue(elementType, "fontStyle", defaultValue: nil as String?)
+        
+        if let family = fontFamily, !family.isEmpty {
+            if let customFont = UIFont(name: family, size: fontSize) {
+                return applyFontTraits(customFont, weight: fontWeight, style: fontStyle)
+            }
+        }
+        
+        // Apply weight and style to system font
+        var font = UIFont.systemFont(ofSize: fontSize)
+        if let weight = fontWeight {
+            if weight == "bold" || weight == "700" || weight == "800" || weight == "900" {
+                font = UIFont.boldSystemFont(ofSize: fontSize)
+            }
+        }
+        if let style = fontStyle, style == "italic" {
+            font = UIFont.italicSystemFont(ofSize: fontSize)
+        }
+        
+        return font
+    }
+    
+    private func applyFontTraits(_ font: UIFont, weight: String?, style: String?) -> UIFont {
+        var traits: UIFontDescriptor.SymbolicTraits = []
+        
+        if let w = weight, (w == "bold" || w == "700" || w == "800" || w == "900") {
+            traits.insert(.traitBold)
+        }
+        if let s = style, s == "italic" {
+            traits.insert(.traitItalic)
+        }
+        
+        if let descriptor = font.fontDescriptor.withSymbolicTraits(traits) {
+            return UIFont(descriptor: descriptor, size: font.pointSize)
+        }
+        
+        return font
+    }
+    
+    private func applyRulesToParagraphStyle(_ elementType: String, base: NSMutableParagraphStyle) -> NSMutableParagraphStyle {
+        let style = NSMutableParagraphStyle()
+        style.lineSpacing = base.lineSpacing
+        style.paragraphSpacing = getRuleValue(elementType, "marginBottom", defaultValue: base.paragraphSpacing)
+        style.paragraphSpacingBefore = getRuleValue(elementType, "marginTop", defaultValue: base.paragraphSpacingBefore)
+        style.firstLineHeadIndent = base.firstLineHeadIndent
+        style.headIndent = base.headIndent
+        
+        return style
+    }
+    
+    private func applyRulesToColor(_ elementType: String, defaultColor: UIColor) -> UIColor {
+        let colorStr: String? = getRuleValue(elementType, "color", defaultValue: nil)
+        if let str = colorStr, let color = resolveColor(str) {
+            return color
+        }
+        return defaultColor
+    }
+}
+
+