react-native-marcus 0.1.0 → 0.2.0

package/lib/typescript/module/src/MarkdownTextInput.web.d.ts

@@ -3,12 +3,34 @@ import React from "react";
 import type { MouseEvent } from "react";
 import type { LineCache } from "./web/utils/parserUtils.js";
 import type { TreeNode } from "./web/utils/treeUtils.js";
+import "./web/MarkdownElements.css";
 import "./web/MarkdownTextInput.css";
-import type { MarkdownStyle } from "./MarcusTextInputDecoratorViewNativeComponent";
-import type { MarkdownRange } from "./commonTypes.js";
+import type { PartialMarkdownStyle } from "./styleUtils.js";
 interface MarkdownTextInputProps extends TextInputProps {
-    markdownStyle?: MarkdownStyle;
-    parser: (text: string) => MarkdownRange[];
+    markdownStyle?: PartialMarkdownStyle;
+    /**
+     * GFM's strikethrough (`~~a~~`) and bare autolinks (`www.example.com`).
+     *
+     * @default false
+     */
+    gfm?: boolean;
+    /**
+     * `@name` mentions, which no flavour of markdown has a notion of.
+     *
+     * @default false
+     */
+    mention?: boolean;
+    /**
+     * LaTeX between double dollar signs: `$$x^2$$` inline, and the same on lines
+     * of its own for a block.
+     *
+     * An input shows what was typed, so the maths stays as written -- what this
+     * turns on is recognising it, which greys the dollars as the markup they are
+     * and leaves the TeX between them alone.
+     *
+     * @default false
+     */
+    math?: boolean;
     onClick?: (e: MouseEvent<HTMLDivElement>) => void;
     dir?: string;
     disabled?: boolean;

package/lib/typescript/module/src/MarkdownTextInput.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownTextInput.web.d.ts","sourceRoot":"","sources":["../../../../src/MarkdownTextInput.web.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,SAAS,EAKT,cAAc,EAKf,MAAM,cAAc,CAAA;AACrB,OAAO,KAAmE,MAAM,OAAO,CAAA;AACvF,OAAO,KAAK,EAKV,UAAU,EAKX,MAAM,OAAO,CAAA;AAGd,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAAyB,CAAA;AAExD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAAuB,CAAA;AAMrD,OAAO,6BAA6B,CAAA;AACpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAA;AAalF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAe,CAAA;AAIlD,UAAU,sBAAuB,SAAQ,cAAc;IACrD,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,aAAa,EAAE,CAAA;IACzC,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,cAAc,CAAC,KAAK,IAAI,CAAA;IACjD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,UAAU,mBAAoB,SAAQ,KAAK;IACzC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,KAAK,iBAAiB,GAAG,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAA;AAE5E,KAAK,SAAS,GAAG;IACf,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAcD,KAAK,wBAAwB,GAAG,cAAc,GAC5C,gBAAgB,GAAG;IACjB,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;IACpB,kGAAkG;IAClG,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB,CAAA;AAEH,KAAK,mBAAmB,GAAG,WAAW,GAAG;IACvC,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,QAAA,MAAM,iBAAiB,kGAmzBtB,CAAA;AAwBD,eAAe,iBAAiB,CAAA;AAEhC,YAAY,EACV,mBAAmB,EACnB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,GACpB,CAAA;AAED,iBAAS,iBAAiB,SAIzB;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"MarkdownTextInput.web.d.ts","sourceRoot":"","sources":["../../../../src/MarkdownTextInput.web.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,SAAS,EAKT,cAAc,EAKf,MAAM,cAAc,CAAA;AACrB,OAAO,KAAmE,MAAM,OAAO,CAAA;AACvF,OAAO,KAAK,EAKV,UAAU,EAKX,MAAM,OAAO,CAAA;AAGd,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAAyB,CAAA;AAExD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAAuB,CAAA;AAMrD,OAAO,4BAA4B,CAAA;AACnC,OAAO,6BAA6B,CAAA;AACpC,OAAO,KAAK,EAAE,oBAAoB,EAAyB,MAAM,iBAAc,CAAA;AAkB/E,UAAU,sBAAuB,SAAQ,cAAc;IACrD,aAAa,CAAC,EAAE,oBAAoB,CAAA;IACpC;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,cAAc,CAAC,KAAK,IAAI,CAAA;IACjD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,UAAU,mBAAoB,SAAQ,KAAK;IACzC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,KAAK,iBAAiB,GAAG,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAA;AAE5E,KAAK,SAAS,GAAG;IACf,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAcD,KAAK,wBAAwB,GAAG,cAAc,GAC5C,gBAAgB,GAAG;IACjB,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;IACpB,kGAAkG;IAClG,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB,CAAA;AAEH,KAAK,mBAAmB,GAAG,WAAW,GAAG;IACvC,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,QAAA,MAAM,iBAAiB,kGAkzBtB,CAAA;AAwBD,eAAe,iBAAiB,CAAA;AAEhC,YAAY,EACV,mBAAmB,EACnB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,GACpB,CAAA;AAED,iBAAS,iBAAiB,SAIzB;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/lib/typescript/module/src/atomUtils.d.ts

@@ -0,0 +1,58 @@
+import type { MarkdownEmbed, MarkdownMath, StrippedMarkdown } from "./stripUtils.js";
+type Atom = ({
+    kind: "embed";
+} & MarkdownEmbed) | ({
+    kind: "math";
+} & MarkdownMath);
+/**
+ * How a maths span is said out loud, or nothing for one that cannot be said.
+ *
+ * Passed in rather than imported so that this module knows nothing about
+ * typesetting: it is `./math`'s `speakMath` at both call sites, and a display
+ * with no maths backend passes one that always declines.
+ */
+type SpeakMath = (tex: string, display: boolean, locale?: string) => string | null;
+declare const NO_ATOMS: Atom[];
+/**
+ * Every placeholder in the stripped text, in the order it stands there.
+ *
+ * Sorting is enough to interleave the two kinds correctly: each index is a
+ * distinct character in the same string, so no two atoms can share one.
+ */
+declare function atomsOf(markdown: StrippedMarkdown): Atom[];
+/**
+ * The text as it should be read out, with every placeholder written back out
+ * as what it stands for.
+ *
+ * A drawing costs exactly one character in the string the platform lays out --
+ * U+FFFC, the object replacement character -- and there is nothing in that
+ * character for a screen reader to say. An image's `alt` is its accessible name
+ * by every spec there is, and left empty it declares the image decorative, so
+ * it is used as written. A maths span is read as what was drawn, which is what
+ * `speak` answers; the TeX behind it is the fallback, because an expression
+ * read out as its source is still better than a sentence with a hole in it.
+ *
+ * `locale` is the language the maths is said in, and is passed straight
+ * through: the prose around it is in whatever language it was written in, and
+ * nothing here can or should change that.
+ */
+declare function describeAtoms(markdown: StrippedMarkdown, speak: SpeakMath, locale?: string): string;
+/**
+ * What a placeholder puts on the clipboard, which is the markdown it was
+ * written as.
+ *
+ * A copy of rendered text is plain text: `**bold**` comes off the screen as
+ * "bold", because that is what a copy of styled text has always been. A drawing
+ * has no plain text at all -- it is one U+FFFC, which pastes as a box -- and
+ * the source is the only honest thing to put there. Written back out with its
+ * dollar signs, a copied paragraph is markdown again and goes back into an
+ * editor as the document it came from.
+ *
+ * An image copies as nothing, the way an `<img>` does on the web: its alt text
+ * describes the picture for someone who cannot see it, and pasting a
+ * description where a picture was is not what anyone asked for.
+ */
+declare function sourceOf(atom: Atom): string;
+export type { Atom, SpeakMath };
+export { NO_ATOMS, atomsOf, describeAtoms, sourceOf };
+//# sourceMappingURL=atomUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"atomUtils.d.ts","sourceRoot":"","sources":["../../../../src/atomUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAc,CAAA;AASjF,KAAK,IAAI,GAAG,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,aAAa,CAAC,GAAG,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAAC,CAAA;AAEnF;;;;;;GAMG;AACH,KAAK,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;AAElF,QAAA,MAAM,QAAQ,EAAE,IAAI,EAAO,CAAA;AAE3B;;;;;GAKG;AACH,iBAAS,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,EAAE,CAkBnD;AAED;;;;;;;;;;;;;;;GAeG;AACH,iBAAS,aAAa,CAAC,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAkB5F;AAED;;;;;;;;;;;;;;GAcG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAQpC;AAED,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;AAE/B,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAA"}

package/lib/typescript/module/src/childrenUtils.d.ts

@@ -0,0 +1,12 @@
+import type React from "react";
+/**
+ * Flattens children into the string they render as, or null if they are not
+ * text.
+ *
+ * Only strings and numbers are markdown. An element child is content there are
+ * no parser offsets for and no way to strip syntax out of, so a subtree
+ * containing one renders unformatted rather than half formatted.
+ */
+declare function flattenText(children: React.ReactNode): string | null;
+export { flattenText };
+//# sourceMappingURL=childrenUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"childrenUtils.d.ts","sourceRoot":"","sources":["../../../../src/childrenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;;;;GAOG;AACH,iBAAS,WAAW,CAAC,QAAQ,EAAE,KAAK,CAAC,SAAS,GAAG,MAAM,GAAG,IAAI,CAI7D;AAwBD,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/lib/typescript/module/src/commonTypes.d.ts

@@ -1,10 +1,46 @@
-type MarkdownType = "bold" | "italic" | "strikethrough" | "emoji" | "mention-here" | "mention-user" | "mention-short" | "mention-report" | "link" | "code" | "pre" | "blockquote" | "list-ordered" | "list-unordered" | "block-prefix" | "heading" | "syntax" | "inline-image" | "codeblock";
+type MarkdownType = "strong" | "emphasis" | "strikethrough" | "emoji" | "mention" | "link" | "label" | "alt" | "title" | "code" | "pre" | "blockquote" | "list-ordered" | "list-unordered" | "block-prefix" | "heading" | "syntax" | "image" | "codeblock" | "math" | "math-block" | "language";
 interface MarkdownRange {
     type: MarkdownType;
     start: number;
     length: number;
     depth?: number;
-    syntaxType?: "opening" | "closing";
 }
-export type { MarkdownType, MarkdownRange };
+/**
+ * What the parser recognises beyond CommonMark.
+ *
+ * Every one of them is off unless it is asked for. Each changes what an
+ * ordinary character means -- a tilde, an `@`, a dollar sign -- and a document
+ * written somewhere else, by someone who never heard of this library, is the
+ * one place where guessing at that is least recoverable. They are the whole of
+ * the parser's configuration: a caller chooses a flavour, not a parser, and the
+ * components take these as props of their own.
+ */
+interface ParserOptions {
+    /**
+     * GFM's strikethrough (`~~a~~`) and bare autolinks (`www.example.com`).
+     *
+     * @default false
+     */
+    gfm?: boolean;
+    /**
+     * `@name` mentions, which no flavour of markdown has a notion of.
+     *
+     * @default false
+     */
+    mention?: boolean;
+    /**
+     * LaTeX between double dollar signs: `$$x^2$$` inline, and the same on lines
+     * of its own for a block.
+     *
+     * Two dollars, never one: `$5 and $6` is a price list in every document that
+     * has ever been written, and single-dollar maths would quietly turn it into a
+     * picture of the word "and".
+     *
+     * @default false
+     */
+    math?: boolean;
+}
+/** A parser, as the components hold one: text in, ranges out. */
+type MarkdownParser = (markdown: string) => MarkdownRange[];
+export type { MarkdownType, MarkdownRange, ParserOptions, MarkdownParser };
 //# sourceMappingURL=commonTypes.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"commonTypes.d.ts","sourceRoot":"","sources":["../../../../src/commonTypes.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,GACb,MAAM,GACN,QAAQ,GACR,eAAe,GACf,OAAO,GACP,cAAc,GACd,cAAc,GACd,eAAe,GACf,gBAAgB,GAChB,MAAM,GACN,MAAM,GACN,KAAK,GACL,YAAY,GACZ,cAAc,GACd,gBAAgB,GAChB,cAAc,GACd,SAAS,GACT,QAAQ,GACR,cAAc,GACd,WAAW,CAAA;AAEf,UAAU,aAAa;IACrB,IAAI,EAAE,YAAY,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;CACnC;AAED,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,CAAA"}
+{"version":3,"file":"commonTypes.d.ts","sourceRoot":"","sources":["../../../../src/commonTypes.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,GACb,QAAQ,GACR,UAAU,GACV,eAAe,GACf,OAAO,GAIP,SAAS,GACT,MAAM,GAIN,OAAO,GAKP,KAAK,GAIL,OAAO,GACP,MAAM,GACN,KAAK,GACL,YAAY,GACZ,cAAc,GACd,gBAAgB,GAChB,cAAc,GACd,SAAS,GACT,QAAQ,GACR,OAAO,GACP,WAAW,GAIX,MAAM,GAEN,YAAY,GAGZ,UAAU,CAAA;AAEd,UAAU,aAAa;IACrB,IAAI,EAAE,YAAY,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;GASG;AACH,UAAU,aAAa;IACrB;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAED,iEAAiE;AACjE,KAAK,cAAc,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,aAAa,EAAE,CAAA;AAE3D,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,CAAA"}

package/lib/typescript/module/src/index.d.ts

@@ -1,5 +1,6 @@
 export { default as MarkdownTextInput, getWorkletRuntime } from "./MarkdownTextInput";
 export type { MarkdownTextInputProps, MarkdownStyle } from "./MarkdownTextInput";
+export { default as MarkdownText } from "./MarkdownText";
+export type { MarkdownTextProps, OnLinkPress, RenderEmbed, RenderSVG } from "./MarkdownText";
 export type { MarkdownType, MarkdownRange } from "./commonTypes.js";
-export { parse as parser } from "./parser/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACrF,YAAY,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAChF,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAe,CAAA;AAChE,OAAO,EAAE,KAAK,IAAI,MAAM,EAAE,MAAM,mBAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACrF,YAAY,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAChF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAA;AACxD,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC5F,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAe,CAAA"}

package/lib/typescript/module/src/math/environment.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What MathJax and SRE assume about their host that React Native does not
+ * provide. Imported before either of them, and first, because `import`
+ * statements are hoisted and run in the order they are written.
+ */
+export {};
+//# sourceMappingURL=environment.d.ts.map

package/lib/typescript/module/src/math/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../../../src/math/environment.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA+DH,OAAO,EAAE,CAAA"}

package/lib/typescript/module/src/math/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The maths backend, in its "there isn't one" form.
+ *
+ * Typesetting TeX takes a library an order of magnitude larger than this one,
+ * and most applications will never draw an equation. So the real backend --
+ * `./mathjax.ts`, right beside this -- is never imported by anything: a
+ * bundler would follow the import and pull MathJax into every app that has
+ * ever installed this package, whether or not it renders maths.
+ *
+ * Instead the two are swapped at build time. `react-native-marcus/metro`'s
+ * `withMath()` resolves this module to that one, so an application opts in by
+ * editing its `metro.config.js` and the default bundle carries nothing.
+ *
+ * What the swap has to preserve is this shape and nothing else.
+ */
+/** One expression, drawn, with the box it needs. */
+interface RenderedMath {
+    /**
+     * A standalone SVG document: glyph outlines inline, no `<use>`, no `<defs>`,
+     * and the colour already substituted in.
+     */
+    svg: string;
+    /** Points, at the font size that was asked for. */
+    width: number;
+    height: number;
+    /**
+     * How far below the baseline the drawing hangs -- zero for `x^2`, real for
+     * `\frac{a}{b}`. Part of the picture rather than of the size: `height`
+     * already covers it.
+     */
+    depth: number;
+}
+/**
+ * Whether maths can be drawn at all.
+ *
+ * Read by the display components, which leave a maths span exactly as it was
+ * written when this is false. Showing `$$x^2$$` is a good deal better than
+ * showing an empty box where an equation should be, and it is the one hint an
+ * application will get that its Metro config is missing a line.
+ */
+declare const available = false;
+declare function renderMath(_tex: string, _display: boolean, _fontSize: number, _color: string | undefined): RenderedMath | null;
+/**
+ * The expression as it should be read out, or nothing.
+ *
+ * A drawn equation is a picture, and the TeX behind it is source code: an
+ * author reading `\frac{a}{b}` knows what it means, and a reader who asked
+ * for a document rather than for its markup hears three words of punctuation.
+ * So a display says what it drew -- "StartFraction a Over b EndFraction" --
+ * while an input, where the TeX is what is on the screen and what the caret
+ * moves through, keeps the TeX.
+ *
+ * `locale` is the language it should be said in, as a name the backend knows;
+ * nothing means the backend's own default. What a document is written in and
+ * what its reader speaks are two different questions, and only the application
+ * knows the answer to the second.
+ *
+ * Returning nothing means the caller falls back to the TeX, which is what the
+ * stub does and what a backend does for an expression it cannot say.
+ */
+declare function speakMath(_tex: string, _display: boolean, _locale?: string): string | null;
+export type { RenderedMath };
+export { available, renderMath, speakMath };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/src/math/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/math/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,oDAAoD;AACpD,UAAU,YAAY;IACpB;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAA;IACX,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;GAOG;AACH,QAAA,MAAM,SAAS,QAAQ,CAAA;AAEvB,iBAAS,UAAU,CACjB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,YAAY,GAAG,IAAI,CAErB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEnF;AAED,YAAY,EAAE,YAAY,EAAE,CAAA;AAE5B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,CAAA"}

package/lib/typescript/module/src/math/mathjax.d.ts

@@ -0,0 +1,63 @@
+/**
+ * TeX -> SVG with MathJax 4, wired up the way React Native needs.
+ *
+ * Nothing imports this module. `react-native-marcus/metro`'s `withMath()`
+ * resolves `./index.ts` -- the stub beside it -- to this file, which is how an
+ * application opts into a dependency this size. See `./index.ts`.
+ *
+ * Three things here are not the defaults:
+ *
+ * - **`liteAdaptor`**, so nothing wants a DOM. It runs the same in Hermes, in a
+ *   browser and in Node, which is what makes one renderer serve all three
+ *   platforms and draw the same glyphs on each.
+ * - **`fontCache: "none"`**, so each expression is a standalone SVG with its
+ *   glyph outlines inline. `"local"`, the default, emits `<use>` against a
+ *   `<defs>` block, which is smaller on a page full of maths and useless when
+ *   every expression is a separate attachment in someone else's view tree.
+ * - **`linebreaks: { inline: false }`**. v4 breaks long inline maths into
+ *   several `<svg>` fragments separated by `<mjx-break>`; one attachment is one
+ *   SVG, and left on, the metrics read off the first fragment are silently
+ *   wrong.
+ *
+ * Every specifier below names `mjs/` outright rather than going through
+ * MathJax's `js/*` export, and that is not cosmetic. That export maps to `mjs`
+ * for `import` and to `cjs` for `require`, so a module reached both ways --
+ * which is exactly what this file does, importing the machinery and requiring
+ * the font ranges -- is loaded twice, and the two copies each hold half of what
+ * is needed. The symptom is every `\mathbb`, `\mathcal`, `\mathfrak`,
+ * `\mathsf` and `\mathtt` coming out blank while everything else draws
+ * perfectly. `mjs/` goes through the package's `"./*": "./*"` fallback, which
+ * has no conditions to disagree about.
+ */
+import "./environment.js";
+import "@mathjax/src/mjs/input/tex/base/BaseConfiguration.js";
+import "@mathjax/src/mjs/input/tex/ams/AmsConfiguration.js";
+import "@mathjax/src/mjs/input/tex/newcommand/NewcommandConfiguration.js";
+import "@mathjax/src/mjs/input/tex/boldsymbol/BoldsymbolConfiguration.js";
+import type { RenderedMath } from "./index.js";
+declare const available = true;
+/**
+ * TeX in, one standalone SVG and its box out.
+ *
+ * The box is read off the root element rather than measured: MathJax reports
+ * width, height and the depth below the baseline in `ex`, and an `ex` is half
+ * the font size by its own `exFactor`. So nothing has to be laid out to find
+ * out how much room to ask for -- which is exactly what a text layout needs to
+ * know before it can lay the line out.
+ *
+ * Returns nothing for an expression it cannot draw, rather than throwing. TeX
+ * that reaches for something the bundled fonts do not carry ends in a
+ * `RangeError`, and one bad equation should cost the equation rather than the
+ * message it is in.
+ */
+declare function renderMath(tex: string, display: boolean, fontSize: number, color: string | undefined): RenderedMath | null;
+/**
+ * TeX in, the expression as a sentence out.
+ *
+ * Returns nothing for anything it cannot say, which includes TeX that does not
+ * parse and a document where the rules never loaded.
+ */
+declare function speakMath(tex: string, display: boolean, locale?: string): string | null;
+export type { RenderedMath };
+export { available, renderMath, speakMath };
+//# sourceMappingURL=mathjax.d.ts.map

package/lib/typescript/module/src/math/mathjax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathjax.d.ts","sourceRoot":"","sources":["../../../../../src/math/mathjax.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,kBAAe,CAAA;AAqBtB,OAAO,sDAAsD,CAAA;AAC7D,OAAO,oDAAoD,CAAA;AAC3D,OAAO,kEAAkE,CAAA;AACzE,OAAO,kEAAkE,CAAA;AAEzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAS,CAAA;AAyJ3C,QAAA,MAAM,SAAS,OAAO,CAAA;AAqBtB;;;;;;;;;;;;;GAaG;AACH,iBAAS,UAAU,CACjB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,YAAY,GAAG,IAAI,CAqBrB;AAyRD;;;;;GAKG;AACH,iBAAS,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyChF;AAED,YAAY,EAAE,YAAY,EAAE,CAAA;AAE5B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,CAAA"}

package/lib/typescript/module/src/metro.d.ts

@@ -0,0 +1,59 @@
+/** As much of a Metro config as this touches. */
+interface MetroConfig {
+    resolver?: {
+        resolveRequest?: ResolveRequest;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+type Resolution = {
+    type?: string;
+    filePath?: string;
+} | null | undefined;
+type ResolveRequest = (context: unknown, moduleName: string, platform: string | null) => Resolution;
+interface WithMathOptions {
+    /**
+     * The package whose `imports` field is read, in case a fork or a pinned copy
+     * is installed under another name.
+     *
+     * @default "@mathjax/src"
+     */
+    packageName?: string;
+    /**
+     * This library, in case it is installed under another name. Its own directory
+     * is what bounds the backend swap below.
+     *
+     * @default "react-native-marcus"
+     */
+    libraryName?: string;
+    /**
+     * The languages maths can be read out in, as the speech engine names them:
+     * `af`, `ca`, `da`, `de`, `en`, `es`, `fr`, `hi`, `it`, `ko`, `nb`, `nn` and
+     * `sv`. Everything else is left out of the bundle.
+     *
+     * This is what `MarkdownText`'s `mathAccessibilityLocale` can choose between.
+     * It is a build-time list rather than a runtime one for the same reason
+     * MathJax itself is: the rules for one language are around 300KB, and an
+     * application that reads its maths in English has no business carrying the
+     * four megabytes of rules for the twelve languages it does not. Naming the
+     * ones you support is the same thing you already do for your own
+     * translations.
+     *
+     * A locale asked for and not bundled is read in English instead, with a
+     * warning in the console saying so.
+     *
+     * @default ["en"]
+     */
+    locales?: string[];
+}
+/**
+ * Teaches Metro to resolve MathJax, and points the library's maths backend at
+ * it.
+ *
+ * Any `resolveRequest` already on the config is kept and called for everything
+ * else, so this composes with whatever else the application is doing.
+ */
+declare function withMath(config: MetroConfig, options?: WithMathOptions): MetroConfig;
+export type { MetroConfig, WithMathOptions };
+export { withMath };
+//# sourceMappingURL=metro.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metro.d.ts","sourceRoot":"","sources":["../../../../src/metro.ts"],"names":[],"mappings":"AAiCA,iDAAiD;AACjD,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE;QACT,cAAc,CAAC,EAAE,cAAc,CAAA;QAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KACvB,CAAA;IACD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,KAAK,UAAU,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAA;AAEzE,KAAK,cAAc,GAAG,CACpB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,KACpB,UAAU,CAAA;AAMf,UAAU,eAAe;IACvB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB;AAoFD;;;;;;GAMG;AACH,iBAAS,QAAQ,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,eAAoB,GAAG,WAAW,CAkDjF;AAMD,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,CAAA;AAE5C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/lib/typescript/module/src/parser/index.d.ts

@@ -1,8 +1,8 @@
-import type { MarkdownRange } from "../commonTypes.js";
+import type { MarkdownParser, MarkdownRange, ParserOptions } from "../commonTypes.js";
 declare module "./index" {
-    function parse(markdown: string): MarkdownRange[];
+    function createParser(options?: ParserOptions): MarkdownParser;
 }
 declare global {
-    function __parse__micromark(markdown: string): MarkdownRange[];
+    function __parse__micromark(markdown: string, options?: ParserOptions): MarkdownRange[];
 }
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/src/parser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/parser/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,mBAAgB,CAAA;AA8JjE,OAAO,QAAQ,SAAS,CAAC;IACvB,SAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,EAAE,CAAA;CACzD;AAED,OAAO,CAAC,MAAM,CAAC;IACb,SAAS,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,EAAE,CAAA;CAC/D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/parser/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAgB,aAAa,EAAE,MAAM,mBAAgB,CAAA;AA2MhG,OAAO,QAAQ,SAAS,CAAC;IACvB,SAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,cAAc,CAAA;CACtE;AAED,OAAO,CAAC,MAAM,CAAC;IACb,SAAS,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,aAAa,EAAE,CAAA;CACxF"}

package/lib/typescript/module/src/parser/micromark-extension-mentions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"micromark-extension-mentions.d.ts","sourceRoot":"","sources":["../../../../../src/parser/micromark-extension-mentions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,SAAS,EAAS,MAAM,sBAAsB,CAAA;AAM3E,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,YAAY;QACpB,OAAO,EAAE,SAAS,CAAA;KACnB;CACF;AAOD,wBAAgB,QAAQ,IAAI,SAAS,CAMpC"}
+{"version":3,"file":"micromark-extension-mentions.d.ts","sourceRoot":"","sources":["../../../../../src/parser/micromark-extension-mentions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,SAAS,EAGV,MAAM,sBAAsB,CAAA;AAU7B,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,YAAY;QACpB,OAAO,EAAE,SAAS,CAAA;KACnB;CACF;AAmBD,wBAAgB,QAAQ,IAAI,SAAS,CAMpC"}

package/lib/typescript/module/src/rangeUtils.d.ts

@@ -1,5 +1,5 @@
 import type { MarkdownRange } from "./commonTypes.js";
-declare function getTagPriority(tag: string): 0 | 1 | -1 | 3 | 2;
+declare function getTagPriority(tag: string): 0 | 2 | 1 | -1 | 3;
 declare function sortRanges(ranges: MarkdownRange[]): MarkdownRange[];
 declare function ungroupRanges(ranges: MarkdownRange[]): MarkdownRange[];
 export { getTagPriority, sortRanges, ungroupRanges };

package/lib/typescript/module/src/stripUtils.d.ts

@@ -0,0 +1,108 @@
+import type { MarkdownRange } from "./commonTypes.js";
+/** What an image stood for, for a caller that has something to show instead. */
+interface MarkdownEmbed {
+    /** Where the placeholder character stands in the stripped text. */
+    index: number;
+    uri: string;
+    alt: string;
+    /** Empty when the image was written without one, never absent. */
+    title: string;
+    /**
+     * Whether the image shares its line with anything else.
+     *
+     * An image is written inline and is laid out inline either way, but what it
+     * is for depends on what is around it: alone on a line it is a figure, and
+     * in the middle of a sentence it is a badge or an emoji. Only the caller can
+     * pick a size, and this is what that decision is usually made on.
+     *
+     * A block marker does not count as company -- an image alone in a list item
+     * or a quote is still alone -- and another image does.
+     */
+    inline: boolean;
+}
+/** A maths span, for a caller that has something to draw it with. */
+interface MarkdownMath {
+    /** Where the placeholder character stands in the stripped text. */
+    index: number;
+    /**
+     * The TeX between the dollars, with the dollars and the padding of `$ x $`
+     * taken off and the surrounding whitespace of a `$$` block trimmed. Never
+     * empty: a span with nothing in it is dropped rather than reported.
+     */
+    tex: string;
+    /**
+     * Whether it was written as a `$$` block on lines of its own, which is what
+     * decides whether TeX sets it in display style: bigger operators, limits
+     * above and below a sum rather than beside it. Where it sits on the page is
+     * the block layout's business, not the typesetter's.
+     */
+    display: boolean;
+}
+/** A link the display can hand to whatever is going to act on a press. */
+interface MarkdownLink {
+    /** Where the link's text stands in the stripped text. */
+    start: number;
+    length: number;
+    uri: string;
+    /** The text between the brackets, which is all that is left of the link. */
+    label: string;
+    /** Empty when the link was written without one, never absent. */
+    title: string;
+}
+interface StrippedMarkdown {
+    text: string;
+    ranges: MarkdownRange[];
+    embeds: MarkdownEmbed[];
+    maths: MarkdownMath[];
+    links: MarkdownLink[];
+}
+interface StripOptions {
+    /**
+     * Replace each image with a single placeholder character and report what it
+     * stood for, instead of leaving its alt text behind as prose.
+     *
+     * One character because that is exactly what a view mounted inside text costs
+     * the platform: both iOS and Android splice a single U+FFFC into the string
+     * the formatters index, in place of the attachment. So the ranges this
+     * returns are already right for a `Text` whose children have the embed
+     * spliced in where the placeholder is.
+     */
+    embeds?: boolean;
+    /**
+     * Replace each maths span with a single placeholder character and report the
+     * TeX it stood for, instead of leaving `$x^2$` behind as prose.
+     *
+     * The same one character an embed costs, for the same reason: what draws the
+     * maths is a view mounted in the text, and a view in a text is one character
+     * to both platforms.
+     */
+    math?: boolean;
+    /**
+     * Report where each link ended up and where it points.
+     *
+     * The destination is removed along with the rest of the markup, so a display
+     * that means to do something when a link is pressed has to be told here or
+     * not at all.
+     */
+    links?: boolean;
+}
+/**
+ * The character standing in for an embed, matching what the platforms use for
+ * an attachment so that the stripped text and the string that reaches the
+ * formatters are the same length.
+ */
+declare const OBJECT_REPLACEMENT = "\uFFFC";
+/**
+ * Removes the markdown syntax from `text` and rewrites `ranges` to index what
+ * is left.
+ *
+ * Ranges are only ever dropped or shortened, never reordered, so the emission
+ * order the native formatters depend on survives -- a `block-prefix` still
+ * arrives immediately before its container, and a container that lost its
+ * marker entirely arrives with none, which is exactly the gutter-without-marker
+ * case the block layout already handles.
+ */
+declare function stripSyntax(text: string, ranges: MarkdownRange[], options?: StripOptions): StrippedMarkdown;
+export type { MarkdownEmbed, MarkdownMath, MarkdownLink, StrippedMarkdown, StripOptions };
+export { OBJECT_REPLACEMENT, stripSyntax };
+//# sourceMappingURL=stripUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stripUtils.d.ts","sourceRoot":"","sources":["../../../../src/stripUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAe,CAAA;AAalD,gFAAgF;AAChF,UAAU,aAAa;IACrB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;IACb;;;;;;;;;;OAUG;IACH,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,qEAAqE;AACrE,UAAU,YAAY;IACpB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAA;IACX;;;;;OAKG;IACH,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,0EAA0E;AAC1E,UAAU,YAAY;IACpB,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAA;IACb,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAA;CACd;AAED,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,KAAK,EAAE,YAAY,EAAE,CAAA;IACrB,KAAK,EAAE,YAAY,EAAE,CAAA;CACtB;AAED,UAAU,YAAY;IACpB;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IACd;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;;GAIG;AACH,QAAA,MAAM,kBAAkB,WAAW,CAAA;AAglBnC;;;;;;;;;GASG;AACH,iBAAS,WAAW,CAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,EAAE,EACvB,OAAO,GAAE,YAAiB,GACzB,gBAAgB,CAsMlB;AAED,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,CAAA;AAEzF,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,CAAA"}

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

@@ -1,8 +1,66 @@
-import type { MarkdownStyle } from "./MarcusTextInputDecoratorViewNativeComponent";
-type PartialMarkdownStyle = Partial<{
+import type { TextStyle, ViewStyle } from "react-native";
+import type { MarkdownEmojiStyle, MarkdownStyle } from "./MarcusTextInputDecoratorViewNativeComponent";
+type MarkdownTextStyleProps = Pick<TextStyle, "color" | "fontFamily" | "fontSize" | "fontStyle" | "fontWeight" | "letterSpacing" | "lineHeight" | "textDecorationLine" | "textDecorationColor" | "textDecorationStyle" | "textShadowColor" | "textShadowOffset" | "textShadowRadius">;
+type MarkdownBoxStyleProps = MarkdownTextStyleProps & Pick<ViewStyle, "backgroundColor" | "borderColor" | "borderWidth" | "borderRadius" | "padding" | "paddingHorizontal" | "paddingVertical" | "margin" | "marginHorizontal" | "marginVertical"> & {
+    padding?: number;
+    paddingHorizontal?: number;
+    paddingVertical?: number;
+    margin?: number;
+    marginHorizontal?: number;
+    marginVertical?: number;
+    borderWidth?: number;
+    borderRadius?: number;
+};
+type MarkdownHeadingStyleProps = MarkdownTextStyleProps & {
+    scale?: number;
+};
+type MarkdownBlockquoteStyleProps = MarkdownTextStyleProps & Pick<ViewStyle, "borderColor"> & {
+    borderWidth?: number;
+    borderRadius?: number;
+    marginStart?: number;
+    paddingStart?: number;
+};
+type MarkdownListStyleProps = {
+    marginStart?: number;
+    paddingStart?: number;
+    markerScale?: number;
+    markerPadding?: number;
+    marker?: MarkdownTextStyleProps;
+};
+/**
+ * A markdown style as it is written: every entry optional, every property
+ * optional, and anything left out taken from the defaults below.
+ */
+type PartialMarkdownStyle = {
+    syntax?: MarkdownTextStyleProps;
+    emoji?: MarkdownEmojiStyle;
+    link?: MarkdownTextStyleProps;
+    strong?: MarkdownTextStyleProps;
+    emphasis?: MarkdownTextStyleProps;
+    strikethrough?: MarkdownTextStyleProps;
+    heading?: MarkdownHeadingStyleProps;
+    blockquote?: MarkdownBlockquoteStyleProps;
+    orderedList?: MarkdownListStyleProps;
+    unorderedList?: MarkdownListStyleProps;
+    code?: MarkdownBoxStyleProps;
+    pre?: MarkdownBoxStyleProps;
+    mention?: MarkdownBoxStyleProps;
+};
+/**
+ * The style once the defaults have been merged in: every entry present, every
+ * property still optional.
+ *
+ * Distinct from `PartialMarkdownStyle`, which is what a caller writes. This is
+ * what a renderer reads, and on the web its lengths have been through React
+ * Native Web's compiler by the time they get there -- a `fontSize` of `16` is
+ * the string `"16px"` -- which is why everything downstream of it either casts
+ * or runs the value back through `toNumber`.
+ */
+type ResolvedMarkdownStyle = Partial<{
     [K in keyof MarkdownStyle]: Partial<MarkdownStyle[K]>;
 }>;
 declare function mergeMarkdownStyleWithDefault(input: PartialMarkdownStyle | undefined): MarkdownStyle;
-export type { PartialMarkdownStyle };
-export { mergeMarkdownStyleWithDefault };
+declare function processMarkdownStyle(input: PartialMarkdownStyle | undefined): MarkdownStyle;
+export type { PartialMarkdownStyle, ResolvedMarkdownStyle, MarkdownTextStyleProps, MarkdownBoxStyleProps, MarkdownHeadingStyleProps, MarkdownBlockquoteStyleProps, MarkdownListStyleProps, };
+export { mergeMarkdownStyleWithDefault, processMarkdownStyle };
 //# sourceMappingURL=styleUtils.d.ts.map