react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/src/web/styles.ts

@@ -0,0 +1,549 @@
+import type { CSSProperties } from 'react';
+import type {
+  BlockTextAlign,
+  MarkdownStyleInternal,
+} from '../types/MarkdownStyleInternal';
+
+const normalizeFontFamily = (value: string): string | undefined =>
+  value || undefined;
+
+const VALID_FONT_WEIGHTS = new Set([
+  'normal',
+  'bold',
+  'bolder',
+  'lighter',
+  '100',
+  '200',
+  '300',
+  '400',
+  '500',
+  '600',
+  '700',
+  '800',
+  '900',
+]);
+
+const normalizeFontWeight = (value: string): CSSProperties['fontWeight'] => {
+  if (!value) return undefined;
+  if (VALID_FONT_WEIGHTS.has(value))
+    return value as CSSProperties['fontWeight'];
+  return undefined;
+};
+
+const normalizeTextAlign = (
+  value: BlockTextAlign
+): CSSProperties['textAlign'] => (value === 'auto' ? undefined : value);
+
+// 'default' is an AST sentinel for "unspecified column alignment".
+function resolveColumnAlign(
+  align: 'left' | 'center' | 'right' | 'default' | undefined
+): 'left' | 'center' | 'right' {
+  if (align === 'center' || align === 'right') return align;
+  return 'left';
+}
+
+export function zeroTrailingMargins(
+  style: MarkdownStyleInternal
+): MarkdownStyleInternal {
+  return {
+    ...style,
+    paragraph: { ...style.paragraph, marginBottom: 0 },
+    h1: { ...style.h1, marginBottom: 0 },
+    h2: { ...style.h2, marginBottom: 0 },
+    h3: { ...style.h3, marginBottom: 0 },
+    h4: { ...style.h4, marginBottom: 0 },
+    h5: { ...style.h5, marginBottom: 0 },
+    h6: { ...style.h6, marginBottom: 0 },
+    blockquote: { ...style.blockquote, marginBottom: 0 },
+    list: { ...style.list, marginBottom: 0 },
+    codeBlock: { ...style.codeBlock, marginBottom: 0 },
+    thematicBreak: { ...style.thematicBreak, marginBottom: 0 },
+    image: { ...style.image, marginBottom: 0 },
+    math: { ...style.math, marginBottom: 0 },
+    table: { ...style.table, marginBottom: 0 },
+  };
+}
+
+type HeadingLevel = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+
+export function toHeadingLevel(level: string): HeadingLevel {
+  const clamped = Math.max(1, Math.min(6, parseInt(level, 10) || 1));
+  return `h${clamped}` as HeadingLevel;
+}
+
+type BaseBlock = Pick<
+  MarkdownStyleInternal['paragraph'],
+  | 'fontSize'
+  | 'fontFamily'
+  | 'fontWeight'
+  | 'color'
+  | 'lineHeight'
+  | 'marginTop'
+  | 'marginBottom'
+  | 'textAlign'
+>;
+
+function baseBlock(block: BaseBlock): CSSProperties {
+  return {
+    fontSize: block.fontSize,
+    fontFamily: normalizeFontFamily(block.fontFamily),
+    fontWeight: normalizeFontWeight(block.fontWeight),
+    color: block.color,
+    lineHeight: `${block.lineHeight}px`,
+    marginTop: block.marginTop,
+    marginBottom: block.marginBottom,
+    textAlign: normalizeTextAlign(block.textAlign),
+  };
+}
+
+function paragraphStyle(style: MarkdownStyleInternal): CSSProperties {
+  return baseBlock(style.paragraph);
+}
+
+function paragraphInBlockquoteStyle(
+  style: MarkdownStyleInternal
+): CSSProperties {
+  return { ...baseBlock(style.paragraph), marginTop: 0, marginBottom: 0 };
+}
+
+function headingStyle(
+  style: MarkdownStyleInternal,
+  level: string
+): CSSProperties {
+  return baseBlock(style[toHeadingLevel(level)]);
+}
+
+function blockquoteStyle(style: MarkdownStyleInternal): CSSProperties {
+  const blockquote = style.blockquote;
+  return {
+    fontSize: blockquote.fontSize,
+    fontFamily: normalizeFontFamily(blockquote.fontFamily),
+    fontWeight: normalizeFontWeight(blockquote.fontWeight),
+    color: blockquote.color,
+    lineHeight: `${blockquote.lineHeight}px`,
+    marginTop: blockquote.marginTop,
+    marginBottom: blockquote.marginBottom,
+    marginInlineStart: 0, // reset UA default (40px in LTR, auto in RTL)
+    marginInlineEnd: 0,
+    paddingInlineStart: blockquote.gapWidth,
+    borderInlineStart: `${blockquote.borderWidth}px solid ${blockquote.borderColor}`,
+    backgroundColor: blockquote.backgroundColor,
+  };
+}
+
+function listStyle(
+  style: MarkdownStyleInternal,
+  isTaskList = false
+): CSSProperties {
+  const list = style.list;
+  return {
+    listStylePosition: 'outside',
+    fontSize: list.fontSize,
+    fontFamily: normalizeFontFamily(list.fontFamily),
+    fontWeight: normalizeFontWeight(list.fontWeight),
+    color: list.color,
+    lineHeight: `${list.lineHeight}px`,
+    marginTop: list.marginTop,
+    marginBottom: list.marginBottom,
+    paddingInlineStart: isTaskList ? 0 : list.marginLeft,
+  };
+}
+
+function codeBlockStyle(style: MarkdownStyleInternal): CSSProperties {
+  const codeBlock = style.codeBlock;
+  return {
+    fontSize: codeBlock.fontSize,
+    fontFamily: normalizeFontFamily(codeBlock.fontFamily),
+    fontWeight: normalizeFontWeight(codeBlock.fontWeight),
+    color: codeBlock.color,
+    lineHeight: `${codeBlock.lineHeight}px`,
+    backgroundColor: codeBlock.backgroundColor,
+    border: `${codeBlock.borderWidth}px solid ${codeBlock.borderColor}`,
+    borderRadius: codeBlock.borderRadius,
+    padding: codeBlock.padding,
+    margin: 0,
+    marginTop: codeBlock.marginTop,
+    marginBottom: codeBlock.marginBottom,
+    overflowX: 'auto',
+    direction: 'ltr',
+  };
+}
+
+function thematicBreakStyle(style: MarkdownStyleInternal): CSSProperties {
+  const thematicBreak = style.thematicBreak;
+  return {
+    border: 'none', // reset UA borders on all sides before drawing only the top
+    borderTop: `${thematicBreak.height}px solid ${thematicBreak.color}`,
+    marginTop: thematicBreak.marginTop,
+    marginBottom: thematicBreak.marginBottom,
+    width: '100%', // <hr> as a flex item doesn't auto-stretch — must be explicit
+  };
+}
+
+function imageStyle(style: MarkdownStyleInternal): CSSProperties {
+  const image = style.image;
+  return {
+    height: image.height,
+    borderRadius: image.borderRadius,
+    marginTop: image.marginTop,
+    marginBottom: image.marginBottom,
+    maxWidth: '100%',
+    display: 'block',
+  };
+}
+
+function inlineImageStyle(style: MarkdownStyleInternal): CSSProperties {
+  const size = style.inlineImage.size;
+  return {
+    width: size,
+    height: size,
+    verticalAlign: 'middle',
+    display: 'inline',
+  };
+}
+
+function strongStyle(style: MarkdownStyleInternal): CSSProperties {
+  const strong = style.strong;
+  return {
+    fontFamily: normalizeFontFamily(strong.fontFamily),
+    fontWeight: normalizeFontWeight(strong.fontWeight) || 'bold',
+    color: strong.color ?? style.paragraph.color,
+  };
+}
+
+function emphasisStyle(style: MarkdownStyleInternal): CSSProperties {
+  const emphasis = style.em;
+  return {
+    fontFamily: normalizeFontFamily(emphasis.fontFamily),
+    fontStyle: emphasis.fontStyle || 'italic', // '' means "inherit default" → fall back to italic
+    color: emphasis.color ?? style.paragraph.color,
+  };
+}
+
+function codeStyle(style: MarkdownStyleInternal): CSSProperties {
+  const code = style.code;
+  return {
+    fontFamily: normalizeFontFamily(code.fontFamily),
+    fontSize: code.fontSize || undefined,
+    color: code.color,
+    backgroundColor: code.backgroundColor,
+    border: `1px solid ${code.borderColor}`,
+    borderRadius: 3,
+    padding: '1px 4px',
+    direction: 'ltr',
+    unicodeBidi: 'embed',
+  };
+}
+
+function linkStyle(style: MarkdownStyleInternal): CSSProperties {
+  const link = style.link;
+  return {
+    color: link.color,
+    fontFamily: normalizeFontFamily(link.fontFamily),
+    textDecoration: link.underline ? 'underline' : 'none',
+  };
+}
+
+/** Compiled variant regexes keyed by the normalized style object. Avoids recompiling on every link render. */
+const _variantRegexCache = new WeakMap<
+  MarkdownStyleInternal['linkVariants'],
+  Array<RegExp | null>
+>();
+
+function getCompiledVariantRegexes(
+  variants: MarkdownStyleInternal['linkVariants']
+): Array<RegExp | null> {
+  let compiled = _variantRegexCache.get(variants);
+  if (!compiled) {
+    compiled = variants.map((variant) => {
+      try {
+        return new RegExp(variant.pattern);
+      } catch {
+        return null;
+      }
+    });
+    _variantRegexCache.set(variants, compiled);
+  }
+  return compiled;
+}
+
+export function linkStyleForUrl(
+  style: MarkdownStyleInternal,
+  url: string
+): CSSProperties {
+  const base = style.link;
+  const compiledVariantRegexes = getCompiledVariantRegexes(style.linkVariants);
+  const variantIndex = compiledVariantRegexes.findIndex(
+    (regex) => regex !== null && regex.test(url)
+  );
+  const resolved =
+    variantIndex !== -1 ? style.linkVariants[variantIndex]! : base;
+
+  const backgroundColor = resolved.backgroundColor;
+  return {
+    color: resolved.color,
+    fontFamily: normalizeFontFamily(base.fontFamily),
+    textDecoration: resolved.underline ? 'underline' : 'none',
+    ...(backgroundColor && backgroundColor !== 'transparent'
+      ? { backgroundColor }
+      : undefined),
+  };
+}
+
+function strikethroughStyle(style: MarkdownStyleInternal): CSSProperties {
+  return {
+    textDecorationLine: 'line-through',
+    textDecorationColor: style.strikethrough.color,
+  };
+}
+
+function underlineStyle(style: MarkdownStyleInternal): CSSProperties {
+  return {
+    textDecorationLine: 'underline',
+    textDecorationColor: style.underline.color,
+  };
+}
+
+function superscriptStyle(style: MarkdownStyleInternal): CSSProperties {
+  const { fontScale, baselineOffsetScale } = style.superscript;
+  return {
+    fontSize: `${fontScale}em`,
+    verticalAlign: `${baselineOffsetScale}em`,
+    lineHeight: 0,
+  };
+}
+
+function subscriptStyle(style: MarkdownStyleInternal): CSSProperties {
+  const { fontScale, baselineOffsetScale } = style.subscript;
+  return {
+    fontSize: `${fontScale}em`,
+    verticalAlign: `-${baselineOffsetScale}em`,
+    lineHeight: 0,
+  };
+}
+
+function highlightStyle(style: MarkdownStyleInternal): CSSProperties {
+  return {
+    backgroundColor: style.highlight.backgroundColor,
+    color:
+      style.highlight.color !== style.paragraph.color
+        ? style.highlight.color
+        : 'inherit',
+  };
+}
+
+function mathInlineStyle(style: MarkdownStyleInternal): CSSProperties {
+  return { color: style.inlineMath.color };
+}
+
+function mathDisplayStyle(style: MarkdownStyleInternal): CSSProperties {
+  const math = style.math;
+  return {
+    fontSize: math.fontSize,
+    color: math.color,
+    backgroundColor: math.backgroundColor,
+    padding: math.padding,
+    marginTop: math.marginTop,
+    marginBottom: math.marginBottom,
+    textAlign: normalizeTextAlign(math.textAlign),
+    overflowX: 'auto',
+  };
+}
+
+function tableStyle(style: MarkdownStyleInternal): CSSProperties {
+  const table = style.table;
+  return {
+    borderCollapse: 'collapse',
+    width: '100%',
+    fontSize: table.fontSize,
+    fontFamily: normalizeFontFamily(table.fontFamily),
+    fontWeight: normalizeFontWeight(table.fontWeight),
+    color: table.color,
+    lineHeight: `${table.lineHeight}px`,
+    border: `${table.borderWidth}px solid ${table.borderColor}`,
+  };
+}
+
+export function listItemStyle(isTask: boolean): CSSProperties | undefined {
+  return isTask ? { listStyle: 'none' } : undefined;
+}
+
+export function checkedTaskTextStyle(
+  style: MarkdownStyleInternal
+): CSSProperties {
+  const taskList = style.taskList;
+  return {
+    color: taskList.checkedTextColor || undefined,
+    textDecorationLine: taskList.checkedStrikethrough
+      ? 'line-through'
+      : undefined,
+  };
+}
+
+function taskCheckboxStyle(style: MarkdownStyleInternal): CSSProperties {
+  const taskList = style.taskList;
+  return {
+    width: taskList.checkboxSize,
+    height: taskList.checkboxSize,
+    borderRadius: taskList.checkboxBorderRadius,
+    marginInlineEnd: 6,
+    accentColor: taskList.checkedColor,
+    verticalAlign: 'middle',
+  };
+}
+
+export function tableBodyRowStyle(
+  style: MarkdownStyleInternal,
+  rowIndex: number
+): CSSProperties {
+  const table = style.table;
+  return {
+    backgroundColor:
+      rowIndex % 2 === 0
+        ? table.rowEvenBackgroundColor
+        : table.rowOddBackgroundColor,
+  };
+}
+
+function tableWrapperStyle(style: MarkdownStyleInternal): CSSProperties {
+  const table = style.table;
+  return {
+    overflowX: 'auto',
+    overflowY: 'hidden',
+    marginTop: table.marginTop,
+    marginBottom: table.marginBottom,
+    // borderRadius must live on the wrapper, not the <table> — border-collapse:
+    // collapse causes browsers to ignore border-radius on the table element itself.
+    borderRadius: table.borderRadius,
+  };
+}
+
+function tableHeaderCellStyle(
+  style: MarkdownStyleInternal,
+  align: 'left' | 'center' | 'right' | 'default' | undefined
+): CSSProperties {
+  const table = style.table;
+  return {
+    backgroundColor: table.headerBackgroundColor,
+    color: table.headerTextColor,
+    fontFamily:
+      normalizeFontFamily(table.headerFontFamily) ??
+      normalizeFontFamily(table.fontFamily),
+    fontWeight: 'bold',
+    padding: `${table.cellPaddingVertical}px ${table.cellPaddingHorizontal}px`,
+    border: `${table.borderWidth}px solid ${table.borderColor}`,
+    textAlign: resolveColumnAlign(align),
+  };
+}
+
+function tableCellStyle(
+  style: MarkdownStyleInternal,
+  align: 'left' | 'center' | 'right' | 'default' | undefined
+): CSSProperties {
+  const table = style.table;
+  return {
+    padding: `${table.cellPaddingVertical}px ${table.cellPaddingHorizontal}px`,
+    border: `${table.borderWidth}px solid ${table.borderColor}`,
+    textAlign: resolveColumnAlign(align),
+  };
+}
+
+export const parseErrorFallbackStyle: CSSProperties = {
+  whiteSpace: 'pre-wrap',
+  margin: 0,
+};
+
+export interface Styles {
+  paragraph: CSSProperties;
+  paragraphInBlockquote: CSSProperties;
+  h1: CSSProperties;
+  h2: CSSProperties;
+  h3: CSSProperties;
+  h4: CSSProperties;
+  h5: CSSProperties;
+  h6: CSSProperties;
+  blockquote: CSSProperties;
+  list: CSSProperties;
+  listNested: CSSProperties;
+  listTask: CSSProperties;
+  codeBlock: CSSProperties;
+  codeBlockFont: CSSProperties;
+  thematicBreak: CSSProperties;
+  image: CSSProperties;
+  inlineImage: CSSProperties;
+  strong: CSSProperties;
+  emphasis: CSSProperties;
+  code: CSSProperties;
+  link: CSSProperties;
+  strikethrough: CSSProperties;
+  underline: CSSProperties;
+  superscript: CSSProperties;
+  subscript: CSSProperties;
+  highlight: CSSProperties;
+  mathInline: CSSProperties;
+  mathDisplay: CSSProperties;
+  table: CSSProperties;
+  tableWrapper: CSSProperties;
+  tableHeaderCell: Record<ColumnAlign, CSSProperties>;
+  tableCell: Record<ColumnAlign, CSSProperties>;
+  taskCheckbox: CSSProperties;
+}
+
+type ColumnAlign = 'left' | 'center' | 'right' | 'default';
+
+const stylesStore = new WeakMap<MarkdownStyleInternal, Styles>();
+
+export function buildStyles(style: MarkdownStyleInternal): Styles {
+  const cached = stylesStore.get(style);
+  if (cached) return cached;
+
+  const codeBlock = codeBlockStyle(style);
+  const result: Styles = {
+    paragraph: paragraphStyle(style),
+    paragraphInBlockquote: paragraphInBlockquoteStyle(style),
+    h1: headingStyle(style, '1'),
+    h2: headingStyle(style, '2'),
+    h3: headingStyle(style, '3'),
+    h4: headingStyle(style, '4'),
+    h5: headingStyle(style, '5'),
+    h6: headingStyle(style, '6'),
+    blockquote: blockquoteStyle(style),
+    list: listStyle(style),
+    listNested: { ...listStyle(style), marginBottom: 0 },
+    listTask: listStyle(style, true),
+    codeBlock,
+    codeBlockFont: { fontFamily: codeBlock.fontFamily },
+    thematicBreak: thematicBreakStyle(style),
+    image: imageStyle(style),
+    inlineImage: inlineImageStyle(style),
+    strong: strongStyle(style),
+    emphasis: emphasisStyle(style),
+    code: codeStyle(style),
+    link: linkStyle(style),
+    strikethrough: strikethroughStyle(style),
+    underline: underlineStyle(style),
+    superscript: superscriptStyle(style),
+    subscript: subscriptStyle(style),
+    highlight: highlightStyle(style),
+    mathInline: mathInlineStyle(style),
+    mathDisplay: mathDisplayStyle(style),
+    table: tableStyle(style),
+    tableWrapper: tableWrapperStyle(style),
+    tableHeaderCell: {
+      left: tableHeaderCellStyle(style, 'left'),
+      center: tableHeaderCellStyle(style, 'center'),
+      right: tableHeaderCellStyle(style, 'right'),
+      default: tableHeaderCellStyle(style, 'default'),
+    },
+    tableCell: {
+      left: tableCellStyle(style, 'left'),
+      center: tableCellStyle(style, 'center'),
+      right: tableCellStyle(style, 'right'),
+      default: tableCellStyle(style, 'default'),
+    },
+    taskCheckbox: taskCheckboxStyle(style),
+  };
+
+  stylesStore.set(style, result);
+  return result;
+}

