react-native-nitro-markdown 0.3.2 → 0.4.1

package/README.md

@@ -86,7 +86,7 @@ bunx expo prebuild
 
 ### Option 1: Batteries Included (Simplest)
 
-Use the `Markdown` component with built-in premium dark-mode styling:
+Use the `Markdown` component with clean, neutral styling that stays out of the way:
 
 ```tsx
 import { Markdown } from "react-native-nitro-markdown";
@@ -100,91 +100,27 @@ export function MyComponent() {
 }
 ```
 
-### Option 2: Light Theme / Theme Presets
+If you're rendering on a dark surface, override `theme.colors.text` (or use the `styles` prop) to match your app's palette.
 
-The default theme is optimized for dark mode. For light backgrounds, use the provided `lightMarkdownTheme`:
-
-```tsx
-import { Markdown, lightMarkdownTheme } from "react-native-nitro-markdown";
-
-<Markdown theme={lightMarkdownTheme}>{"# Light Mode Markdown"}</Markdown>;
-```
-
-Available presets:
-
-- `defaultMarkdownTheme` / `darkMarkdownTheme` - Modern dark theme
-- `lightMarkdownTheme` - Clean light theme
-- `minimalMarkdownTheme` - Bare minimum styling for a clean slate
-
-### Option 3: Custom Theming
-
-Customize the look and feel by passing a partial `theme` object:
-
-```tsx
-import { Markdown } from "react-native-nitro-markdown";
-
-const myTheme = {
-  colors: {
-    text: "#2D3748",
-    heading: "#1A202C",
-    link: "#3182CE",
-  },
-  fontFamilies: {
-    regular: "Inter",
-    heading: "Inter-Bold",
-    mono: "JetBrainsMono",
-  },
-  borderRadius: {
-    s: 4,
-    m: 8,
-    l: 16,
-  },
-  showCodeLanguage: true, // Toggle code language labels
-};
-
-<Markdown theme={myTheme}>{"# Custom Themed Markdown"}</Markdown>;
-```
-
-**Theme Properties:**
-
-- `colors` - All color tokens (text, heading, link, code, codeBackground, codeLanguage, etc.)
-- `spacing` - Spacing tokens (xs, s, m, l, xl)
-- `fontSizes` - Font sizes (xs, s, m, l, xl, h1-h6)
-- `fontFamilies` - Font families for regular, heading, and mono text
-- `borderRadius` - Border radius tokens (s, m, l)
-- `showCodeLanguage` - Show/hide code block language labels
-
-### Option 4: Style Overrides per Node Type
+### Option 2: Style Overrides per Node Type
 
 Apply quick style overrides to specific node types without writing custom renderers:
 
 ```tsx
 <Markdown
   styles={{
-    heading: { color: "red", fontWeight: "900" },
-    code_block: { backgroundColor: "#1a1a2e", borderRadius: 16 },
-    blockquote: { borderLeftColor: "#ff6b6b" },
+    heading: { color: "#0ea5e9", fontWeight: "900" },
+    code_block: { backgroundColor: "#e2e8f0", borderRadius: 16 },
+    blockquote: { borderLeftColor: "#0ea5e9" },
   }}
 >
   {markdown}
 </Markdown>
 ```
 
-### Option 5: Minimal Styling Strategy
+### Option 3: Custom Renderers
 
