@podlite/to-jsx 0.0.8 → 0.0.12

package/lib/index.js

@@ -1,14 +1,4 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
+"use strict";
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -20,66 +10,41 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import React from 'react';
-import toAny from 'pod6/built/exportAny';
-import { subUse, emptyContent, content as nodeContent, setFn } from 'pod6/built/helpers/handlers';
-import clean_plugin from 'pod6/built/plugin-clean-location';
-import makeAttrs from 'pod6/built/helpers/config';
-import { isNamedBlock, isSemanticBlock } from 'pod6/built/helpers/makeTransformer';
-import { parse } from 'pod6';
-import Writer from 'pod6/built/writer';
-import { podlite as podlite_core } from 'podlite';
-import Diagram from '@podlite/diagram';
-import { getNodeId } from '@podlite/schema';
-var helperMakeReact = function (_a) {
-    var wrapElement = _a.wrapElement;
-    var i_key_i = 0;
-    var mapByType = {};
-    var getIdForNode = function (_a) {
-        var _b = _a.type, type = _b === void 0 ? "notype" : _b, _c = _a.name, name = _c === void 0 ? "noname" : _c;
-        var type_idx = "".concat(type, "_").concat(name);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Podlite = void 0;
+const React = require("react");
+const react_1 = require("react");
+const exportAny_1 = require("pod6/built/exportAny");
+const handlers_1 = require("pod6/built/helpers/handlers");
+const plugin_clean_location_1 = require("pod6/built/plugin-clean-location");
+const config_1 = require("pod6/built/helpers/config");
+const makeTransformer_1 = require("pod6/built/helpers/makeTransformer");
+const pod6_1 = require("pod6");
+const writer_1 = require("pod6/built/writer");
+const podlite_1 = require("podlite");
+const diagram_1 = require("@podlite/diagram");
+const schema_1 = require("@podlite/schema");
+const helperMakeReact = ({ wrapElement }) => {
+    let i_key_i = 0;
+    let mapByType = {};
+    const getIdForNode = ({ type = "notype", name = "noname" }) => {
+        const type_idx = `${type}_${name}`;
         if (!mapByType[type_idx]) {
             mapByType[type_idx] = 0;
         }
         ++mapByType[type_idx];
-        return "".concat(type_idx, "_").concat(mapByType[type_idx]);
+        return `${type_idx}_${mapByType[type_idx]}`;
     };
-    return function (src, node, children, extraProps) {
-        if (extraProps === void 0) { extraProps = {}; }
+    return function (src, node, children, extraProps = {}) {
         // for string return it
         if (typeof node == 'string') {
             return node;
         }
-        var attr = __rest(node, []);
-        var key = 'type' in node && node.type ? getIdForNode(node) : ++i_key_i;
-        var result = typeof src === 'function'
-            ? src(__assign(__assign({}, attr), { key: key, children: children }), children)
-            : React.createElement(src, __assign(__assign({}, extraProps), { key: key }), children);
+        const attr = __rest(node, []);
+        const key = 'type' in node && node.type ? getIdForNode(node) : ++i_key_i;
+        const result = typeof src === 'function'
+            ? src(Object.assign(Object.assign({}, attr), { key, children }), children)
+            : (0, react_1.createElement)(src, Object.assign(Object.assign({}, extraProps), { key }), children);
         // // create react element and pass key
         // if (!isValidElementType(src)) {
         //     throw new Error(`Bad React element for ${ruleName} rule `)
@@ -90,167 +55,144 @@ var helperMakeReact = function (_a) {
         return result;
     };
 };
-var Podlite = function (_a) {
-    var children = _a.children, options = __rest(_a, ["children"]);
-    var result = podlite(children, options);
+const Podlite = (_a) => {
+    var { children } = _a, options = __rest(_a, ["children"]);
+    const result = podlite(children, options);
     return result;
 };
-var mapToReact = function (makeComponent) {
-    var mkComponent = function (src) { return function (writer, processor) { return function (node, ctx, interator) {
+exports.Podlite = Podlite;
+const mapToReact = (makeComponent) => {
+    const mkComponent = (src) => (writer, processor) => (node, ctx, interator) => {
         // check if node.content defined
-        return makeComponent(src, node, 'content' in node ? interator(node.content, __assign({}, ctx)) : []);
-    }; }; };
+        return makeComponent(src, node, 'content' in node ? interator(node.content, Object.assign({}, ctx)) : []);
+    };
     // Handle nested block and :nested block attribute
-    var handleNested = function (defaultHandler, implicitLevel) {
-        return function (writer, processor) {
-            var defaultHandlerInited = defaultHandler(writer, processor);
-            return function (node, ctx, interator) {
-                var nesting = makeAttrs(node, ctx).getFirstValue('nested') || implicitLevel;
-                var children = defaultHandlerInited(node, ctx, interator);
+    const handleNested = (defaultHandler, implicitLevel) => {
+        return (writer, processor) => {
+            const defaultHandlerInited = defaultHandler(writer, processor);
+            return (node, ctx, interator) => {
+                const nesting = (0, config_1.default)(node, ctx).getFirstValue('nested') || implicitLevel;
+                const children = defaultHandlerInited(node, ctx, interator);
                 // if no nesting needs - simply return children
                 if (!nesting) {
                     return children;
                 }
-                var arr = __spreadArray([], __read(Array(nesting).keys()), false);
-                return arr.reduce(function (acc) { return makeComponent('blockquote', node, acc); }, children);
+                const arr = [...Array(nesting).keys()];
+                return arr.reduce((acc) => makeComponent('blockquote', node, acc), children);
             };
         };
     };
     return {
         'pod': mkComponent('div'),
-        'root': nodeContent,
-        'data': emptyContent(),
-        ':ambient': emptyContent(),
-        ':code': mkComponent(function (_a) {
-            var children = _a.children, key = _a.key;
-            return React.createElement("code", { key: key },
-                React.createElement("pre", null, children));
-        }),
-        'code': mkComponent(function (_a) {
-            var children = _a.children, key = _a.key;
-            return React.createElement("code", { key: key },
-                React.createElement("pre", null, children));
-        }),
-        'Image': subUse({
+        'root': handlers_1.content,
+        'data': (0, handlers_1.emptyContent)(),
+        ':ambient': (0, handlers_1.emptyContent)(),
+        ':code': mkComponent(({ children, key }) => React.createElement("code", { key: key },
+            React.createElement("pre", null, children))),
+        'code': mkComponent(({ children, key }) => React.createElement("code", { key: key },
+            React.createElement("pre", null, children))),
+        'Image': (0, handlers_1.subUse)({
             // inside head don't wrap into <p>
-            ':image': setFn(function (node, ctx) {
-                var linkTo = ctx.link;
-                return mkComponent(function (_a) {
-                    var children = _a.children, key = _a.key;
-                    var Img = React.createElement("img", { key: key, src: node.src, alt: node.alt });
+            ':image': (0, handlers_1.setFn)((node, ctx) => {
+                const linkTo = ctx.link;
+                return mkComponent(({ children, key }) => {
+                    const Img = node.src.match(/(mp4|mov)$/)
+                        ? React.createElement("video", { controls: true, key: key },
+                            " ",
+                            React.createElement("source", { src: node.src, type: "video/mp4" }),
+                            " ")
+                        : React.createElement("img", { key: key, src: node.src, alt: node.alt });
                     return linkTo ? React.createElement("a", { key: key, href: linkTo }, Img) : Img;
                 });
             }),
-            'caption': mkComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return React.createElement("div", { className: "caption", key: key }, children);
-            })
-        }, setFn(function (node, ctx) {
-            var level = node.level;
-            var id = getNodeId(node, ctx);
-            var conf = makeAttrs(node, ctx);
+            'caption': mkComponent(({ children, key }) => React.createElement("div", { className: "caption", key: key }, children))
+        }, (0, handlers_1.setFn)((node, ctx) => {
+            const { level } = node;
+            const id = (0, schema_1.getNodeId)(node, ctx);
+            const conf = (0, config_1.default)(node, ctx);
             if (conf.exists('link')) {
                 ctx.link = conf.getFirstValue('link');
             }
-            return mkComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return React.createElement("div", { className: "image_block", key: key, id: id }, children);
-            });
+            return mkComponent(({ children, key }) => React.createElement("div", { className: "image_block", key: key, id: id }, children));
         })),
-        'image': nodeContent,
-        ':image': setFn(function (node, ctx) {
-            return mkComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return React.createElement("img", { key: key, src: node.src, alt: node.alt });
-            });
+        'image': handlers_1.content,
+        ':image': (0, handlers_1.setFn)((node, ctx) => {
+            return mkComponent(({ children, key }) => React.createElement("img", { key: key, src: node.src, alt: node.alt }));
         }),
-        'Diagram': function () { return function (node, ctx, interator) {
-            var conf = makeAttrs(node, ctx);
-            var caption = conf.exists("caption")
+        'Diagram': () => (node, ctx, interator) => {
+            const conf = (0, config_1.default)(node, ctx);
+            const caption = conf.exists("caption")
                 ? conf.getFirstValue("caption")
                 : null;
-            var id = getNodeId(node, ctx);
-            return makeComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return React.createElement(Diagram, { id: id, isError: node.custom, caption: caption, chart: node.content[0].value });
-            }, node, interator(node.content, __assign({}, ctx)));
-        }; },
-        ':text': function (writer, processor) { return function (node, ctx, interator) {
+            const id = (0, schema_1.getNodeId)(node, ctx);
+            return makeComponent(({ children, key }) => {
+                return React.createElement(diagram_1.default, { id: id, isError: node.custom, caption: caption, chart: node.content[0].value });
+            }, node, interator(node.content, Object.assign({}, ctx)));
+        },
+        ':text': (writer, processor) => (node, ctx, interator) => {
             return node.value;
-        }; },
-        ':verbatim': function (writer, processor) { return function (node, ctx, interator) {
+        },
+        ':verbatim': (writer, processor) => (node, ctx, interator) => {
             return node.value;
-        }; },
-        'head:block': subUse({
+        },
+        'head:block': (0, handlers_1.subUse)({
             // inside head don't wrap into <p>
-            ':para': nodeContent,
-        }, setFn(function (node, ctx) {
-            var level = node.level;
-            var id = getNodeId(node, ctx);
-            return mkComponent(function (_a) {
-                var level = _a.level, children = _a.children, key = _a.key;
-                return React.createElement("h".concat(level), { key: key, id: id }, children);
-            });
+            ':para': handlers_1.content,
+        }, (0, handlers_1.setFn)((node, ctx) => {
+            const { level } = node;
+            const id = (0, schema_1.getNodeId)(node, ctx);
+            return mkComponent(({ level, children, key }) => (0, react_1.createElement)(`h${level}`, { key, id }, children));
         })),
-        ':blankline': emptyContent(),
+        ':blankline': (0, handlers_1.emptyContent)(),
         ':para': mkComponent('p'),
         'para': mkComponent('div'),
-        'comment:block': emptyContent(),
-        'defn': subUse([
+        'comment:block': (0, handlers_1.emptyContent)(),
+        'defn': (0, handlers_1.subUse)([
             // to avoid overlap para blocks handlers
             // define general :para at first
             { ':para': mkComponent('dd') },
             { 'term:para': mkComponent('dt') },
-        ], nodeContent),
-        "nested": handleNested(nodeContent, 1),
-        'output': mkComponent(function (_a) {
-            var children = _a.children, key = _a.key;
-            return React.createElement("pre", { key: key },
-                React.createElement("samp", null, children));
-        }),
-        'input': mkComponent(function (_a) {
-            var children = _a.children, key = _a.key;
-            return React.createElement("pre", { key: key },
-                React.createElement("kbd", null, children));
-        }),
+        ], handlers_1.content),
+        "nested": handleNested(handlers_1.content, 1),
+        'output': mkComponent(({ children, key }) => React.createElement("pre", { key: key },
+            React.createElement("samp", null, children))),
+        'input': mkComponent(({ children, key }) => React.createElement("pre", { key: key },
+            React.createElement("kbd", null, children))),
         // Directives 
-        ':config': setFn(function (node, ctx) {
+        ':config': (0, handlers_1.setFn)((node, ctx) => {
             // setup context
             if (!ctx.hasOwnProperty('config'))
                 ctx.config = {};
             //collect configs in context
             ctx.config[node.name] = node.config;
-            return emptyContent();
+            return (0, handlers_1.emptyContent)();
         }),
-        ':alias': setFn(function (node, ctx) {
+        ':alias': (0, handlers_1.setFn)((node, ctx) => {
             // set alias
             if (!ctx.hasOwnProperty('alias'))
                 ctx.alias = {};
             //collect configs in context
             ctx.alias[node.name] = node.replacement;
-            return emptyContent();
+            return (0, handlers_1.emptyContent)();
         }),
         // Formatting codes
-        'A<>': function (writer, processor) { return function (node, ctx, interator) {
-            var term = node.content;
+        'A<>': (writer, processor) => (node, ctx, interator) => {
+            let term = node.content;
             if (typeof term !== 'string' && 'value' in term) {
                 term = term.value;
             }
             //get replacement text
             if (!(ctx.alias && ctx.alias.hasOwnProperty(term))) {
-                return makeComponent(function (_a) {
-                    var children = _a.children, key = _a.key;
-                    return React.createElement("code", { key: key },
-                        "A<",
-                        children,
-                        ">");
-                }, node, interator(node.content, ctx));
+                return makeComponent(({ children, key }) => React.createElement("code", { key: key },
+                    "A<",
+                    children,
+                    ">"), node, interator(node.content, ctx));
             }
             else {
-                var src = ctx.alias[term].join('\n');
-                var tree_1 = processor(src);
+                const src = ctx.alias[term].join('\n');
+                const tree_1 = processor(src);
                 // now clean locations
-                var tree = clean_plugin()(tree_1);
+                const tree = (0, plugin_clean_location_1.default)()(tree_1);
                 if (tree[0].type === 'para') {
                     return interator(tree[0].content, ctx);
                 }
@@ -258,15 +200,15 @@ var mapToReact = function (makeComponent) {
                     return interator(tree, ctx);
                 }
             }
-        }; },
+        },
         'B<>': mkComponent('strong'),
         'C<>': mkComponent('code'),
-        'E<>': function (writer, processor) { return function (node, ctx, interator) {
+        'E<>': (writer, processor) => (node, ctx, interator) => {
             if ('content' in node && Array.isArray(node.content))
-                return node.content.filter(function (e) { return e && e.type == 'number'; }).map(function (element) {
+                return node.content.filter(e => e && e.type == 'number').map(element => {
                     return String.fromCharCode(element.value);
                 }).join('');
-        }; },
+        },
         'I<>': mkComponent('i'),
         'K<>': mkComponent('kbd'),
         /**
@@ -281,33 +223,30 @@ var mapToReact = function (makeComponent) {
     border-top-color: #eee;
     }
      */
-        'N<>': function (writer, processor) {
-            writer.addListener('end', function () {
+        'N<>': (writer, processor) => {
+            writer.addListener('end', () => {
                 if (!writer.hasOwnProperty('FOOTNOTES')) {
                     return;
                 }
-                var footnotes = writer.FOOTNOTES;
+                const footnotes = writer.FOOTNOTES;
                 if (footnotes.length < 1) {
                     return;
                 } // if empty footnotes
                 if (!writer.hasOwnProperty('postInterator')) {
                     writer.postInterator = [];
                 }
-                var FootNotes = makeComponent(function (_a) {
-                    var children = _a.children, key = _a.key;
-                    return React.createElement("div", { key: "".concat(key, "_FOOTNOTES"), className: "footnotes" }, footnotes.map(function (footnote, id) {
-                        return React.createElement("p", { key: id },
-                            React.createElement("sup", { id: footnote.fnId, className: "footnote" },
-                                React.createElement("a", { href: "#".concat(footnote.fnRefId) },
-                                    "[",
-                                    footnote.gid,
-                                    "]")),
-                            footnote.make());
-                    }));
-                }, {});
+                const FootNotes = makeComponent(({ children, key }) => React.createElement("div", { key: `${key}_FOOTNOTES`, className: "footnotes" }, footnotes.map((footnote, id) => {
+                    return React.createElement("p", { key: id },
+                        React.createElement("sup", { id: footnote.fnId, className: "footnote" },
+                            React.createElement("a", { href: `#${footnote.fnRefId}` },
+                                "[",
+                                footnote.gid,
+                                "]")),
+                        footnote.make());
+                })), {});
                 writer.postInterator.push(FootNotes);
             });
-            return function (node, ctx, interator) {
+            return (node, ctx, interator) => {
                 // skip empty notes
                 if (node.content.length < 1) {
                     return;
@@ -316,45 +255,42 @@ var mapToReact = function (makeComponent) {
                     writer.gid = 1;
                 }
                 // get foot note id
-                var gid = writer.gid++;
-                var fnRefId = "fnref:".concat(gid);
-                var fnId = "fn:".concat(gid);
+                const gid = writer.gid++;
+                const fnRefId = `fnref:${gid}`;
+                const fnId = `fn:${gid}`;
                 if (!writer.hasOwnProperty('FOOTNOTES')) {
                     writer.FOOTNOTES = [];
                 }
                 writer.FOOTNOTES.push({
-                    gid: gid,
-                    fnRefId: fnRefId,
-                    fnId: fnId,
-                    node: node,
-                    make: function () { return interator(node.content, ctx); }
+                    gid,
+                    fnRefId,
+                    fnId,
+                    node,
+                    make: () => { return interator(node.content, ctx); }
                 });
-                return makeComponent(function (_a) {
-                    var children = _a.children, key = _a.key;
-                    return React.createElement("sup", { key: key, id: fnRefId, className: "footnote" },
-                        React.createElement("a", { href: "#".concat(fnId) },
-                            "[",
-                            gid,
-                            "]"));
-                }, node);
+                return makeComponent(({ children, key }) => React.createElement("sup", { key: key, id: fnRefId, className: "footnote" },
+                    React.createElement("a", { href: `#${fnId}` },
+                        "[",
+                        gid,
+                        "]")), node);
             };
         },
         'R<>': mkComponent('var'),
         'T<>': mkComponent('samp'),
-        'D<>': function (writer, processor) { return function (node, ctx, interator) {
-            var synonyms = node.synonyms;
-            var definition = [node.content[0]];
+        'D<>': (writer, processor) => (node, ctx, interator) => {
+            let { synonyms } = node;
+            let definition = [node.content[0]];
             if (synonyms) {
                 definition = synonyms;
             }
             if (!writer.hasOwnProperty('DEFINITIONS')) {
                 writer.DEFINITIONS = [];
             }
-            writer.DEFINITIONS.push({ definition: definition });
+            writer.DEFINITIONS.push({ definition });
             return makeComponent('dfn', node, interator(node.content, ctx));
-        }; },
-        "L<>": setFn(function (node, ctx) {
-            var meta = node.meta;
+        },
+        "L<>": (0, handlers_1.setFn)((node, ctx) => {
+            let { meta } = node;
             if (meta === null) {
                 meta = node.content;
             }
@@ -365,33 +301,27 @@ var mapToReact = function (makeComponent) {
             if (meta && typeof meta !== 'string' && 'value' in meta) {
                 meta = meta.value;
             }
-            return mkComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return React.createElement("a", { href: meta, key: key }, children);
-            });
+            return mkComponent(({ children, key }) => React.createElement("a", { href: meta, key: key }, children));
         }),
-        'S<>': function (writer, processor) { return function (node, ctx, interator) {
-            var content = node.content || '';
+        'S<>': (writer, processor) => (node, ctx, interator) => {
+            let content = node.content || '';
             if (typeof content !== 'string' && 'value' in content) {
                 content = content.value;
             }
-            var Content = content.split('').map(function (symbol, index) {
+            const Content = content.split('').map((symbol, index) => {
                 if (symbol === ' ')
                     return "\u00a0";
                 if (symbol === '\n')
                     return React.createElement("br", { key: index });
                 return symbol;
             });
-            return makeComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return children;
-            }, {}, Content);
-        }; },
-        'V<>': nodeContent,
-        'Z<>': emptyContent(),
+            return makeComponent(({ children, key }) => children, {}, Content);
+        },
+        'V<>': handlers_1.content,
+        'Z<>': (0, handlers_1.emptyContent)(),
         'U<>': mkComponent('u'),
-        'X<>': function (writer, processor) { return function (node, ctx, interator) {
-            var entry = node.entry;
+        'X<>': (writer, processor) => (node, ctx, interator) => {
+            let { entry } = node;
             if (entry === null && node.content.length > 0) {
                 //@ts-ignore
                 entry = [node.content[0]];
@@ -401,46 +331,42 @@ var mapToReact = function (makeComponent) {
                 writer.INDEXTERMS = [];
             }
             writer.INDEXTERMS.push({
-                entry: entry
+                entry
             });
             return interator(node.content, ctx);
-        }; },
+        },
         // table section
-        'table': function (writer, processor) {
-            return function (node, ctx, interator) {
-                var conf = makeAttrs(node, ctx);
-                var attr = { caption: '' };
-                if (conf.exists('caption')) {
-                    var caption = conf.getFirstValue('caption');
-                    attr.caption = caption;
-                }
-                if (typeof node === 'string') {
-                    return node;
-                }
-                if (!('content' in node)) {
-                    console.warn('[jsx] no content in node');
-                    return '';
-                }
-                return makeComponent(function (_a) {
-                    var key = _a.key, children = _a.children;
-                    return React.createElement("table", { key: key },
-                        React.createElement("caption", { className: "caption" }, attr.caption),
-                        React.createElement("tbody", null, children));
-                }, node, interator(node.content, __assign({}, ctx)));
-            };
+        'table': (writer, processor) => (node, ctx, interator) => {
+            const conf = (0, config_1.default)(node, ctx);
+            let attr = { caption: '' };
+            if (conf.exists('caption')) {
+                const caption = conf.getFirstValue('caption');
+                attr.caption = caption;
+            }
+            if (typeof node === 'string') {
+                return node;
+            }
+            if (!('content' in node)) {
+                console.warn('[jsx] no content in node');
+                return '';
+            }
+            const id = (0, schema_1.getNodeId)(node, ctx);
+            return makeComponent(({ key, children }) => {
+                return React.createElement("table", { key: key, id: id },
+                    React.createElement("caption", { className: "caption" }, attr.caption),
+                    React.createElement("tbody", null, children));
+            }, node, interator(node.content, Object.assign({}, ctx)));
         },
-        ':separator': emptyContent(),
+        ':separator': (0, handlers_1.emptyContent)(),
         'table_row': mkComponent('tr'),
         'table_cell': mkComponent('td'),
-        'table_head': subUse({
+        'table_head': (0, handlers_1.subUse)({
             'table_cell': mkComponent('th')
         }, mkComponent('tr')),
-        ':list': setFn(function (node, ctx) {
-            return node.list === 'ordered' ? mkComponent('ol')
-                : node.list === 'variable' ? mkComponent('dl')
-                    : mkComponent('ul');
-        }),
-        'item:block': function (writer, processor) { return function (node, ctx, interator) {
+        ':list': (0, handlers_1.setFn)((node, ctx) => node.list === 'ordered' ? mkComponent('ol')
+            : node.list === 'variable' ? mkComponent('dl')
+                : mkComponent('ul')),
+        'item:block': (writer, processor) => (node, ctx, interator) => {
             if (typeof node === 'string') {
                 return node;
             }
@@ -452,78 +378,64 @@ var mapToReact = function (makeComponent) {
             if (!(node.content instanceof Array)) {
                 console.error(node);
             }
-            var id = getNodeId(node, ctx);
-            return makeComponent('li', node, interator(node.content, __assign({}, ctx)), { id: id });
-        }; },
+            const id = (0, schema_1.getNodeId)(node, ctx);
+            return makeComponent('li', node, interator(node.content, Object.assign({}, ctx)), { id });
+        },
         // table of content
-        ':toc': setFn(function (node, ctx) {
-            var tocTitle = node.title;
-            return mkComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return React.createElement("div", { className: "toc", key: key },
-                    tocTitle ? React.createElement("div", { className: "toctitle" }, tocTitle) : '',
-                    children);
-            });
+        ':toc': (0, handlers_1.setFn)((node, ctx) => {
+            const tocTitle = node.title;
+            return mkComponent(({ children, key }) => React.createElement("div", { className: "toc", key: key },
+                tocTitle ? React.createElement("div", { className: "toctitle" }, tocTitle) : '',
+                children));
         }),
-        ':toc-list': setFn(function (node, ctx) {
-            var level = node.level;
-            return mkComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return React.createElement("ul", { className: "toc-list listlevel".concat(level), key: key }, children);
-            });
+        ':toc-list': (0, handlers_1.setFn)((node, ctx) => {
+            const { level } = node;
+            return mkComponent(({ children, key }) => React.createElement("ul", { className: `toc-list listlevel${level}`, key: key }, children));
         }),
-        ':toc-item': subUse({
+        ':toc-item': (0, handlers_1.subUse)({
             // inside head don't wrap into <p>
-            ':para': nodeContent,
-        }, setFn(function (node, ctx) {
-            return mkComponent(function (_a) {
-                var children = _a.children, key = _a.key;
-                return React.createElement("li", { className: "toc-item", key: key }, children);
-            });
+            ':para': handlers_1.content,
+        }, (0, handlers_1.setFn)((node, ctx) => {
+            return mkComponent(({ children, key }) => React.createElement("li", { className: "toc-item", key: key }, children));
         })),
     };
 };
-function podlite(children, _a) {
-    var file = _a.file, _b = _a.plugins, plugins = _b === void 0 ? function () { } : _b, wrapElement = _a.wrapElement, tree = _a.tree;
-    var args = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        args[_i - 2] = arguments[_i];
-    }
-    var ast = (function (tree) {
+function podlite(children, { file, plugins = () => { }, wrapElement, tree }, ...args) {
+    const ast = ((tree) => {
         if (tree)
             return tree.interator;
-        var podlite = podlite_core({ importPlugins: true });
-        var treeAfterParsed = podlite.parse(children || file);
+        let podlite = (0, podlite_1.podlite)({ importPlugins: true });
+        let treeAfterParsed = podlite.parse(children || file);
         return podlite.toAst(treeAfterParsed);
     })(tree);
     // const   ast = parse( children || content )
-    var i_key_i = 10000;
-    var makeComponent = helperMakeReact({ wrapElement: wrapElement });
+    let i_key_i = 10000;
+    const makeComponent = helperMakeReact({ wrapElement });
     // TODO: move toJSX to podlite/core
     // const toJSXPlugins= toAnyRules('toJSX', instance.getPlugins())
-    var rules = __assign(__assign({}, mapToReact(makeComponent)), plugins(makeComponent));
-    var writer = new Writer(function (s) {
+    const rules = Object.assign(Object.assign({}, mapToReact(makeComponent)), plugins(makeComponent));
+    const writer = new writer_1.default((s) => {
     });
-    var res = toAny({ processor: parse })
-        .use({ '*:*': function () { return function (node, ctx, interator) {
+    const res = (0, exportAny_1.default)({ processor: pod6_1.parse })
+        .use({ '*:*': () => (node, ctx, interator) => {
             // skip named blocks
-            if (isNamedBlock(node.name)) {
+            if ((0, makeTransformer_1.isNamedBlock)(node.name)) {
                 return null;
             }
-            if (isSemanticBlock(node)) {
-                return makeComponent(function (_a) {
-                    var key = _a.key, children = _a.children;
+            if ((0, makeTransformer_1.isSemanticBlock)(node)) {
+                return makeComponent(({ key, children }) => {
                     return React.createElement("div", { key: key },
                         React.createElement("h1", { className: node.name, key: key }, node.name),
-                        interator(node.content, __assign({}, ctx)));
-                }, node, interator(node.content, __assign({}, ctx)));
+                        interator(node.content, Object.assign({}, ctx)));
+                }, node, interator(node.content, Object.assign({}, ctx)));
             }
             console.warn('[podlite] Not supported: ' + JSON.stringify(node, null, 2));
-            return React.createElement('code', { key: ++i_key_i }, "not supported node:".concat(JSON.stringify(node, null, 2)));
-        }; } })
+            return (0, react_1.createElement)('code', { key: ++i_key_i }, `not supported node:${JSON.stringify(node, null, 2)}`);
+        } })
         .use(rules)
         .run(ast, writer);
     // union main react elements and post processed via onEnd event
     return new Array().concat(res.interator, writer.postInterator);
 }
-export default Podlite;
+exports.default = exports.Podlite;
+//# sourceMappingURL=index.js.map