package/src/web/types.ts

@@ -0,0 +1,92 @@
+import type { ComponentType, ReactNode } from 'react';
+import type { MarkdownStyleInternal } from '../types/MarkdownStyleInternal';
+import type { Styles } from './styles';
+import type {
+  LinkPressEvent,
+  LinkLongPressEvent,
+  TaskListItemPressEvent,
+} from '../types/events';
+import type { KaTeXInstance } from './katex';
+
+export type NodeType =
+  | 'Document'
+  | 'Paragraph'
+  | 'Text'
+  | 'Link'
+  | 'Heading'
+  | 'LineBreak'
+  | 'Strong'
+  | 'Emphasis'
+  | 'Strikethrough'
+  | 'Underline'
+  | 'Superscript'
+  | 'Subscript'
+  | 'Highlight'
+  | 'Code'
+  | 'Image'
+  | 'Blockquote'
+  | 'UnorderedList'
+  | 'OrderedList'
+  | 'ListItem'
+  | 'CodeBlock'
+  | 'ThematicBreak'
+  | 'Table'
+  | 'TableHead'
+  | 'TableBody'
+  | 'TableRow'
+  | 'TableHeaderCell'
+  | 'TableCell'
+  | 'LatexMathInline'
+  | 'LatexMathDisplay';
+
+export interface NodeAttributes {
+  level?: string;
+  url?: string;
+  title?: string;
+  language?: string;
+  fenceChar?: string;
+  isTask?: string;
+  taskChecked?: string;
+  /** Stamped by indexTaskItems() — not present in the raw WASM output. */
+  taskIndex?: number;
+  /** Stamped by markInlineImages() — not present in the raw WASM output. */
+  isInline?: boolean;
+  colCount?: string;
+  headRowCount?: string;
+  bodyRowCount?: string;
+  align?: 'left' | 'center' | 'right' | 'default';
+}
+
+export interface ASTNode {
+  type: NodeType;
+  /** Present on Text, Code, LatexMathInline, LatexMathDisplay nodes. */
+  content?: string;
+  /** Present on nodes that carry structural metadata (Heading, Link, etc.). */
+  attributes?: NodeAttributes;
+  /** Child nodes; absent on leaf nodes (Text, LineBreak, ThematicBreak). */
+  children?: ASTNode[];
+}
+
+export interface RendererCallbacks {
+  onLinkPress?: (event: LinkPressEvent) => void;
+  onLinkLongPress?: (event: LinkLongPressEvent) => void;
+  onTaskListItemPress?: (event: TaskListItemPressEvent) => void;
+}
+
+export interface RenderCapabilities {
+  katex: KaTeXInstance | null;
+}
+
+export interface RendererProps {
+  node: ASTNode;
+  style: MarkdownStyleInternal;
+  styles: Styles;
+  parentType?: NodeType;
+  callbacks: RendererCallbacks;
+  capabilities: RenderCapabilities;
+  renderChildren: (node: ASTNode) => ReactNode;
+}
+
+export type RendererMap = Partial<
+  Record<NodeType, ComponentType<RendererProps>>
+>;