-Start with a clean slate using the `stylingStrategy` prop:
-
-```tsx
-<Markdown stylingStrategy="minimal" theme={myLightTheme}>
-  {content}
-</Markdown>
-```
-
-This zeros out all spacing and removes opinionated colors, letting you build up from scratch.
-
-### Option 6: Custom Renderers
-
-Override specific node types with full control. Custom renderers now receive **pre-mapped props** for common values:
+Override specific node types with full control. Custom renderers receive **pre-mapped props** for common values:
 
 ```tsx
 import {
@@ -225,7 +161,56 @@ const renderers = {
 - `list` → `ordered`, `start`
 - `task_list_item` → `checked`
 
-### Option 7: Style Props on Individual Renderers
+### Option 4: Token Overrides (Theme)
+
+Customize the look and feel by passing a partial `theme` object:
+
+```tsx
+import { Markdown } from "react-native-nitro-markdown";
+
+const myTheme = {
+  colors: {
+    text: "#0f172a",
+    heading: "#0f172a",
+    link: "#0ea5e9",
+    codeBackground: "#e2e8f0",
+  },
+  showCodeLanguage: false,
+};
+
+<Markdown theme={myTheme}>{"# Custom Themed Markdown"}</Markdown>;
+```
+
+Defaults live in `defaultMarkdownTheme` and are intentionally neutral so you can layer your own palette on top.
+
+**Theme Properties:**
+
+- `colors` - All color tokens (text, heading, link, code, codeBackground, codeLanguage, etc.)
+- `spacing` - Spacing tokens (xs, s, m, l, xl)
+- `fontSizes` - Font sizes (xs, s, m, l, xl, h1-h6)
+- `fontFamilies` - Font families for regular, heading, and mono text
+- `headingWeight` - Optional weight for headings (useful for Android custom fonts)
+- `borderRadius` - Border radius tokens (s, m, l)
+- `showCodeLanguage` - Show/hide code block language labels
+
+**Android custom fonts note:**
+If you use a custom heading font on Android and don’t load a bold variant, set
+`headingWeight: "normal"` (or use the `styles` prop) to avoid fallback to a
+system serif font.
+
+### Option 5: Minimal Styling Strategy
+
+Start with a clean slate using the `stylingStrategy` prop:
+
+```tsx
+<Markdown stylingStrategy="minimal" theme={myLightTheme}>
+  {content}
+</Markdown>
+```
+
+This zeros out all spacing and removes opinionated colors, letting you build up from scratch.
+
+### Option 6: Style Props on Individual Renderers
 
 All built-in renderers accept a `style` prop for fine-grained overrides:
 
@@ -238,7 +223,7 @@ import { Heading, CodeBlock, InlineCode } from "react-native-nitro-markdown";
 <InlineCode style={{ backgroundColor: "#ff0" }}>code</InlineCode>
 ```
 
-### Option 8: Auto Content Extraction for Code
+### Option 7: Auto Content Extraction for Code
 
 The `CodeBlock` and `InlineCode` components now accept a `node` prop for automatic content extraction:
 
@@ -257,7 +242,7 @@ code_block: ({ content, language }) => (
 );
 ```
 
-### Option 9: Headless (Minimal Bundle)
+### Option 8: Headless (Minimal Bundle)
 
 For maximum control, data processing, or minimal JS overhead:
 
@@ -273,9 +258,9 @@ const text = getTextContent(ast); // "Hello World"
 const fullText = getFlattenedText(ast); // "Hello World\n\n" (Normalized with line breaks)
 ```
 
-### Option 10: High-Performance Streaming (LLMs)
+### Option 9: High-Performance Streaming (LLMs)
 
-When streaming text token-by-token (e.g., from ChatGPT or Gemini):
+When streaming text token-by-token (e.g., from ChatGPT or Gemini), you should batch UI updates to avoid re-rendering on every token:
 
 ```tsx
 import {
@@ -292,12 +277,31 @@ export function AIResponseStream() {
   }, [session]);
 
   return (
-    <MarkdownStream session={session.getSession()} options={{ gfm: true }} />
+    <MarkdownStream
+      session={session.getSession()}
+      options={{ gfm: true }}
+      updateIntervalMs={60}
+      updateStrategy="raf"
+      useTransitionUpdates
+    />
   );
 }
 ```
 
