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

package/dist/esm/lib/renderRules.js

@@ -0,0 +1,143 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, TouchableWithoutFeedback, View, Platform, StyleSheet, } from 'react-native';
+import { Image } from 'expo-image';
+import openUrl from './util/openUrl';
+import hasParents from './util/hasParents';
+import textStyleProps from './data/textStyleProps';
+const baseRule = (fn) => fn;
+const linkRule = (fn) => fn;
+const imageRule = (fn) => fn;
+const renderRules = {
+    // when unknown elements are introduced, so it wont break
+    unknown: baseRule(() => null),
+    // The main container
+    body: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_body, children: children }, node.key))),
+    // Headings
+    heading1: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_heading1, children: children }, node.key))),
+    heading2: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_heading2, children: children }, node.key))),
+    heading3: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_heading3, children: children }, node.key))),
+    heading4: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_heading4, children: children }, node.key))),
+    heading5: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_heading5, children: children }, node.key))),
+    heading6: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_heading6, children: children }, node.key))),
+    // Horizontal Rule
+    hr: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_hr }, node.key))),
+    // Emphasis
+    strong: baseRule((node, children, parent, styles) => (_jsx(Text, { style: styles.strong, children: children }, node.key))),
+    em: baseRule((node, children, parent, styles) => (_jsx(Text, { style: styles.em, children: children }, node.key))),
+    s: baseRule((node, children, parent, styles) => (_jsx(Text, { style: styles.s, children: children }, node.key))),
+    // Blockquotes
+    blockquote: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_blockquote, children: children }, node.key))),
+    // Lists
+    bullet_list: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_bullet_list, children: children }, node.key))),
+    ordered_list: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_ordered_list, children: children }, node.key))),
+    // this is a unique and quite annoying render rule because it has
+    // child items that can be styled (the list icon and the list content)
+    // outside of the AST tree so there are some work arounds in the
+    // AST renderer specifically to get the styling right here
+    list_item: baseRule((node, children, parent, styles, inheritedStyles = {}) => {
+        // we need to grab any text specific stuff here that is applied on the list_item style
+        // and apply it onto bullet_list_icon. the AST renderer has some workaround code to make
+        // the content classes apply correctly to the child AST tree items as well
+        // as code that forces the creation of the inheritedStyles object for list_items
+        const refStyle = {
+            ...inheritedStyles,
+            ...StyleSheet.flatten(styles.list_item),
+        };
+        const arr = Object.keys(refStyle);
+        const modifiedInheritedStylesObj = {};
+        for (let b = 0; b < arr.length; b++) {
+            if (textStyleProps.includes(arr[b])) {
+                modifiedInheritedStylesObj[arr[b]] = refStyle[arr[b]];
+            }
+        }
+        if (hasParents(parent, 'bullet_list')) {
+            return (_jsxs(View, { style: styles._VIEW_SAFE_list_item, children: [_jsx(Text, { style: [modifiedInheritedStylesObj, styles.bullet_list_icon], accessible: false, children: Platform.select({
+                            android: '\u2022',
+                            ios: '\u00B7',
+                            default: '\u2022',
+                        }) }), _jsx(View, { style: styles._VIEW_SAFE_bullet_list_content, children: children })] }, node.key));
+        }
+        if (hasParents(parent, 'ordered_list')) {
+            const orderedListIndex = parent.findIndex((el) => el.type === 'ordered_list');
+            const orderedList = parent[orderedListIndex];
+            let listItemNumber;
+            if (orderedList.attributes && orderedList.attributes.start) {
+                listItemNumber = orderedList.attributes.start + node.index;
+            }
+            else {
+                listItemNumber = node.index + 1;
+            }
+            return (_jsxs(View, { style: styles._VIEW_SAFE_list_item, children: [_jsxs(Text, { style: [modifiedInheritedStylesObj, styles.ordered_list_icon], children: [listItemNumber, node.markup] }), _jsx(View, { style: styles._VIEW_SAFE_ordered_list_content, children: children })] }, node.key));
+        }
+        // we should not need this, but just in case
+        return (_jsx(View, { style: styles._VIEW_SAFE_list_item, children: children }, node.key));
+    }),
+    // Code
+    code_inline: baseRule((node, children, parent, styles, inheritedStyles = {}) => (_jsx(Text, { style: [inheritedStyles, styles.code_inline], children: node.content }, node.key))),
+    code_block: baseRule((node, children, parent, styles, inheritedStyles = {}) => {
+        // we trim new lines off the end of code blocks because the parser sends an extra one.
+        let { content } = node;
+        if (typeof node.content === 'string' &&
+            node.content.charAt(node.content.length - 1) === '\n') {
+            content = node.content.substring(0, node.content.length - 1);
+        }
+        return (_jsx(Text, { style: [inheritedStyles, styles.code_block], children: content }, node.key));
+    }),
+    fence: baseRule((node, children, parent, styles, inheritedStyles = {}) => {
+        // we trim new lines off the end of code blocks because the parser sends an extra one.
+        let { content } = node;
+        if (typeof node.content === 'string' &&
+            node.content.charAt(node.content.length - 1) === '\n') {
+            content = node.content.substring(0, node.content.length - 1);
+        }
+        return (_jsx(Text, { style: [inheritedStyles, styles.fence], children: content }, node.key));
+    }),
+    // Tables
+    table: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_table, children: children }, node.key))),
+    thead: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_thead, children: children }, node.key))),
+    tbody: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_tbody, children: children }, node.key))),
+    th: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_th, children: children }, node.key))),
+    tr: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_tr, children: children }, node.key))),
+    td: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_td, children: children }, node.key))),
+    // Links
+    link: linkRule((node, children, parent, styles, onLinkPress) => (_jsx(Text, { style: styles.link, onPress: () => openUrl(node.attributes.href, onLinkPress), children: children }, node.key))),
+    blocklink: linkRule((node, children, parent, styles, onLinkPress) => (_jsx(TouchableWithoutFeedback, { onPress: () => openUrl(node.attributes.href, onLinkPress), style: styles.blocklink, children: _jsx(View, { style: styles.image, children: children }) }, node.key))),
+    // Images
+    image: imageRule((node, children, parent, styles, allowedImageHandlers, defaultImageHandler) => {
+        const { src, alt } = node.attributes;
+        if (!src) {
+            return null;
+        }
+        // we check that the source starts with at least one of the elements in allowedImageHandlers
+        const show = allowedImageHandlers.filter((value) => {
+            return src.toLowerCase().startsWith(value.toLowerCase());
+        }).length > 0;
+        if (show === false && defaultImageHandler === null) {
+            return null;
+        }
+        const imageUri = show === true ? src : `${defaultImageHandler !== null && defaultImageHandler !== void 0 ? defaultImageHandler : ''}${src}`;
+        const imageProps = {
+            key: node.key,
+            style: styles._VIEW_SAFE_image,
+            source: {
+                uri: imageUri,
+            },
+        };
+        if (alt) {
+            imageProps.accessible = true;
+            imageProps.accessibilityLabel = alt;
+        }
+        return _jsx(Image, { ...imageProps });
+    }),
+    // Text Output
+    text: baseRule((node, children, parent, styles, inheritedStyles = {}) => (_jsx(Text, { style: [inheritedStyles, styles.text], children: node.content }, node.key))),
+    textgroup: baseRule((node, children, parent, styles) => (_jsx(Text, { style: styles.textgroup, children: children }, node.key))),
+    paragraph: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_paragraph, children: children }, node.key))),
+    hardbreak: baseRule((node, children, parent, styles) => (_jsx(Text, { style: styles.hardbreak, children: '\n' }, node.key))),
+    softbreak: baseRule((node, children, parent, styles) => (_jsx(Text, { style: styles.softbreak, children: '\n' }, node.key))),
+    // Believe these are never used but retained for completeness
+    pre: baseRule((node, children, parent, styles) => (_jsx(View, { style: styles._VIEW_SAFE_pre, children: children }, node.key))),
+    inline: baseRule((node, children, parent, styles) => (_jsx(Text, { style: styles.inline, children: children }, node.key))),
+    span: baseRule((node, children, parent, styles) => (_jsx(Text, { style: styles.span, children: children }, node.key))),
+};
+export default renderRules;

