react-native-jet-markdown 0.2.0-beta.7

package/JetMarkdown.podspec

@@ -0,0 +1,42 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "JetMarkdown"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/alizahid/react-native-jet-markdown.git", :tag => "#{s.version}" }
+
+  # Headers are deliberately NOT in source_files. Xcode's project-wide
+  # header maps index every pod target's headers BY BASENAME, so adding
+  # generically named headers (md4c.h, Parser.h) to the Pods project
+  # shadows other pods' same-named headers in THEIR quoted includes —
+  # react-native-enriched-markdown's forked md4c and unistyles' parser
+  # both stopped compiling. Our own includes are file-relative or resolve
+  # through the search paths below; the headers ship in the npm package
+  # and stay on disk (RN pods integrate via :path, which never cleans).
+  s.source_files = "ios/**/*.{m,mm,swift,cpp}",
+                   "cpp/core/**/*.cpp",
+                   "cpp/react/**/*.cpp",
+                   "cpp/md4c/*.c"
+  s.preserve_paths = "ios/**/*.h", "cpp/**/*.h"
+
+  s.pod_target_xcconfig = {
+    # The override directory must precede generated headers so the custom
+    # component descriptor shadows the codegen default.
+    "HEADER_SEARCH_PATHS" => '"$(PODS_TARGET_SRCROOT)/cpp/react/override" "$(PODS_TARGET_SRCROOT)/cpp"',
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+  }
+
+  # Image pipeline (same core expo-image uses): animated GIF/APNG with lazy
+  # frame decoding, memory + disk caches, request dedupe and cancellation.
+  s.dependency "SDWebImage", "~> 5.21"
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Ali Zahid
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,247 @@
+<p align="center">
+  <img alt="react-native-jet-markdown — native markdown viewer and WYSIWYG editor for React Native" src="https://raw.githubusercontent.com/alizahid/react-native-jet-markdown/main/docs/hero.svg" width="900">
+</p>
+
+<p align="center">
+  Fast, fully native Markdown viewer &amp; WYSIWYG editor for React Native
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/react-native-jet-markdown"><img src="https://img.shields.io/npm/v/react-native-jet-markdown?color=A02F6F&label=npm" alt="npm"></a>
+  <a href="https://github.com/alizahid/react-native-jet-markdown/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/react-native-jet-markdown?color=668C0B" alt="license"></a>
+  <img src="https://img.shields.io/badge/platform-iOS%20%7C%20Android-5E409D" alt="platform">
+  <img src="https://img.shields.io/badge/architecture-Fabric-205EA6" alt="architecture">
+</p>
+
+---
+
+- **One native Fabric view** — markdown is parsed natively with [md4c](https://github.com/mity/md4c) and rendered as attributed text (TextKit on iOS, StaticLayout/Spannable on Android). No WebView, no JS-side layout, no nested `<Text>` trees.
+- **Self-sizing** — the component measures its own height on the Fabric layout thread with a custom C++ shadow node, so it behaves like `<Text>` in any layout, list, or scroll view.
+- **Built for lists** — parse and layout results are cached and shared between measurement and mounting; views recycle cleanly in FlatList / FlashList / LegendList.
+- **Deeply styleable** — a typed, per-element styles API with cascading text styles, box styles, and regex-based mention variants.
+
+## Supported markdown
+
+Headings, paragraphs, images, GFM tables (horizontal scroll with intelligently sized columns), spoilers (Reddit `>!text!<` **and** Discord `||text||`), superscript (`^sup^`, Reddit `^word` and `^(multi word)`), subscript (`~sub~`), bold / italic / strikethrough, ordered + unordered lists (nested), links, mentions, inline code, code blocks (horizontally scrolling, monospace), block quotes, and thematic breaks.
+
+## Installation
+
+```sh
+npm install react-native-jet-markdown
+cd ios && pod install
+```
+
+Requires React Native 0.86+ with the New Architecture (Fabric).
+
+## Usage
+
+```tsx
+import {
+  JetMarkdownView,
+  mergeStyles,
+  type MarkdownStyles,
+} from 'react-native-jet-markdown';
+
+// Default look + overrides. Or pass `defaultStyles` as-is, or your own
+// object from scratch — with no `styles` prop the viewer renders fully
+// plain text.
+const styles: MarkdownStyles = mergeStyles({
+  paragraph: { fontSize: 16, color: '#1F2937' },
+  link: { color: '#2563EB', textDecorationLine: 'underline' },
+  mention: {
+    fontWeight: '600',
+    variants: {
+      '^users://': { color: '#DB2777' },
+      '^channels://': { color: '#059669' },
+    },
+  },
+  spoiler: { backgroundColor: '#374151', borderRadius: 4 },
+});
+
+<JetMarkdownView
+  markdown={'Hello **world**, ping [@ali](users://ali)!'}
+  styles={styles}
+  style={{ padding: 16, gap: 12 }}
+  onLinkPress={({ url }) => Linking.openURL(url)}
+/>;
+```
+
+## Props
+
+| Prop | Type | Description |
+| --- | --- | --- |
+| `markdown` | `string` | The markdown source. |
+| `style` | `MarkdownContainerStyle` | Main container style: `backgroundColor`, `padding`/`padding{Left,Right,Top,Bottom}`, `gap` (spacing between blocks), plus base text styles (`fontSize`, `fontWeight`, `fontFamily`, `color`, `fontVariant`, `textDecoration*`) that cascade into every text element unless overridden per-element via `styles`. Element builtins survive the cascade: heading sizes/weight stay unless `headings.hN` overrides, and code blocks keep their monospace font unless `codeBlock` overrides. For outer layout (margin, width, flex), wrap the viewer in a `View`. |
+| `styles` | `MarkdownStyles` | Per-element styles (below). Omitted = fully plain output (no colors, boxes, heading sizes — only bold/italic runs, monospace code, list markers, and the spoiler cover). Pass the exported `defaultStyles` for the classic look, or `mergeStyles(overrides)` for defaults + your changes. Hoist to module scope or memoize. |
+| `images` | `{ url, width, height }[]` | Pre-sizing data. Listed images lay out at their final size immediately — zero layout shift. Unlisted images render a styled full-width, 200pt-tall placeholder, then snap to their real aspect once loaded. Loading runs on SDWebImage (iOS) and Glide (Android) — the same cores expo-image uses — with memory + disk caches, request dedupe, and animated GIF playback (plus APNG on iOS). |
+| `onLinkPress` | `({ url }) => void` | Link or mention tapped. Mentions arrive with their scheme (e.g. `users://ali`). |
+| `onLinkLongPress` | `({ url }) => void` | Link long-pressed. |
+| `onImagePress` | `({ url, x, y, width, height }) => void` | Image tapped. `width`/`height` are the rendered size and `x`/`y` the position relative to the screen (dp) — everything a lightbox needs for a zoom-from-thumbnail transition. |
+
+## Styling
+
+The viewer ships **unstyled by default**. Two exports cover the common cases:
+
+- `defaultStyles` — a plain `MarkdownStyles` object with the classic markdown look (heading scale, blue links, code boxes, quote bar, table separators). It's just data: spread it, fork it, or use it as a reference.
+- `mergeStyles(overrides)` — deep-merges your overrides into `defaultStyles` (element sections merge key-by-key, heading levels individually).
+
+Two shared shapes compose every element style:
+
+**Text** — `fontSize`, `fontWeight`, `fontFamily`, `color`, `backgroundColor` (run highlight), `fontVariant`, `lineHeight`, `textDecorationColor`, `textDecorationLine`, `textDecorationStyle`
+
+**Layout** — `backgroundColor`, `padding` (+ `paddingHorizontal`/`paddingVertical` and per-side), `borderRadius`, `borderCurve` (iOS), `borderColor`/`borderWidth` (+ per-side)
+
+Every color accepts platform colors (`PlatformColor`, `DynamicColorIOS`) as well as static values — on iOS they stay dynamic and adapt to light/dark automatically; on Android they resolve against the current theme.
+
+| Key | Accepts | Notes |
+| --- | --- | --- |
+| `headings.h1`–`h6` | text | Do **not** inherit `paragraph`, and ignore the base `lineHeight` (a body line height would clip taller headings) — set `headings.hN.lineHeight` explicitly if needed. `defaultStyles`: 32/26/22/18/16/14, bold. |
+| `paragraph` | text | Base for body text; inline styles cascade on top. |
+| `bold`, `italic`, `strikethrough` | text | |
+| `link` | text + `borderRadius`, `borderCurve` (iOS) | `backgroundColor` draws as a rounded chip behind the run. `defaultStyles`: system blue. |
+| `mention` | text + `borderRadius`, `borderCurve` (iOS) + `variants` | `backgroundColor` draws as a rounded chip. `variants` maps a regex (tested against the link URL, longest pattern first) to a style. A link matching any variant is a mention. |
+| `inlineCode` | text + `backgroundColor`, `borderRadius`, `borderCurve` (iOS), `padding(Horizontal/Left/Right)` | Always monospace; the background draws as a rounded chip. `defaultStyles`: 8% black background. |
+| `superscript`, `subscript` | text | Default: 0.7x size with baseline shift. |
+| `spoiler` | `backgroundColor`, `borderRadius`, `borderCurve` | The tap-to-reveal cover — one contiguous polygon even across line wraps. Unstyled: plain black. |
+| `codeBlock` | text + layout | Always monospace; long lines scroll horizontally. `defaultStyles`: 14pt, 8% black, radius 6, padding 12. |
+| `blockQuote` | text + layout | Text styles cascade into quoted content. `defaultStyles`: 3pt left border, 12pt left padding. |
+| `list` | `marginLeft` | |
+| `listMarker` | `width`, `marginLeft`, `color` | Fixed-width marker column. Unstyled: sized to the widest marker. `defaultStyles`: 24. |
+| `listItem` | text | Cascades into item content. |
+| `image` | `borderRadius`, `backgroundColor`, `height`, `maxHeight` | `backgroundColor` shows while loading. |
+| `table` | layout + `minColumnWidth`, `maxColumnWidth` | Unstyled: natural column widths. `defaultStyles`: clamps to `[44, 320]`. |
+| `tableRow` | layout | Base for all rows. `defaultStyles`: 1pt bottom-border separator. |
+| `tableHeaderRow`, `tableBodyRow` | layout | Layer over `tableRow` for header vs body rows. |
+| `tableCell` | text + `padding*` | Header cells are always bold. `defaultStyles`: padding 8. |
+| `tableHeaderCell` | text + `padding*` | Layers over `tableCell` for header cells. |
+| `divider` | `color`, `height` | Thematic break (`---`). Unstyled: 1pt black. `defaultStyles`: subtle hairline. |
+| `gap` | number | Vertical spacing between blocks. The `style` prop's `gap` wins when both are set. Unstyled: 0. `defaultStyles`: 12. |
+
+### Tables
+
+Each column gets its natural (unwrapped) width, clamped to `[minColumnWidth, maxColumnWidth]`. If the table fits the container, the surplus is distributed proportionally so it fills the line; if not, columns keep their readable widths and the table scrolls horizontally.
+
+### Mentions
+
+Mentions are plain markdown links with custom schemes — `[@ali](users://ali)`, `[#general](channels://general)` — classified by the `mention.variants` regexes and styled accordingly. Presses arrive through `onLinkPress`; branch on the URL scheme.
+
+## Using in lists
+
+Rendering hundreds of viewers in FlatList / FlashList / LegendList is a first-class use case:
+
+- Hoist `styles` (and `images` when static) to module scope — every item then shares one parsed native style config.
+- Parse + layout are cached natively and computed on the Fabric layout thread, so scrolling never parses markdown on the main thread.
+- Views reset correctly when recycled; rebinding a view cancels its previous image request, and caches make re-scroll loads instant.
+- Wrapping items in `Pressable` works: taps on links, mentions, and spoilers are claimed by the markdown view; taps on plain text reach your `Pressable`.
+
+```tsx
+const renderItem = ({ item }) => (
+  <Pressable onPress={() => openPost(item)}>
+    <JetMarkdownView markdown={item.body} styles={styles} onLinkPress={openLink} />
+  </Pressable>
+);
+```
+
+## Performance
+
+Numbers from the shared C++ core (Apple M-series, `-O2`; the same code runs on device — expect a few multiples slower on mid-range phones, still far below frame budget):
+
+| Operation | Input | Time |
+| --- | --- | --- |
+| Parse a typical feed post | 1.5 KB mixed markdown | **35 µs** |
+| Parse a large document | 160 KB | **4.1 ms** |
+| Open a document in the editor (`editorFromMarkdown`) | 160 KB, ~6,400 style runs | **4.7 ms** |
+| Serialize the editor back to markdown | 160 KB | **5.8 ms** |
+| Serialize the full `defaultStyles` object in JS | 980 B JSON | **3 µs**, memoized |
+
+Beyond raw parsing: measurement runs on the Fabric layout thread (never on main), parse + layout results are cached and shared between measure and mount, editor keystrokes only rebuild the derived styling of the lines they touch, and markdown serialization is coalesced to once per frame. The 500-item Feed screen in the example app scrolls at 60 fps on both platforms.
+
+### Why styles cross as JSON
+
+You may notice styles ship natively as one `stylesJson` string instead of a structured object. This is deliberate, not legacy: Fabric props cross via JSI either way (there is no old-bridge serialization in either design), codegen cannot express the open-keyed `mention.variants` map, and the string doubles as the cache key shared by the C++ measurer, iOS, and Android — a structured prop would need deep equality or native re-serialization to get the same caching. The cost is ~3 µs once per distinct styles object.
+
+## Editor
+
+`JetMarkdownEditor` is a WYSIWYG editor with markdown as the interchange format: no visible syntax while editing, `onChangeMarkdown` fires with serialized markdown on every edit, and `setValue`/`defaultValue`/paste parse markdown into styled content.
+
+```tsx
+import { JetMarkdownEditor, useJetMarkdownEditor } from "react-native-jet-markdown";
+
+function Compose() {
+  const editor = useJetMarkdownEditor();
+
+  return (
+    <>
+      <JetMarkdownEditor
+        mentionTriggers={["@"]}
+        onChangeMarkdown={(markdown) => save(markdown)}
+        onMentionChange={({ query }) => search(query)}
+        placeholder="Write something..."
+        ref={editor.ref}
+      />
+      <Button onPress={editor.toggleBold} title="B" />
+    </>
+  );
+}
+```
+
+### Formatting
+
+Inline marks — bold, italic, strikethrough, inline code, spoiler, superscript, subscript — toggle over the selection, or arm for the text typed next at a collapsed cursor (`toggleBold()`, `toggleItalic()`, `toggleStrikethrough()`, `toggleCode()`, `toggleSpoiler()`, `toggleSuperscript()`, `toggleSubscript()`).
+
+Blocks apply per line: `toggleHeading(1-6)`, `toggleBlockQuote()`, `toggleCodeBlock()`, `toggleUnorderedList()`, `toggleOrderedList()`. Enter continues a list, Enter on an empty item exits it, Enter after a heading returns to paragraph, and backspace at the start of a formatted line clears its block first.
+
+`onChangeState` reports the formatting at the cursor or selection (`isBold`, `headingLevel`, `isUnorderedList`, ...) for toolbar highlighting.
+
+### Links & mentions
+
+`insertLink(url, label?)` links the selection (or inserts a linked label), `removeLink()` strips it. Typing a bare `http(s)://` URL followed by a space emits `onLinkDetected` — call `insertLink` if you want it linkified.
+
+Mentions start when a `mentionTriggers` character is typed at a word start: `onMentionStart` → `onMentionChange` (with the growing query) → `onMentionEnd`. Call `insertMention(trigger, label, url)` — e.g. `("@", "ali", "users://ali")` — to replace the query with an atomic token that deletes as one unit.
+
+### Paste
+
+Paste never inserts directly. `onPaste` receives `{ text?, images?, preventDefault() }` — images are reported (never auto-inserted) with `url`, `width`, `height`. Unless you call `preventDefault()` synchronously, the pasted text is parsed as markdown and inserted styled.
+
+### Everything else
+
+`getMarkdown()` resolves the current markdown; `focus()`, `blur()`, `setSelection(start, end)`, `setValue(markdown)`, and `insertMarkdown(markdown)` do what they say. Hardware keyboards get Cmd+B / Cmd+I (iOS) and Ctrl+B / Ctrl+I (Android). The editor shares the viewer's `style` / `styles` contract — the `base`/`paragraph` cascade drives the root text and `link.color` drives links. The viewer's `gap` is not applied while editing (a text field flows line to line); drive the editing feel with the text styles themselves.
+
+## Platform notes & limitations
+
+- New Architecture (Fabric) only; React Native 0.86+.
+- `textDecorationStyle`/`textDecorationColor` render fully on iOS; Android draws plain underline/strikethrough.
+- `borderCurve: 'continuous'` is iOS-only.
+- `fontVariant` supports `tabular-nums`, `proportional-nums`, `oldstyle-nums`, `lining-nums`, `small-caps` (font support required).
+- `allowFontScaling` (default `true`) scales all text — including `lineHeight` — with the system font size setting on both components.
+- Spoilers and inline formatting inside link labels stay literal; spoilers inside table cells are unsupported (the `|` delimiter conflicts).
+- Code blocks render plain monospace (no syntax highlighting).
+
+## Sponsors
+
+Development of react-native-jet-markdown is supported by:
+
+<table>
+  <tr>
+    <td align="center" width="200">
+      <a href="https://duet.so">
+        <img alt="Duet" src="https://github.com/alizahid/react-native-jet-markdown/blob/main/.github/duet.png?raw=true" width="96"><br>
+        <b>Duet</b>
+      </a>
+      <br>
+      <sub>Your AI coworker that runs your business 24/7</sub>
+    </td>
+    <td align="center" width="200">
+      <a href="https://acorn.blue">
+        <img alt="Acorn" src="https://github.com/alizahid/react-native-jet-markdown/blob/main/.github/acorn.png?raw=true" width="96"><br>
+        <b>Acorn</b>
+      </a>
+      <br>
+      <sub>Reddit for mobile</sub>
+    </td>
+  </tr>
+</table>
+
+## License
+
+MIT

package/android/CMakeLists.txt

@@ -0,0 +1,52 @@
+# Supersedes the codegen-generated CMakeLists (react-native.config.js points
+# autolinking here) so the library can compile the shared C++ core and swap
+# the codegen component descriptor for the custom measurable shadow node.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+set(lib_android_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(lib_cpp_DIR ${lib_android_DIR}/../cpp)
+set(lib_codegen_DIR ${lib_android_DIR}/build/generated/source/codegen/jni)
+
+file(GLOB codegen_SRCS CONFIGURE_DEPENDS
+  ${lib_codegen_DIR}/*.cpp
+  ${lib_codegen_DIR}/react/renderer/components/JetMarkdownViewSpec/*.cpp)
+# The custom descriptor in cpp/react/override replaces the generated one.
+list(FILTER codegen_SRCS EXCLUDE REGEX "ComponentDescriptors\\.cpp$")
+
+file(GLOB lib_SRCS CONFIGURE_DEPENDS
+  ${lib_cpp_DIR}/core/*.cpp
+  ${lib_cpp_DIR}/react/*.cpp)
+
+# md4c is C; keep it out of the C++-flagged reactnative target.
+add_library(jetmarkdown_md4c STATIC ${lib_cpp_DIR}/md4c/md4c.c)
+set_target_properties(jetmarkdown_md4c PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+add_library(
+  react_codegen_JetMarkdownViewSpec
+  OBJECT
+  ${codegen_SRCS}
+  ${lib_SRCS}
+  ${lib_android_DIR}/src/main/cpp/JniBindings.cpp
+)
+
+# The override directory must come first so
+# <react/renderer/components/JetMarkdownViewSpec/ComponentDescriptors.h>
+# resolves to the custom descriptor everywhere (autolinking included).
+target_include_directories(react_codegen_JetMarkdownViewSpec PUBLIC
+  ${lib_cpp_DIR}/react/override
+  ${lib_codegen_DIR}
+  ${lib_codegen_DIR}/react/renderer/components/JetMarkdownViewSpec
+  ${lib_cpp_DIR}
+)
+
+target_link_libraries(
+  react_codegen_JetMarkdownViewSpec
+  jetmarkdown_md4c
+  fbjni
+  jsi
+  reactnative
+)
+
+target_compile_reactnative_options(react_codegen_JetMarkdownViewSpec PRIVATE)

package/android/build.gradle

@@ -0,0 +1,55 @@
+buildscript {
+  ext.JetMarkdown = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return JetMarkdown[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.jetmarkdown"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  // Image pipeline (same core expo-image uses, same major version to avoid
+  // classpath conflicts): animated GIF, downsampling, memory + disk caches,
+  // request cancellation.
+  implementation "com.github.bumptech.glide:glide:5.0.5"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/JniBindings.cpp

@@ -0,0 +1,243 @@
+// JNI surface for com.jetmarkdown.JetMarkdownNative. This TU is linked
+// into the app's libappmodules.so (which owns JNI_OnLoad), so natives are
+// exported by name instead of registered from an OnLoad hook.
+//
+// Strings cross as UTF-8 byte arrays: JNI's NewStringUTF/GetStringUTFChars
+// speak modified UTF-8 and corrupt supplementary characters (emoji).
+
+#include <jni.h>
+#include <pthread.h>
+
+#include <string>
+#include <vector>
+
+#include "core/AstSerializer.h"
+#include "core/EditorRuns.h"
+#include "core/Parser.h"
+#include "react/JetMarkdownMeasurer.h"
+
+namespace {
+
+JavaVM* g_vm = nullptr;
+jobject g_measurer = nullptr;
+jmethodID g_measureMethod = nullptr;
+
+std::string toStdString(JNIEnv* env, jbyteArray value) {
+  if (value == nullptr) {
+    return {};
+  }
+  const jsize length = env->GetArrayLength(value);
+  std::string result(static_cast<size_t>(length), '\0');
+  if (length > 0) {
+    env->GetByteArrayRegion(value, 0, length, reinterpret_cast<jbyte*>(result.data()));
+  }
+  return result;
+}
+
+jbyteArray toByteArray(JNIEnv* env, const uint8_t* data, size_t size) {
+  jbyteArray result = env->NewByteArray(static_cast<jsize>(size));
+  if (result != nullptr && size > 0) {
+    env->SetByteArrayRegion(
+        result, 0, static_cast<jsize>(size), reinterpret_cast<const jbyte*>(data));
+  }
+  return result;
+}
+
+// Threads WE attach must detach before exiting or ART aborts the process
+// ("Native thread exiting without having called DetachCurrentThread"); a
+// pthread key destructor covers early exits.
+pthread_key_t g_detachKey;
+pthread_once_t g_detachKeyOnce = PTHREAD_ONCE_INIT;
+
+void detachCurrentThread(void*) {
+  if (g_vm != nullptr) {
+    g_vm->DetachCurrentThread();
+  }
+}
+
+void makeDetachKey() {
+  pthread_key_create(&g_detachKey, detachCurrentThread);
+}
+
+JNIEnv* currentEnv() {
+  if (g_vm == nullptr) {
+    return nullptr;
+  }
+  JNIEnv* env = nullptr;
+  const jint state = g_vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
+  if (state == JNI_EDETACHED) {
+    if (g_vm->AttachCurrentThread(&env, nullptr) != JNI_OK) {
+      return nullptr;
+    }
+    pthread_once(&g_detachKeyOnce, makeDetachKey);
+    pthread_setspecific(g_detachKey, env);
+  } else if (state != JNI_OK) {
+    return nullptr;
+  }
+  return env;
+}
+
+} // namespace
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_jetmarkdown_JetMarkdownNative_parse(JNIEnv* env, jclass, jbyteArray markdown) {
+  const std::string input = toStdString(env, markdown);
+  const auto document = jetmarkdown::parseMarkdown(input);
+  const std::vector<uint8_t> bytes = jetmarkdown::serializeAst(document->root);
+  return toByteArray(env, bytes.data(), bytes.size());
+}
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_jetmarkdown_JetMarkdownNative_markdownFromEditorContent(
+    JNIEnv* env,
+    jclass,
+    jbyteArray text,
+    jintArray runs,
+    jintArray lineBlocks,
+    jintArray linkRanges,
+    jbyteArray linkUrls) {
+  std::vector<jetmarkdown::StyledRun> styledRuns;
+  if (runs != nullptr) {
+    const jsize length = env->GetArrayLength(runs);
+    std::vector<jint> values(static_cast<size_t>(length));
+    if (length > 0) {
+      env->GetIntArrayRegion(runs, 0, length, values.data());
+    }
+    for (jsize i = 0; i + 2 < length; i += 3) {
+      styledRuns.push_back(
+          {static_cast<uint32_t>(values[i]),
+           static_cast<uint32_t>(values[i + 1]),
+           static_cast<uint32_t>(values[i + 2])});
+    }
+  }
+  std::vector<jetmarkdown::EditorLine> lines;
+  if (lineBlocks != nullptr) {
+    const jsize length = env->GetArrayLength(lineBlocks);
+    std::vector<jint> values(static_cast<size_t>(length));
+    if (length > 0) {
+      env->GetIntArrayRegion(lineBlocks, 0, length, values.data());
+    }
+    for (jsize i = 0; i + 1 < length; i += 2) {
+      lines.push_back(
+          {static_cast<jetmarkdown::EditorBlockType>(values[i]),
+           static_cast<uint8_t>(values[i + 1])});
+    }
+  }
+  // Link URLs cross as one newline-joined blob (URLs cannot contain '\n').
+  std::vector<jetmarkdown::LinkRun> links;
+  if (linkRanges != nullptr) {
+    const jsize length = env->GetArrayLength(linkRanges);
+    std::vector<jint> values(static_cast<size_t>(length));
+    if (length > 0) {
+      env->GetIntArrayRegion(linkRanges, 0, length, values.data());
+    }
+    const std::string urls = toStdString(env, linkUrls);
+    size_t urlStart = 0;
+    for (jsize i = 0; i + 1 < length; i += 2) {
+      const size_t urlEnd = urls.find('\n', urlStart);
+      links.push_back(
+          {static_cast<uint32_t>(values[i]),
+           static_cast<uint32_t>(values[i + 1]),
+           urls.substr(urlStart, urlEnd == std::string::npos ? std::string::npos
+                                                             : urlEnd - urlStart)});
+      urlStart = urlEnd == std::string::npos ? urls.size() : urlEnd + 1;
+    }
+  }
+  const std::string result = jetmarkdown::markdownFromEditor(
+      toStdString(env, text), styledRuns, lines, links);
+  return toByteArray(
+      env, reinterpret_cast<const uint8_t*>(result.data()), result.size());
+}
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_jetmarkdown_JetMarkdownNative_editorFromMarkdownContent(
+    JNIEnv* env,
+    jclass,
+    jbyteArray markdown) {
+  const jetmarkdown::EditorDocument document =
+      jetmarkdown::editorFromMarkdown(toStdString(env, markdown));
+  // [int32 runCount][runCount x (start, end, flags)][int32 lineCount]
+  // [lineCount x (type, level)][utf8 text], little-endian.
+  std::vector<uint8_t> bytes;
+  bytes.reserve(
+      8 + document.runs.size() * 12 + document.lines.size() * 8 +
+      document.text.size());
+  const auto push32 = [&bytes](uint32_t value) {
+    bytes.push_back(static_cast<uint8_t>(value & 0xFF));
+    bytes.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
+    bytes.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
+    bytes.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
+  };
+  push32(static_cast<uint32_t>(document.runs.size()));
+  for (const jetmarkdown::StyledRun& run : document.runs) {
+    push32(run.start);
+    push32(run.end);
+    push32(run.flags);
+  }
+  push32(static_cast<uint32_t>(document.lines.size()));
+  for (const jetmarkdown::EditorLine& line : document.lines) {
+    push32(static_cast<uint32_t>(line.type));
+    push32(line.level);
+  }
+  push32(static_cast<uint32_t>(document.links.size()));
+  for (const jetmarkdown::LinkRun& link : document.links) {
+    push32(link.start);
+    push32(link.end);
+    push32(static_cast<uint32_t>(link.url.size()));
+  }
+  for (const jetmarkdown::LinkRun& link : document.links) {
+    bytes.insert(bytes.end(), link.url.begin(), link.url.end());
+  }
+  bytes.insert(bytes.end(), document.text.begin(), document.text.end());
+  return toByteArray(env, bytes.data(), bytes.size());
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_jetmarkdown_JetMarkdownNative_installMeasurer(
+    JNIEnv* env,
+    jclass,
+    jobject measurer) {
+  env->GetJavaVM(&g_vm);
+  if (g_measurer != nullptr) {
+    env->DeleteGlobalRef(g_measurer);
+  }
+  g_measurer = env->NewGlobalRef(measurer);
+
+  jclass measurerClass = env->GetObjectClass(measurer);
+  g_measureMethod = env->GetMethodID(measurerClass, "measure", "([B[B[BFF)F");
+  env->DeleteLocalRef(measurerClass);
+
+  jetmarkdown::JetMarkdownMeasurer::shared().install(
+      [](const std::string& markdown,
+         const std::string& stylesJson,
+         const std::string& imagesJson,
+         float maxWidth,
+         float fontScale) -> float {
+        JNIEnv* jniEnv = currentEnv();
+        if (jniEnv == nullptr || g_measurer == nullptr || g_measureMethod == nullptr) {
+          return 0.0f;
+        }
+        jbyteArray jMarkdown = toByteArray(
+            jniEnv, reinterpret_cast<const uint8_t*>(markdown.data()), markdown.size());
+        jbyteArray jStyles = toByteArray(
+            jniEnv, reinterpret_cast<const uint8_t*>(stylesJson.data()), stylesJson.size());
+        jbyteArray jImages = toByteArray(
+            jniEnv, reinterpret_cast<const uint8_t*>(imagesJson.data()), imagesJson.size());
+        if (jMarkdown == nullptr || jStyles == nullptr || jImages == nullptr) {
+          // NewByteArray OOM leaves a pending exception; calling into Java
+          // with one pending is undefined behavior.
+          jniEnv->ExceptionClear();
+          return 0.0f;
+        }
+        const jfloat height = jniEnv->CallFloatMethod(
+            g_measurer, g_measureMethod, jMarkdown, jStyles, jImages, maxWidth, fontScale);
+        jniEnv->DeleteLocalRef(jMarkdown);
+        jniEnv->DeleteLocalRef(jStyles);
+        jniEnv->DeleteLocalRef(jImages);
+        if (jniEnv->ExceptionCheck()) {
+          jniEnv->ExceptionClear();
+          return 0.0f;
+        }
+        return static_cast<float>(height);
+      });
+}