react-native-marcus 0.1.1 → 0.2.0

package/lib/typescript/module/src/styleUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"styleUtils.d.ts","sourceRoot":"","sources":["../../../../src/styleUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAA;AAElF,KAAK,oBAAoB,GAAG,OAAO,CAAC;KACjC,CAAC,IAAI,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;CACtD,CAAC,CAAA;AAyEF,iBAAS,6BAA6B,CAAC,KAAK,EAAE,oBAAoB,GAAG,SAAS,GAAG,aAAa,CAiB7F;AAED,YAAY,EAAE,oBAAoB,EAAE,CAAA;AAEpC,OAAO,EAAE,6BAA6B,EAAE,CAAA"}
+{"version":3,"file":"styleUtils.d.ts","sourceRoot":"","sources":["../../../../src/styleUtils.ts"],"names":[],"mappings":"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"}

package/lib/typescript/module/src/web/utils/blockLayout.d.ts

@@ -1,5 +1,5 @@
 import type { MarkdownRange } from "../../commonTypes.js";
-import type { PartialMarkdownStyle } from "../../styleUtils.js";
+import type { ResolvedMarkdownStyle } from "../../styleUtils.js";
 import type { TextMeasurer } from "./measureUtils.js";
 /**
  * Where one line's text sits, and what has to be drawn in the space to its left.
@@ -16,7 +16,35 @@ type LineLayout = {
     /** Space to open after a marker, so the next container's gutter lands between the two. */
     gaps: Map<number, number>;
 };
+/**
+ * How a list's markers are drawn, which is the one thing a display does differently from an input.
+ *
+ * A display renders the marker rather than showing it: an unordered item's `-` becomes a bullet, an
+ * ordered item's `1.` stays the number it means but at its own scale, and both hold a little room
+ * either side. An input shows the marker you typed, in the base font, because there it is text
+ * being edited rather than a rendering of it. `MarkdownFormatter` draws the same distinction on
+ * both native platforms from the same style values.
+ *
+ * `fontSize` is what the wrapped element renders at, in pixels, which is what a marker is sized in
+ * proportion to.
+ */
+type MarkerRendering = {
+    display: boolean;
+    fontSize: number;
+};
+/** An input's markers, and the default everywhere the question does not arise. */
+declare const SHOWN_MARKERS: MarkerRendering;
 declare function toNumber(value: string | number | undefined | null): number;
+/**
+ * The marker at the end of a prefix: the `-` of a bullet or the `1.` of a numbered item, without
+ * the indent in front of it or the space after it.
+ *
+ * Read off the text rather than taken from the `syntax` range covering it, because a prefix runs
+ * from wherever the previous container's marker ended and so can carry another container's marker
+ * with it -- the ordered list in `- > 1. ` is handed `> 1. `. The last run of non-blanks is this
+ * container's own. `MarkdownFormatter` reads it the same way on both native platforms.
+ */
+declare function markerRun(prefix: string): string;
 /**
  * Places the containers of every line, left to right -- the web half of `BlockLayout` in
  * `apple/MarkdownFormatter.swift` and `android/.../MarkdownFormatter.kt`, and deliberately the same
@@ -35,7 +63,7 @@ declare function toNumber(value: string | number | undefined | null): number;
  * to -- so it has to run before `sortRanges` rearranges them into the containment order the DOM
  * builder needs.
  */
-declare function layoutBlocks(text: string, ranges: MarkdownRange[], markdownStyle: PartialMarkdownStyle, measure: TextMeasurer): Map<number, LineLayout>;
-export { layoutBlocks, toNumber };
-export type { LineLayout };
+declare function layoutBlocks(text: string, ranges: MarkdownRange[], markdownStyle: ResolvedMarkdownStyle, measure: TextMeasurer, rendering?: MarkerRendering): Map<number, LineLayout>;
+export { layoutBlocks, markerRun, SHOWN_MARKERS, toNumber };
+export type { LineLayout, MarkerRendering };
 //# sourceMappingURL=blockLayout.d.ts.map

