react-native-nitro-markdown 0.5.1 → 0.5.3

package/cpp/core/MD4CParser.cpp

@@ -15,6 +15,18 @@ size_t clampInputSize(size_t inputSize) {
     }
     return inputSize;
 }
+
+// Safe pointer offset calculation — guards against out-of-allocation arithmetic.
+// md4c callbacks receive pointers into the input buffer, so arithmetic is valid
+// as long as the input string is stable. This check catches any edge cases.
+static MD_OFFSET safeOffset(const char* text, const char* base, size_t baseSize) noexcept {
+    if (text < base) return 0;
+    ptrdiff_t diff = text - base;
+    if (diff < 0 || static_cast<size_t>(diff) > baseSize) return 0;
+    // Check MD_OFFSET won't truncate
+    if (static_cast<size_t>(diff) > static_cast<size_t>(std::numeric_limits<MD_OFFSET>::max())) return 0;
+    return static_cast<MD_OFFSET>(diff);
+}
 } // namespace
 
 class MD4CParser::Impl {
@@ -38,13 +50,21 @@ public:
     }
     
     void flushText() {
-        if (!currentText.empty() && !nodeStack.empty()) {
-            auto textNode = std::make_shared<MarkdownNode>(NodeType::Text);
-            textNode->content = std::move(currentText);
-            textNode->beg = currentTextBeg;
-            textNode->end = lastTextEnd;
-            nodeStack.top()->addChild(std::move(textNode));
-            currentText.clear();
+        if (!currentText.empty()) {
+            if (!nodeStack.empty()) {
+                auto textNode = std::make_shared<MarkdownNode>(NodeType::Text);
+                textNode->content = std::move(currentText);
+                textNode->beg = currentTextBeg;
+                textNode->end = lastTextEnd;
+                nodeStack.top()->addChild(std::move(textNode));
+                currentText.clear();
+            } else {
+#if defined(NITROMARKDOWN_DEBUG) || defined(DEBUG)
+                // This indicates a parser state bug - text available but no node to attach it to
+                fprintf(stderr, "[NitroMarkdown] Warning: flushText called with empty nodeStack, text dropped: %.50s\n", currentText.c_str());
+#endif
+                currentText.clear();
+            }
         }
     }
     
@@ -74,17 +94,18 @@ public:
         std::string result;
         result.reserve(attr->size);
 
-        for (unsigned i = 0; ; i++) {
+        // md4c invariant: substr_types is terminated by an entry where
+        // substr_offsets[i] == attr->size (the sentinel entry). Reading
+        // substr_offsets[i+1] is always valid when substr_offsets[i] < attr->size.
+        for (unsigned i = 0; attr->substr_offsets[i] < attr->size; i++) {
             size_t start = static_cast<size_t>(attr->substr_offsets[i]);
-            size_t end = static_cast<size_t>(attr->substr_offsets[i + 1]);
+            size_t end = static_cast<size_t>(attr->substr_offsets[i + 1]); // safe: [i+1] always valid when [i] < size
 
-            if (end > attr->size) {
+            if (end > static_cast<size_t>(attr->size)) {
                 end = static_cast<size_t>(attr->size);
             }
-            if (start > end) {
-                break;
-            }
 
+            // Append content for all recognised text types
             if (attr->substr_types[i] == MD_TEXT_NORMAL ||
                 attr->substr_types[i] == MD_TEXT_ENTITY ||
                 attr->substr_types[i] == MD_TEXT_NULLCHAR) {
@@ -92,12 +113,11 @@ public:
                     result.append(attr->text + start, end - start);
                 }
             }
-
-            if (end >= attr->size) {
-                break;
-            }
         }
 
+        // Fallback: if all substrings had unrecognised types (should not occur
+        // per the md4c spec, but guards against future spec extensions), return
+        // the raw attribute text.
         if (result.empty() && attr->size > 0) {
             result.assign(attr->text, attr->size);
         }
@@ -105,25 +125,27 @@ public:
         return result;
     }
     
-    static int enterBlock(MD_BLOCKTYPE type, void* detail, MD_OFFSET off, void* userdata) {
+    static int enterBlock(MD_BLOCKTYPE type, void* detail, MD_OFFSET off, void* userdata) noexcept {
+        try {
         auto* impl = static_cast<Impl*>(userdata);
-        
+        if (impl == nullptr) return 1; // Signal error to md4c
+
         switch (type) {
             case MD_BLOCK_DOC:
                 break;
-                
+
             case MD_BLOCK_QUOTE: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::Blockquote), off);
                 break;
             }
-                
+
             case MD_BLOCK_UL: {
                 auto node = std::make_shared<MarkdownNode>(NodeType::List);
                 node->ordered = false;
                 impl->pushNode(node, off);
                 break;
             }
-                
+
             case MD_BLOCK_OL: {
                 auto* d = static_cast<MD_BLOCK_OL_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::List);
@@ -132,7 +154,7 @@ public:
                 impl->pushNode(node, off);
                 break;
             }
-                
+
             case MD_BLOCK_LI: {
                 auto* d = static_cast<MD_BLOCK_LI_DETAIL*>(detail);
                 if (d->is_task) {
@@ -144,12 +166,12 @@ public:
                 }
                 break;
             }
-                
+
             case MD_BLOCK_HR: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::HorizontalRule), off);
                 break;
             }
