react-native-nitro-markdown 0.4.3 → 0.5.1

package/android/src/main/java/com/nitromarkdown/NitroMarkdownPackage.kt

@@ -5,11 +5,12 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
+import com.margelo.nitro.com.nitromarkdown.NitroMarkdownOnLoad
 
 class NitroMarkdownPackage : TurboReactPackage() {
     companion object {
         init {
-            System.loadLibrary("NitroMarkdown")
+            NitroMarkdownOnLoad.initializeNative()
         }
     }
 

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,31 @@ class HybridMarkdownSession: HybridMarkdownSessionSpec {
         }
     }
     
-    private func notifyListeners() {
+    func reset(text: String) -> Void {
+      lock.lock()
+      buffer = text
+      lock.unlock()
+      notifyListeners(from: 0, to: Double((text as NSString).length))
+    }
+
+    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
+    }
+
+    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.map

@@ -1 +1 @@
-{"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":[]}
+{"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;AA8FO,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,9 +3,13 @@
 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;
+exports.stripSourceOffsets = stripSourceOffsets;
 var _reactNativeNitroModules = require("react-native-nitro-modules");
 /**
  * Headless entry point for react-native-nitro-markdown.
@@ -33,8 +37,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 +54,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.
@@ -94,5 +131,24 @@ const getFlattenedText = node => {
       return childrenText;
   }
 };
+
+/**
+ * Recursively removes `beg`/`end` source offset fields from an AST.
+ * Useful to reduce memory in environments that don't need source mapping.
+ */
 exports.getFlattenedText = getFlattenedText;
+function stripSourceOffsets(node) {
+  const {
+    beg: _beg,
+    end: _end,
+    children,
+    ...rest
+  } = node;
+  return {
+    ...rest,
+    ...(children ? {
+      children: children.map(stripSourceOffsets)
+    } : {})
+  };
+}
 //# sourceMappingURL=headless.js.map

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","stripSourceOffsets","beg","_beg","end","_end","rest"],"sourceRoot":"../../src","sources":["headless.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/index.js

@@ -27,7 +27,8 @@ var _exportNames = {
   MathBlock: true,
   createMarkdownSession: true,
   useMarkdownSession: true,
-  useStream: true
+  useStream: true,
+  defaultHighlighter: true
 };
 Object.defineProperty(exports, "Blockquote", {
   enumerable: true,
@@ -137,6 +138,12 @@ Object.defineProperty(exports, "createMarkdownSession", {
     return _MarkdownSession.createMarkdownSession;
   }
 });
+Object.defineProperty(exports, "defaultHighlighter", {
+  enumerable: true,
+  get: function () {
+    return _codeHighlight.defaultHighlighter;
+  }
+});
 Object.defineProperty(exports, "defaultMarkdownTheme", {
   enumerable: true,
   get: function () {
@@ -201,4 +208,5 @@ var _image = require("./renderers/image.js");
 var _math = require("./renderers/math.js");
 var _MarkdownSession = require("./MarkdownSession.js");
 var _useMarkdownStream = require("./use-markdown-stream.js");
+var _codeHighlight = require("./utils/code-highlight.js");
 //# sourceMappingURL=index.js.map

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;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":[]}
+{"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","_codeHighlight"],"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;AAGA,IAAA6B,cAAA,GAAA7B,OAAA","ignoreList":[]}