package/lib/typescript/module/src/web/utils/blockLayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blockLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/blockLayout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,sBAAmB,CAAA;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAgB,CAAA;AAIlD;;;;;;;GAOG;AACH,KAAK,UAAU,GAAG;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,0FAA0F;IAC1F,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1B,CAAA;AAED,iBAAS,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CASnE;AA0BD;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,YAAY,CACnB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,EAAE,EACvB,aAAa,EAAE,oBAAoB,EACnC,OAAO,EAAE,YAAY,GACpB,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CA+EzB;AAED,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAA;AACjC,YAAY,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"blockLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/blockLayout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,sBAAmB,CAAA;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAkB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAgB,CAAA;AAIlD;;;;;;;GAOG;AACH,KAAK,UAAU,GAAG;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,0FAA0F;IAC1F,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1B,CAAA;AAED;;;;;;;;;;;GAWG;AACH,KAAK,eAAe,GAAG;IACrB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,kFAAkF;AAClF,QAAA,MAAM,aAAa,EAAE,eAAiD,CAAA;AAEtE,iBAAS,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CASnE;AAmDD;;;;;;;;GAQG;AACH,iBAAS,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKzC;AAoCD;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,YAAY,CACnB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,EAAE,EACvB,aAAa,EAAE,qBAAqB,EACpC,OAAO,EAAE,YAAY,EACrB,SAAS,GAAE,eAA+B,GACzC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CA6FzB;AAED,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAA;AAC3D,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,CAAA"}

package/lib/typescript/module/src/web/utils/blockUtils.d.ts

@@ -1,22 +1,34 @@
-import type { PartialMarkdownStyle } from "../../styleUtils.js";
-import type { LineLayout } from "./blockLayout.js";
+import type { ResolvedMarkdownStyle } from "../../styleUtils.js";
+import type { LineLayout, MarkerRendering } from "./blockLayout.js";
 import type { NodeType } from "./treeUtils.js";
 /**
  * Applies the layout the block walk computed for one line.
  *
- * Everything a container contributes lands here rather than on the container's own span: its gutter
+ * Everything a container contributes lands here rather than on the container's own element: its gutter
  * is part of the paragraph's indent, and its ribbon is painted behind the whole paragraph. That is
  * how the native formatters do it too, and on the web it is the only placement that works -- a
- * container's span begins before the markers of the containers outside it, so a border drawn on it
+ * container's element begins before the markers of the containers outside it, so a border drawn on it
  * would sit in front of a bullet that is meant to precede it, and a gutter set on it would open
  * before that bullet rather than after.
  *
- * `padding-left` holds every line of the paragraph at the indent, and the negative `text-indent`
+ * `padding-inline-start` holds every line of the paragraph at the indent, and the negative `text-indent`
  * pulls the first one back to where its own marker starts -- `firstLineHeadIndent` and `headIndent`,
  * spelled in CSS. A line that wraps, or a line continuing the block with no marker of its own, then
  * lines up with the text above it instead of with the marker.
  */
-declare function addLineLayout(node: HTMLElement, layout: LineLayout | undefined, markdownStyle: PartialMarkdownStyle): void;
+declare function addLineLayout(node: HTMLElement, layout: LineLayout | undefined, markdownStyle: ResolvedMarkdownStyle): void;
+/**
+ * Turns a line's ribbons round when the line reads right to left.
+ *
+ * Asked of the browser rather than worked out from the text, because the browser is what lays the
+ * line out: whatever it resolved `dir="auto"` to is where it put the gutter, and the bars belong on
+ * that side whether or not a bidi rule written here would have agreed. `:dir()` is unsupported in
+ * browsers older than Safari 16.4, where `matches` throws and the fallback edge stands.
+ *
+ * Called once the line holds its text, since that is what a line's own direction is read from, and
+ * only for a line that has ribbons: nothing else on a line is measured from an edge.
+ */
+declare function setRibbonEdge(node: HTMLElement, layout: LineLayout | undefined): void;
 /**
  * Opens the space a marker holds for the container that follows it.
  *
@@ -24,10 +36,10 @@ declare function addLineLayout(node: HTMLElement, layout: LineLayout | undefined
  * puts a nested list's indent between the quote's `>` and the bullet rather than in front of both.
  */
 declare function addBlockPrefixGap(node: HTMLElement, gap: number | undefined): void;
-declare function addStyleToBlock(targetElement: HTMLElement, type: NodeType, markdownStyle: PartialMarkdownStyle, isMultiline?: boolean): void;
+declare function addStyleToBlock(targetElement: HTMLElement, type: NodeType, markdownStyle: ResolvedMarkdownStyle, isMultiline?: boolean, rendering?: MarkerRendering): void;
 declare const MULTILINE_MARKDOWN_TYPES: string[];
 declare function isMultilineMarkdownType(type: NodeType): boolean;
 declare function isChildOfMarkdownElement(node: HTMLElement, elementType: NodeType): boolean;
 declare function isChildOfMultilineMarkdownElement(node: HTMLElement): boolean;
-export { addStyleToBlock, addLineLayout, addBlockPrefixGap, isMultilineMarkdownType, isChildOfMarkdownElement, isChildOfMultilineMarkdownElement, MULTILINE_MARKDOWN_TYPES, };
+export { addStyleToBlock, addLineLayout, setRibbonEdge, addBlockPrefixGap, isMultilineMarkdownType, isChildOfMarkdownElement, isChildOfMultilineMarkdownElement, MULTILINE_MARKDOWN_TYPES, };
 //# sourceMappingURL=blockUtils.d.ts.map