-### Option 11: Extracting Plain Text
+**Recommended defaults for token streaming:**
+- `updateStrategy="raf"` for smooth, frame-aligned updates
+- `updateIntervalMs={50–100}` when using `updateStrategy="interval"`
+- Avoid per-token UI updates by batching token appends
+
+**Streaming props:**
+
+| Prop | Type | Default | Description |
+| :-- | :-- | :-- | :-- |
+| `updateIntervalMs` | `number` | `50` | Throttle UI updates when using interval strategy |
+| `updateStrategy` | `"interval" \| "raf"` | `"interval"` | Interval batching or frame-aligned updates |
+| `useTransitionUpdates` | `boolean` | `false` | Use React transitions to keep input responsive |
+
+### Option 10: Extracting Plain Text
 
 You can extract the plain text representation (with proper line breaks) using the `onParseComplete` callback. This is useful for "Copy All" buttons or TTS.
 
@@ -344,11 +348,9 @@ export {
   getFlattenedText,
 } from "./headless";
 
-// Theme presets
+// Theme tokens
 export {
   defaultMarkdownTheme,
-  lightMarkdownTheme,
-  darkMarkdownTheme,
   minimalMarkdownTheme,
   mergeThemes,
 };

package/cpp/core/MD4CParser.cpp

@@ -3,9 +3,20 @@
 
 #include <stack>
 #include <cstring>