package/src/web/utils.ts

@@ -0,0 +1,52 @@
+import type { ASTNode } from './types';
+
+/** Recursively collects plain text content from an AST node's subtree. */
+export function extractNodeText(node: ASTNode): string {
+  if (node.content !== undefined) return node.content;
+  return node.children?.map(extractNodeText).join('') ?? '';
+}
+
+/** Extracts the filename from a URL path, without extension. */
+export function filenameFromUrl(url: string): string {
+  try {
+    const pathname = new URL(url, 'https://placeholder').pathname;
+    const filename = pathname.split('/').pop() ?? '';
+    return filename.replace(/\.[^.]+$/, '');
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Stamps each task ListItem with a sequential `taskIndex` matching the order
+ * native C++ assigns — so onTaskListItemPress.index is correct on web too.
+ * Mutates the AST in-place (safe: called once on the freshly-parsed result).
+ */
+export function indexTaskItems(node: ASTNode, counter = { value: 0 }): void {
+  if (node.type === 'ListItem' && node.attributes?.isTask === 'true') {
+    node.attributes.taskIndex = counter.value++;
+  }
+  node.children?.forEach((child) => indexTaskItems(child, counter));
+}
+
+/**
+ * Stamps Image nodes with `isInline` when they appear inside a paragraph
+ * that also contains other content (text, links, etc.).
+ * Matches native behavior: sole-child images are block-level, mixed are inline.
+ * Mutates the AST in-place (safe: called once on the freshly-parsed result).
+ */
+export function markInlineImages(node: ASTNode): void {
+  if (node.type === 'Paragraph' && node.children) {
+    const hasNonImageChild = node.children.some(
+      (child) => child.type !== 'Image'
+    );
+    if (hasNonImageChild) {
+      for (const child of node.children) {
+        if (child.type === 'Image') {
+          child.attributes = { ...child.attributes, isInline: true };
+        }
+      }
+    }
+  }
+  node.children?.forEach(markInlineImages);
+}

package/src/web/wasm/md4c.d.ts

@@ -0,0 +1,21 @@
+// Type declarations for the Emscripten-generated md4c WASM module.
+// The actual md4c.js file is produced by cpp/wasm/build.sh and committed to git.
+
+interface Md4cModule {
+  cwrap(
+    name: string,
+    returnType: string,
+    argTypes: string[]
+  ): (...args: unknown[]) => unknown;
+  ccall(
+    name: string,
+    returnType: string,
+    argTypes: string[],
+    args: unknown[]
+  ): unknown;
+  UTF8ToString(ptr: number): string;
+}
+
+declare function createMd4cModule(options?: object): Promise<Md4cModule>;
+
+export default createMd4cModule;