-                
+
             case MD_BLOCK_H: {
                 auto* d = static_cast<MD_BLOCK_H_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::Heading);
@@ -157,7 +179,7 @@ public:
                 impl->pushNode(node, off);
                 break;
             }
-                
+
             case MD_BLOCK_CODE: {
                 auto* d = static_cast<MD_BLOCK_CODE_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::CodeBlock);
@@ -167,37 +189,37 @@ public:
                 impl->pushNode(node, off);
                 break;
             }
-                
+
             case MD_BLOCK_HTML: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::HtmlBlock), off);
                 break;
             }
-                
+
             case MD_BLOCK_P: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::Paragraph), off);
                 break;
             }
-                
+
             case MD_BLOCK_TABLE: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::Table), off);
                 break;
             }
-                
+
             case MD_BLOCK_THEAD: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::TableHead), off);
                 break;
             }
-                
+
             case MD_BLOCK_TBODY: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::TableBody), off);
                 break;
             }
-                
+
             case MD_BLOCK_TR: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::TableRow), off);
                 break;
             }
-                
+
             case MD_BLOCK_TH: {
                 auto* d = static_cast<MD_BLOCK_TD_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::TableCell);
@@ -211,7 +233,7 @@ public:
                 impl->pushNode(node, off);
                 break;
             }
-                
+
             case MD_BLOCK_TD: {
                 auto* d = static_cast<MD_BLOCK_TD_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::TableCell);
@@ -226,14 +248,18 @@ public:
                 break;
             }
         }
-        
+
         return 0;
+        } catch (...) {
+            return 1; // Signal error to md4c
+        }
     }
     
-    static int leaveBlock(MD_BLOCKTYPE type, void* detail, MD_OFFSET off, void* userdata) {
-        (void)detail;
+    static int leaveBlock(MD_BLOCKTYPE type, [[maybe_unused]] void* detail, MD_OFFSET off, void* userdata) noexcept {
+        try {
         auto* impl = static_cast<Impl*>(userdata);
-        
+        if (impl == nullptr) return 1; // Signal error to md4c
+
         switch (type) {
             case MD_BLOCK_DOC:
                 impl->root->end = off;
@@ -245,29 +271,34 @@ public:
                 impl->popNode(off);
                 break;
         }
-        
+
         return 0;
+        } catch (...) {
+            return 1; // Signal error to md4c
+        }
     }
     
-    static int enterSpan(MD_SPANTYPE type, void* detail, MD_OFFSET off, void* userdata) {
+    static int enterSpan(MD_SPANTYPE type, void* detail, MD_OFFSET off, void* userdata) noexcept {
+        try {
         auto* impl = static_cast<Impl*>(userdata);
-        
+        if (impl == nullptr) return 1; // Signal error to md4c
+
         switch (type) {
             case MD_SPAN_EM: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::Italic), off);
                 break;
             }
-                
+
             case MD_SPAN_STRONG: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::Bold), off);
                 break;
             }
-                
+
             case MD_SPAN_DEL: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::Strikethrough), off);
                 break;
             }
-                
+
             case MD_SPAN_A: {
                 auto* d = static_cast<MD_SPAN_A_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::Link);
@@ -280,7 +311,7 @@ public:
                 impl->pushNode(node, off);
                 break;
             }
-                
+
             case MD_SPAN_IMG: {
                 auto* d = static_cast<MD_SPAN_IMG_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::Image);