package/dist/esm/lib/styles.js

@@ -0,0 +1,180 @@
+import { Platform } from 'react-native';
+// this is converted to a stylesheet internally at run time with StyleSheet.create(
+export const styles = {
+    // The main container
+    body: {},
+    // Headings
+    heading1: {
+        flexDirection: 'row',
+        fontSize: 32,
+    },
+    heading2: {
+        flexDirection: 'row',
+        fontSize: 24,
+    },
+    heading3: {
+        flexDirection: 'row',
+        fontSize: 18,
+    },
+    heading4: {
+        flexDirection: 'row',
+        fontSize: 16,
+    },
+    heading5: {
+        flexDirection: 'row',
+        fontSize: 13,
+    },
+    heading6: {
+        flexDirection: 'row',
+        fontSize: 11,
+    },
+    // Horizontal Rule
+    hr: {
+        backgroundColor: '#000000',
+        height: 1,
+    },
+    // Emphasis
+    strong: {
+        fontWeight: 'bold',
+    },
+    em: {
+        fontStyle: 'italic',
+    },
+    s: {
+        textDecorationLine: 'line-through',
+    },
+    // Blockquotes
+    blockquote: {
+        backgroundColor: '#F5F5F5',
+        borderColor: '#CCC',
+        borderLeftWidth: 4,
+        marginLeft: 5,
+        paddingHorizontal: 5,
+    },
+    // Lists
+    bullet_list: {},
+    ordered_list: {},
+    list_item: {
+        flexDirection: 'row',
+        justifyContent: 'flex-start',
+    },
+    // @pseudo class, does not have a unique render rule
+    bullet_list_icon: {
+        marginLeft: 10,
+        marginRight: 10,
+    },
+    // @pseudo class, does not have a unique render rule
+    bullet_list_content: {
+        flex: 1,
+    },
+    // @pseudo class, does not have a unique render rule
+    ordered_list_icon: {
+        marginLeft: 10,
+        marginRight: 10,
+    },
+    // @pseudo class, does not have a unique render rule
+    ordered_list_content: {
+        flex: 1,
+    },
+    // Code
+    code_inline: {
+        borderWidth: 1,
+        borderColor: '#CCCCCC',
+        backgroundColor: '#f5f5f5',
+        padding: 10,
+        borderRadius: 4,
+        ...Platform.select({
+            ['ios']: {
+                fontFamily: 'Courier',
+            },
+            ['android']: {
+                fontFamily: 'monospace',
+            },
+        }),
+    },
+    code_block: {
+        borderWidth: 1,
+        borderColor: '#CCCCCC',
+        backgroundColor: '#f5f5f5',
+        padding: 10,
+        borderRadius: 4,
+        ...Platform.select({
+            ['ios']: {
+                fontFamily: 'Courier',
+            },
+            ['android']: {
+                fontFamily: 'monospace',
+            },
+        }),
+    },
+    fence: {
+        borderWidth: 1,
+        borderColor: '#CCCCCC',
+        backgroundColor: '#f5f5f5',
+        padding: 10,
+        borderRadius: 4,
+        ...Platform.select({
+            ['ios']: {
+                fontFamily: 'Courier',
+            },
+            ['android']: {
+                fontFamily: 'monospace',
+            },
+        }),
+    },
+    // Tables
+    table: {
+        borderWidth: 1,
+        borderColor: '#000000',
+        borderRadius: 3,
+    },
+    thead: {},
+    tbody: {},
+    th: {
+        flex: 1,
+        padding: 5,
+    },
+    tr: {
+        borderBottomWidth: 1,
+        borderColor: '#000000',
+        flexDirection: 'row',
+    },
+    td: {
+        flex: 1,
+        padding: 5,
+    },
+    // Links
+    link: {
+        textDecorationLine: 'underline',
+    },
+    blocklink: {
+        flex: 1,
+        borderColor: '#000000',
+        borderBottomWidth: 1,
+    },
+    // Images
+    image: {
+        flex: 1,
+    },
+    // Text Output
+    text: {},
+    textgroup: {},
+    paragraph: {
+        marginTop: 10,
+        marginBottom: 10,
+        flexWrap: 'wrap',
+        flexDirection: 'row',
+        alignItems: 'flex-start',
+        justifyContent: 'flex-start',
+        width: '100%',
+    },
+    hardbreak: {
+        width: '100%',
+        height: 1,
+    },
+    softbreak: {},
+    // Believe these are never used but retained for completeness
+    pre: {},
+    inline: {},
+    span: {},
+};

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

