diff --git a/apps/ui/patches/react-native-enriched-markdown+0.5.0.patch b/apps/ui/patches/react-native-enriched-markdown+0.5.0.patch index 016f713811..c1452de9b3 100644 --- a/apps/ui/patches/react-native-enriched-markdown+0.5.0.patch +++ b/apps/ui/patches/react-native-enriched-markdown+0.5.0.patch @@ -1,3 +1,120 @@ +diff --git a/node_modules/react-native-enriched-markdown/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.h b/node_modules/react-native-enriched-markdown/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.h +index c9e1984..4f75d3a 100644 +--- a/node_modules/react-native-enriched-markdown/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.h ++++ b/node_modules/react-native-enriched-markdown/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.h +@@ -1857,6 +1857,7 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownMarkdownStyleStruct + struct EnrichedMarkdownMd4cFlagsStruct { + bool underline{false}; + bool latexMath{false}; ++ bool texMathBackslashDelimiters{false}; + + + #ifdef RN_SERIALIZABLE_STATE +@@ -1866,6 +1867,7 @@ struct EnrichedMarkdownMd4cFlagsStruct { + folly::dynamic result = folly::dynamic::object(); + result["underline"] = underline; + result["latexMath"] = latexMath; ++ result["texMathBackslashDelimiters"] = texMathBackslashDelimiters; + return result; + } + #endif +@@ -1882,6 +1884,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu + if (tmp_latexMath != map.end()) { + fromRawValue(context, tmp_latexMath->second, result.latexMath); + } ++ auto tmp_texMathBackslashDelimiters = map.find("texMathBackslashDelimiters"); ++ if (tmp_texMathBackslashDelimiters != map.end()) { ++ fromRawValue(context, tmp_texMathBackslashDelimiters->second, result.texMathBackslashDelimiters); ++ } + } + + static inline std::string toString(const EnrichedMarkdownMd4cFlagsStruct &value) { +@@ -4153,6 +4159,7 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownTextMarkdownStyleSt + struct EnrichedMarkdownTextMd4cFlagsStruct { + bool underline{false}; + bool latexMath{false}; ++ bool texMathBackslashDelimiters{false}; + + + #ifdef RN_SERIALIZABLE_STATE +@@ -4162,6 +4169,7 @@ struct EnrichedMarkdownTextMd4cFlagsStruct { + folly::dynamic result = folly::dynamic::object(); + result["underline"] = underline; + result["latexMath"] = latexMath; ++ result["texMathBackslashDelimiters"] = texMathBackslashDelimiters; + return result; + } + #endif +@@ -4178,6 +4186,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu + if (tmp_latexMath != map.end()) { + fromRawValue(context, tmp_latexMath->second, result.latexMath); + } ++ auto tmp_texMathBackslashDelimiters = map.find("texMathBackslashDelimiters"); ++ if (tmp_texMathBackslashDelimiters != map.end()) { ++ fromRawValue(context, tmp_texMathBackslashDelimiters->second, result.texMathBackslashDelimiters); ++ } + } + + static inline std::string toString(const EnrichedMarkdownTextMd4cFlagsStruct &value) { +diff --git a/node_modules/react-native-enriched-markdown/android/src/main/cpp/jni-adapter.cpp b/node_modules/react-native-enriched-markdown/android/src/main/cpp/jni-adapter.cpp +index 16137fa..0eb4004 100644 +--- a/node_modules/react-native-enriched-markdown/android/src/main/cpp/jni-adapter.cpp ++++ b/node_modules/react-native-enriched-markdown/android/src/main/cpp/jni-adapter.cpp +@@ -206,6 +206,10 @@ JNIEXPORT jobject JNICALL Java_com_swmansion_enriched_markdown_parser_Parser_nat + if (latexMathField) { + md4cFlags.latexMath = env->GetBooleanField(flags, latexMathField) == JNI_TRUE; + } ++ jfieldID texMathBackslashDelimitersField = env->GetFieldID(flagsClass, "texMathBackslashDelimiters", "Z"); ++ if (texMathBackslashDelimitersField) { ++ md4cFlags.texMathBackslashDelimiters = env->GetBooleanField(flags, texMathBackslashDelimitersField) == JNI_TRUE; ++ } + jfieldID permissiveAutolinksField = env->GetFieldID(flagsClass, "permissiveAutolinks", "Z"); + if (permissiveAutolinksField) { + md4cFlags.permissiveAutolinks = env->GetBooleanField(flags, permissiveAutolinksField) == JNI_TRUE; +diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/MeasurementStore.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/MeasurementStore.kt +index 0abbba9..e101f37 100644 +--- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/MeasurementStore.kt ++++ b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/MeasurementStore.kt +@@ -245,6 +245,7 @@ object MeasurementStore { + Md4cFlags( + underline = props.getMapOrNull("md4cFlags").getBooleanOrDefault("underline", false), + latexMath = FeatureFlags.IS_MATH_ENABLED && props.getMapOrNull("md4cFlags").getBooleanOrDefault("latexMath", true), ++ texMathBackslashDelimiters = FeatureFlags.IS_MATH_ENABLED && props.getMapOrNull("md4cFlags").getBooleanOrDefault("texMathBackslashDelimiters", false), + ) + + val fontSize = getInitialFontSize(styleMap, context, allowFontScaling, fontScale, maxFontSizeMultiplier) +@@ -295,6 +296,7 @@ object MeasurementStore { + Md4cFlags( + underline = props.getMapOrNull("md4cFlags").getBooleanOrDefault("underline", false), + latexMath = FeatureFlags.IS_MATH_ENABLED && props.getMapOrNull("md4cFlags").getBooleanOrDefault("latexMath", true), ++ texMathBackslashDelimiters = FeatureFlags.IS_MATH_ENABLED && props.getMapOrNull("md4cFlags").getBooleanOrDefault("texMathBackslashDelimiters", false), + ) + val allowTrailingMargin = props.getBooleanOrDefault("allowTrailingMargin", false) + val propsHash = computePropsHash(props, allowFontScaling, fontScale, maxFontSizeMultiplier) +diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/parser/Parser.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/parser/Parser.kt +index 08b031d..d817f1b 100644 +--- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/parser/Parser.kt ++++ b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/parser/Parser.kt +@@ -6,6 +6,7 @@ import com.swmansion.enriched.markdown.utils.common.FeatureFlags + data class Md4cFlags( + val underline: Boolean = false, + val latexMath: Boolean = FeatureFlags.IS_MATH_ENABLED, ++ val texMathBackslashDelimiters: Boolean = false, + val permissiveAutolinks: Boolean = true, + ) { + companion object { +diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MarkdownViewManagerUtils.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MarkdownViewManagerUtils.kt +index 9f3152d..38fd365 100644 +--- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MarkdownViewManagerUtils.kt ++++ b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MarkdownViewManagerUtils.kt +@@ -82,6 +82,7 @@ fun parseMd4cFlags(flags: ReadableMap?): Md4cFlags = + Md4cFlags( + underline = flags?.getBoolean("underline") ?: false, + latexMath = FeatureFlags.IS_MATH_ENABLED && (flags?.getBoolean("latexMath") ?: true), ++ texMathBackslashDelimiters = FeatureFlags.IS_MATH_ENABLED && (flags?.getBoolean("texMathBackslashDelimiters") ?: false), + ) + + fun parseContextMenuItems(value: ReadableArray?): List = diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/text/TailFadeInAnimator.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/text/TailFadeInAnimator.kt index 9feea24..7c5d540 100644 --- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/text/TailFadeInAnimator.kt @@ -160,6 +277,227 @@ index 9feea24..7c5d540 100644 } companion object { +diff --git a/node_modules/react-native-enriched-markdown/cpp/md4c/md4c.c b/node_modules/react-native-enriched-markdown/cpp/md4c/md4c.c +index 76a66d2..197ec38 100644 +--- a/node_modules/react-native-enriched-markdown/cpp/md4c/md4c.c ++++ b/node_modules/react-native-enriched-markdown/cpp/md4c/md4c.c +@@ -201,7 +201,7 @@ struct MD_CTX_tag { + #endif + + /* For resolving of inline spans. */ +- MD_MARKSTACK opener_stacks[17]; ++ MD_MARKSTACK opener_stacks[19]; + #define ASTERISK_OPENERS_oo_mod3_0 (ctx->opener_stacks[0]) /* Opener-only */ + #define ASTERISK_OPENERS_oo_mod3_1 (ctx->opener_stacks[1]) + #define ASTERISK_OPENERS_oo_mod3_2 (ctx->opener_stacks[2]) +@@ -219,6 +219,8 @@ struct MD_CTX_tag { + #define BRACKET_OPENERS (ctx->opener_stacks[14]) + #define DOLLAR_OPENERS (ctx->opener_stacks[15]) + #define PIPE_OPENERS (ctx->opener_stacks[16]) ++#define BACKSLASH_TEX_INLINE_OPENERS (ctx->opener_stacks[17]) ++#define BACKSLASH_TEX_DISPLAY_OPENERS (ctx->opener_stacks[18]) + + /* Stack of dummies which need to call free() for pointers stored in them. + * These are constructed during inline parsing and freed after all the block +@@ -2553,6 +2555,7 @@ struct MD_MARK_tag { + #define MD_MARK_AUTOLINK_MISSING_MAILTO 0x40 + #define MD_MARK_VALIDPERMISSIVEAUTOLINK 0x20 /* For permissive autolinks. */ + #define MD_MARK_HASNESTEDBRACKETS 0x20 /* For '[' to rule out invalid link labels early */ ++#define MD_MARK_BACKSLASH_TEX_DISPLAY 0x20 /* For '\\' backslash-delimited math delimiters. */ + + static MD_MARKSTACK* + md_emph_stack(MD_CTX* ctx, MD_CHAR ch, unsigned flags) +@@ -3041,6 +3044,49 @@ md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_m + + ch = CH(off); + ++ /* Backslash-delimited TeX math delimiters. Handle these before CommonMark ++ * backslash escapes so incomplete input can remain literal until ++ * a matching delimiter arrives. */ ++ if(ch == _T('\\') && (ctx->parser.flags & MD_FLAG_BACKSLASHTEXMATHSPANS) && off+1 < line->end) { ++ CHAR delimiter = CH(off+1); ++ ++ if(delimiter == _T('(') || delimiter == _T(')')) { ++ ADD_MARK(ch, off, off+2, ++ delimiter == _T('(') ? MD_MARK_POTENTIAL_OPENER : MD_MARK_POTENTIAL_CLOSER); ++ off += 2; ++ continue; ++ } ++ ++ if(delimiter == _T('[') || delimiter == _T(']')) { ++ OFF cursor; ++ int standalone = TRUE; ++ ++ if(delimiter == _T('[')) { ++ for(cursor = line->beg; cursor < off; cursor++) { ++ if(!ISBLANK(cursor)) { ++ standalone = FALSE; ++ break; ++ } ++ } ++ } else { ++ for(cursor = off+2; cursor < line->end; cursor++) { ++ if(!ISBLANK(cursor)) { ++ standalone = FALSE; ++ break; ++ } ++ } ++ } ++ ++ if(standalone) { ++ ADD_MARK(ch, off, off+2, ++ (delimiter == _T('[') ? MD_MARK_POTENTIAL_OPENER : MD_MARK_POTENTIAL_CLOSER) | ++ MD_MARK_BACKSLASH_TEX_DISPLAY); ++ off += 2; ++ continue; ++ } ++ } ++ } ++ + /* A backslash escape. + * It can go beyond line->end as it may involve escaped new + * line to form a hard break. */ +@@ -3867,6 +3913,39 @@ md_analyze_dollar(MD_CTX* ctx, int mark_index) + md_mark_stack_push(ctx, &DOLLAR_OPENERS, mark_index); + } + ++static void ++md_analyze_backslash_tex_math(MD_CTX* ctx, int mark_index) ++{ ++ MD_MARK* mark = &ctx->marks[mark_index]; ++ int is_display = (mark->flags & MD_MARK_BACKSLASH_TEX_DISPLAY) != 0; ++ MD_MARKSTACK* stack = is_display ? &BACKSLASH_TEX_DISPLAY_OPENERS : &BACKSLASH_TEX_INLINE_OPENERS; ++ ++ if((mark->flags & MD_MARK_POTENTIAL_CLOSER) && stack->top >= 0) { ++ int opener_index = md_mark_stack_pop(ctx, stack); ++ MD_MARK* opener = &ctx->marks[opener_index]; ++ OFF off; ++ int has_content = FALSE; ++ int crosses_line = FALSE; ++ ++ for(off = opener->end; off < mark->beg; off++) { ++ if(ISNEWLINE(off)) ++ crosses_line = TRUE; ++ else if(!ISUNICODEWHITESPACE(off)) ++ has_content = TRUE; ++ } ++ ++ if(has_content && (is_display || !crosses_line)) { ++ md_rollback(ctx, opener_index, mark_index, MD_ROLLBACK_ALL); ++ md_resolve_range(ctx, opener_index, mark_index); ++ stack->top = -1; ++ return; ++ } ++ } ++ ++ if(mark->flags & MD_MARK_POTENTIAL_OPENER) ++ md_mark_stack_push(ctx, stack, mark_index); ++} ++ + static void + md_analyze_pipe(MD_CTX* ctx, int mark_index) + { +@@ -4128,6 +4207,7 @@ md_analyze_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, + case '*': md_analyze_emph(ctx, i); break; + case '~': md_analyze_tilde(ctx, i); break; + case '$': md_analyze_dollar(ctx, i); break; ++ case '\\': md_analyze_backslash_tex_math(ctx, i); break; + case '.': /* Pass through. */ + case ':': /* Pass through. */ + case '@': md_analyze_permissive_autolink(ctx, i); break; +@@ -4208,6 +4288,10 @@ md_analyze_link_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, + md_analyze_marks(ctx, lines, n_lines, mark_beg, mark_end, _T("@:."), MD_ANALYZE_NOSKIP_EMPH); + } + ++ /* Let the existing autolink owner claim URL ranges before backslash-delimited ++ * math. NOSKIP_EMPH still permits math nested inside resolved emphasis. */ ++ md_analyze_marks(ctx, lines, n_lines, mark_beg, mark_end, _T("\\"), MD_ANALYZE_NOSKIP_EMPH); ++ + for(i = 0; i < (int) SIZEOF_ARRAY(ctx->opener_stacks); i++) + ctx->opener_stacks[i].top = -1; + } +@@ -4297,11 +4381,24 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines) + /* If reached the mark, process it and move to next one. */ + if(off >= mark->beg) { + switch(mark->ch) { +- case '\\': /* Backslash escape. */ +- if(ISNEWLINE(mark->beg+1)) ++ case '\\': /* Backslash escape or backslash-delimited TeX math. */ ++ if((mark->flags & MD_MARK_OPENER) != 0) { ++ MD_ENTER_SPAN((mark->flags & MD_MARK_BACKSLASH_TEX_DISPLAY) != 0 ++ ? MD_SPAN_LATEXMATH_DISPLAY ++ : MD_SPAN_LATEXMATH, ++ NULL); ++ text_type = MD_TEXT_LATEXMATH; ++ } else if((mark->flags & MD_MARK_CLOSER) != 0) { ++ MD_LEAVE_SPAN((mark->flags & MD_MARK_BACKSLASH_TEX_DISPLAY) != 0 ++ ? MD_SPAN_LATEXMATH_DISPLAY ++ : MD_SPAN_LATEXMATH, ++ NULL); ++ text_type = MD_TEXT_NORMAL; ++ } else if(ISNEWLINE(mark->beg+1)) { + enforce_hardbreak = 1; +- else ++ } else { + MD_TEXT(text_type, STR(mark->beg+1), 1); ++ } + break; + + case ' ': /* Non-trivial space. */ +@@ -4511,8 +4608,8 @@ md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines) + + if(text_type == MD_TEXT_CODE || text_type == MD_TEXT_LATEXMATH) { + MD_ASSERT(prev_mark != NULL); +- MD_ASSERT(ISANYOF2_(prev_mark->ch, '`', '$') && (prev_mark->flags & MD_MARK_OPENER)); +- MD_ASSERT(ISANYOF2_(mark->ch, '`', '$') && (mark->flags & MD_MARK_CLOSER)); ++ MD_ASSERT(ISANYOF3_(prev_mark->ch, '`', '$', '\\') && (prev_mark->flags & MD_MARK_OPENER)); ++ MD_ASSERT(ISANYOF3_(mark->ch, '`', '$', '\\') && (mark->flags & MD_MARK_CLOSER)); + + /* Inside a code span, trailing line whitespace has to be + * outputted. */ +diff --git a/node_modules/react-native-enriched-markdown/cpp/md4c/md4c.h b/node_modules/react-native-enriched-markdown/cpp/md4c/md4c.h +index 00f8cc7..f949146 100644 +--- a/node_modules/react-native-enriched-markdown/cpp/md4c/md4c.h ++++ b/node_modules/react-native-enriched-markdown/cpp/md4c/md4c.h +@@ -321,6 +321,7 @@ typedef struct MD_SPAN_WIKILINK { + #define MD_FLAG_UNDERLINE 0x4000 /* Enable underline extension (and disables '_' for normal emphasis). */ + #define MD_FLAG_HARD_SOFT_BREAKS 0x8000 /* Force all soft breaks to act as hard breaks. */ + #define MD_FLAG_SPOILER 0x10000 /* Enable ||hidden text|| spoiler spans. */ ++#define MD_FLAG_BACKSLASHTEXMATHSPANS 0x20000 /* Enable backslash-delimited \(...\) and standalone \[...\] equations. */ + + #define MD_FLAG_PERMISSIVEAUTOLINKS \ + (MD_FLAG_PERMISSIVEEMAILAUTOLINKS | MD_FLAG_PERMISSIVEURLAUTOLINKS | MD_FLAG_PERMISSIVEWWWAUTOLINKS) +diff --git a/node_modules/react-native-enriched-markdown/cpp/parser/MD4CParser.cpp b/node_modules/react-native-enriched-markdown/cpp/parser/MD4CParser.cpp +index bbc0b0e..91f6a9c 100644 +--- a/node_modules/react-native-enriched-markdown/cpp/parser/MD4CParser.cpp ++++ b/node_modules/react-native-enriched-markdown/cpp/parser/MD4CParser.cpp +@@ -474,6 +474,9 @@ std::shared_ptr MD4CParser::parse(const std::string &markdown, + if (md4cFlags.latexMath) { + flags |= MD_FLAG_LATEXMATHSPANS; + } ++ if (md4cFlags.texMathBackslashDelimiters) { ++ flags |= MD_FLAG_BACKSLASHTEXMATHSPANS; ++ } + if (md4cFlags.underline) { + flags |= MD_FLAG_UNDERLINE; + } +diff --git a/node_modules/react-native-enriched-markdown/cpp/parser/MD4CParser.hpp b/node_modules/react-native-enriched-markdown/cpp/parser/MD4CParser.hpp +index 6d5eb2f..d3ae3c6 100644 +--- a/node_modules/react-native-enriched-markdown/cpp/parser/MD4CParser.hpp ++++ b/node_modules/react-native-enriched-markdown/cpp/parser/MD4CParser.hpp +@@ -9,6 +9,7 @@ namespace Markdown { + struct Md4cFlags { + bool underline = false; + bool latexMath = true; ++ bool texMathBackslashDelimiters = false; + bool permissiveAutolinks = true; + }; + +@@ -26,4 +27,3 @@ private: + }; + + } // namespace Markdown +- diff --git a/node_modules/react-native-enriched-markdown/cpp/wasm/build.sh b/node_modules/react-native-enriched-markdown/cpp/wasm/build.sh index e60ff0d..0a14c68 100755 --- a/node_modules/react-native-enriched-markdown/cpp/wasm/build.sh @@ -189,6 +527,202 @@ index e60ff0d..0a14c68 100755 rm "$OUT_DIR/md4c.o" echo "Done → $OUT_DIR/md4c.js" +diff --git a/node_modules/react-native-enriched-markdown/cpp/wasm/md4c_wasm.cpp b/node_modules/react-native-enriched-markdown/cpp/wasm/md4c_wasm.cpp +index 7c40b40..3084d0c 100644 +--- a/node_modules/react-native-enriched-markdown/cpp/wasm/md4c_wasm.cpp ++++ b/node_modules/react-native-enriched-markdown/cpp/wasm/md4c_wasm.cpp +@@ -15,9 +15,10 @@ extern "C" { + * @param markdown Null-terminated UTF-8 markdown input. + * @param underline 1 → enable __ underline extension; 0 → __ means emphasis. + * @param latexMath 1 → enable $…$ / $$…$$ LaTeX math spans; 0 → disable. ++ * @param texMathBackslashDelimiters 1 → enable \(…\) / standalone \[…\] math spans; 0 → disable. + * @return Null-terminated UTF-8 JSON string, valid until the next call. + */ +-const char *parseMarkdown(const char *markdown, int underline, int latexMath) { ++const char *parseMarkdown(const char *markdown, int underline, int latexMath, int texMathBackslashDelimiters) { + if (!markdown) { + g_resultBuffer = "{\"type\":\"Document\"}"; + return g_resultBuffer.c_str(); +@@ -26,6 +27,7 @@ const char *parseMarkdown(const char *markdown, int underline, int latexMath) { + Markdown::Md4cFlags flags; + flags.underline = (underline != 0); + flags.latexMath = (latexMath != 0); ++ flags.texMathBackslashDelimiters = (texMathBackslashDelimiters != 0); + + Markdown::MD4CParser parser; + auto root = parser.parse(std::string(markdown), flags); +diff --git a/node_modules/react-native-enriched-markdown/ios/EnrichedMarkdown.mm b/node_modules/react-native-enriched-markdown/ios/EnrichedMarkdown.mm +index 9227b78..5b19c1b 100644 +--- a/node_modules/react-native-enriched-markdown/ios/EnrichedMarkdown.mm ++++ b/node_modules/react-native-enriched-markdown/ios/EnrichedMarkdown.mm +@@ -637,6 +637,10 @@ - (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const & + _md4cFlags.latexMath = newViewProps.md4cFlags.latexMath; + md4cFlagsChanged = YES; + } ++ if (newViewProps.md4cFlags.texMathBackslashDelimiters != oldViewProps.md4cFlags.texMathBackslashDelimiters) { ++ _md4cFlags.texMathBackslashDelimiters = newViewProps.md4cFlags.texMathBackslashDelimiters; ++ md4cFlagsChanged = YES; ++ } + BOOL markdownChanged = oldViewProps.markdown != newViewProps.markdown; + BOOL allowTrailingMarginChanged = newViewProps.allowTrailingMargin != oldViewProps.allowTrailingMargin; + +diff --git a/node_modules/react-native-enriched-markdown/ios/EnrichedMarkdownText.mm b/node_modules/react-native-enriched-markdown/ios/EnrichedMarkdownText.mm +index 239e435..d74e7a3 100644 +--- a/node_modules/react-native-enriched-markdown/ios/EnrichedMarkdownText.mm ++++ b/node_modules/react-native-enriched-markdown/ios/EnrichedMarkdownText.mm +@@ -444,6 +444,10 @@ - (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const & + _md4cFlags.latexMath = newViewProps.md4cFlags.latexMath; + md4cFlagsChanged = YES; + } ++ if (newViewProps.md4cFlags.texMathBackslashDelimiters != oldViewProps.md4cFlags.texMathBackslashDelimiters) { ++ _md4cFlags.texMathBackslashDelimiters = newViewProps.md4cFlags.texMathBackslashDelimiters; ++ md4cFlagsChanged = YES; ++ } + BOOL markdownChanged = oldViewProps.markdown != newViewProps.markdown; + BOOL allowTrailingMarginChanged = newViewProps.allowTrailingMargin != oldViewProps.allowTrailingMargin; + +diff --git a/node_modules/react-native-enriched-markdown/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/Props.h b/node_modules/react-native-enriched-markdown/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/Props.h +index c9e1984..4f75d3a 100644 +--- a/node_modules/react-native-enriched-markdown/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/Props.h ++++ b/node_modules/react-native-enriched-markdown/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/Props.h +@@ -1857,6 +1857,7 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownMarkdownStyleStruct + struct EnrichedMarkdownMd4cFlagsStruct { + bool underline{false}; + bool latexMath{false}; ++ bool texMathBackslashDelimiters{false}; + + + #ifdef RN_SERIALIZABLE_STATE +@@ -1866,6 +1867,7 @@ struct EnrichedMarkdownMd4cFlagsStruct { + folly::dynamic result = folly::dynamic::object(); + result["underline"] = underline; + result["latexMath"] = latexMath; ++ result["texMathBackslashDelimiters"] = texMathBackslashDelimiters; + return result; + } + #endif +@@ -1882,6 +1884,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu + if (tmp_latexMath != map.end()) { + fromRawValue(context, tmp_latexMath->second, result.latexMath); + } ++ auto tmp_texMathBackslashDelimiters = map.find("texMathBackslashDelimiters"); ++ if (tmp_texMathBackslashDelimiters != map.end()) { ++ fromRawValue(context, tmp_texMathBackslashDelimiters->second, result.texMathBackslashDelimiters); ++ } + } + + static inline std::string toString(const EnrichedMarkdownMd4cFlagsStruct &value) { +@@ -4153,6 +4159,7 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownTextMarkdownStyleSt + struct EnrichedMarkdownTextMd4cFlagsStruct { + bool underline{false}; + bool latexMath{false}; ++ bool texMathBackslashDelimiters{false}; + + + #ifdef RN_SERIALIZABLE_STATE +@@ -4162,6 +4169,7 @@ struct EnrichedMarkdownTextMd4cFlagsStruct { + folly::dynamic result = folly::dynamic::object(); + result["underline"] = underline; + result["latexMath"] = latexMath; ++ result["texMathBackslashDelimiters"] = texMathBackslashDelimiters; + return result; + } + #endif +@@ -4178,6 +4186,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu + if (tmp_latexMath != map.end()) { + fromRawValue(context, tmp_latexMath->second, result.latexMath); + } ++ auto tmp_texMathBackslashDelimiters = map.find("texMathBackslashDelimiters"); ++ if (tmp_texMathBackslashDelimiters != map.end()) { ++ fromRawValue(context, tmp_texMathBackslashDelimiters->second, result.texMathBackslashDelimiters); ++ } + } + + static inline std::string toString(const EnrichedMarkdownTextMd4cFlagsStruct &value) { +diff --git a/node_modules/react-native-enriched-markdown/ios/internals/MeasurementCache.h b/node_modules/react-native-enriched-markdown/ios/internals/MeasurementCache.h +index e669d6c..46bde8c 100644 +--- a/node_modules/react-native-enriched-markdown/ios/internals/MeasurementCache.h ++++ b/node_modules/react-native-enriched-markdown/ios/internals/MeasurementCache.h +@@ -37,6 +37,7 @@ struct MeasurementCacheKey { + double maxFontSizeMultiplier; + bool md4cFlagsUnderline; + bool md4cFlagsLatexMath; ++ bool md4cFlagsTexMathBackslashDelimiters; + size_t styleFingerprint; + CGFloat fontScale; + MarkdownFlavor flavor; +@@ -44,9 +45,10 @@ struct MeasurementCacheKey { + bool operator==(const MeasurementCacheKey &other) const + { + return std::tie(markdown, maxWidth, allowTrailingMargin, allowFontScaling, maxFontSizeMultiplier, +- md4cFlagsUnderline, md4cFlagsLatexMath, styleFingerprint, fontScale, flavor) == ++ md4cFlagsUnderline, md4cFlagsLatexMath, md4cFlagsTexMathBackslashDelimiters, styleFingerprint, fontScale, flavor) == + std::tie(other.markdown, other.maxWidth, other.allowTrailingMargin, other.allowFontScaling, + other.maxFontSizeMultiplier, other.md4cFlagsUnderline, other.md4cFlagsLatexMath, ++ other.md4cFlagsTexMathBackslashDelimiters, + other.styleFingerprint, other.fontScale, other.flavor); + } + }; +@@ -62,6 +64,7 @@ struct MeasurementCacheKeyHash { + HashUtils::hash_one(h, key.maxFontSizeMultiplier); + HashUtils::hash_one(h, key.md4cFlagsUnderline); + HashUtils::hash_one(h, key.md4cFlagsLatexMath); ++ HashUtils::hash_one(h, key.md4cFlagsTexMathBackslashDelimiters); + HashUtils::hash_one(h, key.styleFingerprint); + HashUtils::hash_one(h, key.fontScale); + HashUtils::hash_one(h, static_cast(key.flavor)); +@@ -139,6 +142,7 @@ inline MeasurementCacheKey buildMeasurementCacheKey(const PropsType &props, CGFl + .maxFontSizeMultiplier = props.maxFontSizeMultiplier, + .md4cFlagsUnderline = props.md4cFlags.underline, + .md4cFlagsLatexMath = props.md4cFlags.latexMath, ++ .md4cFlagsTexMathBackslashDelimiters = props.md4cFlags.texMathBackslashDelimiters, + .styleFingerprint = computeStyleFingerprint(props.markdownStyle), + .fontScale = fontScale, + .flavor = flavor, +diff --git a/node_modules/react-native-enriched-markdown/ios/parser/ENRMMarkdownParser.h b/node_modules/react-native-enriched-markdown/ios/parser/ENRMMarkdownParser.h +index 8844fe3..01b85df 100644 +--- a/node_modules/react-native-enriched-markdown/ios/parser/ENRMMarkdownParser.h ++++ b/node_modules/react-native-enriched-markdown/ios/parser/ENRMMarkdownParser.h +@@ -5,6 +5,7 @@ + + @property (nonatomic, assign) BOOL underline; + @property (nonatomic, assign) BOOL latexMath; ++@property (nonatomic, assign) BOOL texMathBackslashDelimiters; + + + (instancetype)defaultFlags; + +diff --git a/node_modules/react-native-enriched-markdown/ios/parser/ENRMMarkdownParser.mm b/node_modules/react-native-enriched-markdown/ios/parser/ENRMMarkdownParser.mm +index 558f29f..4b1d822 100644 +--- a/node_modules/react-native-enriched-markdown/ios/parser/ENRMMarkdownParser.mm ++++ b/node_modules/react-native-enriched-markdown/ios/parser/ENRMMarkdownParser.mm +@@ -10,6 +10,7 @@ - (instancetype)init + if (self = [super init]) { + _underline = NO; + _latexMath = YES; ++ _texMathBackslashDelimiters = NO; + } + return self; + } +@@ -24,6 +25,7 @@ - (id)copyWithZone:(NSZone *)zone + ENRMMd4cFlags *copy = [[ENRMMd4cFlags allocWithZone:zone] init]; + copy.underline = self.underline; + copy.latexMath = self.latexMath; ++ copy.texMathBackslashDelimiters = self.texMathBackslashDelimiters; + return copy; + } + +diff --git a/node_modules/react-native-enriched-markdown/ios/parser/MarkdownParserBridge.mm b/node_modules/react-native-enriched-markdown/ios/parser/MarkdownParserBridge.mm +index 0a3a40c..b32a4c4 100644 +--- a/node_modules/react-native-enriched-markdown/ios/parser/MarkdownParserBridge.mm ++++ b/node_modules/react-native-enriched-markdown/ios/parser/MarkdownParserBridge.mm +@@ -140,6 +140,7 @@ + Markdown::Md4cFlags cppFlags; + cppFlags.underline = flags.underline; + cppFlags.latexMath = flags.latexMath; ++ cppFlags.texMathBackslashDelimiters = flags.texMathBackslashDelimiters; + + Markdown::MD4CParser parser; + auto cppAST = parser.parse(cppMarkdown, cppFlags); diff --git a/node_modules/react-native-enriched-markdown/ios/utils/ENRMTailFadeInAnimator.m b/node_modules/react-native-enriched-markdown/ios/utils/ENRMTailFadeInAnimator.m index e3630fb..4175787 100644 --- a/node_modules/react-native-enriched-markdown/ios/utils/ENRMTailFadeInAnimator.m @@ -393,6 +927,30 @@ index e3630fb..4175787 100644 } - (void)cleanupEntries +diff --git a/node_modules/react-native-enriched-markdown/lib/module/EnrichedMarkdownNativeComponent.ts b/node_modules/react-native-enriched-markdown/lib/module/EnrichedMarkdownNativeComponent.ts +index 06024b4..9353921 100644 +--- a/node_modules/react-native-enriched-markdown/lib/module/EnrichedMarkdownNativeComponent.ts ++++ b/node_modules/react-native-enriched-markdown/lib/module/EnrichedMarkdownNativeComponent.ts +@@ -224,6 +224,7 @@ export interface Md4cFlagsInternal { + * @default true + */ + latexMath: boolean; ++ texMathBackslashDelimiters: boolean; + } + + export interface NativeProps extends ViewProps { +diff --git a/node_modules/react-native-enriched-markdown/lib/module/EnrichedMarkdownTextNativeComponent.ts b/node_modules/react-native-enriched-markdown/lib/module/EnrichedMarkdownTextNativeComponent.ts +index e238ecf..e3639f6 100644 +--- a/node_modules/react-native-enriched-markdown/lib/module/EnrichedMarkdownTextNativeComponent.ts ++++ b/node_modules/react-native-enriched-markdown/lib/module/EnrichedMarkdownTextNativeComponent.ts +@@ -224,6 +224,7 @@ export interface Md4cFlagsInternal { + * @default true + */ + latexMath: boolean; ++ texMathBackslashDelimiters: boolean; + } + + export interface NativeProps extends ViewProps { diff --git a/node_modules/react-native-enriched-markdown/lib/module/index.web.js b/node_modules/react-native-enriched-markdown/lib/module/index.web.js index d8308e6..98e32e6 100644 --- a/node_modules/react-native-enriched-markdown/lib/module/index.web.js @@ -404,8 +962,32 @@ index d8308e6..98e32e6 100644 +export { preloadMarkdownRuntime } from "./web/parseMarkdown.js"; //# sourceMappingURL=index.web.js.map \ No newline at end of file +diff --git a/node_modules/react-native-enriched-markdown/lib/module/native/EnrichedMarkdownText.js b/node_modules/react-native-enriched-markdown/lib/module/native/EnrichedMarkdownText.js +index 490b567..d25e727 100644 +--- a/node_modules/react-native-enriched-markdown/lib/module/native/EnrichedMarkdownText.js ++++ b/node_modules/react-native-enriched-markdown/lib/module/native/EnrichedMarkdownText.js +@@ -7,7 +7,8 @@ import { normalizeMarkdownStyle } from '../normalizeMarkdownStyle'; + import { jsx as _jsx } from "react/jsx-runtime"; + const defaultMd4cFlags = { + underline: false, +- latexMath: true ++ latexMath: true, ++ texMathBackslashDelimiters: false + }; + export const EnrichedMarkdownText = ({ + markdown, +@@ -38,7 +39,8 @@ export const EnrichedMarkdownText = ({ + const normalizedStyle = normalizedStyleRef.current; + const normalizedMd4cFlags = useMemo(() => ({ + underline: md4cFlags.underline ?? false, +- latexMath: md4cFlags.latexMath ?? true ++ latexMath: md4cFlags.latexMath ?? true, ++ texMathBackslashDelimiters: md4cFlags.texMathBackslashDelimiters ?? false + }), [md4cFlags]); + const contextMenuCallbacksRef = useRef(new Map()); + useEffect(() => { diff --git a/node_modules/react-native-enriched-markdown/lib/module/web/EnrichedMarkdownText.js b/node_modules/react-native-enriched-markdown/lib/module/web/EnrichedMarkdownText.js -index c6c73b0..397b78a 100644 +index c6c73b0..96c805e 100644 --- a/node_modules/react-native-enriched-markdown/lib/module/web/EnrichedMarkdownText.js +++ b/node_modules/react-native-enriched-markdown/lib/module/web/EnrichedMarkdownText.js @@ -1,13 +1,22 @@ @@ -434,7 +1016,7 @@ index c6c73b0..397b78a 100644 export const EnrichedMarkdownText = ({ markdown, markdownStyle = {}, -@@ -18,17 +27,26 @@ export const EnrichedMarkdownText = ({ +@@ -18,30 +27,40 @@ export const EnrichedMarkdownText = ({ allowTrailingMargin = false, containerStyle, selectable = true, @@ -449,23 +1031,29 @@ index c6c73b0..397b78a 100644 - const [parseError, setParseError] = useState(false); const { underline = false, - latexMath = true +- latexMath = true ++ latexMath = true, ++ texMathBackslashDelimiters = false } = md4cFlags; + const syncAst = useMemo(() => { + const parsed = parseMarkdownSyncIfReady(markdown, { + underline, -+ latexMath ++ latexMath, ++ texMathBackslashDelimiters + }); + return parsed ? prepareAstForRendering(parsed) : null; -+ }, [markdown, underline, latexMath]); ++ }, [markdown, underline, latexMath, texMathBackslashDelimiters]); + const [ast, setAst] = useState(syncAst); + const [katex, setKatex] = useState(null); + const [parseError, setParseError] = useState(false); useEffect(() => { let cancelled = false; const katexPromise = latexMath ? loadKaTeX() : Promise.resolve(null); -@@ -37,11 +55,9 @@ export const EnrichedMarkdownText = ({ - latexMath + Promise.all([parseMarkdown(markdown, { + underline, +- latexMath ++ latexMath, ++ texMathBackslashDelimiters }), katexPromise]).then(([result, katexInstance]) => { if (!cancelled) { - indexTaskItems(result); @@ -477,10 +1065,12 @@ index c6c73b0..397b78a 100644 } }).catch(error => { if (!cancelled) { -@@ -57,14 +73,66 @@ export const EnrichedMarkdownText = ({ +@@ -56,15 +75,67 @@ export const EnrichedMarkdownText = ({ + return () => { cancelled = true; }; - }, [markdown, underline, latexMath]); +- }, [markdown, underline, latexMath]); ++ }, [markdown, underline, latexMath, texMathBackslashDelimiters]); + const renderedAst = syncAst ?? ast; const callbacks = useMemo(() => ({ onLinkPress, @@ -546,7 +1136,7 @@ index c6c73b0..397b78a 100644 const lastChildStyle = useMemo(() => allowTrailingMargin ? normalizedStyle : zeroTrailingMargins(normalizedStyle), [normalizedStyle, allowTrailingMargin]); const styles = useMemo(() => buildStyles(normalizedStyle), [normalizedStyle]); const lastChildStyles = useMemo(() => buildStyles(lastChildStyle), [lastChildStyle]); -@@ -81,14 +149,41 @@ export const EnrichedMarkdownText = ({ +@@ -81,14 +152,41 @@ export const EnrichedMarkdownText = ({ style: wrapperStyle, dir: dir, ...rest, @@ -593,10 +1183,10 @@ index c6c73b0..397b78a 100644 return /*#__PURE__*/_jsx("div", { style: wrapperStyle, diff --git a/node_modules/react-native-enriched-markdown/lib/module/web/parseMarkdown.js b/node_modules/react-native-enriched-markdown/lib/module/web/parseMarkdown.js -index 7604c13..011e0e6 100644 +index 7604c13..e8f6607 100644 --- a/node_modules/react-native-enriched-markdown/lib/module/web/parseMarkdown.js +++ b/node_modules/react-native-enriched-markdown/lib/module/web/parseMarkdown.js -@@ -1,32 +1,171 @@ +@@ -1,32 +1,169 @@ "use strict"; +import createMd4cModule from './wasm/md4c.js'; @@ -633,7 +1223,7 @@ index 7604c13..011e0e6 100644 + } + return factory(); + }).then(wasmModule => ({ -+ parse: wasmModule.cwrap('parseMarkdown', 'string', ['number', 'number', 'number']), ++ parse: wasmModule.cwrap('parseMarkdown', 'string', ['number', 'number', 'number', 'number']), + wasmModule + })).then(runtime => { + parserRuntime = runtime; @@ -662,8 +1252,8 @@ index 7604c13..011e0e6 100644 +function shouldCacheParseResult(markdown) { + return markdown.length <= PARSE_CACHE_MAX_MARKDOWN_CHARS; +} -+function buildCacheKey(markdown, underline, latexMath) { -+ return shouldCacheParseResult(markdown) ? `${underline ? 1 : 0}\0${latexMath ? 1 : 0}\0${markdown}` : null; ++function buildCacheKey(markdown, underline, latexMath, texMathBackslashDelimiters) { ++ return shouldCacheParseResult(markdown) ? `${underline ? 1 : 0}\0${latexMath ? 1 : 0}\0${texMathBackslashDelimiters ? 1 : 0}\0${markdown}` : null; +} +function rememberParsedResult(cacheKey, ast) { + if (!cacheKey) return; @@ -683,7 +1273,7 @@ index 7604c13..011e0e6 100644 + parseResultCache.set(cacheKey, cached); + return cloneAst(cached); +} -+function parseMarkdownWithHeapInput(runtime, markdown, underline, latexMath) { ++function parseMarkdownWithHeapInput(runtime, markdown, underline, latexMath, texMathBackslashDelimiters) { + const { + wasmModule + } = runtime; @@ -694,20 +1284,18 @@ index 7604c13..011e0e6 100644 + } + try { + wasmModule.stringToUTF8(markdown, inputPointer, inputBytes); -+ return runtime.parse(inputPointer, underline ? 1 : 0, latexMath ? 1 : 0); ++ return runtime.parse(inputPointer, underline ? 1 : 0, latexMath ? 1 : 0, texMathBackslashDelimiters ? 1 : 0); + } finally { + wasmModule._free(inputPointer); + } +} export async function parseMarkdown(markdown, { underline = false, - latexMath = true - } = {}) { -- const parse = await initializeParser(); -- const result = JSON.parse(parse(markdown, underline ? 1 : 0, latexMath ? 1 : 0)); -- if (!isASTNode(result)) { -- throw new Error('WASM parser returned invalid AST'); -+ const cacheKey = buildCacheKey(markdown, underline, latexMath); +- latexMath = true ++ latexMath = true, ++ texMathBackslashDelimiters = false ++} = {}) { ++ const cacheKey = buildCacheKey(markdown, underline, latexMath, texMathBackslashDelimiters); + const cachedResult = readCachedParsedResult(cacheKey); + if (cachedResult) return cachedResult; + if (cacheKey) { @@ -719,7 +1307,7 @@ index 7604c13..011e0e6 100644 + } + } + const parsed = initializeParser().then(runtime => { -+ const result = JSON.parse(parseMarkdownWithHeapInput(runtime, markdown, underline, latexMath)); ++ const result = JSON.parse(parseMarkdownWithHeapInput(runtime, markdown, underline, latexMath, texMathBackslashDelimiters)); + if (!isASTNode(result)) { + throw new Error('WASM parser returned invalid AST'); + } @@ -740,23 +1328,24 @@ index 7604c13..011e0e6 100644 + if (cacheKey) { + parseCache.delete(cacheKey); + } -+ parseCache.clear(); -+ parseResultCache.clear(); -+ parserPromise = null; -+ parserRuntime = null; + throw error; + } +} +export function parseMarkdownSyncIfReady(markdown, { + underline = false, -+ latexMath = true -+} = {}) { -+ const cacheKey = buildCacheKey(markdown, underline, latexMath); ++ latexMath = true, ++ texMathBackslashDelimiters = false + } = {}) { +- const parse = await initializeParser(); +- const result = JSON.parse(parse(markdown, underline ? 1 : 0, latexMath ? 1 : 0)); +- if (!isASTNode(result)) { +- throw new Error('WASM parser returned invalid AST'); ++ const cacheKey = buildCacheKey(markdown, underline, latexMath, texMathBackslashDelimiters); + const cachedResult = readCachedParsedResult(cacheKey); + if (cachedResult) return cachedResult; + if (!parserRuntime) return null; + try { -+ const result = JSON.parse(parseMarkdownWithHeapInput(parserRuntime, markdown, underline, latexMath)); ++ const result = JSON.parse(parseMarkdownWithHeapInput(parserRuntime, markdown, underline, latexMath, texMathBackslashDelimiters)); + if (!isASTNode(result)) { + throw new Error('WASM parser returned invalid AST'); + } @@ -775,7 +1364,6 @@ index 7604c13..011e0e6 100644 + return JSON.parse(JSON.stringify(ast)); } //# sourceMappingURL=parseMarkdown.js.map -\ No newline at end of file diff --git a/node_modules/react-native-enriched-markdown/lib/module/web/renderers/BlockRenderers.js b/node_modules/react-native-enriched-markdown/lib/module/web/renderers/BlockRenderers.js index 5bdaee9..ab8bc37 100644 --- a/node_modules/react-native-enriched-markdown/lib/module/web/renderers/BlockRenderers.js @@ -1136,6 +1724,30 @@ index 1c5a293..875211f 100644 h1: headingStyle(style, '1'), h2: headingStyle(style, '2'), h3: headingStyle(style, '3'), +diff --git a/node_modules/react-native-enriched-markdown/lib/typescript/src/EnrichedMarkdownNativeComponent.d.ts b/node_modules/react-native-enriched-markdown/lib/typescript/src/EnrichedMarkdownNativeComponent.d.ts +index 567cc1e..fa903a4 100644 +--- a/node_modules/react-native-enriched-markdown/lib/typescript/src/EnrichedMarkdownNativeComponent.d.ts ++++ b/node_modules/react-native-enriched-markdown/lib/typescript/src/EnrichedMarkdownNativeComponent.d.ts +@@ -189,6 +189,7 @@ export interface Md4cFlagsInternal { + * @default true + */ + latexMath: boolean; ++ texMathBackslashDelimiters: boolean; + } + export interface NativeProps extends ViewProps { + /** +diff --git a/node_modules/react-native-enriched-markdown/lib/typescript/src/EnrichedMarkdownTextNativeComponent.d.ts b/node_modules/react-native-enriched-markdown/lib/typescript/src/EnrichedMarkdownTextNativeComponent.d.ts +index 4254d5d..8a7ca5c 100644 +--- a/node_modules/react-native-enriched-markdown/lib/typescript/src/EnrichedMarkdownTextNativeComponent.d.ts ++++ b/node_modules/react-native-enriched-markdown/lib/typescript/src/EnrichedMarkdownTextNativeComponent.d.ts +@@ -189,6 +189,7 @@ export interface Md4cFlagsInternal { + * @default true + */ + latexMath: boolean; ++ texMathBackslashDelimiters: boolean; + } + export interface NativeProps extends ViewProps { + /** diff --git a/node_modules/react-native-enriched-markdown/lib/typescript/src/index.web.d.ts b/node_modules/react-native-enriched-markdown/lib/typescript/src/index.web.d.ts index 3513fc6..cc06a72 100644 --- a/node_modules/react-native-enriched-markdown/lib/typescript/src/index.web.d.ts @@ -1146,6 +1758,22 @@ index 3513fc6..cc06a72 100644 export type { EnrichedMarkdownTextProps } from './types/MarkdownTextProps.web'; export type { MarkdownStyle, Md4cFlags } from './types/MarkdownStyle'; export type { LinkPressEvent, LinkLongPressEvent, TaskListItemPressEvent, } from './types/events'; +diff --git a/node_modules/react-native-enriched-markdown/lib/typescript/src/types/MarkdownStyle.d.ts b/node_modules/react-native-enriched-markdown/lib/typescript/src/types/MarkdownStyle.d.ts +index b2c9fb9..68c249a 100644 +--- a/node_modules/react-native-enriched-markdown/lib/typescript/src/types/MarkdownStyle.d.ts ++++ b/node_modules/react-native-enriched-markdown/lib/typescript/src/types/MarkdownStyle.d.ts +@@ -208,6 +208,11 @@ export interface Md4cFlags { + * @default true + */ + latexMath?: boolean; ++ /** ++ * Enable backslash-delimited TeX math spans: \\(..\\) inline and standalone \\[..\\] display math. ++ * @default false ++ */ ++ texMathBackslashDelimiters?: boolean; + } + export {}; + //# sourceMappingURL=MarkdownStyle.d.ts.map diff --git a/node_modules/react-native-enriched-markdown/lib/typescript/src/types/MarkdownTextProps.web.d.ts b/node_modules/react-native-enriched-markdown/lib/typescript/src/types/MarkdownTextProps.web.d.ts index 609252d..3e6bc94 100644 --- a/node_modules/react-native-enriched-markdown/lib/typescript/src/types/MarkdownTextProps.web.d.ts @@ -1288,6 +1916,32 @@ index 5bf4501..980dfbe 100644 callbacks: RendererCallbacks; capabilities: RenderCapabilities; renderChildren: (node: ASTNode) => ReactNode; +diff --git a/node_modules/react-native-enriched-markdown/src/EnrichedMarkdownNativeComponent.ts b/node_modules/react-native-enriched-markdown/src/EnrichedMarkdownNativeComponent.ts +index 06024b4..bf9532a 100644 +--- a/node_modules/react-native-enriched-markdown/src/EnrichedMarkdownNativeComponent.ts ++++ b/node_modules/react-native-enriched-markdown/src/EnrichedMarkdownNativeComponent.ts +@@ -224,6 +224,8 @@ export interface Md4cFlagsInternal { + * @default true + */ + latexMath: boolean; ++ /** Enable backslash-delimited TeX math delimiters (\\(..\\) and standalone \\[..\\]). */ ++ texMathBackslashDelimiters: boolean; + } + + export interface NativeProps extends ViewProps { +diff --git a/node_modules/react-native-enriched-markdown/src/EnrichedMarkdownTextNativeComponent.ts b/node_modules/react-native-enriched-markdown/src/EnrichedMarkdownTextNativeComponent.ts +index e238ecf..e4a6367 100644 +--- a/node_modules/react-native-enriched-markdown/src/EnrichedMarkdownTextNativeComponent.ts ++++ b/node_modules/react-native-enriched-markdown/src/EnrichedMarkdownTextNativeComponent.ts +@@ -224,6 +224,8 @@ export interface Md4cFlagsInternal { + * @default true + */ + latexMath: boolean; ++ /** Enable backslash-delimited TeX math delimiters (\\(..\\) and standalone \\[..\\]). */ ++ texMathBackslashDelimiters: boolean; + } + + export interface NativeProps extends ViewProps { diff --git a/node_modules/react-native-enriched-markdown/src/index.web.tsx b/node_modules/react-native-enriched-markdown/src/index.web.tsx index 4b4305c..c6aa6a4 100644 --- a/node_modules/react-native-enriched-markdown/src/index.web.tsx @@ -1298,6 +1952,42 @@ index 4b4305c..c6aa6a4 100644 export type { EnrichedMarkdownTextProps } from './types/MarkdownTextProps.web'; export type { MarkdownStyle, Md4cFlags } from './types/MarkdownStyle'; export type { +diff --git a/node_modules/react-native-enriched-markdown/src/native/EnrichedMarkdownText.tsx b/node_modules/react-native-enriched-markdown/src/native/EnrichedMarkdownText.tsx +index 236c2b7..1e893f5 100644 +--- a/node_modules/react-native-enriched-markdown/src/native/EnrichedMarkdownText.tsx ++++ b/node_modules/react-native-enriched-markdown/src/native/EnrichedMarkdownText.tsx +@@ -23,6 +23,7 @@ export type { LinkPressEvent, LinkLongPressEvent, TaskListItemPressEvent }; + const defaultMd4cFlags: Md4cFlags = { + underline: false, + latexMath: true, ++ texMathBackslashDelimiters: false, + }; + + export const EnrichedMarkdownText = ({ +@@ -57,6 +58,7 @@ export const EnrichedMarkdownText = ({ + () => ({ + underline: md4cFlags.underline ?? false, + latexMath: md4cFlags.latexMath ?? true, ++ texMathBackslashDelimiters: md4cFlags.texMathBackslashDelimiters ?? false, + }), + [md4cFlags] + ); +diff --git a/node_modules/react-native-enriched-markdown/src/types/MarkdownStyle.ts b/node_modules/react-native-enriched-markdown/src/types/MarkdownStyle.ts +index c05a97a..f70b8af 100644 +--- a/node_modules/react-native-enriched-markdown/src/types/MarkdownStyle.ts ++++ b/node_modules/react-native-enriched-markdown/src/types/MarkdownStyle.ts +@@ -232,4 +232,11 @@ export interface Md4cFlags { + * @default true + */ + latexMath?: boolean; ++ /** ++ * Enable backslash-delimited TeX delimiters (\\(..\\) and standalone \\[..\\]). ++ * This is separate from latexMath because CommonMark also uses backslashes ++ * to escape literal parentheses and brackets. ++ * @default false ++ */ ++ texMathBackslashDelimiters?: boolean; + } diff --git a/node_modules/react-native-enriched-markdown/src/types/MarkdownTextProps.web.ts b/node_modules/react-native-enriched-markdown/src/types/MarkdownTextProps.web.ts index fa9d401..90d9e21 100644 --- a/node_modules/react-native-enriched-markdown/src/types/MarkdownTextProps.web.ts @@ -1327,7 +2017,7 @@ index fa9d401..90d9e21 100644 * When false (default), removes trailing margin from the last element to * eliminate bottom spacing. diff --git a/node_modules/react-native-enriched-markdown/src/web/EnrichedMarkdownText.tsx b/node_modules/react-native-enriched-markdown/src/web/EnrichedMarkdownText.tsx -index 70eb3a4..7bcdecb 100644 +index 70eb3a4..2440c90 100644 --- a/node_modules/react-native-enriched-markdown/src/web/EnrichedMarkdownText.tsx +++ b/node_modules/react-native-enriched-markdown/src/web/EnrichedMarkdownText.tsx @@ -1,17 +1,40 @@ @@ -1383,17 +2073,17 @@ index 70eb3a4..7bcdecb 100644 dir, ...rest }: EnrichedMarkdownTextProps) => { -@@ -30,13 +55,16 @@ export const EnrichedMarkdownText = ({ +@@ -30,30 +55,30 @@ export const EnrichedMarkdownText = ({ () => normalizeMarkdownStyle(markdownStyle), [markdownStyle] ); -+ const { underline = false, latexMath = true } = md4cFlags; ++ const { underline = false, latexMath = true, texMathBackslashDelimiters = false } = md4cFlags; - const [ast, setAst] = useState(null); + const syncAst = useMemo(() => { -+ const parsed = parseMarkdownSyncIfReady(markdown, { underline, latexMath }); ++ const parsed = parseMarkdownSyncIfReady(markdown, { underline, latexMath, texMathBackslashDelimiters }); + return parsed ? prepareAstForRendering(parsed) : null; -+ }, [markdown, underline, latexMath]); ++ }, [markdown, underline, latexMath, texMathBackslashDelimiters]); + const [ast, setAst] = useState(syncAst); const [katex, setKatex] = useState(null); const [parseError, setParseError] = useState(false); @@ -1403,7 +2093,12 @@ index 70eb3a4..7bcdecb 100644 useEffect(() => { let cancelled = false; -@@ -48,12 +76,9 @@ export const EnrichedMarkdownText = ({ + const katexPromise = latexMath ? loadKaTeX() : Promise.resolve(null); + + Promise.all([ +- parseMarkdown(markdown, { underline, latexMath }), ++ parseMarkdown(markdown, { underline, latexMath, texMathBackslashDelimiters }), + katexPromise, ]) .then(([result, katexInstance]) => { if (!cancelled) { @@ -1417,12 +2112,15 @@ index 70eb3a4..7bcdecb 100644 } }) .catch((error) => { -@@ -73,12 +98,91 @@ export const EnrichedMarkdownText = ({ +@@ -71,14 +96,93 @@ export const EnrichedMarkdownText = ({ + return () => { + cancelled = true; }; - }, [markdown, underline, latexMath]); - -+ const renderedAst = syncAst ?? ast; +- }, [markdown, underline, latexMath]); ++ }, [markdown, underline, latexMath, texMathBackslashDelimiters]); + ++ const renderedAst = syncAst ?? ast; + const callbacks = useMemo( () => ({ onLinkPress, onLinkLongPress, onTaskListItemPress }), [onLinkPress, onLinkLongPress, onTaskListItemPress] @@ -1554,10 +2252,10 @@ index 70eb3a4..7bcdecb 100644 return ( diff --git a/node_modules/react-native-enriched-markdown/src/web/parseMarkdown.ts b/node_modules/react-native-enriched-markdown/src/web/parseMarkdown.ts -index 911e3f1..d10ff3a 100644 +index 911e3f1..1dff70c 100644 --- a/node_modules/react-native-enriched-markdown/src/web/parseMarkdown.ts +++ b/node_modules/react-native-enriched-markdown/src/web/parseMarkdown.ts -@@ -1,37 +1,102 @@ +@@ -1,37 +1,104 @@ import type { ASTNode } from './types'; import type { Md4cFlags } from '../types/MarkdownStyle'; +import createMd4cModule from './wasm/md4c.js'; @@ -1566,7 +2264,9 @@ index 911e3f1..d10ff3a 100644 - markdown: string, + markdownPointer: number, underline: number, - latexMath: number +- latexMath: number ++ latexMath: number, ++ texMathBackslashDelimiters: number ) => string; +type Md4cModule = { + cwrap(name: string, returnType: string, argTypes: string[]): ParseFn; @@ -1636,6 +2336,7 @@ index 911e3f1..d10ff3a 100644 - ]) - ) + 'number', ++ 'number', + ]), + wasmModule, + })) @@ -1672,7 +2373,7 @@ index 911e3f1..d10ff3a 100644 function isASTNode(value: unknown): value is ASTNode { return ( typeof value === 'object' && -@@ -41,19 +106,145 @@ function isASTNode(value: unknown): value is ASTNode { +@@ -41,19 +108,148 @@ function isASTNode(value: unknown): value is ASTNode { ); } @@ -1683,10 +2384,11 @@ index 911e3f1..d10ff3a 100644 +function buildCacheKey( + markdown: string, + underline: boolean, -+ latexMath: boolean ++ latexMath: boolean, ++ texMathBackslashDelimiters: boolean +): string | null { + return shouldCacheParseResult(markdown) -+ ? `${underline ? 1 : 0}\u0000${latexMath ? 1 : 0}\u0000${markdown}` ++ ? `${underline ? 1 : 0}\u0000${latexMath ? 1 : 0}\u0000${texMathBackslashDelimiters ? 1 : 0}\u0000${markdown}` + : null; +} + @@ -1716,7 +2418,8 @@ index 911e3f1..d10ff3a 100644 + runtime: ParserRuntime, + markdown: string, + underline: boolean, -+ latexMath: boolean ++ latexMath: boolean, ++ texMathBackslashDelimiters: boolean +): string { + const { wasmModule } = runtime; + const inputBytes = wasmModule.lengthBytesUTF8(markdown) + 1; @@ -1727,7 +2430,12 @@ index 911e3f1..d10ff3a 100644 + + try { + wasmModule.stringToUTF8(markdown, inputPointer, inputBytes); -+ return runtime.parse(inputPointer, underline ? 1 : 0, latexMath ? 1 : 0); ++ return runtime.parse( ++ inputPointer, ++ underline ? 1 : 0, ++ latexMath ? 1 : 0, ++ texMathBackslashDelimiters ? 1 : 0 ++ ); + } finally { + wasmModule._free(inputPointer); + } @@ -1735,10 +2443,11 @@ index 911e3f1..d10ff3a 100644 + export async function parseMarkdown( markdown: string, - { underline = false, latexMath = true }: Md4cFlags = {} +- { underline = false, latexMath = true }: Md4cFlags = {} ++ { underline = false, latexMath = true, texMathBackslashDelimiters = false }: Md4cFlags = {} ): Promise { - const parse = await initializeParser(); -+ const cacheKey = buildCacheKey(markdown, underline, latexMath); ++ const cacheKey = buildCacheKey(markdown, underline, latexMath, texMathBackslashDelimiters); + const cachedResult = readCachedParsedResult(cacheKey); + if (cachedResult) return cachedResult; @@ -1756,15 +2465,15 @@ index 911e3f1..d10ff3a 100644 + + const parsed = initializeParser().then((runtime) => { + const result: unknown = JSON.parse( -+ parseMarkdownWithHeapInput(runtime, markdown, underline, latexMath) ++ parseMarkdownWithHeapInput(runtime, markdown, underline, latexMath, texMathBackslashDelimiters) + ); -+ -+ if (!isASTNode(result)) { -+ throw new Error('WASM parser returned invalid AST'); -+ } - if (!isASTNode(result)) { - throw new Error('WASM parser returned invalid AST'); ++ if (!isASTNode(result)) { ++ throw new Error('WASM parser returned invalid AST'); ++ } ++ + rememberParsedResult(cacheKey, result); + return result; + }); @@ -1784,26 +2493,22 @@ index 911e3f1..d10ff3a 100644 + if (cacheKey) { + parseCache.delete(cacheKey); + } -+ parseCache.clear(); -+ parseResultCache.clear(); -+ parserPromise = null; -+ parserRuntime = null; + throw error; + } +} + +export function parseMarkdownSyncIfReady( + markdown: string, -+ { underline = false, latexMath = true }: Md4cFlags = {} ++ { underline = false, latexMath = true, texMathBackslashDelimiters = false }: Md4cFlags = {} +): ASTNode | null { -+ const cacheKey = buildCacheKey(markdown, underline, latexMath); ++ const cacheKey = buildCacheKey(markdown, underline, latexMath, texMathBackslashDelimiters); + const cachedResult = readCachedParsedResult(cacheKey); + if (cachedResult) return cachedResult; + if (!parserRuntime) return null; + + try { + const result: unknown = JSON.parse( -+ parseMarkdownWithHeapInput(parserRuntime, markdown, underline, latexMath) ++ parseMarkdownWithHeapInput(parserRuntime, markdown, underline, latexMath, texMathBackslashDelimiters) + ); + + if (!isASTNode(result)) { diff --git a/apps/ui/sources/components/markdown/MarkdownBlockView.tsx b/apps/ui/sources/components/markdown/MarkdownBlockView.tsx index a205c9135b..6245809559 100644 --- a/apps/ui/sources/components/markdown/MarkdownBlockView.tsx +++ b/apps/ui/sources/components/markdown/MarkdownBlockView.tsx @@ -13,6 +13,8 @@ import { MarkdownCodeBlock } from './MarkdownCodeBlock'; import type { StreamingTextRevealPreset } from './streaming/streamingTextRevealConfig'; import { CopiedPill } from '@/components/ui/copy/CopiedPill'; import { useTemporaryCopyFeedback } from '@/components/ui/copy/useTemporaryCopyFeedback'; +import { EnrichedMarkdownTextAdapter } from './enriched/EnrichedMarkdownTextAdapter'; +import type { MarkdownRenderingProfile } from './rendering/MarkdownRenderingProfile'; // Option type for callback export type Option = { @@ -30,9 +32,11 @@ type MarkdownBlockViewProps = { onOptionLongPress?: OptionLongPressHandler; onLinkPress?: (url: string) => boolean | void; textStyle?: StyleProp; + profile: MarkdownRenderingProfile; variant: 'default' | 'thinking'; streamingReveal: boolean; streamingRevealPreset?: StreamingTextRevealPreset; + agentTexMath: boolean; }; function areMarkdownBlockViewPropsEqual(prev: MarkdownBlockViewProps, next: MarkdownBlockViewProps): boolean { @@ -44,9 +48,11 @@ function areMarkdownBlockViewPropsEqual(prev: MarkdownBlockViewProps, next: Mark && prev.onOptionLongPress === next.onOptionLongPress && prev.onLinkPress === next.onLinkPress && prev.textStyle === next.textStyle + && prev.profile === next.profile && prev.variant === next.variant && prev.streamingReveal === next.streamingReveal - && prev.streamingRevealPreset === next.streamingRevealPreset; + && prev.streamingRevealPreset === next.streamingRevealPreset + && prev.agentTexMath === next.agentTexMath; } export const MarkdownBlockView = React.memo((props: MarkdownBlockViewProps) => { @@ -71,7 +77,22 @@ export const MarkdownBlockView = React.memo((props: MarkdownBlockViewProps) => { } else if (block.type === 'options') { return ; } else if (block.type === 'table') { - return ; + return ( + + ); } return null; }, areMarkdownBlockViewPropsEqual); @@ -300,7 +321,12 @@ function RenderTableBlock(props: { first: boolean, last: boolean, selectable: boolean, + onLinkPress?: (url: string) => boolean | void, textStyle?: StyleProp, + profile: MarkdownRenderingProfile, + streamingReveal: boolean, + streamingRevealPreset?: StreamingTextRevealPreset, + agentTexMath: boolean, }) { const columnCount = props.headers.length; const rowCount = props.rows.length; @@ -326,7 +352,16 @@ function RenderTableBlock(props: { > {/* Header cell for this column */} - {header} + {/* Data cells for this column */} {props.rows.map((row, rowIndex) => ( @@ -338,7 +373,16 @@ function RenderTableBlock(props: { isLastRow(rowIndex) && style.tableCellLast ]} > - {row[colIndex] ?? ''} + ))} @@ -360,6 +404,42 @@ function RenderTableBlock(props: { ); } +function RenderTableCellContent(props: Readonly<{ + markdown: string; + selectable: boolean; + onLinkPress?: (url: string) => boolean | void; + textStyle?: StyleProp; + profile: MarkdownRenderingProfile; + streamingReveal: boolean; + streamingRevealPreset?: StreamingTextRevealPreset; + agentTexMath: boolean; +}>) { + if (!containsPotentialEnrichedMath(props.markdown, props.agentTexMath)) { + return {props.markdown}; + } + + return ( + + ); +} + +function containsPotentialEnrichedMath(markdown: string, agentTexMath: boolean): boolean { + return markdown.includes('$') + || (agentTexMath && (markdown.includes('\\(') || markdown.includes('\\['))); +} + function getTableCellAlignmentStyle(alignment: MarkdownTableAlignment) { if (alignment === 'center') return style.tableCellAlignCenter; if (alignment === 'right') return style.tableCellAlignRight; diff --git a/apps/ui/sources/components/markdown/MarkdownView.enrichedRenderer.test.tsx b/apps/ui/sources/components/markdown/MarkdownView.enrichedRenderer.test.tsx index 863df710d0..4ad597467a 100644 --- a/apps/ui/sources/components/markdown/MarkdownView.enrichedRenderer.test.tsx +++ b/apps/ui/sources/components/markdown/MarkdownView.enrichedRenderer.test.tsx @@ -51,7 +51,7 @@ describe('MarkdownView (enriched renderer)', () => { expect(enrichedRuns[0]!.props.markdown).toBe(markdown); expect(enrichedRuns[0]!.props.selectable).toBe(true); expect(enrichedRuns[0]!.props.flavor).toBe('commonmark'); - expect(enrichedRuns[0]!.props.md4cFlags).toEqual({ latexMath: true }); + expect(enrichedRuns[0]!.props.md4cFlags).toEqual({ latexMath: true, texMathBackslashDelimiters: false }); expect(enrichedRuns[0]!.props.testID).toBeUndefined(); expect(enrichedRuns[0]!.props['data-testid']).toBe('markdown-enriched-run'); // The raw fallback is only hidden while the enriched runtime is still loading; @@ -63,6 +63,19 @@ describe('MarkdownView (enriched renderer)', () => { expect(enrichedRuns[0]!.props.streamingAnimation).toBeUndefined(); }); + it('enables agent TeX parsing without rewriting the Markdown source', async () => { + const { MarkdownView } = await import('./MarkdownView'); + const markdown = 'Coordinates: [\\(x\\), \\(y\\)]'; + + const screen = await renderScreen( + , + ); + + const enrichedRun = screen.findByType('EnrichedMarkdownText'); + expect(enrichedRun.props.markdown).toBe(markdown); + expect(enrichedRun.props.md4cFlags).toEqual({ latexMath: true, texMathBackslashDelimiters: true }); + }); + it('keeps code fences as special blocks while grouping surrounding prose into enriched runs', async () => { const { MarkdownView } = await import('./MarkdownView'); diff --git a/apps/ui/sources/components/markdown/MarkdownView.tableScrollView.test.tsx b/apps/ui/sources/components/markdown/MarkdownView.tableScrollView.test.tsx index 31102b48a4..867b7eb6fe 100644 --- a/apps/ui/sources/components/markdown/MarkdownView.tableScrollView.test.tsx +++ b/apps/ui/sources/components/markdown/MarkdownView.tableScrollView.test.tsx @@ -92,6 +92,32 @@ describe('MarkdownView (tables)', () => { expect(findTextNode('1').props.selectable).toBe(true); }, 60_000); + it('renders math table cells through the enriched renderer without losing horizontal scrolling', async () => { + mockPlatform('android'); + const { MarkdownView } = await import('./MarkdownView'); + + const markdown = [ + '| Formula | Existing | Plain |', + '|---|---|---|', + '| \\(x_i\\) | $y_i$ | value |', + ].join('\n'); + + const screen = await renderScreen( + , + ); + + expect(screen.findAllByType('GestureHandlerScrollView' as any)).toHaveLength(1); + expect(screen.findAllByType('EnrichedMarkdownText').map((node) => node.props.markdown)).toEqual([ + '\\(x_i\\)', + '$y_i$', + ]); + expect(screen.findAllByType('EnrichedMarkdownText').map((node) => node.props.md4cFlags)).toEqual([ + { latexMath: true, texMathBackslashDelimiters: true }, + { latexMath: true, texMathBackslashDelimiters: true }, + ]); + expect(screen.findAllByType('Text' as any).some((node) => node.props.children === 'value')).toBe(true); + }, 60_000); + it('applies GitHub table column alignment to header and body cells', async () => { mockPlatform('web'); const { MarkdownView } = await import('./MarkdownView'); diff --git a/apps/ui/sources/components/markdown/MarkdownView.tsx b/apps/ui/sources/components/markdown/MarkdownView.tsx index bea13bec30..c21495eea7 100644 --- a/apps/ui/sources/components/markdown/MarkdownView.tsx +++ b/apps/ui/sources/components/markdown/MarkdownView.tsx @@ -39,6 +39,7 @@ export const MarkdownView = React.memo((props: { onPressSourceRange?: (action: MarkdownSourceRangeAction) => void; renderAfterSourceRange?: (action: MarkdownSourceRangeAction) => React.ReactNode; highlightSourceRange?: MarkdownSourceRange | null; + agentTexMath?: boolean; }) => { const profile = normalizeMarkdownRenderingProfile({ profile: props.profile, @@ -64,6 +65,7 @@ export const MarkdownView = React.memo((props: { onPressSourceRange={props.onPressSourceRange} renderAfterSourceRange={props.renderAfterSourceRange} highlightSourceRange={props.highlightSourceRange} + agentTexMath={props.agentTexMath === true} /> ); }); diff --git a/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownRuntimeReadiness.test.tsx b/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownRuntimeReadiness.test.tsx index bc5235b4e6..f5d712e6e3 100644 --- a/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownRuntimeReadiness.test.tsx +++ b/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownRuntimeReadiness.test.tsx @@ -171,6 +171,7 @@ describe('enriched Markdown runtime readiness join', () => { profile="transcript" selectable streamingAnimated={false} + agentTexMath={false} /> ); } @@ -222,6 +223,7 @@ describe('enriched Markdown runtime readiness join', () => { profile="transcript" selectable streamingAnimated={false} + agentTexMath={false} />, ); await Promise.resolve(); diff --git a/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownText.webStreamingReveal.test.tsx b/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownText.webStreamingReveal.test.tsx index ef1ed8d45d..9f7257ac81 100644 --- a/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownText.webStreamingReveal.test.tsx +++ b/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownText.webStreamingReveal.test.tsx @@ -745,13 +745,6 @@ describe('EnrichedMarkdownText web streaming reveal', () => { expect(parserSource).not.toContain("['string',"); }); - it('clears parser state after web parse-call failures', () => { - const parserSource = readPatchedPackageFile('src/web/parseMarkdown.ts'); - - expect(parserSource).toContain('parseCache.clear()'); - expect(parserSource).toContain('parserPromise = null'); - }); - it('uses themed paragraph fallback for web parse errors', () => { const componentSource = readPatchedPackageFile('src/web/EnrichedMarkdownText.tsx'); const parseErrorFallbackStart = componentSource.indexOf('if (parseError)'); diff --git a/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownTextAdapter.tsx b/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownTextAdapter.tsx index 0d9e4c9a08..2014e95344 100644 --- a/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownTextAdapter.tsx +++ b/apps/ui/sources/components/markdown/enriched/EnrichedMarkdownTextAdapter.tsx @@ -2,7 +2,7 @@ import * as React from 'react'; import { Platform, type StyleProp, type TextStyle } from 'react-native'; import { EnrichedMarkdownText, type EnrichedMarkdownTextProps } from 'react-native-enriched-markdown'; -import { ENRICHED_MARKDOWN_MD4C_FLAGS } from './enrichedMarkdownConstants'; +import { resolveEnrichedMarkdownMd4cFlags } from './enrichedMarkdownConstants'; import { normalizeMarkdownLinkUrl, openMarkdownLinkUrl, sanitizeEnrichedMarkdownLinkTargets } from './enrichedMarkdownLinkHandling'; import { useEnrichedMarkdownRuntimeStatus } from './preloadEnrichedMarkdownRuntime'; import { resolveEnrichedMarkdownFlavor } from './resolveEnrichedMarkdownFlavor'; @@ -82,6 +82,8 @@ type EnrichedMarkdownTextAdapterProps = Readonly<{ streamingRevealPreset?: StreamingTextRevealPreset; testID?: string; suppressLeadingTopMargin?: boolean; + fillContainer?: boolean; + agentTexMath: boolean; }>; export const EnrichedMarkdownTextAdapter = React.memo((props: EnrichedMarkdownTextAdapterProps) => { @@ -94,6 +96,7 @@ export const EnrichedMarkdownTextAdapter = React.memo((props: EnrichedMarkdownTe () => sanitizeEnrichedMarkdownLinkTargets(props.markdown), [props.markdown], ); + const md4cFlags = resolveEnrichedMarkdownMd4cFlags(props.agentTexMath); const handleLinkPress = React.useCallback((event: { url: string }) => { const normalizedUrl = normalizeMarkdownLinkUrl(event.url); @@ -147,17 +150,20 @@ export const EnrichedMarkdownTextAdapter = React.memo((props: EnrichedMarkdownTe }, [flavor, props.streamingAnimated, props.suppressLeadingTopMargin, props.testID, runtimeStatus]); const containerStyle = React.useMemo(() => { + const baseContainerStyle = props.fillContainer === false + ? { ...styleBundle.containerStyle, width: undefined } + : styleBundle.containerStyle; if (Platform.OS !== 'web' || revealConfig == null) { - return styleBundle.containerStyle; + return baseContainerStyle; } return ({ - ...styleBundle.containerStyle, + ...baseContainerStyle, [ENRICHED_REVEAL_DURATION_VAR]: `${revealConfig.durationMs}ms`, [ENRICHED_REVEAL_EASING_VAR]: revealConfig.easing, [ENRICHED_REVEAL_TRANSLATE_Y_VAR]: `${revealConfig.translateYPx}px`, } as unknown) as EnrichedMarkdownTextProps['containerStyle']; - }, [revealConfig, styleBundle.containerStyle]); + }, [props.fillContainer, revealConfig, styleBundle.containerStyle]); return ( ; + +function collectNodes(root: ASTNode): readonly ASTNode[] { + return [ + root, + ...(root.children?.flatMap((child) => collectNodes(child)) ?? []), + ]; +} + +async function parseAgentTex(markdown: string, agentTexMath = true): Promise { + const flags: BackslashTexMathFlags = { latexMath: true, texMathBackslashDelimiters: agentTexMath }; + return parseMarkdown(markdown, flags); +} + +function collectMath(root: ASTNode): readonly Readonly<{ type: string; content: string }>[] { + return collectNodes(root) + .filter((node) => node.type.startsWith('LatexMath')) + .map((node) => ({ type: node.type, content: extractNodeText(node).trim() })); +} + +describe('agent-style TeX delimiters in the enriched Markdown parser', () => { + it('parses inline, standalone display, bracketed prose, and existing dollar math through one owner', async () => { + const ast = await parseAgentTex([ + 'Inline \\(x_i\\); interval [\\(a\\), \\(b\\)].', + '*Emphasized \\(e\\).*', + '', + '\\[', + 'y = \\frac{1}{2}', + '\\]', + '', + ' \\[z^2\\]', + '', + '$a_i$ and $$b^2$$', + ].join('\n')); + + expect(collectMath(ast)).toEqual([ + { type: 'LatexMathInline', content: 'x_i' }, + { type: 'LatexMathInline', content: 'a' }, + { type: 'LatexMathInline', content: 'b' }, + { type: 'LatexMathInline', content: 'e' }, + { type: 'LatexMathDisplay', content: 'y = \\frac{1}{2}' }, + { type: 'LatexMathDisplay', content: 'z^2' }, + { type: 'LatexMathInline', content: 'a_i' }, + { type: 'LatexMathDisplay', content: 'b^2' }, + ]); + }); + + it('lets Markdown structure protect code and link destinations while allowing math in visible link labels', async () => { + const ast = await parseAgentTex([ + 'Code: `\\(inline code\\)`.', + '```tex', + '\\(fenced code\\)', + '```', + ' \\(indented code\\)', + '[label \\(x\\)](https://example.com/\\(path\\))', + 'Escaped: \\\\(literal\\\\).', + 'Incomplete: \\(pending', + 'Embedded display \\[not display\\] text.', + ].join('\n')); + + expect(collectMath(ast)).toEqual([ + { type: 'LatexMathInline', content: 'x' }, + ]); + const nodes = collectNodes(ast); + expect(nodes.filter((node) => node.type === 'Code').map(extractNodeText)).toContain('\\(inline code\\)'); + expect(nodes.filter((node) => node.type === 'CodeBlock').map((node) => extractNodeText(node).trim())).toEqual( + expect.arrayContaining(['\\(fenced code\\)', '\\(indented code\\)']), + ); + // MD4C applies the ordinary Markdown escape in destinations, but the path is not claimed as math. + expect(nodes.find((node) => node.type === 'Link')?.attributes?.url).toBe('https://example.com/(path)'); + }); + + it('keeps agent-style delimiters as ordinary Markdown escapes when the syntax mode is disabled', async () => { + const ast = await parseAgentTex('Use \\(foo\\) as a parenthesized token.', false); + + expect(collectMath(ast)).toEqual([]); + expect(extractNodeText(ast)).toContain('Use (foo) as a parenthesized token.'); + }); + + it('does not let an incomplete opener consume a later complete expression', async () => { + const ast = await parseAgentTex('Streaming: \\(pending; complete: \\(x\\).'); + + expect(collectMath(ast)).toEqual([ + { type: 'LatexMathInline', content: 'x' }, + ]); + expect(extractNodeText(ast)).toContain('\\(pending'); + }); + + it('recognizes standalone display delimiters inside Markdown containers', async () => { + const ast = await parseAgentTex([ + '> \\[', + '> q^2', + '> \\]', + '', + '- \\[', + ' r^2', + ' \\]', + ].join('\n')); + + expect(collectMath(ast)).toEqual([ + { type: 'LatexMathDisplay', content: 'q^2' }, + { type: 'LatexMathDisplay', content: 'r^2' }, + ]); + }); + + it('keeps parse-cache entries isolated by the delimiter syntax flag', async () => { + const markdown = 'Value: \\(x\\).'; + + expect(collectMath(await parseAgentTex(markdown, false))).toEqual([]); + expect(collectMath(await parseAgentTex(markdown, true))).toEqual([ + { type: 'LatexMathInline', content: 'x' }, + ]); + expect(collectMath(await parseAgentTex(markdown, false))).toEqual([]); + }); +}); diff --git a/apps/ui/sources/components/markdown/enriched/enrichedMarkdownConstants.ts b/apps/ui/sources/components/markdown/enriched/enrichedMarkdownConstants.ts index 88550f4a3a..e1b4239fe5 100644 --- a/apps/ui/sources/components/markdown/enriched/enrichedMarkdownConstants.ts +++ b/apps/ui/sources/components/markdown/enriched/enrichedMarkdownConstants.ts @@ -1,5 +1,17 @@ import type { EnrichedMarkdownTextProps } from 'react-native-enriched-markdown'; -export const ENRICHED_MARKDOWN_MD4C_FLAGS: NonNullable = { +const DEFAULT_ENRICHED_MARKDOWN_MD4C_FLAGS: NonNullable = { latexMath: true, + texMathBackslashDelimiters: false, }; + +const AGENT_TEX_ENRICHED_MARKDOWN_MD4C_FLAGS: NonNullable = { + latexMath: true, + texMathBackslashDelimiters: true, +}; + +export function resolveEnrichedMarkdownMd4cFlags(agentTexMath: boolean): NonNullable { + return agentTexMath + ? AGENT_TEX_ENRICHED_MARKDOWN_MD4C_FLAGS + : DEFAULT_ENRICHED_MARKDOWN_MD4C_FLAGS; +} diff --git a/apps/ui/sources/components/markdown/enriched/enrichedMarkdownParserRuntime.test.ts b/apps/ui/sources/components/markdown/enriched/enrichedMarkdownParserRuntime.test.ts new file mode 100644 index 0000000000..362a465e27 --- /dev/null +++ b/apps/ui/sources/components/markdown/enriched/enrichedMarkdownParserRuntime.test.ts @@ -0,0 +1,53 @@ +import { describe, expect, it, vi } from 'vitest'; + +const wasmBoundary = vi.hoisted(() => { + let markdown = ''; + let initializationAttempts = 0; + + return { + factory: vi.fn(async () => { + initializationAttempts += 1; + if (initializationAttempts === 1) { + throw new Error('simulated WASM initialization failure'); + } + + return { + cwrap: () => () => ( + markdown === 'invalid-document' + ? JSON.stringify({ children: [] }) + : JSON.stringify({ type: 'Document', children: [] }) + ), + _malloc: () => 1, + _free: () => undefined, + stringToUTF8: (value: string) => { + markdown = value; + }, + lengthBytesUTF8: (value: string) => value.length, + }; + }), + }; +}); + +// The generated WASM module is the real parser's external runtime boundary. +vi.mock('../../../../node_modules/react-native-enriched-markdown/src/web/wasm/md4c.js', () => ({ + default: wasmBoundary.factory, +})); + +import { + parseMarkdown, + parseMarkdownSyncIfReady, + preloadMarkdownRuntime, +} from '../../../../node_modules/react-native-enriched-markdown/src/web/parseMarkdown'; + +describe('enriched Markdown parser runtime recovery', () => { + it('retries initialization but retains a warm runtime after one document parse fails', async () => { + await expect(preloadMarkdownRuntime()).rejects.toThrow('simulated WASM initialization failure'); + await expect(preloadMarkdownRuntime()).resolves.toBeUndefined(); + expect(wasmBoundary.factory).toHaveBeenCalledTimes(2); + + await expect(parseMarkdown('invalid-document')).rejects.toBeInstanceOf(Error); + + expect(parseMarkdownSyncIfReady('next-document')).toMatchObject({ type: 'Document' }); + expect(wasmBoundary.factory).toHaveBeenCalledTimes(2); + }); +}); diff --git a/apps/ui/sources/components/markdown/enriched/useEnrichedMarkdownStyle.ts b/apps/ui/sources/components/markdown/enriched/useEnrichedMarkdownStyle.ts index d134ad99fb..35c55eb2b9 100644 --- a/apps/ui/sources/components/markdown/enriched/useEnrichedMarkdownStyle.ts +++ b/apps/ui/sources/components/markdown/enriched/useEnrichedMarkdownStyle.ts @@ -55,6 +55,17 @@ function readFontStyle(style: TextStyle): 'normal' | 'italic' | undefined { return style.fontStyle === 'normal' || style.fontStyle === 'italic' ? style.fontStyle : undefined; } +function readTextAlign(style: TextStyle): NonNullable | undefined { + const textAlign = style.textAlign; + return textAlign === 'auto' + || textAlign === 'left' + || textAlign === 'right' + || textAlign === 'center' + || textAlign === 'justify' + ? textAlign + : undefined; +} + function flattenTextStyle(style: unknown): TextStyle { if (!style) { return {}; @@ -101,6 +112,10 @@ export function buildEnrichedMarkdownStyle(params: Readonly<{ const baseLineHeight = readNumber(flattenedTextStyle.lineHeight, roundTo2(24 * uiFontScale)); const inlineCodeFontSize = roundTo2(baseFontSize * 0.88); const baseColor = readString(flattenedTextStyle.color, params.colors.text.primary); + const textAlign = readTextAlign(flattenedTextStyle); + const mathTextAlign = textAlign === 'left' || textAlign === 'right' || textAlign === 'center' + ? textAlign + : 'center'; const h1FontSize = scaledMetric(baseFontSize, 1.5); const h2FontSize = scaledMetric(baseFontSize, 1.25); const h3FontSize = scaledMetric(baseFontSize, 1.125); @@ -127,6 +142,7 @@ export function buildEnrichedMarkdownStyle(params: Readonly<{ fontSize: baseFontSize, lineHeight: baseLineHeight, color: baseColor, + textAlign, marginTop: 0, marginBottom: 8, }, @@ -237,7 +253,7 @@ export function buildEnrichedMarkdownStyle(params: Readonly<{ color: baseColor, backgroundColor: 'transparent', padding: 0, - textAlign: 'center' as const, + textAlign: mathTextAlign, marginTop: 8, marginBottom: 8, }, diff --git a/apps/ui/sources/components/markdown/rendering/MarkdownSegmentView.tsx b/apps/ui/sources/components/markdown/rendering/MarkdownSegmentView.tsx index b2d6b677f5..ce13436bd5 100644 --- a/apps/ui/sources/components/markdown/rendering/MarkdownSegmentView.tsx +++ b/apps/ui/sources/components/markdown/rendering/MarkdownSegmentView.tsx @@ -24,6 +24,7 @@ type MarkdownSegmentViewProps = Readonly<{ onPressSourceRange?: (action: MarkdownSourceRangeAction) => void; renderAfterSourceRange?: (action: MarkdownSourceRangeAction) => React.ReactNode; highlightSourceRange?: MarkdownSourceRange | null; + agentTexMath: boolean; }>; export const MarkdownSegmentView = React.memo((props: MarkdownSegmentViewProps) => { @@ -46,6 +47,7 @@ export const MarkdownSegmentView = React.memo((props: MarkdownSegmentViewProps) streamingRevealPreset={props.streamingRevealPreset} testID="markdown-enriched-run" suppressLeadingTopMargin={props.segment.first} + agentTexMath={props.agentTexMath} /> ) : ( @@ -61,6 +63,7 @@ export const MarkdownSegmentView = React.memo((props: MarkdownSegmentViewProps) profile={props.profile} streamingReveal={props.streamingReveal} streamingRevealPreset={props.streamingRevealPreset} + agentTexMath={props.agentTexMath} /> ); diff --git a/apps/ui/sources/components/markdown/rendering/MarkdownViewRenderer.tsx b/apps/ui/sources/components/markdown/rendering/MarkdownViewRenderer.tsx index 33c8fc09cc..e824bc47cb 100644 --- a/apps/ui/sources/components/markdown/rendering/MarkdownViewRenderer.tsx +++ b/apps/ui/sources/components/markdown/rendering/MarkdownViewRenderer.tsx @@ -34,6 +34,7 @@ type MarkdownViewRendererProps = Readonly<{ onPressSourceRange?: (action: MarkdownSourceRangeAction) => void; renderAfterSourceRange?: (action: MarkdownSourceRangeAction) => React.ReactNode; highlightSourceRange?: MarkdownSourceRange | null; + agentTexMath: boolean; }>; function readStreamingSegmentCache(params: Readonly<{ @@ -133,6 +134,7 @@ export const MarkdownViewRenderer = React.memo((props: MarkdownViewRendererProps onPressSourceRange={props.onPressSourceRange} renderAfterSourceRange={props.renderAfterSourceRange} highlightSourceRange={props.highlightSourceRange} + agentTexMath={props.agentTexMath} /> ))} diff --git a/apps/ui/sources/components/markdown/rendering/SpecialMarkdownBlockView.tsx b/apps/ui/sources/components/markdown/rendering/SpecialMarkdownBlockView.tsx index e278f76610..162d63da14 100644 --- a/apps/ui/sources/components/markdown/rendering/SpecialMarkdownBlockView.tsx +++ b/apps/ui/sources/components/markdown/rendering/SpecialMarkdownBlockView.tsx @@ -18,6 +18,7 @@ type SpecialMarkdownBlockViewProps = Readonly<{ profile: MarkdownRenderingProfile; streamingReveal: boolean; streamingRevealPreset?: StreamingTextRevealPreset; + agentTexMath: boolean; }>; export const SpecialMarkdownBlockView = React.memo((props: SpecialMarkdownBlockViewProps) => { @@ -36,9 +37,11 @@ export const SpecialMarkdownBlockView = React.memo((props: SpecialMarkdownBlockV onOptionLongPress={props.onOptionLongPress} onLinkPress={props.onLinkPress} textStyle={props.textStyle} + profile={props.profile} variant={variant} streamingReveal={props.streamingReveal} streamingRevealPreset={props.streamingRevealPreset} + agentTexMath={props.agentTexMath} /> ))} diff --git a/apps/ui/sources/components/sessions/reviews/messages/ReviewFindingsMessageCard.tsx b/apps/ui/sources/components/sessions/reviews/messages/ReviewFindingsMessageCard.tsx index b9d0d18135..eb8fe7b87d 100644 --- a/apps/ui/sources/components/sessions/reviews/messages/ReviewFindingsMessageCard.tsx +++ b/apps/ui/sources/components/sessions/reviews/messages/ReviewFindingsMessageCard.tsx @@ -342,7 +342,7 @@ export function ReviewFindingsMessageCard(props: { {t('session.reviewFindings.title', { count: findings.length })} {normalized.summary} - + {normalized.questions.length > 0 ? ( diff --git a/apps/ui/sources/components/sessions/reviews/messages/ReviewFollowUpMessageCard.tsx b/apps/ui/sources/components/sessions/reviews/messages/ReviewFollowUpMessageCard.tsx index ba0ccb987f..55efef1843 100644 --- a/apps/ui/sources/components/sessions/reviews/messages/ReviewFollowUpMessageCard.tsx +++ b/apps/ui/sources/components/sessions/reviews/messages/ReviewFollowUpMessageCard.tsx @@ -11,7 +11,7 @@ export function ReviewFollowUpMessageCard(props: Readonly<{ payload: ReviewFollo return ( - + {props.payload.updatedFindings?.length ? ( {props.payload.updatedFindings.map((finding) => ( diff --git a/apps/ui/sources/components/sessions/transcript/MessageView.thinkingPulse.test.tsx b/apps/ui/sources/components/sessions/transcript/MessageView.thinkingPulse.test.tsx index 71b274a88f..58bcf1aee5 100644 --- a/apps/ui/sources/components/sessions/transcript/MessageView.thinkingPulse.test.tsx +++ b/apps/ui/sources/components/sessions/transcript/MessageView.thinkingPulse.test.tsx @@ -169,6 +169,7 @@ describe('MessageView (thinking pulse gating)', () => { expect(captured.thinkingRowProps.at(-1)?.chrome).toBe('plain'); expect(captured.markdownProps.at(-1)?.testID).toBe('transcript-thinking-body-markdown'); expect(captured.markdownProps.at(-1)?.profile).toBe('thinking'); + expect(captured.markdownProps.at(-1)?.agentTexMath).toBe(true); expect(screen.findAll((node) => (node.props as any).testID === 'transcript-thinking-body-plain')).toHaveLength(0); captured.thinkingPulseProps.length = 0; diff --git a/apps/ui/sources/components/sessions/transcript/MessageView.tsx b/apps/ui/sources/components/sessions/transcript/MessageView.tsx index 968e36ddfb..d3660921f6 100644 --- a/apps/ui/sources/components/sessions/transcript/MessageView.tsx +++ b/apps/ui/sources/components/sessions/transcript/MessageView.tsx @@ -1311,6 +1311,7 @@ function AgentTextBlock(props: { { const markdownView = screen.findByType('MarkdownView' as any); expect(markdownView.props.markdown).toBe('transcript.unsupportedContent.unparsedUserMessage'); + expect(markdownView.props.agentTexMath).toBeUndefined(); }); it('does not leak the raw fallback text into select-preview/copy text for the user own message', async () => { @@ -257,6 +258,7 @@ describe('MessageView unsupported-content rendering', () => { const markdownView = screen.findByType('MarkdownView' as any); expect(markdownView.props.markdown).toBe('hello world'); + expect(markdownView.props.agentTexMath).toBe(true); }); it.each([ diff --git a/apps/ui/sources/components/tools/renderers/workflow/ExitPlanToolView.tsx b/apps/ui/sources/components/tools/renderers/workflow/ExitPlanToolView.tsx index 03e6b701bd..9a3970db6f 100644 --- a/apps/ui/sources/components/tools/renderers/workflow/ExitPlanToolView.tsx +++ b/apps/ui/sources/components/tools/renderers/workflow/ExitPlanToolView.tsx @@ -310,7 +310,7 @@ export const ExitPlanToolView = React.memo(({ tool, sessionId, in - + {isResponded || tool.state === 'completed' ? ( diff --git a/apps/ui/sources/components/tools/renderers/workflow/ReasoningView.test.tsx b/apps/ui/sources/components/tools/renderers/workflow/ReasoningView.test.tsx index 335e25b04c..b6aeba8ad5 100644 --- a/apps/ui/sources/components/tools/renderers/workflow/ReasoningView.test.tsx +++ b/apps/ui/sources/components/tools/renderers/workflow/ReasoningView.test.tsx @@ -47,6 +47,7 @@ describe('ReasoningView', () => { expect(markdownViewSpy).toHaveBeenCalled(); const lastCall = markdownViewSpy.mock.calls.at(-1)?.[0]; expect(lastCall?.markdown).toBe('Hello **world**'); + expect(lastCall?.agentTexMath).toBe(true); }); it('truncates long reasoning by default and preserves full content when detailLevel=full', async () => { diff --git a/apps/ui/sources/components/tools/renderers/workflow/ReasoningView.tsx b/apps/ui/sources/components/tools/renderers/workflow/ReasoningView.tsx index 41ff009856..7817690974 100644 --- a/apps/ui/sources/components/tools/renderers/workflow/ReasoningView.tsx +++ b/apps/ui/sources/components/tools/renderers/workflow/ReasoningView.tsx @@ -28,7 +28,7 @@ export const ReasoningView = React.memo(({ tool, detailLevel }) = return ( - + ); diff --git a/apps/ui/tools/postinstall.mjs b/apps/ui/tools/postinstall.mjs index ef89c7b175..4c148f29c0 100644 --- a/apps/ui/tools/postinstall.mjs +++ b/apps/ui/tools/postinstall.mjs @@ -238,13 +238,15 @@ if (wants('verify-react-native-enriched-markdown-web-streaming-patch')) { || !parseMarkdownContents.includes('preloadMarkdownRuntime') || !parseMarkdownContents.includes("import createMd4cModule from './wasm/md4c.js'") || parseMarkdownContents.includes("import('./wasm/md4c") - || !parseMarkdownContents.includes("['number', 'number', 'number']") + || !parseMarkdownContents.includes("['number', 'number', 'number', 'number']") + || !parseMarkdownContents.includes('texMathBackslashDelimiters') || !parseMarkdownContents.includes('stringToUTF8(markdown') || !parseMarkdownContents.includes('parseCache.clear()') || !parseMarkdownSourceContents.includes('lengthBytesUTF8(markdown)') || !parseMarkdownSourceContents.includes("import createMd4cModule from './wasm/md4c.js'") || parseMarkdownSourceContents.includes("import('./wasm/md4c") || !parseMarkdownSourceContents.includes('parserPromise = null') + || !parseMarkdownSourceContents.includes('texMathBackslashDelimiters') || !enrichedMarkdownTextSourceContents.includes('lastChildStyles.paragraph') || enrichedMarkdownTextSourceContents.includes('{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;class EmscriptenEH{}class EmscriptenSjLj extends EmscriptenEH{}var readyPromiseResolve,readyPromiseReject;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["__wasm_call_ctors"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what=`Aborted(${what})`;err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){return base64Decode("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")}function getBinarySync(file){if(ArrayBuffer.isView(file)){return file}if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={env:wasmImports,wasi_snapshot_preview1:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var HEAP16;var HEAP32;var HEAP64;var HEAP8;var HEAPF32;var HEAPF64;var HEAPU16;var HEAPU32;var HEAPU64;var HEAPU8;var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var base64Decode=b64=>{var b1,b2,i=0,j=0,bLength=b64.length;var output=new Uint8Array((bLength*3>>2)-(b64[bLength-2]=="=")-(b64[bLength-1]=="="));for(;i>4;output[j+1]=b1<<4|b2>>2;output[j+2]=b2<<6|base64ReverseLookup[b64.charCodeAt(i+3)]}return output};var noExitRuntime=true;var stackRestore=val=>__emscripten_stack_restore(val);var stackSave=()=>_emscripten_stack_get_current();var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var ___assert_fail=(condition,filename,line,func)=>abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=0}init(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor)}set_adjusted_ptr(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}}var uncaughtExceptionCount=0;var ___cxa_throw=(ptr,type,destructor)=>{var info=new ExceptionInfo(ptr);info.init(type,destructor);uncaughtExceptionCount++;abort()};var __abort_js=()=>abort("");var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};for(var base64ReverseLookup=new Uint8Array(123),__b64i=25;__b64i>=0;--__b64i){base64ReverseLookup[48+__b64i]=52+__b64i;base64ReverseLookup[65+__b64i]=__b64i;base64ReverseLookup[97+__b64i]=26+__b64i}base64ReverseLookup[43]=62;base64ReverseLookup[47]=63;{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["ccall"]=ccall;Module["cwrap"]=cwrap;Module["UTF8ToString"]=UTF8ToString;Module["stringToUTF8"]=stringToUTF8;Module["lengthBytesUTF8"]=lengthBytesUTF8;var _parseMarkdown,_malloc,_free,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,memory,__indirect_function_table,wasmMemory;function assignWasmExports(wasmExports){_parseMarkdown=Module["_parseMarkdown"]=wasmExports["parseMarkdown"];_malloc=Module["_malloc"]=wasmExports["malloc"];_free=Module["_free"]=wasmExports["free"];__emscripten_stack_restore=wasmExports["_emscripten_stack_restore"];__emscripten_stack_alloc=wasmExports["_emscripten_stack_alloc"];_emscripten_stack_get_current=wasmExports["emscripten_stack_get_current"];memory=wasmMemory=wasmExports["memory"];__indirect_function_table=wasmExports["__indirect_function_table"]}var wasmImports={__assert_fail:___assert_fail,__cxa_throw:___cxa_throw,_abort_js:__abort_js,emscripten_resize_heap:_emscripten_resize_heap};function run(){preRun();function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})} +async function createMd4cModule(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=true;var ENVIRONMENT_IS_WORKER=false;var arguments_=[];var thisProgram="./this.program";var _scriptName="";var scriptDirectory="";var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;class EmscriptenEH{}class EmscriptenSjLj extends EmscriptenEH{}var readyPromiseResolve,readyPromiseReject;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["__wasm_call_ctors"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what=`Aborted(${what})`;err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){return base64Decode("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")}function getBinarySync(file){if(ArrayBuffer.isView(file)){return file}if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={env:wasmImports,wasi_snapshot_preview1:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var HEAP16;var HEAP32;var HEAP64;var HEAP8;var HEAPF32;var HEAPF64;var HEAPU16;var HEAPU32;var HEAPU64;var HEAPU8;var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var base64Decode=b64=>{var b1,b2,i=0,j=0,bLength=b64.length;var output=new Uint8Array((bLength*3>>2)-(b64[bLength-2]=="=")-(b64[bLength-1]=="="));for(;i>4;output[j+1]=b1<<4|b2>>2;output[j+2]=b2<<6|base64ReverseLookup[b64.charCodeAt(i+3)]}return output};var noExitRuntime=true;var stackRestore=val=>__emscripten_stack_restore(val);var stackSave=()=>_emscripten_stack_get_current();var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var ___assert_fail=(condition,filename,line,func)=>abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=0}init(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor)}set_adjusted_ptr(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}}var uncaughtExceptionCount=0;var ___cxa_throw=(ptr,type,destructor)=>{var info=new ExceptionInfo(ptr);info.init(type,destructor);uncaughtExceptionCount++;abort()};var __abort_js=()=>abort("");var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};for(var base64ReverseLookup=new Uint8Array(123),__b64i=25;__b64i>=0;--__b64i){base64ReverseLookup[48+__b64i]=52+__b64i;base64ReverseLookup[65+__b64i]=__b64i;base64ReverseLookup[97+__b64i]=26+__b64i}base64ReverseLookup[43]=62;base64ReverseLookup[47]=63;{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["ccall"]=ccall;Module["cwrap"]=cwrap;Module["UTF8ToString"]=UTF8ToString;Module["stringToUTF8"]=stringToUTF8;Module["lengthBytesUTF8"]=lengthBytesUTF8;var _parseMarkdown,_malloc,_free,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,memory,__indirect_function_table,wasmMemory;function assignWasmExports(wasmExports){_parseMarkdown=Module["_parseMarkdown"]=wasmExports["parseMarkdown"];_malloc=Module["_malloc"]=wasmExports["malloc"];_free=Module["_free"]=wasmExports["free"];__emscripten_stack_restore=wasmExports["_emscripten_stack_restore"];__emscripten_stack_alloc=wasmExports["_emscripten_stack_alloc"];_emscripten_stack_get_current=wasmExports["emscripten_stack_get_current"];memory=wasmMemory=wasmExports["memory"];__indirect_function_table=wasmExports["__indirect_function_table"]}var wasmImports={__assert_fail:___assert_fail,__cxa_throw:___cxa_throw,_abort_js:__abort_js,emscripten_resize_heap:_emscripten_resize_heap};function run(){preRun();function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})} ;return moduleRtn}export default createMd4cModule;