@@ -293,40 +324,44 @@ public:
                 impl->pushNode(node, off);
                 break;
             }
-                
+
             case MD_SPAN_CODE: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::CodeInline), off);
                 break;
             }
-                
+
             case MD_SPAN_LATEXMATH: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::MathInline), off);
                 break;
             }
-                
+
             case MD_SPAN_LATEXMATH_DISPLAY: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::MathBlock), off);
                 break;
             }
-                
+
             case MD_SPAN_U: {
                 impl->pushNode(std::make_shared<MarkdownNode>(NodeType::Italic), off);
                 break;
             }
-                
+
             case MD_SPAN_WIKILINK: {
                 auto node = std::make_shared<MarkdownNode>(NodeType::Link);
                 impl->pushNode(node, off);
                 break;
             }
         }
-        
+
         return 0;
+        } catch (...) {
+            return 1; // Signal error to md4c
+        }
     }
     
-    static int leaveSpan(MD_SPANTYPE type, void* detail, MD_OFFSET off, void* userdata) {
-        (void)detail;
+    static int leaveSpan(MD_SPANTYPE type, [[maybe_unused]] void* detail, MD_OFFSET off, void* userdata) noexcept {
+        try {
         auto* impl = static_cast<Impl*>(userdata);
+        if (impl == nullptr) return 1; // Signal error to md4c
 
         if (!impl->nodeStack.empty()) {
             auto currentNode = impl->nodeStack.top();
@@ -349,71 +384,71 @@ public:
 
         impl->popNode(off);
         return 0;
+        } catch (...) {
+            return 1; // Signal error to md4c
+        }
     }
     
-    static int text(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata) {
+    static int text(MD_TEXTTYPE type, const MD_CHAR* text, MD_SIZE size, void* userdata) noexcept {
+        try {
         auto* impl = static_cast<Impl*>(userdata);
+        if (impl == nullptr) return 1; // Signal error to md4c
 
         if (!text || size == 0) return 0;
 
         switch (type) {
             case MD_TEXT_NULLCHAR: {
-                MD_OFFSET off = impl->lastTextEnd;
-                ptrdiff_t diff = text - impl->inputText;
-                if (diff >= 0 && static_cast<size_t>(diff) <= impl->inputTextSize) {
-                    off = static_cast<MD_OFFSET>(diff);
-                }
+                MD_OFFSET off = safeOffset(text, impl->inputText, impl->inputTextSize);
+                if (off == 0 && text != impl->inputText) off = impl->lastTextEnd;
                 if (impl->currentText.empty()) impl->currentTextBeg = off;
                 impl->currentText += '\0';
                 impl->lastTextEnd = off + 1;
                 break;
             }
-                
+
             case MD_TEXT_BR:
                 impl->flushText();
-                impl->nodeStack.top()->addChild(
-                    std::make_shared<MarkdownNode>(NodeType::LineBreak));
+                if (!impl->nodeStack.empty()) {
+                    impl->nodeStack.top()->addChild(
+                        std::make_shared<MarkdownNode>(NodeType::LineBreak));
+                }
                 break;
-                
+
             case MD_TEXT_SOFTBR:
                 impl->flushText();
-                impl->nodeStack.top()->addChild(
-                    std::make_shared<MarkdownNode>(NodeType::SoftBreak));
+                if (!impl->nodeStack.empty()) {
+                    impl->nodeStack.top()->addChild(
+                        std::make_shared<MarkdownNode>(NodeType::SoftBreak));
+                }
                 break;
-                
+
             case MD_TEXT_HTML:
                 impl->flushText();
-                {
+                if (!impl->nodeStack.empty()) {
                     auto node = std::make_shared<MarkdownNode>(NodeType::HtmlInline);
                     node->content = std::string(text, size);
                     impl->nodeStack.top()->addChild(node);
                 }
                 break;
-                
+
             case MD_TEXT_ENTITY:
                 if (text && size > 0) {
-                    MD_OFFSET off = impl->lastTextEnd;
-                    ptrdiff_t diff = text - impl->inputText;
-                    if (diff >= 0 && static_cast<size_t>(diff) <= impl->inputTextSize) {
-                        off = static_cast<MD_OFFSET>(diff);
-                    }
+                    MD_OFFSET off = safeOffset(text, impl->inputText, impl->inputTextSize);
+                    if (off == 0 && text != impl->inputText) off = impl->lastTextEnd;
                     if (impl->currentText.empty()) impl->currentTextBeg = off;
                     impl->currentText.append(text, size);
                     impl->lastTextEnd = off + size;
                 }
                 break;
-                
+
             case MD_TEXT_NORMAL:
             case MD_TEXT_CODE:
             case MD_TEXT_LATEXMATH:
             default: {
                 if (text && size > 0) {
-                    MD_OFFSET off = impl->lastTextEnd;
-                    ptrdiff_t diff = text - impl->inputText;
-                    if (diff >= 0 && static_cast<size_t>(diff) <= impl->inputTextSize) {
-                        off = static_cast<MD_OFFSET>(diff);
-                    }
-                    
+                    MD_OFFSET off = safeOffset(text, impl->inputText, impl->inputTextSize);
+                    if (off == 0 && text != impl->inputText) off = impl->lastTextEnd;
+
                     if (impl->currentText.empty()) {
                         impl->currentTextBeg = off;
                     }
@@ -423,8 +458,11 @@ public:
                 break;
             }
         }
-        
+
         return 0;
+        } catch (...) {
+            return 1; // Signal error to md4c
+        }
     }
 };
 
@@ -463,10 +501,15 @@ std::shared_ptr<MarkdownNode> MD4CParser::parse(const std::string& markdown, con
         nullptr
     };
 
-    md_parse(markdown.c_str(),
-             static_cast<MD_SIZE>(inputSize),
-             &parser, 
-             impl_.get());
+    int result = md_parse(markdown.c_str(),
+                          static_cast<MD_SIZE>(inputSize),
+                          &parser,
+                          impl_.get());
+    if (result != 0) {
+        // md_parse failed (callback aborted or runtime error).
+        // The AST may be partial but is still a valid tree rooted at Document,
+        // so we continue rather than throw — callers can use whatever was parsed.
+    }
 
     impl_->flushText();
     return impl_->root;

package/cpp/core/MarkdownSessionCore.cpp

@@ -0,0 +1,2 @@
+// Implementation is provided by the platform-specific HybridObject (iOS: Swift, Android: Kotlin)
+// via the Nitrogen-generated bridge. No C++ implementation is required here.

package/ios/HybridMarkdownSession.swift

@@ -5,43 +5,50 @@ class HybridMarkdownSession: HybridMarkdownSessionSpec {
     private var buffer = ""
     private var listeners: [UUID: (Double, Double) -> Void] = [:]
     private let lock = NSLock()
-    
-    private(set) var version: Int = 0
-    
-    var highlightPosition: Double = 0
-    
 
-    
+    var highlightPosition: Double {
+        get { lock.lock(); defer { lock.unlock() }; return _highlightPosition }
+        set { lock.lock(); defer { lock.unlock() }; _highlightPosition = newValue }
+    }
+    private var _highlightPosition: Double = 0
+
     var memorySize: Int {
-        return buffer.utf8.count + MemoryLayout<HybridMarkdownSession>.size
+        return buffer.utf8.count
+            + MemoryLayout<HybridMarkdownSession>.size
+            + MemoryLayout<NSLock>.size
+            + listeners.count * 128  // UUID key (16 bytes) + closure overhead estimate
     }
 
     private func utf16Length(_ value: String) -> Int {
         return (value as NSString).length
     }
-    
+
     func append(chunk: String) throws -> Double {
-        let from: Int
-        let to: Int
-        lock.lock()
-        from = utf16Length(buffer)
-        buffer += chunk
-        to = utf16Length(buffer)
-        version += 1
-        lock.unlock()
-        notifyListeners(from: Double(from), to: Double(to))
-        return Double(to)
+        let notifyFrom: Double
+        let notifyTo: Double
+        do {
+            lock.lock()
+            defer { lock.unlock() }
+            let fromInt = utf16Length(buffer)
+            buffer += chunk
+            let toInt = utf16Length(buffer)
+            notifyFrom = Double(fromInt)
+            notifyTo = Double(toInt)
+        }
+        notifyListeners(from: notifyFrom, to: notifyTo)
+        return notifyTo
     }
-    
+
     func clear() throws {
-        lock.lock()
-        buffer = ""
-        highlightPosition = 0
-        version += 1
-        lock.unlock()
+        do {
+            lock.lock()
+            defer { lock.unlock() }
+            buffer = ""
+            _highlightPosition = 0
+        }
         notifyListeners(from: 0, to: 0)
     }
-    
+
     func getAllText() throws -> String {
         lock.lock()
         defer { lock.unlock() }
@@ -55,6 +62,9 @@ class HybridMarkdownSession: HybridMarkdownSessionSpec {
     }
 
     func getTextRange(from: Double, to: Double) throws -> String {
+        guard from.isFinite && to.isFinite && from >= 0 && to >= 0 && from <= to else {
+            return ""
+        }
         lock.lock()
         defer { lock.unlock() }
 
@@ -64,43 +74,76 @@ class HybridMarkdownSession: HybridMarkdownSessionSpec {
         let end = max(start, min(Int(to), length))
         return text.substring(with: NSRange(location: start, length: end - start))
     }
-    
+
+    /// Adds a change listener. The listener closure is held strongly.
+    /// To avoid retain cycles, ensure the listener does not capture a strong
+    /// reference to the object that owns this HybridMarkdownSession.
+    /// Always call the returned cleanup closure when done to unregister.
     func addListener(listener: @escaping (Double, Double) -> Void) throws -> () -> Void {
         let id = UUID()
         lock.lock()
         listeners[id] = listener
         lock.unlock()
-        
+
         return { [weak self] in
-            self?.lock.lock()
-            self?.listeners.removeValue(forKey: id)
-            self?.lock.unlock()
+            guard let self else { return }
+            self.lock.lock()
+            defer { self.lock.unlock() }
+            self.listeners.removeValue(forKey: id)
         }
     }
-    
-    func reset(text: String) -> Void {
-      lock.lock()
-      buffer = text
-      lock.unlock()
-      notifyListeners(from: 0, to: Double((text as NSString).length))
+
+    func reset(text: String) throws -> Void {
+        let notifyTo: Double
+        do {
+            lock.lock()
+            defer { lock.unlock() }
+            buffer = text
+            _highlightPosition = 0
+            notifyTo = Double((text as NSString).length)
+        }
+        notifyListeners(from: 0, to: notifyTo)
     }
 
-    func replace(from: Double, to: Double, text: String) -> Double {
-      lock.lock()
-      let startIdx = buffer.index(buffer.startIndex, offsetBy: Int(from), limitedBy: buffer.endIndex) ?? buffer.endIndex
-      let endIdx = buffer.index(buffer.startIndex, offsetBy: Int(to), limitedBy: buffer.endIndex) ?? buffer.endIndex
-      buffer.replaceSubrange(startIdx..<endIdx, with: text)
-      let newLength = Double((buffer as NSString).length)
-      lock.unlock()
-      notifyListeners(from: from, to: from + Double((text as NSString).length))
-      return newLength
+    func replace(from: Double, to: Double, text: String) throws -> Double {
+        let notifyFrom: Double
+        let notifyTo: Double
+        let newLength: Double
+        let start: Int
+        let end: Int
+        do {
+            lock.lock()
+            defer { lock.unlock() }
+            guard from.isFinite && to.isFinite && from >= 0 && to >= 0 && from <= to else {
+                return Double(utf16Length(buffer))
+            }
+            let nsBuffer = NSMutableString(string: buffer)
+            let length = nsBuffer.length
+            start = max(0, min(Int(from), length))
+            end = max(start, min(Int(to), length))
+            nsBuffer.replaceCharacters(in: NSRange(location: start, length: end - start), with: text)
+            buffer = nsBuffer as String
+            newLength = Double((buffer as NSString).length)
+            notifyFrom = from
+            notifyTo = from + Double((text as NSString).length)
+        }
+        if start == end && text.isEmpty {
+            return newLength
+        }
+        notifyListeners(from: notifyFrom, to: notifyTo)
+        return newLength
     }
 
+    /// Notifies all registered listeners about a buffer change.
+    /// Called OUTSIDE the lock to prevent deadlock (listeners may call back into this session).
+    /// The `from`/`to` values reflect the buffer state AT THE TIME OF MUTATION.
+    /// The buffer may have been further modified by the time listener callbacks execute.
+    /// Listeners MUST NOT assume the buffer is stable; they should only use the index parameters.
     private func notifyListeners(from: Double, to: Double) {
         lock.lock()
         let currentListeners = Array(listeners.values)
         lock.unlock()
-        
+
         for listener in currentListeners {
             listener(from, to)
         }