@@ -0,0 +1,8 @@
+export default class Token {
+    constructor(type, nesting = 0, children = null, block = false) {
+        this.type = type;
+        this.nesting = nesting;
+        this.children = children;
+        this.block = block;
+    }
+}

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

@@ -0,0 +1,55 @@
+import getTokenTypeByToken from './getTokenTypeByToken';
+import flattenInlineTokens from './flattenInlineTokens';
+import renderInlineAsText from './renderInlineAsText';
+export function cleanupTokens(tokens) {
+    tokens = flattenInlineTokens(tokens);
+    tokens.forEach((token) => {
+        var _a;
+        token.type = getTokenTypeByToken(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] = renderInlineAsText((_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/esm/lib/util/convertAdditionalStyles.js

@@ -0,0 +1,36 @@
+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;
+}
+export default 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/esm/lib/util/flattenInlineTokens.js

@@ -0,0 +1,14 @@
+export default 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/esm/lib/util/getTokenTypeByToken.js

@@ -0,0 +1,18 @@
+const regSelectOpenClose = /_open|_close/g;
+export default 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/esm/lib/util/getUniqueID.js

@@ -0,0 +1,5 @@
+let uuid = new Date().getTime();
+export default function getUniqueID() {
+    uuid++;
+    return `rnmr_${uuid.toString(16)}`;
+}

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

@@ -0,0 +1,24 @@
+import TokenGroup from './Token';
+export default function groupTextTokens(tokens) {
+    const result = [];
+    let hasGroup = false;
+    tokens.forEach((token) => {
+        if (!token.block && !hasGroup) {
+            hasGroup = true;
+            result.push(new TokenGroup('textgroup', 1));
+            result.push(token);
+        }
+        else if (!token.block && hasGroup) {
+            result.push(token);
+        }
+        else if (token.block && hasGroup) {
+            hasGroup = false;
+            result.push(new TokenGroup('textgroup', -1));
+            result.push(token);
+        }
+        else {
+            result.push(token);
+        }
+    });
+    return result;
+}

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

@@ -0,0 +1,3 @@
+export default function hasParents(parents, type) {
+    return parents.findIndex((el) => el.type === type) > -1;
+}

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

@@ -0,0 +1,30 @@
+export default 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/esm/lib/util/openUrl.js

@@ -0,0 +1,12 @@
+import { Linking } from 'react-native';
+export default function openUrl(url, customCallback) {
+    if (customCallback) {
+        const result = customCallback(url);
+        if (url && result && typeof result === 'boolean') {
+            Linking.openURL(url);
+        }
+    }
+    else if (url) {
+        Linking.openURL(url);
+    }
+}

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

@@ -0,0 +1,9 @@
+import textStyleProps from '../data/textStyleProps';
+export default function removeTextStyleProps(style) {
+    const intersection = textStyleProps.filter((value) => Object.keys(style).includes(value));
+    const obj = { ...style };
+    intersection.forEach((value) => {
+        delete obj[value];
+    });
+    return obj;
+}

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

@@ -0,0 +1,13 @@
+export default 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/esm/lib/util/splitTextNonTextNodes.js

@@ -0,0 +1,18 @@
+function isTextElement(node) {
+    if (typeof node.type === 'string') {
+        return node.type === 'Text';
+    }
+    const displayName = node.type.displayName;
+    return displayName === 'Text';
+}
+export default 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/esm/lib/util/stringToTokens.js

@@ -0,0 +1,10 @@
+export function stringToTokens(source, markdownIt) {
+    let result = [];
+    try {
+        result = markdownIt.parse(source, {});
+    }
+    catch (err) {
+        console.warn(err);
+    }
+    return result;
+}

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

@@ -0,0 +1,57 @@
+import getUniqueID from './getUniqueID';
+import getTokenTypeByToken from './getTokenTypeByToken';
+function createNode(token, tokenIndex) {
+    var _a, _b, _c;
+    const type = getTokenTypeByToken(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: `${getUniqueID()}_${type}`,
+        content,
+        tokenIndex,
+        index: 0,
+        attributes,
+        children: tokensToAST((_c = token.children) !== null && _c !== void 0 ? _c : []),
+    };
+}
+export default 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/esm/types.js

@@ -0,0 +1 @@
+export {};