@novastera-oss/react-native-markdown-display 8.0.1

package/dist/cjs/lib/util/Token.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Token {
+    constructor(type, nesting = 0, children = null, block = false) {
+        this.type = type;
+        this.nesting = nesting;
+        this.children = children;
+        this.block = block;
+    }
+}
+exports.default = Token;

package/dist/cjs/lib/util/cleanupTokens.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupTokens = cleanupTokens;
+const getTokenTypeByToken_1 = __importDefault(require("./getTokenTypeByToken"));
+const flattenInlineTokens_1 = __importDefault(require("./flattenInlineTokens"));
+const renderInlineAsText_1 = __importDefault(require("./renderInlineAsText"));
+function cleanupTokens(tokens) {
+    tokens = (0, flattenInlineTokens_1.default)(tokens);
+    tokens.forEach((token) => {
+        var _a;
+        token.type = (0, getTokenTypeByToken_1.default)(token);
+        // set image and hardbreak to block elements
+        if (token.type === 'image' || token.type === 'hardbreak') {
+            token.block = true;
+        }
+        // Set img alt text
+        if (token.type === 'image' && token.attrs) {
+            const altIndex = typeof token.attrIndex === 'function'
+                ? token.attrIndex('alt')
+                : token.attrs.findIndex((attr) => attr[0] === 'alt');
+            if (altIndex >= 0) {
+                token.attrs[altIndex][1] = (0, renderInlineAsText_1.default)((_a = token.children) !== null && _a !== void 0 ? _a : []);
+            }
+        }
+    });
+    /**
+     * changing a link token to a blocklink to fix issue where link tokens with
+     * nested non text tokens breaks component
+     */
+    const stack = [];
+    tokens = tokens.reduce((acc, token) => {
+        if (token.type === 'link' && token.nesting === 1) {
+            stack.push(token);
+        }
+        else if (stack.length > 0 &&
+            token.type === 'link' &&
+            token.nesting === -1) {
+            if (stack.some((stackToken) => stackToken.block)) {
+                stack[0].type = 'blocklink';
+                stack[0].block = true;
+                token.type = 'blocklink';
+                token.block = true;
+            }
+            stack.push(token);
+            while (stack.length) {
+                acc.push(stack.shift());
+            }
+        }
+        else if (stack.length > 0) {
+            stack.push(token);
+        }
+        else {
+            acc.push(token);
+        }
+        return acc;
+    }, []);
+    return tokens;
+}

