react-native-marcus 0.1.1 → 0.2.0

package/lib/typescript/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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";
+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";
+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/commonjs/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,eAAe,CAAA;AAqBtB,OAAO,sDAAsD,CAAA;AAC7D,OAAO,oDAAoD,CAAA;AAC3D,OAAO,kEAAkE,CAAA;AACzE,OAAO,kEAAkE,CAAA;AAEzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,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/commonjs/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/commonjs/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/commonjs/src/parser/index.d.ts

@@ -1,8 +1,8 @@
-import type { MarkdownRange } from "../commonTypes";
+import type { MarkdownParser, MarkdownRange, ParserOptions } from "../commonTypes";
 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/commonjs/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,gBAAgB,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,gBAAgB,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/commonjs/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/commonjs/src/rangeUtils.d.ts

@@ -1,5 +1,5 @@
 import type { MarkdownRange } from "./commonTypes";
-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/commonjs/src/stripUtils.d.ts

@@ -0,0 +1,108 @@
+import type { MarkdownRange } from "./commonTypes";
+/** 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/commonjs/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,eAAe,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/commonjs/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

package/lib/typescript/commonjs/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/commonjs/src/web/utils/blockLayout.d.ts

@@ -1,5 +1,5 @@
 import type { MarkdownRange } from "../../commonTypes";
-import type { PartialMarkdownStyle } from "../../styleUtils";
+import type { ResolvedMarkdownStyle } from "../../styleUtils";
 import type { TextMeasurer } from "./measureUtils";
 /**
  * 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/commonjs/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,mBAAmB,CAAA;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,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,mBAAmB,CAAA;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,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/commonjs/src/web/utils/blockUtils.d.ts

@@ -1,22 +1,34 @@
-import type { PartialMarkdownStyle } from "../../styleUtils";
-import type { LineLayout } from "./blockLayout";
+import type { ResolvedMarkdownStyle } from "../../styleUtils";
+import type { LineLayout, MarkerRendering } from "./blockLayout";
 import type { NodeType } from "./treeUtils";
 /**
  * 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/commonjs/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,kBAAkB,CAAA;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,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,kBAAkB,CAAA;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,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/commonjs/src/web/utils/elementUtils.d.ts

@@ -0,0 +1,37 @@
+import type { HTMLMarkdownElement } from "../../MarkdownTextInput.web";
+import type { NodeType } from "./treeUtils";
+/**
+ * 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/commonjs/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,6BAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,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"}