react-native-nitro-markdown 0.4.2 → 0.5.0

package/android/src/main/java/com/margelo/nitro/com/nitromarkdown/HybridMarkdownSession.kt

@@ -2,7 +2,7 @@ package com.margelo.nitro.com.nitromarkdown
 
 class HybridMarkdownSession : HybridMarkdownSessionSpec() {
     private var buffer = StringBuilder()
-    private val listeners = mutableMapOf<Long, () -> Unit>()
+    private val listeners = mutableMapOf<Long, (Double, Double) -> Unit>()
     private var nextListenerId = 0L
     private val lock = Any()
 
@@ -17,11 +17,16 @@ class HybridMarkdownSession : HybridMarkdownSessionSpec() {
     override val memorySize: Long
         get() = buffer.length.toLong()
 
-    override fun append(chunk: String) {
+    override fun append(chunk: String): Double {
+        val from: Int
+        val to: Int
         synchronized(lock) {
+            from = buffer.length
             buffer.append(chunk)
+            to = buffer.length
         }
-        notifyListeners()
+        notifyListeners(from.toDouble(), to.toDouble())
+        return to.toDouble()
     }
 
     override fun clear() {
@@ -29,7 +34,7 @@ class HybridMarkdownSession : HybridMarkdownSessionSpec() {
             buffer.clear()
             highlightPosition = 0.0
         }
-        notifyListeners()
+        notifyListeners(0.0, 0.0)
     }
 
     override fun getAllText(): String {
@@ -38,7 +43,21 @@ class HybridMarkdownSession : HybridMarkdownSessionSpec() {
         }
     }
 
-    override fun addListener(listener: () -> Unit): () -> Unit {
+    override fun getLength(): Double {
+        synchronized(lock) {
+            return buffer.length.toDouble()
+        }
+    }
+
+    override fun getTextRange(from: Double, to: Double): String {
+        synchronized(lock) {
+            val start = from.toInt().coerceIn(0, buffer.length)
+            val end = to.toInt().coerceIn(start, buffer.length)
+            return buffer.substring(start, end)
+        }
+    }
+
+    override fun addListener(listener: (Double, Double) -> Unit): () -> Unit {
         val id: Long
         synchronized(lock) {
             id = nextListenerId++
@@ -51,11 +70,11 @@ class HybridMarkdownSession : HybridMarkdownSessionSpec() {
         }
     }
 
-    private fun notifyListeners() {
-        val currentListeners: Collection<() -> Unit>
+    private fun notifyListeners(from: Double, to: Double) {
+        val currentListeners: Collection<(Double, Double) -> Unit>
         synchronized(lock) {
             currentListeners = listeners.values.toList()
         }
-        currentListeners.forEach { it() }
+        currentListeners.forEach { it(from, to) }
     }
 }

package/cpp/bindings/HybridMarkdownParser.cpp

@@ -1,114 +1,264 @@
 #include "HybridMarkdownParser.hpp"
-#include <sstream>
-#include <iomanip>
+#include <cctype>
+#include <string>
 
 namespace margelo::nitro::Markdown {
 
-std::string HybridMarkdownParser::parse(const std::string& text) {
-    InternalParserOptions opts;
-    opts.gfm = true;
-    opts.math = true;
-    
-    auto ast = parser_->parse(text, opts);
-    return nodeToJson(ast);
-}
+namespace {
 
-std::string HybridMarkdownParser::parseWithOptions(const std::string& text, const ParserOptions& options) {
-    InternalParserOptions internalOpts;
-    internalOpts.gfm = options.gfm.value_or(true);
-    internalOpts.math = options.math.value_or(true);
-    
-    auto ast = parser_->parse(text, internalOpts);
-    return nodeToJson(ast);
-}
+inline void appendEscapedJsonString(std::string& output, const std::string& input) {
+    static constexpr char kHex[] = "0123456789abcdef";
 
-static std::string escapeJson(const std::string& s) {
-    std::ostringstream o;
-    for (char c : s) {
+    for (unsigned char c : input) {
         switch (c) {
-            case '"': o << "\\\""; break;
-            case '\\': o << "\\\\"; break;
-            case '\b': o << "\\b"; break;
-            case '\f': o << "\\f"; break;
-            case '\n': o << "\\n"; break;
-            case '\r': o << "\\r"; break;
-            case '\t': o << "\\t"; break;
-            default:
-                if ('\x00' <= c && c <= '\x1f') {
-                    o << "\\u" << std::hex << std::setw(4) << std::setfill('0') << (int)(unsigned char)c;
+            case '"':
+                output += "\\\"";
+                break;
+            case '\\':
+                output += "\\\\";
+                break;
+            case '\b':
+                output += "\\b";
+                break;
+            case '\f':
+                output += "\\f";
+                break;
+            case '\n':
+                output += "\\n";
+                break;
+            case '\r':
+                output += "\\r";
+                break;
+            case '\t':
+                output += "\\t";
+                break;
+            default: {
+                if (c <= 0x1f) {
+                    output += "\\u00";
+                    output.push_back(kHex[(c >> 4) & 0x0f]);
+                    output.push_back(kHex[c & 0x0f]);
                 } else {
-                    o << c;
+                    output.push_back(static_cast<char>(c));
                 }
+                break;
+            }
         }
     }
-    return o.str();
 }
 
-std::string HybridMarkdownParser::nodeToJson(const std::shared_ptr<InternalMarkdownNode>& node) {
-    std::ostringstream json;
-    json << "{";
-    json << "\"type\":\"" << ::NitroMarkdown::nodeTypeToString(node->type) << "\"";
-    json << ",\"beg\":" << node->beg;
-    json << ",\"end\":" << node->end;
+inline void appendStringField(std::string& output, const char* key, const std::string& value) {
+    output.push_back(',');
+    output.push_back('"');
+    output += key;
+    output += "\":\"";
+    appendEscapedJsonString(output, value);
+    output.push_back('"');
+}
+
+inline void appendIntField(std::string& output, const char* key, int value) {
+    output.push_back(',');
+    output.push_back('"');
+    output += key;
+    output += "\":";
+    output += std::to_string(value);
+}
+
+inline void appendOffsetField(std::string& output, const char* key, unsigned int value) {
+    output.push_back(',');
+    output.push_back('"');
+    output += key;
+    output += "\":";
+    output += std::to_string(value);
+}
+
+inline void appendBoolField(std::string& output, const char* key, bool value) {
+    output.push_back(',');
+    output.push_back('"');
+    output += key;
+    output += "\":";
+    output += value ? "true" : "false";
+}
+
+void appendNodeJson(std::string& output, const std::shared_ptr<InternalMarkdownNode>& node) {
+    output.push_back('{');
+
+    output += "\"type\":\"";
+    output += ::NitroMarkdown::nodeTypeToString(node->type);
+    output.push_back('"');
+
+    appendOffsetField(output, "beg", node->beg);
+    appendOffsetField(output, "end", node->end);
 
     if (node->content.has_value()) {
-        json << ",\"content\":\"" << escapeJson(node->content.value()) << "\"";
+        appendStringField(output, "content", node->content.value());
     }
-    
+
     if (node->level.has_value()) {
-        json << ",\"level\":" << node->level.value();
+        appendIntField(output, "level", node->level.value());
     }
-    
+
     if (node->href.has_value()) {
-        json << ",\"href\":\"" << escapeJson(node->href.value()) << "\"";
+        appendStringField(output, "href", node->href.value());
     }
-    
+
     if (node->title.has_value()) {
-        json << ",\"title\":\"" << escapeJson(node->title.value()) << "\"";
+        appendStringField(output, "title", node->title.value());
     }
-    
+
     if (node->alt.has_value()) {
-        json << ",\"alt\":\"" << escapeJson(node->alt.value()) << "\"";
+        appendStringField(output, "alt", node->alt.value());
     }
-    
+
     if (node->language.has_value()) {
-        json << ",\"language\":\"" << escapeJson(node->language.value()) << "\"";
+        appendStringField(output, "language", node->language.value());
     }
-    
+
     if (node->ordered.has_value()) {
-        json << ",\"ordered\":" << (node->ordered.value() ? "true" : "false");
+        appendBoolField(output, "ordered", node->ordered.value());
     }
-    
+
     if (node->start.has_value()) {
-        json << ",\"start\":" << node->start.value();
+        appendIntField(output, "start", node->start.value());
     }
-    
+
     if (node->checked.has_value()) {
-        json << ",\"checked\":" << (node->checked.value() ? "true" : "false");
+        appendBoolField(output, "checked", node->checked.value());
     }
-    
+
     if (node->isHeader.has_value()) {
-        json << ",\"isHeader\":" << (node->isHeader.value() ? "true" : "false");
+        appendBoolField(output, "isHeader", node->isHeader.value());
     }
-    
+
     if (node->align.has_value()) {
         std::string alignStr = ::NitroMarkdown::textAlignToString(node->align.value());
         if (!alignStr.empty()) {
-            json << ",\"align\":\"" << alignStr << "\"";
+            appendStringField(output, "align", alignStr);
         }
     }
 
     if (!node->children.empty()) {
-        json << ",\"children\":[";
+        output += ",\"children\":[";
         for (size_t i = 0; i < node->children.size(); ++i) {
-            if (i > 0) json << ",";
-            json << nodeToJson(node->children[i]);
+            if (i > 0) {
+                output.push_back(',');
+            }
+            appendNodeJson(output, node->children[i]);
         }
-        json << "]";
+        output.push_back(']');
+    }
+
+    output.push_back('}');
+}
+
+std::string trimCopy(const std::string& input) {
+    size_t start = 0;
+    while (start < input.size() && std::isspace(static_cast<unsigned char>(input[start]))) {
+        start++;
+    }
+
+    size_t end = input.size();
+    while (end > start && std::isspace(static_cast<unsigned char>(input[end - 1]))) {
+        end--;
     }
+
+    return input.substr(start, end - start);
+}
+
+std::string flattenNodeText(const std::shared_ptr<InternalMarkdownNode>& node) {
+    using ::NitroMarkdown::NodeType;
+
+    if (!node) return "";
+
+    switch (node->type) {
+        case NodeType::Text:
+        case NodeType::CodeInline:
+        case NodeType::MathInline:
+        case NodeType::HtmlInline:
+            return node->content.value_or("");
+        case NodeType::CodeBlock:
+        case NodeType::MathBlock:
+        case NodeType::HtmlBlock:
+            return trimCopy(node->content.value_or("")) + "\n\n";
+        case NodeType::LineBreak:
+            return "\n";
+        case NodeType::SoftBreak:
+            return " ";
+        case NodeType::HorizontalRule:
+            return "---\n\n";
+        case NodeType::Image:
+            return node->alt.value_or(node->title.value_or(""));
+        default:
+            break;
+    }
+
+    std::string childrenText;
+    childrenText.reserve(128);
+    for (const auto& child : node->children) {
+        childrenText += flattenNodeText(child);
+    }
+
+    switch (node->type) {
+        case NodeType::Paragraph:
+        case NodeType::Heading:
+        case NodeType::Blockquote:
+            return trimCopy(childrenText) + "\n\n";
+        case NodeType::ListItem:
+        case NodeType::TaskListItem:
+            return trimCopy(childrenText) + "\n";
+        case NodeType::List:
+            return childrenText + "\n";
+        case NodeType::TableRow:
+            return childrenText + "\n";
+        case NodeType::TableCell:
+            return childrenText + " | ";
+        default:
+            return childrenText;
+    }
+}
+
+} // namespace
+
+std::string HybridMarkdownParser::parse(const std::string& text) {
+    InternalParserOptions opts;
+    opts.gfm = true;
+    opts.math = true;
     
-    json << "}";
-    return json.str();
+    auto ast = parser_->parse(text, opts);
+    return nodeToJson(ast);
+}
+
+std::string HybridMarkdownParser::parseWithOptions(const std::string& text, const ParserOptions& options) {
+    InternalParserOptions internalOpts;
+    internalOpts.gfm = options.gfm.value_or(true);
+    internalOpts.math = options.math.value_or(true);
+    
+    auto ast = parser_->parse(text, internalOpts);
+    return nodeToJson(ast);
+}
+
+std::string HybridMarkdownParser::extractPlainText(const std::string& text) {
+    InternalParserOptions opts;
+    opts.gfm = true;
+    opts.math = true;
+
+    auto ast = parser_->parse(text, opts);
+    return flattenNodeText(ast);
+}
+
+std::string HybridMarkdownParser::extractPlainTextWithOptions(const std::string& text, const ParserOptions& options) {
+    InternalParserOptions internalOpts;
+    internalOpts.gfm = options.gfm.value_or(true);
+    internalOpts.math = options.math.value_or(true);
+
+    auto ast = parser_->parse(text, internalOpts);
+    return flattenNodeText(ast);
+}
+
+std::string HybridMarkdownParser::nodeToJson(const std::shared_ptr<InternalMarkdownNode>& node) {
+    std::string json;
+    json.reserve(1024);
+    appendNodeJson(json, node);
+    return json;
 }
 
 } // namespace margelo::nitro::Markdown

package/cpp/bindings/HybridMarkdownParser.hpp

@@ -19,6 +19,8 @@ public:
 
     std::string parse(const std::string& text) override;
     std::string parseWithOptions(const std::string& text, const ParserOptions& options) override;
+    std::string extractPlainText(const std::string& text) override;
+    std::string extractPlainTextWithOptions(const std::string& text, const ParserOptions& options) override;
 
 private:
     std::unique_ptr<::NitroMarkdown::MD4CParser> parser_;

package/ios/HybridMarkdownSession.swift

@@ -3,7 +3,7 @@ import NitroModules
 
 class HybridMarkdownSession: HybridMarkdownSessionSpec {
     private var buffer = ""
-    private var listeners: [UUID: () -> Void] = [:]
+    private var listeners: [UUID: (Double, Double) -> Void] = [:]
     private let lock = NSLock()
     
     private(set) var version: Int = 0
@@ -15,13 +15,22 @@ class HybridMarkdownSession: HybridMarkdownSessionSpec {
     var memorySize: Int {
         return buffer.utf8.count + MemoryLayout<HybridMarkdownSession>.size
     }
+
+    private func utf16Length(_ value: String) -> Int {
+        return (value as NSString).length
+    }
     
-    func append(chunk: String) throws {
+    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()
+        notifyListeners(from: Double(from), to: Double(to))
+        return Double(to)
     }
     
     func clear() throws {
@@ -30,7 +39,7 @@ class HybridMarkdownSession: HybridMarkdownSessionSpec {
         highlightPosition = 0
         version += 1
         lock.unlock()
-        notifyListeners()
+        notifyListeners(from: 0, to: 0)
     }
     
     func getAllText() throws -> String {
@@ -38,8 +47,25 @@ class HybridMarkdownSession: HybridMarkdownSessionSpec {
         defer { lock.unlock() }
         return buffer
     }
+
+    func getLength() throws -> Double {
+        lock.lock()
+        defer { lock.unlock() }
+        return Double(utf16Length(buffer))
+    }
+
+    func getTextRange(from: Double, to: Double) throws -> String {
+        lock.lock()
+        defer { lock.unlock() }
+
+        let text = buffer as NSString
+        let length = text.length
+        let start = max(0, min(Int(from), length))
+        let end = max(start, min(Int(to), length))
+        return text.substring(with: NSRange(location: start, length: end - start))
+    }
     
-    func addListener(listener: @escaping () -> Void) throws -> () -> Void {
+    func addListener(listener: @escaping (Double, Double) -> Void) throws -> () -> Void {
         let id = UUID()
         lock.lock()
         listeners[id] = listener
@@ -52,13 +78,13 @@ class HybridMarkdownSession: HybridMarkdownSessionSpec {
         }
     }
     
-    private func notifyListeners() {
+    private func notifyListeners(from: Double, to: Double) {
         lock.lock()
         let currentListeners = Array(listeners.values)
         lock.unlock()
         
         for listener in currentListeners {
-            listener()
+            listener(from, to)
         }
     }
 }

package/lib/commonjs/MarkdownContext.js

@@ -10,7 +10,8 @@ const MarkdownContext = exports.MarkdownContext = /*#__PURE__*/(0, _react.create
   renderers: {},
   theme: _theme.defaultMarkdownTheme,
   styles: undefined,
-  stylingStrategy: "opinionated"
+  stylingStrategy: "opinionated",
+  onLinkPress: undefined
 });
 const useMarkdownContext = () => (0, _react.useContext)(MarkdownContext);
 exports.useMarkdownContext = useMarkdownContext;

package/lib/commonjs/MarkdownContext.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","require","_theme","MarkdownContext","exports","createContext","renderers","theme","defaultMarkdownTheme","styles","undefined","stylingStrategy","useMarkdownContext","useContext"],"sourceRoot":"../../src","sources":["MarkdownContext.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMA,IAAAC,MAAA,GAAAD,OAAA;AAoFO,MAAME,eAAe,GAAAC,OAAA,CAAAD,eAAA,gBAAG,IAAAE,oBAAa,EAAuB;EACjEC,SAAS,EAAE,CAAC,CAAC;EACbC,KAAK,EAAEC,2BAAoB;EAC3BC,MAAM,EAAEC,SAAS;EACjBC,eAAe,EAAE;AACnB,CAAC,CAAC;AAEK,MAAMC,kBAAkB,GAAGA,CAAA,KAAM,IAAAC,iBAAU,EAACV,eAAe,CAAC;AAACC,OAAA,CAAAQ,kBAAA,GAAAA,kBAAA","ignoreList":[]}
+{"version":3,"names":["_react","require","_theme","MarkdownContext","exports","createContext","renderers","theme","defaultMarkdownTheme","styles","undefined","stylingStrategy","onLinkPress","useMarkdownContext","useContext"],"sourceRoot":"../../src","sources":["MarkdownContext.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAOA,IAAAC,MAAA,GAAAD,OAAA;AAwFO,MAAME,eAAe,GAAAC,OAAA,CAAAD,eAAA,gBAAG,IAAAE,oBAAa,EAAuB;EACjEC,SAAS,EAAE,CAAC,CAAC;EACbC,KAAK,EAAEC,2BAAoB;EAC3BC,MAAM,EAAEC,SAAS;EACjBC,eAAe,EAAE,aAAa;EAC9BC,WAAW,EAAEF;AACf,CAAC,CAAC;AAEK,MAAMG,kBAAkB,GAAGA,CAAA,KAAM,IAAAC,iBAAU,EAACX,eAAe,CAAC;AAACC,OAAA,CAAAS,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/lib/commonjs/headless.js

@@ -3,7 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getTextContent = exports.getFlattenedText = exports.MarkdownParserModule = void 0;
+exports.MarkdownParserModule = void 0;
+exports.extractPlainText = extractPlainText;
+exports.extractPlainTextWithOptions = extractPlainTextWithOptions;
+exports.getTextContent = exports.getFlattenedText = void 0;
 exports.parseMarkdown = parseMarkdown;
 exports.parseMarkdownWithOptions = parseMarkdownWithOptions;
 var _reactNativeNitroModules = require("react-native-nitro-modules");
@@ -33,8 +36,14 @@ const MarkdownParserModule = exports.MarkdownParserModule = _reactNativeNitroMod
  * @returns The root node of the parsed AST
  */
 function parseMarkdown(text) {
-  const jsonStr = MarkdownParserModule.parse(text);
-  return JSON.parse(jsonStr);
+  if (typeof MarkdownParserModule.parse === "function") {
+    const jsonStr = MarkdownParserModule.parse(text);
+    return JSON.parse(jsonStr);
+  }
+  return {
+    type: "document",
+    children: []
+  };
 }
 
 /**
@@ -44,8 +53,35 @@ function parseMarkdown(text) {
  * @returns The root node of the parsed AST
  */
 function parseMarkdownWithOptions(text, options) {
-  const jsonStr = MarkdownParserModule.parseWithOptions(text, options);
-  return JSON.parse(jsonStr);
+  if (typeof MarkdownParserModule.parseWithOptions === "function") {
+    const jsonStr = MarkdownParserModule.parseWithOptions(text, options);
+    return JSON.parse(jsonStr);
+  }
+  return {
+    type: "document",
+    children: []
+  };
+}
+
+/**
+ * Parse markdown and return flattened plain text directly from native parser.
+ * Useful for search/indexing flows that don't need full AST rendering.
+ */
+function extractPlainText(text) {
+  if (typeof MarkdownParserModule.extractPlainText === "function") {
+    return MarkdownParserModule.extractPlainText(text);
+  }
+  return getFlattenedText(parseMarkdown(text));
+}
+
+/**
+ * Parse markdown with options and return flattened plain text from native parser.
+ */
+function extractPlainTextWithOptions(text, options) {
+  if (typeof MarkdownParserModule.extractPlainTextWithOptions === "function") {
+    return MarkdownParserModule.extractPlainTextWithOptions(text, options);
+  }
+  return getFlattenedText(parseMarkdownWithOptions(text, options));
 }
 /**
  * Extract text content from a markdown node recursively.

package/lib/commonjs/headless.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeNitroModules","require","MarkdownParserModule","exports","NitroModules","createHybridObject","parseMarkdown","text","jsonStr","parse","JSON","parseMarkdownWithOptions","options","parseWithOptions","getTextContent","node","content","children","map","join","getFlattenedText","type","trim","alt","title","childrenText"],"sourceRoot":"../../src","sources":["headless.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_reactNativeNitroModules","require","MarkdownParserModule","exports","NitroModules","createHybridObject","parseMarkdown","text","parse","jsonStr","JSON","type","children","parseMarkdownWithOptions","options","parseWithOptions","extractPlainText","getFlattenedText","extractPlainTextWithOptions","getTextContent","node","content","map","join","trim","alt","title","childrenText"],"sourceRoot":"../../src","sources":["headless.ts"],"mappings":"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","ignoreList":[]}

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","_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":[]}
+{"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;AAOA,IAAAc,eAAA,GAAAd,OAAA;AAGA,IAAAe,gBAAA,GAAAf,OAAA;AAmBA,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":[]}