package/dist/cjs/lib/util/convertAdditionalStyles.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = convertAdditionalStyles;
+function toCamelCase(input) {
+    return input.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function parseValue(value) {
+    const trimmed = value.trim();
+    const pxMatch = trimmed.match(/^(-?\d+(\.\d+)?)px$/);
+    if (pxMatch) {
+        return Number(pxMatch[1]);
+    }
+    const numMatch = trimmed.match(/^-?\d+(\.\d+)?$/);
+    if (numMatch) {
+        return Number(trimmed);
+    }
+    return trimmed;
+}
+function convertAdditionalStyles(style) {
+    if (!style || typeof style !== 'string') {
+        return {};
+    }
+    const rules = style.split(';');
+    const tuples = rules
+        .map((rule) => {
+        const [rawKey, rawValue] = rule.split(':');
+        if (rawKey && rawValue) {
+            const key = toCamelCase(rawKey.trim());
+            const value = parseValue(rawValue);
+            return [key, value];
+        }
+        return null;
+    })
+        .filter((x) => x !== null);
+    return tuples.reduce((acc, [key, value]) => {
+        acc[key] = value;
+        return acc;
+    }, {});
+}

package/dist/cjs/lib/util/flattenInlineTokens.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flattenTokens;
+function flattenTokens(tokens) {
+    return tokens.reduce((acc, curr) => {
+        if (curr.type === 'inline' && curr.children && curr.children.length > 0) {
+            const children = flattenTokens(curr.children);
+            while (children.length) {
+                acc.push(children.shift());
+            }
+        }
+        else {
+            acc.push(curr);
+        }
+        return acc;
+    }, []);
+}

package/dist/cjs/lib/util/getTokenTypeByToken.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getTokenTypeByToken;
+const regSelectOpenClose = /_open|_close/g;
+function getTokenTypeByToken(token) {
+    var _a, _b;
+    let cleanedType = 'unknown';
+    if (token.type) {
+        cleanedType = token.type.replace(regSelectOpenClose, '');
+    }
+    switch (cleanedType) {
+        case 'heading': {
+            cleanedType = `${cleanedType}${(_b = (_a = token.tag) === null || _a === void 0 ? void 0 : _a.substr(1)) !== null && _b !== void 0 ? _b : ''}`;
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    return cleanedType;
+}

package/dist/cjs/lib/util/getUniqueID.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getUniqueID;
+let uuid = new Date().getTime();
+function getUniqueID() {
+    uuid++;
+    return `rnmr_${uuid.toString(16)}`;
+}

package/dist/cjs/lib/util/groupTextTokens.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = groupTextTokens;
+const Token_1 = __importDefault(require("./Token"));
+function groupTextTokens(tokens) {
+    const result = [];
+    let hasGroup = false;
+    tokens.forEach((token) => {
+        if (!token.block && !hasGroup) {
+            hasGroup = true;
+            result.push(new Token_1.default('textgroup', 1));
+            result.push(token);
+        }
+        else if (!token.block && hasGroup) {
+            result.push(token);
+        }
+        else if (token.block && hasGroup) {
+            hasGroup = false;
+            result.push(new Token_1.default('textgroup', -1));
+            result.push(token);
+        }
+        else {
+            result.push(token);
+        }
+    });
+    return result;
+}

package/dist/cjs/lib/util/hasParents.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = hasParents;
+function hasParents(parents, type) {
+    return parents.findIndex((el) => el.type === type) > -1;
+}

package/dist/cjs/lib/util/omitListItemParagraph.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = omitListItemParagraph;
+function omitListItemParagraph(tokens) {
+    // used to ensure that we remove the correct ending paragraph token
+    let depth = null;
+    return tokens.filter((token, index) => {
+        // update depth if we've already removed a starting paragraph token
+        if (depth !== null) {
+            depth = depth + token.nesting;
+        }
+        // check for a list_item token followed by paragraph token (to remove)
+        if (token.type === 'list_item' && token.nesting === 1 && depth === null) {
+            const next = index + 1 in tokens ? tokens[index + 1] : null;
+            if (next && next.type === 'paragraph' && next.nesting === 1) {
+                depth = 0;
+                return true;
+            }
+        }
+        else if (token.type === 'paragraph') {
+            if (token.nesting === 1 && depth === 1) {
+                // remove the paragraph token immediately after the list_item token
+                return false;
+            }
+            else if (token.nesting === -1 && depth === 0) {
+                // remove the ending paragraph token; reset depth
+                depth = null;
+                return false;
+            }
+        }
+        return true;
+    });
+}

package/dist/cjs/lib/util/openUrl.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = openUrl;
+const react_native_1 = require("react-native");
+function openUrl(url, customCallback) {
+    if (customCallback) {
+        const result = customCallback(url);
+        if (url && result && typeof result === 'boolean') {
+            react_native_1.Linking.openURL(url);
+        }
+    }
+    else if (url) {
+        react_native_1.Linking.openURL(url);
+    }
+}

package/dist/cjs/lib/util/removeTextStyleProps.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = removeTextStyleProps;
+const textStyleProps_1 = __importDefault(require("../data/textStyleProps"));
+function removeTextStyleProps(style) {
+    const intersection = textStyleProps_1.default.filter((value) => Object.keys(style).includes(value));
+    const obj = { ...style };
+    intersection.forEach((value) => {
+        delete obj[value];
+    });
+    return obj;
+}

package/dist/cjs/lib/util/renderInlineAsText.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = renderInlineAsText;
+function renderInlineAsText(tokens) {
+    var _a;
+    let result = '';
+    for (let i = 0, len = tokens.length; i < len; i++) {
+        if (tokens[i].type === 'text') {
+            result += tokens[i].content;
+        }
+        else if (tokens[i].type === 'image') {
+            result += renderInlineAsText((_a = tokens[i].children) !== null && _a !== void 0 ? _a : []);
+        }
+    }
+    return result;
+}

package/dist/cjs/lib/util/splitTextNonTextNodes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = splitTextNonTextNodes;
+function isTextElement(node) {
+    if (typeof node.type === 'string') {
+        return node.type === 'Text';
+    }
+    const displayName = node.type.displayName;
+    return displayName === 'Text';
+}
+function splitTextNonTextNodes(children) {
+    return children.reduce((acc, curr) => {
+        if (isTextElement(curr)) {
+            acc.textNodes.push(curr);
+        }
+        else {
+            acc.nonTextNodes.push(curr);
+        }
+        return acc;
+    }, { textNodes: [], nonTextNodes: [] });
+}

package/dist/cjs/lib/util/stringToTokens.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToTokens = stringToTokens;
+function stringToTokens(source, markdownIt) {
+    let result = [];
+    try {
+        result = markdownIt.parse(source, {});
+    }
+    catch (err) {
+        console.warn(err);
+    }
+    return result;
+}

package/dist/cjs/lib/util/tokensToAST.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = tokensToAST;
+const getUniqueID_1 = __importDefault(require("./getUniqueID"));
+const getTokenTypeByToken_1 = __importDefault(require("./getTokenTypeByToken"));
+function createNode(token, tokenIndex) {
+    var _a, _b, _c;
+    const type = (0, getTokenTypeByToken_1.default)(token);
+    const content = (_a = token.content) !== null && _a !== void 0 ? _a : '';
+    let attributes = {};
+    if (token.attrs) {
+        attributes = token.attrs.reduce((prev, curr) => {
+            const [name, value] = curr;
+            return { ...prev, [name]: value };
+        }, {});
+    }
+    return {
+        type,
+        sourceType: token.type,
+        sourceInfo: token.info,
+        sourceMeta: token.meta,
+        block: token.block,
+        markup: (_b = token.markup) !== null && _b !== void 0 ? _b : '',
+        key: `${(0, getUniqueID_1.default)()}_${type}`,
+        content,
+        tokenIndex,
+        index: 0,
+        attributes,
+        children: tokensToAST((_c = token.children) !== null && _c !== void 0 ? _c : []),
+    };
+}
+function tokensToAST(tokens) {
+    var _a;
+    let stack = [];
+    let children = [];
+    if (!tokens || tokens.length === 0) {
+        return [];
+    }
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const astNode = createNode(token, i);
+        if (!(astNode.type === 'text' &&
+            astNode.children.length === 0 &&
+            astNode.content === '')) {
+            astNode.index = children.length;
+            if (token.nesting === 1) {
+                children.push(astNode);
+                stack.push(children);
+                children = astNode.children;
+            }
+            else if (token.nesting === -1) {
+                children = (_a = stack.pop()) !== null && _a !== void 0 ? _a : [];
+            }
+            else if (token.nesting === 0) {
+                children.push(astNode);
+            }
+        }
+    }
+    return children;
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/index.js

@@ -0,0 +1,112 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Base Markdown component
+ * @author Novastera + contributors
+ */
+import React, { useMemo } from 'react';
+import { Text, StyleSheet } from 'react-native';
+import MarkdownIt from 'markdown-it';
+import { Image as MarkdownImage } from 'expo-image';
+import parser from './lib/parser';
+import getUniqueID from './lib/util/getUniqueID';
+import hasParents from './lib/util/hasParents';
+import openUrl from './lib/util/openUrl';
+import tokensToAST from './lib/util/tokensToAST';
+import renderRules from './lib/renderRules';
+import AstRenderer from './lib/AstRenderer';
+import removeTextStyleProps from './lib/util/removeTextStyleProps';
+import { styles } from './lib/styles';
+import { stringToTokens } from './lib/util/stringToTokens';
+import textStyleProps from './lib/data/textStyleProps';
+export { getUniqueID, openUrl, hasParents, renderRules, AstRenderer, parser, stringToTokens, tokensToAST, MarkdownIt, styles, removeTextStyleProps, textStyleProps, MarkdownImage, MarkdownImage as FitImage, };
+// we use StyleSheet.flatten here to make sure we have an object, in case someone
+// passes in a StyleSheet.create result to the style prop
+const getStyle = (mergeStyle, style) => {
+    let useStyles = {};
+    const styleRecord = (style !== null && style !== void 0 ? style : {});
+    if (mergeStyle === true && style) {
+        // make sure we get anything user defuned
+        Object.keys(styleRecord).forEach((value) => {
+            const styleEntry = styleRecord[value];
+            useStyles[value] = {
+                ...StyleSheet.flatten(styleEntry !== null && styleEntry !== void 0 ? styleEntry : {}),
+            };
+        });
+        // combine any existing styles
+        Object.keys(styles).forEach((value) => {
+            const styleEntry = styleRecord[value];
+            useStyles[value] = {
+                ...styles[value],
+                ...StyleSheet.flatten(styleEntry !== null && styleEntry !== void 0 ? styleEntry : {}),
+            };
+        });
+    }
+    else {
+        useStyles = {
+            ...styles,
+        };
+        if (style) {
+            Object.keys(styleRecord).forEach((value) => {
+                const styleEntry = styleRecord[value];
+                useStyles[value] = {
+                    ...StyleSheet.flatten(styleEntry !== null && styleEntry !== void 0 ? styleEntry : {}),
+                };
+            });
+        }
+    }
+    Object.keys(useStyles).forEach((value) => {
+        useStyles['_VIEW_SAFE_' + value] = removeTextStyleProps(useStyles[value]);
+    });
+    return StyleSheet.create(useStyles);
+};
+const getRenderer = (renderer, rules, style, mergeStyle = true, onLinkPress, maxTopLevelChildren, topLevelMaxExceededItem, allowedImageHandlers, defaultImageHandler, debugPrintTree) => {
+    if (renderer && rules) {
+        console.warn('react-native-markdown-display you are using renderer and rules at the same time. This is not possible, props.rules is ignored');
+    }
+    if (renderer && style) {
+        console.warn('react-native-markdown-display you are using renderer and style at the same time. This is not possible, props.style is ignored');
+    }
+    // these checks are here to prevent extra overhead.
+    if (renderer) {
+        if (typeof renderer === 'function') {
+            return renderer;
+        }
+        if (typeof renderer.render === 'function') {
+            return renderer;
+        }
+        throw new Error('Provided renderer is not compatible with function or AstRenderer. please change');
+    }
+    const useStyles = getStyle(mergeStyle, style);
+    return new AstRenderer({
+        ...renderRules,
+        ...(rules || {}),
+    }, useStyles, onLinkPress, maxTopLevelChildren, topLevelMaxExceededItem, allowedImageHandlers, defaultImageHandler, debugPrintTree);
+};
+const Markdown = React.memo(({ children, renderer, rules, style, mergeStyle = true, markdownit = MarkdownIt({
+    typographer: true,
+}), onLinkPress, maxTopLevelChildren = null, topLevelMaxExceededItem = _jsx(Text, { children: "..." }, "dotdotdot"), allowedImageHandlers = [
+    'data:image/png;base64',
+    'data:image/gif;base64',
+    'data:image/jpeg;base64',
+    'https://',
+    'http://',
+], defaultImageHandler = 'https://', debugPrintTree = false, }) => {
+    const memoizedRenderer = useMemo(() => getRenderer(renderer, rules, style, mergeStyle, onLinkPress, maxTopLevelChildren, topLevelMaxExceededItem, allowedImageHandlers, defaultImageHandler, debugPrintTree), [
+        maxTopLevelChildren,
+        onLinkPress,
+        renderer,
+        rules,
+        style,
+        mergeStyle,
+        topLevelMaxExceededItem,
+        allowedImageHandlers,
+        defaultImageHandler,
+        debugPrintTree,
+    ]);
+    const memoizedParser = useMemo(() => markdownit, [markdownit]);
+    const render = typeof memoizedRenderer === 'function'
+        ? memoizedRenderer
+        : memoizedRenderer.render;
+    return parser(children, render, memoizedParser);
+});
+export default Markdown;

package/dist/esm/lib/AstRenderer.js

@@ -0,0 +1,123 @@
+import { StyleSheet } from 'react-native';
+import getUniqueID from './util/getUniqueID';
+import convertAdditionalStyles from './util/convertAdditionalStyles';
+import textStyleProps from './data/textStyleProps';
+export default class AstRenderer {
+    constructor(renderRules, style, onLinkPress, maxTopLevelChildren, topLevelMaxExceededItem, allowedImageHandlers, defaultImageHandler, debugPrintTree) {
+        this.getRenderFunction = (type) => {
+            const renderFunction = this._renderRules[type];
+            if (!renderFunction) {
+                console.warn(`Warning, unknown render rule encountered: ${type}. 'unknown' render rule used (by default, returns null - nothing rendered)`);
+                return this._renderRules.unknown;
+            }
+            return renderFunction;
+        };
+        this.renderNode = (node, parentNodes, isRoot = false) => {
+            var _a, _b;
+            const renderFunction = this.getRenderFunction(node.type);
+            const parents = [...parentNodes];
+            if (this._debugPrintTree === true) {
+                let str = '';
+                for (let a = 0; a < parents.length; a++) {
+                    str = str + '-';
+                }
+                console.log(`${str}${node.type}`);
+            }
+            parents.unshift(node);
+            // calculate the children first
+            let children = node.children.map((value) => {
+                return this.renderNode(value, parents);
+            });
+            // render any special types of nodes that have different renderRule function signatures
+            if (node.type === 'link' || node.type === 'blocklink') {
+                return renderFunction(node, children, parentNodes, this._style, this._onLinkPress);
+            }
+            if (node.type === 'image') {
+                return renderFunction(node, children, parentNodes, this._style, (_a = this._allowedImageHandlers) !== null && _a !== void 0 ? _a : [], (_b = this._defaultImageHandler) !== null && _b !== void 0 ? _b : null);
+            }
+            // We are at the bottom of some tree - grab all the parent styles
+            // this effectively grabs the styles from parents and
+            // applies them in order of priority parent (least) to child (most)
+            // to allow styling global, then lower down things individually
+            // we have to handle list_item seperately here because they have some child
+            // pseudo classes that need the additional style props from parents passed down to them
+            if (children.length === 0 || node.type === 'list_item') {
+                const styleObj = {};
+                for (let a = parentNodes.length - 1; a > -1; a--) {
+                    // grab and additional attributes specified by markdown-it
+                    let refStyle = {};
+                    const styleAttr = parentNodes[a].attributes.style;
+                    if (typeof styleAttr === 'string') {
+                        refStyle = convertAdditionalStyles(styleAttr);
+                    }
+                    // combine in specific styles for the object
+                    if (this._style[parentNodes[a].type]) {
+                        refStyle = {
+                            ...refStyle,
+                            ...StyleSheet.flatten(this._style[parentNodes[a].type]),
+                        };
+                        // workaround for list_items and their content cascading down the tree
+                        if (parentNodes[a].type === 'list_item') {
+                            let contentStyle = {};
+                            if (parentNodes[a + 1].type === 'bullet_list') {
+                                contentStyle = this._style
+                                    .bullet_list_content;
+                            }
+                            else if (parentNodes[a + 1].type === 'ordered_list') {
+                                contentStyle = this._style
+                                    .ordered_list_content;
+                            }
+                            refStyle = {
+                                ...refStyle,
+                                ...StyleSheet.flatten(contentStyle),
+                            };
+                        }
+                    }
+                    // then work out if any of them are text styles that should be used in the end.
+                    const arr = Object.keys(refStyle);
+                    for (let b = 0; b < arr.length; b++) {
+                        if (textStyleProps.includes(arr[b])) {
+                            styleObj[arr[b]] = refStyle[arr[b]];
+                        }
+                    }
+                }
+                const baseRenderFunction = renderFunction;
+                return baseRenderFunction(node, children, parentNodes, this._style, styleObj);
+            }
+            // cull top level children
+            if (isRoot === true &&
+                this._maxTopLevelChildren &&
+                children.length > this._maxTopLevelChildren) {
+                children = children.slice(0, this._maxTopLevelChildren);
+                if (this._topLevelMaxExceededItem) {
+                    children.push(this._topLevelMaxExceededItem);
+                }
+            }
+            // render anythign else that has a normal signature
+            const baseRenderFunction = renderFunction;
+            return baseRenderFunction(node, children, parentNodes, this._style);
+        };
+        this.render = (nodes) => {
+            const root = {
+                type: 'body',
+                sourceType: 'body',
+                key: getUniqueID(),
+                content: '',
+                markup: '',
+                tokenIndex: -1,
+                index: 0,
+                attributes: {},
+                children: nodes,
+            };
+            return this.renderNode(root, [], true);
+        };
+        this._renderRules = renderRules;
+        this._style = style;
+        this._onLinkPress = onLinkPress;
+        this._maxTopLevelChildren = maxTopLevelChildren;
+        this._topLevelMaxExceededItem = topLevelMaxExceededItem;
+        this._allowedImageHandlers = allowedImageHandlers;
+        this._defaultImageHandler = defaultImageHandler;
+        this._debugPrintTree = debugPrintTree;
+    }
+}

package/dist/esm/lib/data/textStyleProps.js

@@ -0,0 +1,22 @@
+const textStyleProps = [
+    'textShadowOffset',
+    'color',
+    'fontSize',
+    'fontStyle',
+    'fontWeight',
+    'lineHeight',
+    'textAlign',
+    'textDecorationLine',
+    'textShadowColor',
+    'fontFamily',
+    'textShadowRadius',
+    'includeFontPadding',
+    'textAlignVertical',
+    'fontVariant',
+    'letterSpacing',
+    'textDecorationColor',
+    'textDecorationStyle',
+    'textTransform',
+    'writingDirection',
+];
+export default textStyleProps;

package/dist/esm/lib/parser.js

@@ -0,0 +1,16 @@
+import tokensToAST from './util/tokensToAST';
+import { stringToTokens } from './util/stringToTokens';
+import { cleanupTokens } from './util/cleanupTokens';
+import groupTextTokens from './util/groupTextTokens';
+import omitListItemParagraph from './util/omitListItemParagraph';
+export default function parser(source, renderer, markdownIt) {
+    if (Array.isArray(source)) {
+        return renderer(source);
+    }
+    let tokens = stringToTokens(source, markdownIt);
+    tokens = cleanupTokens(tokens);
+    tokens = groupTextTokens(tokens);
+    tokens = omitListItemParagraph(tokens);
+    const astTree = tokensToAST(tokens);
+    return renderer(astTree);
+}