react-native-nitro-markdown 0.5.2 → 0.5.4

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,89 @@ 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() && text && size > 0) {
+                    MD_OFFSET off = safeOffset(text, impl->inputText, impl->inputTextSize);
+                    if (off == 0 && text != impl->inputText) off = impl->lastTextEnd;
+
+                    if (impl->nodeStack.top()->type == NodeType::HtmlBlock) {
+                        auto htmlBlock = impl->nodeStack.top();
+                        if (htmlBlock->content.has_value()) {
+                            htmlBlock->content->append(text, size);
+                        } else {
+                            htmlBlock->content = std::string(text, size);
+                        }
+                        htmlBlock->end = off + size;
+                        impl->lastTextEnd = off + size;
+                        break;
+                    }
+
                     auto node = std::make_shared<MarkdownNode>(NodeType::HtmlInline);
                     node->content = std::string(text, size);
+                    node->beg = off;
+                    node->end = off + size;
                     impl->nodeStack.top()->addChild(node);
+                    impl->lastTextEnd = off + size;
                 }
                 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 +476,11 @@ public:
                 break;
             }
         }
-        
+
         return 0;
+        } catch (...) {
+            return 1; // Signal error to md4c
+        }
     }
 };
 
@@ -438,7 +494,7 @@ std::shared_ptr<MarkdownNode> MD4CParser::parse(const std::string& markdown, con
     size_t inputSize = clampInputSize(markdown.size());
     impl_->inputTextSize = inputSize;
     
-    unsigned int flags = MD_FLAG_NOHTML;
+    unsigned int flags = options.html ? 0 : MD_FLAG_NOHTML;
     
     if (options.gfm) {
         flags |= MD_FLAG_TABLES;
@@ -463,10 +519,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/cpp/core/MarkdownTypes.hpp

@@ -118,7 +118,7 @@ struct MarkdownNode {
 struct ParserOptions {
     bool gfm = true;
     bool math = true;
+    bool html = false;
 };
 
 } // namespace NitroMarkdown
-