package/lib/typescript/module/src/web/utils/blockUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blockUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/blockUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAkB,CAAA;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAe,CAAA;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAa,CAAA;AAqB3C;;;;;;;;;;;;;;GAcG;AACH,iBAAS,aAAa,CACpB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,aAAa,EAAE,oBAAoB,QAiCpC;AAED;;;;;GAKG;AACH,iBAAS,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,QAIpE;AAED,iBAAS,eAAe,CACtB,aAAa,EAAE,WAAW,EAC1B,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,oBAAoB,EACnC,WAAW,UAAO,QAiFnB;AAgCD,QAAA,MAAM,wBAAwB,UAAgB,CAAA;AAE9C,iBAAS,uBAAuB,CAAC,IAAI,EAAE,QAAQ,WAE9C;AAiBD,iBAAS,wBAAwB,CAAC,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAEnF;AACD,iBAAS,iCAAiC,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAIrE;AAED,OAAO,EACL,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,iCAAiC,EACjC,wBAAwB,GACzB,CAAA"}
+{"version":3,"file":"blockUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/blockUtils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAkB,CAAA;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAe,CAAA;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAa,CAAA;AAiH3C;;;;;;;;;;;;;;GAcG;AACH,iBAAS,aAAa,CACpB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,aAAa,EAAE,qBAAqB,QA4CrC;AAiBD;;;;;;;;;;GAUG;AACH,iBAAS,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,SAAS,QAYvE;AAwBD;;;;;GAKG;AACH,iBAAS,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,QAOpE;AAED,iBAAS,eAAe,CACtB,aAAa,EAAE,WAAW,EAC1B,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,qBAAqB,EACpC,WAAW,UAAO,EAClB,SAAS,GAAE,eAA+B,QA+F3C;AAsJD,QAAA,MAAM,wBAAwB,UAAgB,CAAA;AAE9C,iBAAS,uBAAuB,CAAC,IAAI,EAAE,QAAQ,WAE9C;AAiBD,iBAAS,wBAAwB,CAAC,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAEnF;AACD,iBAAS,iCAAiC,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAIrE;AAED,OAAO,EACL,eAAe,EACf,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,iCAAiC,EACjC,wBAAwB,GACzB,CAAA"}

package/lib/typescript/module/src/web/utils/elementUtils.d.ts

@@ -0,0 +1,37 @@
+import type { HTMLMarkdownElement } from "../../MarkdownTextInput.web.js";
+import type { NodeType } from "./treeUtils.js";
+/**
+ * The tag each markdown type is built as.
+ *
+ * A range says what a run of text *is*; the element it becomes should say the same thing to
+ * everything that reads the document rather than looking at it. A screen reader announces a
+ * `<strong>` and a `<blockquote>` and says nothing about a span; text copied out of the input
+ * arrives in another editor still emphasised; and the page `expo export` prerenders carries the
+ * structure rather than a wall of undifferentiated spans.
+ *
+ * `data-type` stays on every one of them regardless -- it is what the styling, the CSS and the
+ * render-model baselines are keyed on, and it distinguishes the several types that share a tag.
+ *
+ * Two pairings are worth spelling out. A fenced or indented block is `<pre>` from `codeblock`, the
+ * range covering the whole thing including its fences, with `<code>` inside it from `pre`, the
+ * range covering only the code -- which is the nesting HTML asks for, in the opposite naming to
+ * ours. And `link` is an anchor even in the input, where it has no `href` yet: an anchor without
+ * one is exactly what HTML has for a link whose destination is not resolved.
+ *
+ * Everything absent from here is a span, because HTML has nothing that means it: markdown's own
+ * punctuation, the parts of a link's markup, a mention, an emoji run.
+ */
+/** Marks an element as one of ours, for the rules that undo the tag's browser defaults. */
+declare const ELEMENT_CLASS = "react-native-marcus";
+declare function isBlockLevelType(type: NodeType): boolean;
+/**
+ * Builds the element for a range, tagged and typed.
+ *
+ * `level` applies to headings only, and is the ATX level: `1` through `6` produce that heading,
+ * and `0` produces a span. A level arrives as one nested range per level -- `ungroupRanges` is what
+ * turns `depth` into the nesting the size scaling compounds down -- so only the outermost of them
+ * can be the heading itself, and the copies inside it are spans. `<h2><h2>` is not a thing.
+ */
+declare function createMarkdownElement(type: NodeType, level?: number): HTMLMarkdownElement;
+export { createMarkdownElement, isBlockLevelType, ELEMENT_CLASS };
+//# sourceMappingURL=elementUtils.d.ts.map