+#include <limits>
 
 namespace NitroMarkdown {
 
+namespace {
+size_t clampInputSize(size_t inputSize) {
+    size_t maxSize = static_cast<size_t>(std::numeric_limits<MD_SIZE>::max());
+    if (inputSize > maxSize) {
+        return maxSize;
+    }
+    return inputSize;
+}
+} // namespace
+
 class MD4CParser::Impl {
 public:
     std::shared_ptr<MarkdownNode> root;
@@ -55,25 +66,42 @@ public:
     }
     
     std::string getAttributeText(const MD_ATTRIBUTE* attr) {
-        if (!attr || attr->size == 0) return "";
+        if (!attr || attr->size == 0 || !attr->text) return "";
+        if (!attr->substr_types || !attr->substr_offsets) {
+            return std::string(attr->text, attr->size);
+        }
 
         std::string result;
         result.reserve(attr->size);
-        
-        for (unsigned i = 0; i < attr->size; i++) {
+
+        for (unsigned i = 0; ; i++) {
+            size_t start = static_cast<size_t>(attr->substr_offsets[i]);
+            size_t end = static_cast<size_t>(attr->substr_offsets[i + 1]);
+
+            if (end > attr->size) {
+                end = static_cast<size_t>(attr->size);
+            }
+            if (start > end) {
+                break;
+            }
+
             if (attr->substr_types[i] == MD_TEXT_NORMAL ||
                 attr->substr_types[i] == MD_TEXT_ENTITY ||
                 attr->substr_types[i] == MD_TEXT_NULLCHAR) {
-                result.append(attr->substr_offsets[i], 
-                    i + 1 < attr->size ? attr->substr_offsets[i + 1] - attr->substr_offsets[i] 
-                                       : attr->size - attr->substr_offsets[i]);
+                if (end > start) {
+                    result.append(attr->text + start, end - start);
+                }
+            }
+
+            if (end >= attr->size) {
+                break;
             }
         }
-        
-        if (result.empty() && attr->text && attr->size > 0) {
+
+        if (result.empty() && attr->size > 0) {
             result.assign(attr->text, attr->size);
         }
-        
+
         return result;
     }
     
@@ -133,8 +161,8 @@ public:
             case MD_BLOCK_CODE: {
                 auto* d = static_cast<MD_BLOCK_CODE_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::CodeBlock);
-                if (d->lang.text && d->lang.size > 0) {
-                    node->language = std::string(d->lang.text, d->lang.size);
+                if (d->lang.size > 0) {
+                    node->language = impl->getAttributeText(&d->lang);
                 }
                 impl->pushNode(node, off);
                 break;
@@ -243,11 +271,11 @@ public:
             case MD_SPAN_A: {
                 auto* d = static_cast<MD_SPAN_A_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::Link);
-                if (d->href.text && d->href.size > 0) {
-                    node->href = std::string(d->href.text, d->href.size);
+                if (d->href.size > 0) {
+                    node->href = impl->getAttributeText(&d->href);
                 }
-                if (d->title.text && d->title.size > 0) {
-                    node->title = std::string(d->title.text, d->title.size);
+                if (d->title.size > 0) {
+                    node->title = impl->getAttributeText(&d->title);
                 }
                 impl->pushNode(node, off);
                 break;
@@ -256,11 +284,11 @@ public:
             case MD_SPAN_IMG: {
                 auto* d = static_cast<MD_SPAN_IMG_DETAIL*>(detail);
                 auto node = std::make_shared<MarkdownNode>(NodeType::Image);
-                if (d->src.text && d->src.size > 0) {
-                    node->href = std::string(d->src.text, d->src.size);
+                if (d->src.size > 0) {
+                    node->href = impl->getAttributeText(&d->src);
                 }
-                if (d->title.text && d->title.size > 0) {
-                    node->title = std::string(d->title.text, d->title.size);
+                if (d->title.size > 0) {
+                    node->title = impl->getAttributeText(&d->title);
                 }
                 impl->pushNode(node, off);
                 break;
@@ -329,10 +357,17 @@ public:
         if (!text || size == 0) return 0;
 
         switch (type) {
-            case MD_TEXT_NULLCHAR:
-                if (impl->currentText.empty()) impl->currentTextBeg = impl->lastTextEnd;
+            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);
+                }
+                if (impl->currentText.empty()) impl->currentTextBeg = off;
                 impl->currentText += '\0';
+                impl->lastTextEnd = off + 1;
                 break;
+            }
                 
             case MD_TEXT_BR:
                 impl->flushText();
@@ -400,7 +435,8 @@ MD4CParser::~MD4CParser() = default;
 std::shared_ptr<MarkdownNode> MD4CParser::parse(const std::string& markdown, const ParserOptions& options) {
     impl_->reset();
     impl_->inputText = markdown.c_str();
-    impl_->inputTextSize = markdown.size();
+    size_t inputSize = clampInputSize(markdown.size());
+    impl_->inputTextSize = inputSize;
     
     unsigned int flags = MD_FLAG_NOHTML;
     
@@ -427,8 +463,8 @@ std::shared_ptr<MarkdownNode> MD4CParser::parse(const std::string& markdown, con
         nullptr
     };
 
-    md_parse(markdown.c_str(), 
-             static_cast<MD_SIZE>(markdown.size()), 
+    md_parse(markdown.c_str(),
+             static_cast<MD_SIZE>(inputSize),
              &parser, 
              impl_.get());
 
@@ -437,4 +473,3 @@ std::shared_ptr<MarkdownNode> MD4CParser::parse(const std::string& markdown, con
 }
 
 } // namespace NitroMarkdown
-

package/cpp/core/MD4CParser.hpp

@@ -3,6 +3,12 @@
 #include "MarkdownTypes.hpp"
 #include <string>
 #include <memory>
+#include <cstddef>
+
+#ifdef NITRO_MARKDOWN_TESTING
+#include "../md4c/md4c.h"
+#include <limits>
+#endif
 
 namespace NitroMarkdown {
 
@@ -11,6 +17,13 @@ public:
     MD4CParser();
     ~MD4CParser();
     std::shared_ptr<MarkdownNode> parse(const std::string& markdown, const ParserOptions& options);
+
+#ifdef NITRO_MARKDOWN_TESTING
+    static size_t clampInputSizeForTest(size_t inputSize) {
+        size_t maxSize = static_cast<size_t>(std::numeric_limits<MD_SIZE>::max());
+        return inputSize > maxSize ? maxSize : inputSize;
+    }
+#endif
     
 private:
     class Impl;
@@ -18,4 +31,3 @@ private:
 };
 
 } // namespace NitroMarkdown
-

package/cpp/md4c/md4c.c

@@ -6489,7 +6489,7 @@ md_parse(const MD_CHAR* text, MD_SIZE size, const MD_PARSER* parser, void* userd
     ctx.code_indent_offset = (ctx.parser.flags & MD_FLAG_NOINDENTEDCODEBLOCKS) ? (OFF)(-1) : 4;
     md_build_mark_char_map(&ctx);
     ctx.doc_ends_with_newline = (size > 0  &&  ISNEWLINE_(text[size-1]));
-    ctx.max_ref_def_output = MIN(MIN(16 * (uint64_t)size, (uint64_t)(1024 * 1024)), (uint64_t)SZ_MAX);
+    ctx.max_ref_def_output = (SZ) MIN(MIN(16 * (uint64_t)size, (uint64_t)(1024 * 1024)), (uint64_t)SZ_MAX);
 
     /* Reset all mark stacks and lists. */
     for(i = 0; i < (int) SIZEOF_ARRAY(ctx.opener_stacks); i++)

package/lib/commonjs/index.js

@@ -4,14 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
-  DefaultMarkdownRenderer: true,
   Markdown: true,
   MarkdownStream: true,
   useMarkdownContext: true,
   MarkdownContext: true,
   defaultMarkdownTheme: true,
-  lightMarkdownTheme: true,
-  darkMarkdownTheme: true,
   minimalMarkdownTheme: true,
   mergeThemes: true,
   Heading: true,
@@ -44,12 +41,6 @@ Object.defineProperty(exports, "CodeBlock", {
     return _code.CodeBlock;
   }
 });
-Object.defineProperty(exports, "DefaultMarkdownRenderer", {
-  enumerable: true,
-  get: function () {
-    return _defaultMarkdownRenderer.DefaultMarkdownRenderer;
-  }
-});
 Object.defineProperty(exports, "Heading", {
   enumerable: true,
   get: function () {
@@ -146,24 +137,12 @@ Object.defineProperty(exports, "createMarkdownSession", {
     return _MarkdownSession.createMarkdownSession;
   }
 });
-Object.defineProperty(exports, "darkMarkdownTheme", {
-  enumerable: true,
-  get: function () {
-    return _theme.darkMarkdownTheme;
-  }
-});
 Object.defineProperty(exports, "defaultMarkdownTheme", {
   enumerable: true,
   get: function () {
     return _theme.defaultMarkdownTheme;
   }
 });
-Object.defineProperty(exports, "lightMarkdownTheme", {
-  enumerable: true,
-  get: function () {
-    return _theme.lightMarkdownTheme;
-  }
-});
 Object.defineProperty(exports, "mergeThemes", {
   enumerable: true,
   get: function () {
@@ -206,7 +185,6 @@ Object.keys(_headless).forEach(function (key) {
     }
   });
 });
-var _defaultMarkdownRenderer = require("./default-markdown-renderer.js");
 var _markdown = require("./markdown.js");
 var _markdownStream = require("./markdown-stream.js");
 var _MarkdownContext = require("./MarkdownContext.js");

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_headless","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_defaultMarkdownRenderer","_markdown","_markdownStream","_MarkdownContext","_theme","_heading","_paragraph","_link","_blockquote","_horizontalRule","_code","_list","_table","_image","_math","_MarkdownSession","_useMarkdownStream"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,SAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAL,SAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAb,SAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AAEA,IAAAS,wBAAA,GAAAb,OAAA;AACA,IAAAc,SAAA,GAAAd,OAAA;AACA,IAAAe,eAAA,GAAAf,OAAA;AAEA,IAAAgB,gBAAA,GAAAhB,OAAA;AAkBA,IAAAiB,MAAA,GAAAjB,OAAA;AAcA,IAAAkB,QAAA,GAAAlB,OAAA;AACA,IAAAmB,UAAA,GAAAnB,OAAA;AACA,IAAAoB,KAAA,GAAApB,OAAA;AACA,IAAAqB,WAAA,GAAArB,OAAA;AACA,IAAAsB,eAAA,GAAAtB,OAAA;AACA,IAAAuB,KAAA,GAAAvB,OAAA;AACA,IAAAwB,KAAA,GAAAxB,OAAA;AACA,IAAAyB,MAAA,GAAAzB,OAAA;AACA,IAAA0B,MAAA,GAAA1B,OAAA;AACA,IAAA2B,KAAA,GAAA3B,OAAA;AAEA,IAAA4B,gBAAA,GAAA5B,OAAA;AAEA,IAAA6B,kBAAA,GAAA7B,OAAA","ignoreList":[]}
+{"version":3,"names":["_headless","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_markdown","_markdownStream","_MarkdownContext","_theme","_heading","_paragraph","_link","_blockquote","_horizontalRule","_code","_list","_table","_image","_math","_MarkdownSession","_useMarkdownStream"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,SAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAL,SAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAb,SAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AAEA,IAAAS,SAAA,GAAAb,OAAA;AACA,IAAAc,eAAA,GAAAd,OAAA;AAEA,IAAAe,gBAAA,GAAAf,OAAA;AAkBA,IAAAgB,MAAA,GAAAhB,OAAA;AAYA,IAAAiB,QAAA,GAAAjB,OAAA;AACA,IAAAkB,UAAA,GAAAlB,OAAA;AACA,IAAAmB,KAAA,GAAAnB,OAAA;AACA,IAAAoB,WAAA,GAAApB,OAAA;AACA,IAAAqB,eAAA,GAAArB,OAAA;AACA,IAAAsB,KAAA,GAAAtB,OAAA;AACA,IAAAuB,KAAA,GAAAvB,OAAA;AACA,IAAAwB,MAAA,GAAAxB,OAAA;AACA,IAAAyB,MAAA,GAAAzB,OAAA;AACA,IAAA0B,KAAA,GAAA1B,OAAA;AAEA,IAAA2B,gBAAA,GAAA3B,OAAA;AAEA,IAAA4B,kBAAA,GAAA5B,OAAA","ignoreList":[]}

package/lib/commonjs/markdown-stream.js

@@ -13,16 +13,65 @@ var _jsxRuntime = require("react/jsx-runtime");
  */
 const MarkdownStream = ({
   session,
+  updateIntervalMs = 50,
+  updateStrategy = "interval",
+  useTransitionUpdates = false,
   ...props
 }) => {
   const [text, setText] = (0, _react.useState)(() => session.getAllText());
+  const pendingUpdateRef = (0, _react.useRef)(false);
+  const updateTimerRef = (0, _react.useRef)(null);
+  const rafRef = (0, _react.useRef)(null);
+  const lastEmittedRef = (0, _react.useRef)(text);
   (0, _react.useEffect)(() => {
     // Ensure initial state is synced
-    setText(session.getAllText());
-    return session.addListener(() => {
-      setText(session.getAllText());
+    const initialText = session.getAllText();
+    setText(initialText);
+    lastEmittedRef.current = initialText;
+    const flushUpdate = () => {
+      updateTimerRef.current = null;
+      if (rafRef.current !== null) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+      if (!pendingUpdateRef.current) return;
+      pendingUpdateRef.current = false;
+      const latest = session.getAllText();
+      if (latest === lastEmittedRef.current) return;
+      lastEmittedRef.current = latest;
+      if (useTransitionUpdates) {
+        (0, _react.startTransition)(() => setText(latest));
+      } else {
+        setText(latest);
+      }
+    };
+    const scheduleFlush = () => {
+      if (updateStrategy === "raf") {
+        if (rafRef.current === null) {
+          rafRef.current = requestAnimationFrame(flushUpdate);
+        }
+        return;
+      }
+      if (!updateTimerRef.current) {
+        updateTimerRef.current = setTimeout(flushUpdate, updateIntervalMs);
+      }
+    };
+    const unsubscribe = session.addListener(() => {
+      pendingUpdateRef.current = true;
+      scheduleFlush();
     });
-  }, [session]);
+    return () => {
+      unsubscribe();
+      if (updateTimerRef.current) {
+        clearTimeout(updateTimerRef.current);
+        updateTimerRef.current = null;
+      }
+      if (rafRef.current !== null) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+    };
+  }, [session, updateIntervalMs, updateStrategy, useTransitionUpdates]);
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(_markdown.Markdown, {
     ...props,
     children: text

package/lib/commonjs/markdown-stream.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","require","_markdown","_jsxRuntime","MarkdownStream","session","props","text","setText","useState","getAllText","useEffect","addListener","jsx","Markdown","children","exports"],"sourceRoot":"../../src","sources":["markdown-stream.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAA0D,IAAAE,WAAA,GAAAF,OAAA;AAU1D;AACA;AACA;AACA;AACO,MAAMG,cAAuC,GAAGA,CAAC;EACtDC,OAAO;EACP,GAAGC;AACL,CAAC,KAAK;EACJ,MAAM,CAACC,IAAI,EAAEC,OAAO,CAAC,GAAG,IAAAC,eAAQ,EAAC,MAAMJ,OAAO,CAACK,UAAU,CAAC,CAAC,CAAC;EAE5D,IAAAC,gBAAS,EAAC,MAAM;IACd;IACAH,OAAO,CAACH,OAAO,CAACK,UAAU,CAAC,CAAC,CAAC;IAE7B,OAAOL,OAAO,CAACO,WAAW,CAAC,MAAM;MAC/BJ,OAAO,CAACH,OAAO,CAACK,UAAU,CAAC,CAAC,CAAC;IAC/B,CAAC,CAAC;EACJ,CAAC,EAAE,CAACL,OAAO,CAAC,CAAC;EAEb,oBAAO,IAAAF,WAAA,CAAAU,GAAA,EAACX,SAAA,CAAAY,QAAQ;IAAA,GAAKR,KAAK;IAAAS,QAAA,EAAGR;EAAI,CAAW,CAAC;AAC/C,CAAC;AAACS,OAAA,CAAAZ,cAAA,GAAAA,cAAA","ignoreList":[]}
+{"version":3,"names":["_react","require","_markdown","_jsxRuntime","MarkdownStream","session","updateIntervalMs","updateStrategy","useTransitionUpdates","props","text","setText","useState","getAllText","pendingUpdateRef","useRef","updateTimerRef","rafRef","lastEmittedRef","useEffect","initialText","current","flushUpdate","cancelAnimationFrame","latest","startTransition","scheduleFlush","requestAnimationFrame","setTimeout","unsubscribe","addListener","clearTimeout","jsx","Markdown","children","exports"],"sourceRoot":"../../src","sources":["markdown-stream.tsx"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/markdown.js

@@ -364,22 +364,37 @@ const createBaseStyles = theme => _reactNative.StyleSheet.create({
   errorText: {
     color: "#f87171",
     fontSize: 14,
-    fontFamily: theme.fontFamilies.mono ?? "monospace"
+    fontFamily: theme.fontFamilies.mono ?? "monospace",
+    ...(_reactNative.Platform.OS === "android" && {
+      includeFontPadding: false
+    })
   },
   text: {
     color: theme.colors.text,
     fontSize: theme.fontSizes.m,
     lineHeight: theme.fontSizes.m * 1.6,
-    fontFamily: theme.fontFamilies.regular
+    fontFamily: theme.fontFamilies.regular,
+    ...(_reactNative.Platform.OS === "android" && {
+      includeFontPadding: false
+    })
   },
   bold: {
-    fontWeight: "700"
+    fontWeight: "700",
+    ...(_reactNative.Platform.OS === "android" && {
+      includeFontPadding: false
+    })
   },
   italic: {
-    fontStyle: "italic"
+    fontStyle: "italic",
+    ...(_reactNative.Platform.OS === "android" && {
+      includeFontPadding: false
+    })
   },
   strikethrough: {
-    textDecorationLine: "line-through"
+    textDecorationLine: "line-through",
+    ...(_reactNative.Platform.OS === "android" && {
+      includeFontPadding: false
+    })
   }
 });
 //# sourceMappingURL=markdown.js.map