package/lib/typescript/module/src/web/utils/elementUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/elementUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAa,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2FAA2F;AAC3F,QAAA,MAAM,aAAa,wBAAwB,CAAA;AAgC3C,iBAAS,gBAAgB,CAAC,IAAI,EAAE,QAAQ,WAEvC;AAED;;;;;;;GAOG;AACH,iBAAS,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,SAAI,GAAG,mBAAmB,CAe7E;AAED,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,aAAa,EAAE,CAAA"}

package/lib/typescript/module/src/web/utils/parserUtils.d.ts

@@ -1,7 +1,7 @@
 import type { HTMLMarkdownElement, MarkdownTextInputElement } from "../../MarkdownTextInput.web.js";
 import type { TreeNode } from "./treeUtils.js";
-import type { PartialMarkdownStyle } from "../../styleUtils.js";
-import type { LineLayout } from "./blockLayout.js";
+import type { ResolvedMarkdownStyle } from "../../styleUtils.js";
+import type { LineLayout, MarkerRendering } from "./blockLayout.js";
 import type { TextMeasurer } from "./measureUtils.js";
 import type { MarkdownRange } from "../../commonTypes.js";
 type Paragraph = {
@@ -18,7 +18,7 @@ type Paragraph = {
  */
 declare function normalizeLines(lines: Paragraph[], ranges: MarkdownRange[]): Paragraph[];
 /** Builds HTML DOM structure based on passed text and markdown ranges */
-declare function parseRangesToHTMLNodes(text: string, ranges: MarkdownRange[], isMultiline?: boolean, markdownStyle?: PartialMarkdownStyle, disableInlineStyles?: boolean, measure?: TextMeasurer): {
+declare function parseRangesToHTMLNodes(text: string, ranges: MarkdownRange[], isMultiline?: boolean, markdownStyle?: ResolvedMarkdownStyle, disableInlineStyles?: boolean, measure?: TextMeasurer, rendering?: MarkerRendering): {
     dom: HTMLMarkdownElement;
     tree: TreeNode;
 };
@@ -31,11 +31,11 @@ type CachedLine = {
     node: TreeNode;
 };
 type LineCache = {
-    markdownStyle: PartialMarkdownStyle;
+    markdownStyle: ResolvedMarkdownStyle;
     isMultiline: boolean;
     lines: CachedLine[];
 };
-declare function updateInputStructure(parserFunction: (input: string) => MarkdownRange[], target: MarkdownTextInputElement, text: string, cursorPositionIndex: number | null, isMultiline?: boolean, markdownStyle?: PartialMarkdownStyle, alwaysMoveCursorToTheEnd?: boolean, shouldForceDOMUpdate?: boolean, shouldScrollIntoView?: boolean): {
+declare function updateInputStructure(parserFunction: (input: string) => MarkdownRange[], target: MarkdownTextInputElement, text: string, cursorPositionIndex: number | null, isMultiline?: boolean, markdownStyle?: ResolvedMarkdownStyle, alwaysMoveCursorToTheEnd?: boolean, shouldForceDOMUpdate?: boolean, shouldScrollIntoView?: boolean): {
     text: string;
     cursorPosition: number;
 };

package/lib/typescript/module/src/web/utils/parserUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parserUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/parserUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,gCAA6B,CAAA;AAEhG,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,gBAAa,CAAA;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAkB,CAAA;AAS5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAe,CAAA;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAgB,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,sBAAmB,CAAA;AAGpE,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,aAAa,EAAE,CAAA;IAC/B,qFAAqF;IACrF,MAAM,CAAC,EAAE,UAAU,CAAA;CACpB,CAAA;AAmFD;;;GAGG;AACH,iBAAS,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,eA2BlE;AA2SD,yEAAyE;AACzE,iBAAS,sBAAsB,CAC7B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,EAAE,EACvB,WAAW,UAAO,EAClB,aAAa,GAAE,oBAAyB,EACxC,mBAAmB,UAAQ,EAC3B,OAAO,GAAE,YAAuC;;;EAyBjD;AAED;;GAEG;AACH,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,QAAQ,CAAA;CACf,CAAA;AAED,KAAK,SAAS,GAAG;IACf,aAAa,EAAE,oBAAoB,CAAA;IACnC,WAAW,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB,CAAA;AA0QD,iBAAS,oBAAoB,CAC3B,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,aAAa,EAAE,EAClD,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,EACZ,mBAAmB,EAAE,MAAM,GAAG,IAAI,EAClC,WAAW,UAAO,EAClB,aAAa,GAAE,oBAAyB,EACxC,wBAAwB,UAAQ,EAChC,oBAAoB,UAAQ,EAC5B,oBAAoB,UAAQ;;;EAiD7B;AAED,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,cAAc,EAAE,CAAA;AACvE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,CAAA"}
+{"version":3,"file":"parserUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/parserUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,gCAA6B,CAAA;AAEhG,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,gBAAa,CAAA;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAkB,CAAA;AAW7D,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAe,CAAA;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAgB,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,sBAAmB,CAAA;AAGpE,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,aAAa,EAAE,CAAA;IAC/B,qFAAqF;IACrF,MAAM,CAAC,EAAE,UAAU,CAAA;CACpB,CAAA;AAmFD;;;GAGG;AACH,iBAAS,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,eA2BlE;AA6XD,yEAAyE;AACzE,iBAAS,sBAAsB,CAC7B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,EAAE,EACvB,WAAW,UAAO,EAClB,aAAa,GAAE,qBAA0B,EACzC,mBAAmB,UAAQ,EAC3B,OAAO,GAAE,YAAuC,EAChD,SAAS,GAAE,eAA+B;;;EA0B3C;AAED;;GAEG;AACH,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,QAAQ,CAAA;CACf,CAAA;AAED,KAAK,SAAS,GAAG;IACf,aAAa,EAAE,qBAAqB,CAAA;IACpC,WAAW,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB,CAAA;AA4QD,iBAAS,oBAAoB,CAC3B,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,aAAa,EAAE,EAClD,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,EACZ,mBAAmB,EAAE,MAAM,GAAG,IAAI,EAClC,WAAW,UAAO,EAClB,aAAa,GAAE,qBAA0B,EACzC,wBAAwB,UAAQ,EAChC,oBAAoB,UAAQ,EAC5B,oBAAoB,UAAQ;;;EAiD7B;AAED,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,cAAc,EAAE,CAAA;AACvE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,CAAA"}

package/lib/typescript/module/src/web/utils/treeUtils.d.ts

@@ -1,6 +1,11 @@
 import type { HTMLMarkdownElement } from "../../MarkdownTextInput.web.js";
 import type { MarkdownRange, MarkdownType } from "../../commonTypes.js";
-type NodeType = MarkdownType | "line" | "text" | "br" | "root";
+/**
+ * `list-item` is the one node with no range behind it: `<ul>` and `<ol>` may hold nothing but
+ * `<li>`, so the builder puts one inside each list container and everything the container holds
+ * goes in there. It covers exactly what its container does.
+ */
+type NodeType = MarkdownType | "line" | "text" | "br" | "root" | "list-item";
 type TreeNode = Omit<MarkdownRange, "type"> & {
     element: HTMLMarkdownElement;
     parentNode: TreeNode | null;

package/lib/typescript/module/src/web/utils/treeUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/treeUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,sBAAmB,CAAA;AAEpE,KAAK,QAAQ,GAAG,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAAA;AAE9D,KAAK,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,GAAG;IAC5C,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,QAAQ,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,QAAQ,EAAE,CAAA;IACtB,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,mBAAmB,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,iBAAS,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,EAAE,MAAM,SAAI,EAAE,KAAK,SAAI,GAAG,QAAQ,CAWxF;AAED;;;;;;GAMG;AACH,iBAAS,aAAa,CACpB,OAAO,EAAE,mBAAmB,EAC5B,cAAc,EAAE,QAAQ,EACxB,IAAI,EAAE,QAAQ,EACd,MAAM,GAAE,MAAM,GAAG,IAAW,EAC5B,KAAK,GAAE,MAAM,GAAG,IAAW,YAyC5B;AAED,iBAAS,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,GAAG,QAAQ,GAAG,IAAI,CAuBxF;AAED,iBAAS,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAqC9E;AAED,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAA;AAEvF,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"treeUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/treeUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,sBAAmB,CAAA;AAEpE;;;;GAIG;AACH,KAAK,QAAQ,GAAG,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,WAAW,CAAA;AAE5E,KAAK,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,GAAG;IAC5C,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,QAAQ,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,QAAQ,EAAE,CAAA;IACtB,IAAI,EAAE,QAAQ,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,mBAAmB,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,iBAAS,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,EAAE,MAAM,SAAI,EAAE,KAAK,SAAI,GAAG,QAAQ,CAWxF;AAED;;;;;;GAMG;AACH,iBAAS,aAAa,CACpB,OAAO,EAAE,mBAAmB,EAC5B,cAAc,EAAE,QAAQ,EACxB,IAAI,EAAE,QAAQ,EACd,MAAM,GAAE,MAAM,GAAG,IAAW,EAC5B,KAAK,GAAE,MAAM,GAAG,IAAW,YAyC5B;AAED,iBAAS,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,GAAG,QAAQ,GAAG,IAAI,CAuBxF;AAED,iBAAS,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAqC9E;AAED,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAA;AAEvF,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAA"}

package/lib/typescript/module/src/web/utils/webStyleUtils.d.ts

@@ -1,6 +1,6 @@
 import type { TextStyle } from "react-native";
-import type { MarkdownStyle } from "../../MarcusTextInputDecoratorViewNativeComponent";
-declare function processMarkdownStyle(input: MarkdownStyle | undefined): MarkdownStyle;
+import type { PartialMarkdownStyle, ResolvedMarkdownStyle } from "../../styleUtils.js";
+declare function processMarkdownStyle(input: PartialMarkdownStyle | undefined): ResolvedMarkdownStyle;
 declare function parseToReactDOMStyle(style: TextStyle): any;
 declare const idGenerator: Generator<string, void, unknown>;
 export { parseToReactDOMStyle, processMarkdownStyle, idGenerator };

package/lib/typescript/module/src/web/utils/webStyleUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webStyleUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/webStyleUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mDAAmD,CAAA;AAiDtF,iBAAS,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,aAAa,CAE7E;AAED,iBAAS,oBAAoB,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG,CAEnD;AASD,QAAA,MAAM,WAAW,kCAAqB,CAAA;AAEtC,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"webStyleUtils.d.ts","sourceRoot":"","sources":["../../../../../../src/web/utils/webStyleUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,qBAAkB,CAAA;AAwEnF,iBAAS,oBAAoB,CAAC,KAAK,EAAE,oBAAoB,GAAG,SAAS,GAAG,qBAAqB,CAE5F;AAED,iBAAS,oBAAoB,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG,CAEnD;AASD,QAAA,MAAM,WAAW,kCAAqB,CAAA;AAEtC,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,WAAW,EAAE,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-marcus",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Drop-in replacement for React Native's TextInput component with Markdown formatting.",
   "author": {
     "name": "Tomas Ravinskas",
@@ -33,6 +33,16 @@
         "default": "./lib/commonjs/index.js"
       }
     },
+    "./metro": {
+      "import": {
+        "types": "./lib/typescript/module/src/metro.d.ts",
+        "default": "./lib/module/metro.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/src/metro.d.ts",
+        "default": "./lib/commonjs/metro.js"
+      }
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -88,22 +98,36 @@
     "markdown"
   ],
   "peerDependencies": {
+    "@mathjax/src": "^4.1.0",
+    "speech-rule-engine": "^5.0.0-rc.4",
     "react": "*",
+    "react-dom": "*",
     "react-native": ">=0.81",
     "react-native-web": "^0.21.0",
     "react-native-worklets": ">=0.7.0"
   },
   "peerDependenciesMeta": {
+    "@mathjax/src": {
+      "optional": true
+    },
+    "speech-rule-engine": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
     "react-native-web": {
       "optional": true
     }
   },
   "devDependencies": {
+    "@mathjax/src": "^4.1.3",
     "@playwright/test": "^1.62.1",
     "@react-native/babel-preset": "^0.86.3",
     "@react-native/jest-preset": "^0.86.3",
     "@types/jest": "^29.5.14",
     "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.7",
     "del-cli": "^7.0.0",
     "detox": "^20.51.4",
     "emoji-regex": "^10.6.0",
@@ -115,6 +139,7 @@
     "mdast-util-from-markdown": "^2.0.3",
     "micromark-extension-gfm-autolink-literal": "^2.1.0",
     "micromark-extension-gfm-strikethrough": "^2.1.0",
+    "micromark-extension-math": "^3.1.0",
     "nodemon": "^3.1.14",
     "patch-package": "^8.0.0",
     "prettier": "2.8.8",
@@ -124,6 +149,7 @@
     "react-native-builder-bob": "^0.43.0",
     "react-native-web": "^0.21.2",
     "react-native-worklets": "0.10.1",
+    "speech-rule-engine": "5.0.0-rc.4",
     "tsx": "^4.23.13",
     "typescript": "~6.0.3"
   },
@@ -160,7 +186,8 @@
     },
     "ios": {
       "componentProvider": {
-        "MarcusTextInputDecoratorView": "MarcusTextInputDecoratorComponentView"
+        "MarcusTextInputDecoratorView": "MarcusTextInputDecoratorComponentView",
+        "MarcusTextDecoratorView": "MarcusTextDecoratorComponentView"
       }
     }
   }

package/react-native.config.js

@@ -2,7 +2,14 @@ module.exports = {
   dependency: {
     platforms: {
       android: {
-        componentDescriptors: ["MarcusTextInputDecoratorViewComponentDescriptor"],
+        // Listed by hand because autolinking skips any component declared
+        // `interfaceOnly`, and both of these are. Without this the descriptor is
+        // never registered, the decorator falls back to a plain view -- which
+        // `display: contents` then flattens away -- and no markdown is applied.
+        componentDescriptors: [
+          "MarcusTextInputDecoratorViewComponentDescriptor",
+          "MarcusTextDecoratorViewComponentDescriptor",
+        ],
         cmakeListsPath: "../android/src/main/new_arch/CMakeLists.txt",
       },
     },

package/src/MarcusTextDecoratorViewNativeComponent.ts

@@ -0,0 +1,199 @@
+import { codegenNativeComponent } from "react-native"
+import type { ColorValue, ViewProps } from "react-native"
+
+import type { Float, Int32 } from "react-native/Libraries/Types/CodegenTypes"
+
+import type { MarkdownStyle as TextInputMarkdownStyle } from "./MarcusTextInputDecoratorViewNativeComponent"
+
+// Codegen parses each `*NativeComponent` file on its own and does not follow
+// imports, so the style has to be spelled out again rather than shared with
+// `MarcusTextInputDecoratorViewNativeComponent`. The assertion further down is
+// what keeps the copy honest: the two have to stay assignable in both
+// directions or `tsc --noEmit` fails.
+
+// The text attributes one styled run can carry: the subset of React Native's
+// `TextStyle` that survives as an `NSAttributedString` attribute on iOS, as a
+// span on Android, and as a declaration on an inline element on the web.
+//
+// Everything here is optional and everything unset is inherited, which is what a
+// run of markdown wants -- a mention that only names a colour keeps the face,
+// the size and the weight of the prose it sits in. Native reads "unset" off the
+// zero value: an empty string, a null colour, a zero length. That costs nothing,
+// because a zero-length `letterSpacing`, `lineHeight` or `fontSize` means the
+// same as leaving it out.
+//
+// `fontWeight`, `fontStyle`, `textDecorationLine` and `textDecorationStyle`
+// arrive as plain strings rather than as unions. Codegen turns a union of string
+// literals into an enum named after the prop it was found on, so the same
+// spelling on twelve entries would become twelve unrelated C++ types and the one
+// conversion template in `RCTMarcusStyle+Codegen.h` could not read any of them.
+// The public type in `styleUtils` is the narrow one; this is the wire.
+interface MarkdownTextStyle {
+  color?: ColorValue
+  fontFamily?: string
+  fontSize?: Float
+  fontStyle?: string
+  fontWeight?: string
+  letterSpacing?: Float
+  // Applies to whole lines: the platforms set it on the paragraph, so a range
+  // covering part of a line raises the height of all of it.
+  lineHeight?: Float
+  textDecorationLine?: string
+  // iOS and web only. Android draws an underline and a strikethrough in the text
+  // colour and offers no way to say otherwise.
+  textDecorationColor?: ColorValue
+  textDecorationStyle?: string
+  textShadowColor?: ColorValue
+  textShadowOffset?: { width: Float; height: Float }
+  textShadowRadius?: Float
+}
+
+// A run drawn as a box rather than as a background behind the glyphs: an inline
+// or fenced run of code, or a mention's pill. Rounded, optionally bordered, with
+// room inside it and around it, on top of whatever text attributes it carries.
+//
+// What the room holds open differs, because a block owns its lines and a run
+// shares one. A block's padding and margin are held open on the leading edge and
+// vertically, and a line long enough to wrap reaches the padding on the trailing
+// edge rather than stopping in front of it: neither platform can reserve a
+// trailing indent per paragraph. An inline run holds its padding and margin open
+// on both sides, by widening the characters it starts and ends with, and grows
+// into the line's own spacing above and below rather than pushing the lines
+// apart.
+//
+// `padding` is the fallback for both axes; `paddingHorizontal` and
+// `paddingVertical` win over it where they are set, and `margin` the same. A
+// fenced block usually wants more room above and below than beside it, and one
+// number cannot say that.
+interface MarkdownBoxStyle extends MarkdownTextStyle {
+  backgroundColor?: ColorValue
+  borderColor?: ColorValue
+  borderWidth?: Float
+  borderRadius?: Float
+  padding?: Float
+  paddingHorizontal?: Float
+  paddingVertical?: Float
+  margin?: Float
+  marginHorizontal?: Float
+  marginVertical?: Float
+}
+
+interface MarkdownHeadingStyle extends MarkdownTextStyle {
+  // Each level down multiplies the one above, so level N is
+  // fontSize * scale^(N - 1). Six levels, matching HTML.
+  scale?: Float
+}
+
+// The bar beside a quoted block, the indent it opens, and the text inside it.
+//
+// `marginStart` and `paddingStart` rather than `marginLeft`/`paddingLeft`
+// because the gutter opens on the line's leading edge, which is the right-hand
+// side of a right-to-left paragraph. Both platforms already indent from the
+// leading edge -- `NSParagraphStyle`'s head indent and Android's leading margin
+// are both writing-direction relative -- so the names now say what was always
+// drawn, and the web builder resolves them to `padding-inline-start`.
+interface MarkdownBlockquoteStyle extends MarkdownTextStyle {
+  borderColor?: ColorValue
+  borderWidth?: Float
+  // Rounds the bar's ends. A bar whose radius is half its width comes out a
+  // capsule.
+  borderRadius?: Float
+  marginStart?: Float
+  paddingStart?: Float
+}
+
+// Indent, and the marker that sits in the gutter it opens. Kept as two separate
+// entries so a renderer can style ordered and unordered lists differently, which
+// is exactly what `markerScale` ends up meaning: an ordered item's number is
+// text, an unordered item's bullet is a shape.
+//
+// Both markers are sized from the base font -- the size the wrapped `Text`
+// renders at -- rather than from a size of their own, so a list marks itself in
+// proportion to the prose it marks however that prose is sized. `marker` styles
+// the marker itself, and what it leaves unset falls back to `syntax`, which is
+// where a marker's colour came from before this entry existed.
+//
+// Only `MarkdownText` draws them. An input shows the marker you typed, in the
+// base font, because it is text you are editing rather than a rendering of it.
+interface MarkdownListStyle {
+  marginStart?: Float
+  paddingStart?: Float
+  // An ordered item's number is drawn at this fraction of the base font size; an
+  // unordered item's bullet takes it as a diameter, as a fraction of the same.
+  markerScale?: Float
+  // Room held open either side of the marker, between the gutter and the text.
+  markerPadding?: Float
+  marker?: MarkdownTextStyle
+}
+
+// Left as the two values it always was rather than folded into
+// `MarkdownTextStyle`: an emoji run is swapped onto a font that has the glyph
+// and sized to sit with the prose, and nothing else about it is worth saying.
+interface MarkdownEmojiStyle {
+  fontSize?: Float
+  fontFamily?: string
+}
+
+interface MarkdownStyle {
+  syntax: MarkdownTextStyle
+  emoji: MarkdownEmojiStyle
+  link: MarkdownTextStyle
+  strong: MarkdownTextStyle
+  emphasis: MarkdownTextStyle
+  strikethrough: MarkdownTextStyle
+  heading: MarkdownHeadingStyle
+  blockquote: MarkdownBlockquoteStyle
+  orderedList: MarkdownListStyle
+  unorderedList: MarkdownListStyle
+  code: MarkdownBoxStyle
+  pre: MarkdownBoxStyle
+  // A name with an `@` in front of it, drawn as a pill: the same inline box an
+  // inline run of code sits in, and so the same lengths.
+  mention: MarkdownBoxStyle
+}
+
+// `MarkdownRange` with `depth` filled in: codegen has no optional numbers, and
+// the formatters read a missing depth as zero anyway.
+interface MarkdownRangeStruct {
+  type: string
+  start: Int32
+  length: Int32
+  depth: Int32
+}
+
+// What one placeholder character copies as. `index` is its offset in the
+// stripped text -- the same string the ranges are measured against -- and
+// `text` is the markdown it was written as, which is what the platform puts on
+// the clipboard in its place.
+interface MarkdownSubstitutionStruct {
+  index: Int32
+  text: string
+}
+
+interface NativeProps extends ViewProps {
+  markdownStyle: MarkdownStyle
+  // The parse result, already stripped of syntax and remapped onto the text the
+  // child `Text` is rendering. Unlike the input decorator there is no parser to
+  // register: a `Text`'s content only ever changes by a re-render, so JS always
+  // knows the string and can hand over finished ranges.
+  ranges: ReadonlyArray<MarkdownRangeStruct>
+  // Every drawing in the text, and the source it copies as. A view mounted in a
+  // `Text` is one U+FFFC in the string the platform lays out, and that is what
+  // both platforms would otherwise hand to the clipboard: an equation copies as
+  // an empty box. Only the display needs this -- an input has the source on the
+  // screen already, and copies it by doing nothing.
+  substitutions: ReadonlyArray<MarkdownSubstitutionStruct>
+}
+
+type Assignable<A extends B, B> = A
+
+type StyleMatchesTextInput = [
+  Assignable<MarkdownStyle, TextInputMarkdownStyle>,
+  Assignable<TextInputMarkdownStyle, MarkdownStyle>,
+]
+
+export default codegenNativeComponent<NativeProps>("MarcusTextDecoratorView", {
+  interfaceOnly: true,
+})
+
+export type { MarkdownRangeStruct, MarkdownSubstitutionStruct, StyleMatchesTextInput }