@podlite/to-jsx 0.0.15 → 0.0.17

package/CHANGELOG.md

@@ -1,45 +1,79 @@
 # @podlite/to-jsx
 
 ## Upcoming
+
+## 0.0.17
+
+- refactor
+
+## 0.0.16
+
+- refactor
+
 ## 0.0.15
+
 - refactor logic for plugins
+
 ## 0.0.14
+
 - add Strikethrough inline element support
 - add toJSX support
+
 ## 0.0.13
+
 - update deps
+
 ## 0.0.12
+
 - fix imports
 - update deps
+
 ## 0.0.11
+
 - use <video> tags for mov/mp4 media
 - update deps
+
 ## 0.0.10
+
 - fix id for =table
+
 ## 0.0.9
+
 - fix npm
+
 ## 0.0.8
+
 - add support for =Image
 - add caption for =Diagram
 - add support for id html attribute
+
 ## 0.0.7
+
 - fix deps
+
 ## 0.0.6
+
 - fix process empty L<>
 
 ## 0.0.5
+
 - update deps
 - declare tree arg
+
 ## 0.0.4
+
 - update deps
+
 ## 0.0.3
+
 - update deps
 
 ## 0.0.2
+
 - implement =defn
 - implemnt =nested
 - fix dependencies
 
 ## 0.0.1
-- initial version
 
+- initial version

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 Alexandr Zahatski
+Copyright © 2021-2024 Aliaksandr Zahatski
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1 +1,41 @@
-# @podlite/to-jsx
+# @podlite/to-jsx
+
+<div align="center">
+
+[![Podlite](https://github.com/zag/specs/raw/podlite-specification/assets/podlite_logo_256x256.png)](https://podlite.org)
+
+</div>
+
+**Podlite is a lightweight block-based markup language designed for flexibility and ease of use.**
+
+Unbound by any specific domain, programming language, or concept, Podlite stands out as a universal markup language. It's versatile enough to be successfully implemented across various development fields, from web development to scientific research.
+
+Podlite is not limited to any specific application domain, programming language, or concept.
+
+In addition, the support for Markdown markup as a standard block adds convenience and allows for the use of familiar syntax for text formatting.
+
+One of the key features of Podlite is its extensibility. This allows for defining unique and domain-specific blocks and expanding the language's functionality according to the requirements of your project.
+
+Its flexibility makes it an ideal tool for creating documentation, blogs, educational materials, and much more.
+
+Podlite aims to provide users with a means for creativity and expressing ideas in a structured form, while ensuring ease of use and high flexibility in content creation.
+
+## Useful links
+
+📖 _Project site_: [podlite.org](https://podlite.org)
+
+📌 _Github_: [github.com/podlite](https://github.com/podlite/) 🤩
+
+🖥️ _Online editor_: [pod6.in](https://pod6.in/)
+
+🖥️ _Desktop editor/viewer_: [github.com/podlite/podlite-desktop](https://github.com/podlite/podlite-desktop) - the viewer and editor of `.podlite` and `.pod6` files for Windows, Linux and Mac.
+
+📚 _Podlite for web_ - static site generator: [github.com/podlite/podlite-web](https://github.com/podlite/podlite-web)
+
+## AUTHOR
+
+Copyright (c) 2021-2024 Aliaksandr Zahatski
+
+## License
+
+Released under a MIT License.

package/index.js

@@ -1,2 +1,2 @@
 'use strict'
-module.exports = require('./lib')
+module.exports = require('./lib')

package/jest.config.js

@@ -1,2 +1 @@
-
 module.exports = require('../../jest.config')

package/jest.tsconfig.json

@@ -1 +1 @@
-{"extends": "../../jest.tsconfig.json"}
+{ "extends": "../../jest.tsconfig.json" }

package/lib/index.d.ts

@@ -1,6 +1,5 @@
 import * as React from 'react';
-import { PodliteExport } from 'podlite';
-import { PodNode } from '@podlite/schema';
+import { PodNode, PodliteExport } from '@podlite/schema';
 export declare type CreateElement = typeof React.createElement;
 export interface WrapElement {
     (node: PodNode, children: React.ReactChild, ctx: any): JSX.Element;
@@ -16,9 +15,9 @@ export declare const Podlite: React.FC<{
 export declare const TestPodlite: ({ children, ...options }: {
     [x: string]: any;
     children: any;
-}) => JSX.Element;
-export declare const makeTestPodlite: (podlite?: import("podlite").Podlite) => ({ children, ...options }: {
+}) => React.JSX.Element;
+export declare const makeTestPodlite: (podlite?: import("@podlite/schema").Podlite) => ({ children, ...options }: {
     [x: string]: any;
     children: any;
-}) => JSX.Element;
+}) => React.JSX.Element;
 export default Podlite;

package/lib/index.js

@@ -1,32 +1,12 @@
-"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)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTestPodlite = exports.TestPodlite = 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 schema_1 = require("@podlite/schema");
+import * as React from 'react';
+import { createElement } from 'react';
+import { podlite as podlite_core } from 'podlite';
+import { getNodeId, parse, makeAttrs, emptyContent, content as nodeContent, setFn, subUse, toAny, isNamedBlock, isSemanticBlock, Writer, toAnyRules, frozenIds, } from '@podlite/schema';
+import { pluginCleanLocation as clean_plugin } from '@podlite/schema';
 const helperMakeReact = ({ wrapElement }) => {
     let i_key_i = 0;
     let mapByType = {};
-    const getIdForNode = ({ type = "notype", name = "noname" }) => {
+    const getIdForNode = ({ type = 'notype', name = 'noname' }) => {
         const type_idx = `${type}_${name}`;
         if (!mapByType[type_idx]) {
             mapByType[type_idx] = 0;
@@ -39,11 +19,11 @@ const helperMakeReact = ({ wrapElement }) => {
         if (typeof node == 'string') {
             return node;
         }
-        const attr = __rest(node, []);
+        const { ...attr } = 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);
+            ? src({ ...attr, key, children }, children)
+            : createElement(src, { ...extraProps, key }, children);
         // // create react element and pass key
         // if (!isValidElementType(src)) {
         //     throw new Error(`Bad React element for ${ruleName} rule `)
@@ -54,47 +34,45 @@ const helperMakeReact = ({ wrapElement }) => {
         return result;
     };
 };
-const Podlite = (_a) => {
-    var { children } = _a, options = __rest(_a, ["children"]);
+export const Podlite = ({ children, ...options }) => {
     const result = podlite(children, options);
     return result;
 };
-exports.Podlite = Podlite;
 const mapToReact = (makeComponent) => {
-    const mkComponent = (src) => (writer, processor) => (node, ctx, interator) => {
+    const mkComponent = src => (writer, processor) => (node, ctx, interator) => {
         // prepare extraProps for createElement
         // add id attribute if exists
-        const id = (0, schema_1.getNodeId)(node, ctx);
+        const id = getNodeId(node, ctx)?.replace(/\s/g, '-');
         // check if node.content defined
-        return makeComponent(src, node, 'content' in node ? interator(node.content, Object.assign({}, ctx)) : [], { id }, ctx);
+        return makeComponent(src, node, 'content' in node ? interator(node.content, { ...ctx }) : [], { id }, ctx);
     };
     // Handle nested block and :nested block attribute
     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 nesting = makeAttrs(node, ctx).getFirstValue('nested') || implicitLevel;
                 const children = defaultHandlerInited(node, ctx, interator);
                 // if no nesting needs - simply return children
                 if (!nesting) {
                     return children;
                 }
                 const arr = [...Array(nesting).keys()];
-                return arr.reduce((acc) => makeComponent('blockquote', node, acc), children);
+                return arr.reduce(acc => makeComponent('blockquote', node, acc), children);
             };
         };
     };
     return {
-        'pod': mkComponent('div'),
-        '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': handlers_1.content,
-        ':image': (0, handlers_1.setFn)((node, ctx) => {
+        pod: mkComponent('div'),
+        root: nodeContent,
+        data: emptyContent(),
+        ':ambient': 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: nodeContent,
+        ':image': setFn((node, ctx) => {
             return mkComponent(({ children, key }) => React.createElement("img", { key: key, src: node.src, alt: node.alt }));
         }),
         ':text': (writer, processor) => (node, ctx, interator) => {
@@ -103,45 +81,45 @@ const mapToReact = (makeComponent) => {
         ':verbatim': (writer, processor) => (node, ctx, interator) => {
             return node.value;
         },
-        'head:block': (0, handlers_1.subUse)({
+        'head:block': subUse({
             // inside head don't wrap into <p>
-            ':para': handlers_1.content,
-        }, (0, handlers_1.setFn)((node, ctx) => {
+            ':para': nodeContent,
+        }, 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));
+            const id = getNodeId(node, ctx)?.replace(/\s/g, '-');
+            return mkComponent(({ level, children, key }) => createElement(`h${level}`, { key, id }, children));
         })),
-        ':blankline': (0, handlers_1.emptyContent)(),
+        ':blankline': emptyContent(),
         ':para': mkComponent('p'),
-        'para': mkComponent('div'),
-        'comment:block': (0, handlers_1.emptyContent)(),
-        'defn': (0, handlers_1.subUse)([
+        para: mkComponent('div'),
+        'comment:block': emptyContent(),
+        defn: subUse([
             // to avoid overlap para blocks handlers
             // define general :para at first
             { ':para': mkComponent('dd') },
             { 'term:para': mkComponent('dt') },
-        ], 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': (0, handlers_1.setFn)((node, ctx) => {
+        ], nodeContent),
+        nested: handleNested(nodeContent, 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((node, ctx) => {
             // setup context
             if (!ctx.hasOwnProperty('config'))
                 ctx.config = {};
             //collect configs in context
             ctx.config[node.name] = node.config;
-            return (0, handlers_1.emptyContent)();
+            return emptyContent();
         }),
-        ':alias': (0, handlers_1.setFn)((node, ctx) => {
+        ':alias': setFn((node, ctx) => {
             // set alias
             if (!ctx.hasOwnProperty('alias'))
                 ctx.alias = {};
             //collect configs in context
             ctx.alias[node.name] = node.replacement;
-            return (0, handlers_1.emptyContent)();
+            return emptyContent();
         }),
         // Formatting codes
         'A<>': (writer, processor) => (node, ctx, interator) => {
@@ -160,7 +138,7 @@ const mapToReact = (makeComponent) => {
                 const src = ctx.alias[term].join('\n');
                 const tree_1 = processor(src);
                 // now clean locations
-                const tree = (0, plugin_clean_location_1.default)()(tree_1);
+                const tree = clean_plugin()(tree_1);
                 if (tree[0].type === 'para') {
                     return interator(tree[0].content, ctx);
                 }
@@ -173,24 +151,27 @@ const mapToReact = (makeComponent) => {
         'C<>': mkComponent('code'),
         'E<>': (writer, processor) => (node, ctx, interator) => {
             if ('content' in node && Array.isArray(node.content))
-                return node.content.filter(e => e && e.type == 'number').map(element => {
+                return node.content
+                    .filter(e => e && e.type == 'number')
+                    .map(element => {
                     return String.fromCharCode(element.value);
-                }).join('');
+                })
+                    .join('');
         },
         'I<>': mkComponent('i'),
         'K<>': mkComponent('kbd'),
         /**
-     * CSS rules for footnotes
-     
-    .footnote a {
-        text-decoration: none;
-    }
-    .footnotes {
-    border-top-style: solid;
-    border-top-width: 1px;
-    border-top-color: #eee;
-    }
-     */
+         * CSS rules for footnotes
+         
+        .footnote a {
+            text-decoration: none;
+        }
+        .footnotes {
+        border-top-style: solid;
+        border-top-width: 1px;
+        border-top-color: #eee;
+        }
+         */
         'N<>': (writer, processor) => {
             writer.addListener('end', () => {
                 if (!writer.hasOwnProperty('FOOTNOTES')) {
@@ -203,15 +184,15 @@ const mapToReact = (makeComponent) => {
                 if (!writer.hasOwnProperty('postInterator')) {
                     writer.postInterator = [];
                 }
-                const FootNotes = makeComponent(({ children, key }) => React.createElement("div", { key: `${key}_FOOTNOTES`, className: "footnotes" }, footnotes.map((footnote, id) => {
-                    return React.createElement("p", { key: id },
+                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());
-                })), {});
+                        footnote.make()));
+                }))), {});
                 writer.postInterator.push(FootNotes);
             });
             return (node, ctx, interator) => {
@@ -234,13 +215,15 @@ const mapToReact = (makeComponent) => {
                     fnRefId,
                     fnId,
                     node,
-                    make: () => { return interator(node.content, ctx); }
+                    make: () => {
+                        return interator(node.content, ctx);
+                    },
                 });
-                return makeComponent(({ children, key }) => React.createElement("sup", { key: key, id: fnRefId, className: "footnote" },
+                return makeComponent(({ children, key }) => (React.createElement("sup", { key: key, id: fnRefId, className: "footnote" },
                     React.createElement("a", { href: `#${fnId}` },
                         "[",
                         gid,
-                        "]")), node);
+                        "]"))), node);
             };
         },
         'R<>': mkComponent('var'),
@@ -257,7 +240,7 @@ const mapToReact = (makeComponent) => {
             writer.DEFINITIONS.push({ definition });
             return makeComponent('dfn', node, interator(node.content, ctx));
         },
-        "L<>": (0, handlers_1.setFn)((node, ctx) => {
+        'L<>': setFn((node, ctx) => {
             let { meta } = node;
             if (meta === null) {
                 meta = node.content;
@@ -269,7 +252,7 @@ const mapToReact = (makeComponent) => {
             if (meta && typeof meta !== 'string' && 'value' in meta) {
                 meta = meta.value;
             }
-            return mkComponent(({ children, key }) => React.createElement("a", { href: meta, key: key }, children));
+            return mkComponent(({ children, key }) => (React.createElement("a", { href: meta, key: key }, children)));
         }),
         'S<>': (writer, processor) => (node, ctx, interator) => {
             let content = node.content || '';
@@ -278,15 +261,15 @@ const mapToReact = (makeComponent) => {
             }
             const Content = content.split('').map((symbol, index) => {
                 if (symbol === ' ')
-                    return "\u00a0";
+                    return '\u00a0';
                 if (symbol === '\n')
                     return React.createElement("br", { key: index });
                 return symbol;
             });
             return makeComponent(({ children, key }) => children, {}, Content);
         },
-        'V<>': handlers_1.content,
-        'Z<>': (0, handlers_1.emptyContent)(),
+        'V<>': nodeContent,
+        'Z<>': emptyContent(),
         'U<>': mkComponent('u'),
         'X<>': (writer, processor) => (node, ctx, interator) => {
             let { entry } = node;
@@ -299,14 +282,14 @@ const mapToReact = (makeComponent) => {
                 writer.INDEXTERMS = [];
             }
             writer.INDEXTERMS.push({
-                entry
+                entry,
             });
             return interator(node.content, ctx);
         },
         'Delete<>': mkComponent('del'),
         // table section
-        'table': (writer, processor) => (node, ctx, interator) => {
-            const conf = (0, config_1.default)(node, ctx);
+        table: (writer, processor) => (node, ctx, interator) => {
+            const conf = makeAttrs(node, ctx);
             let attr = { caption: '' };
             if (conf.exists('caption')) {
                 const caption = conf.getFirstValue('caption');
@@ -319,22 +302,20 @@ const mapToReact = (makeComponent) => {
                 console.warn('[jsx] no content in node');
                 return '';
             }
-            const id = (0, schema_1.getNodeId)(node, ctx);
+            const id = getNodeId(node, ctx)?.replace(/\s/g, '-');
             return makeComponent(({ key, children }) => {
-                return React.createElement("table", { key: key, id: id },
+                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)));
+                    React.createElement("tbody", null, children)));
+            }, node, interator(node.content, { ...ctx }));
         },
-        ':separator': (0, handlers_1.emptyContent)(),
-        'table_row': mkComponent('tr'),
-        'table_cell': mkComponent('td'),
-        'table_head': (0, handlers_1.subUse)({
-            'table_cell': mkComponent('th')
+        ':separator': emptyContent(),
+        table_row: mkComponent('tr'),
+        table_cell: mkComponent('td'),
+        table_head: subUse({
+            table_cell: mkComponent('th'),
         }, mkComponent('tr')),
-        ':list': (0, handlers_1.setFn)((node, ctx) => node.list === 'ordered' ? mkComponent('ol')
-            : node.list === 'variable' ? mkComponent('dl')
-                : mkComponent('ul')),
+        ':list': 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;
@@ -347,83 +328,84 @@ const mapToReact = (makeComponent) => {
             if (!(node.content instanceof Array)) {
                 console.error(node);
             }
-            const id = (0, schema_1.getNodeId)(node, ctx);
-            return makeComponent('li', node, interator(node.content, Object.assign({}, ctx)), { id });
+            const id = getNodeId(node, ctx)?.replace(/\s/g, '-');
+            return makeComponent('li', node, interator(node.content, { ...ctx }), { id });
         },
         // table of content
-        ':toc': (0, handlers_1.setFn)((node, ctx) => {
+        ':toc': setFn((node, ctx) => {
             const tocTitle = node.title;
-            return mkComponent(({ children, key }) => React.createElement("div", { className: "toc", key: key },
+            return mkComponent(({ children, key }) => (React.createElement("div", { className: "toc", key: key },
                 tocTitle ? React.createElement("div", { className: "toctitle" }, tocTitle) : '',
-                children));
+                children)));
         }),
-        ':toc-list': (0, handlers_1.setFn)((node, ctx) => {
+        ':toc-list': setFn((node, ctx) => {
             const { level } = node;
-            return mkComponent(({ children, key }) => React.createElement("ul", { className: `toc-list listlevel${level}`, key: key }, children));
+            return mkComponent(({ children, key }) => (React.createElement("ul", { className: `toc-list listlevel${level}`, key: key }, children)));
         }),
-        ':toc-item': (0, handlers_1.subUse)({
+        ':toc-item': subUse({
             // inside head don't wrap into <p>
-            ':para': handlers_1.content,
-        }, (0, handlers_1.setFn)((node, ctx) => {
-            return mkComponent(({ children, key }) => React.createElement("li", { className: "toc-item", key: key }, children));
+            ':para': nodeContent,
+        }, setFn((node, ctx) => {
+            return mkComponent(({ children, key }) => (React.createElement("li", { className: "toc-item", key: key }, children)));
         })),
     };
 };
-function podlite(children, { file, plugins = () => { }, wrapElement, tree }, ...args) {
-    const ast = ((tree) => {
+function podlite(children, { file, plugins = () => { }, wrapElement, tree, }, ...args) {
+    const ast = (tree => {
         if (tree)
             return tree.interator;
-        let podlite = (0, podlite_1.podlite)({ importPlugins: true });
+        let podlite = podlite_core({ importPlugins: true });
         let treeAfterParsed = podlite.parse(children || file);
         return podlite.toAst(treeAfterParsed);
     })(tree);
     // const   ast = parse( children || content )
     let i_key_i = 10000;
     const makeComponent = helperMakeReact({ wrapElement });
-    const jsxPlugins = (0, podlite_1.toAnyRules)('toJSX', (0, podlite_1.podlite)({ importPlugins: true }).getPlugins());
+    const jsxPlugins = toAnyRules('toJSX', podlite_core({ importPlugins: true }).getPlugins());
     // initialize each plugin
     const jsxPluginInited = Object.fromEntries(Object.entries(jsxPlugins).map(([key, value]) => [key, value(makeComponent)]));
-    const rules = Object.assign(Object.assign(Object.assign({}, mapToReact(makeComponent)), plugins(makeComponent)), jsxPluginInited);
-    const writer = new writer_1.default((s) => {
-    });
-    const res = (0, exportAny_1.default)({ processor: pod6_1.parse })
-        .use({ '*:*': () => (node, ctx, interator) => {
+    const rules = {
+        ...mapToReact(makeComponent),
+        ...plugins(makeComponent),
+        ...jsxPluginInited,
+    };
+    const writer = new Writer(s => { });
+    const res = toAny({ processor: parse })
+        .use({
+        '*:*': () => (node, ctx, interator) => {
             // skip named blocks
-            if ((0, makeTransformer_1.isNamedBlock)(node.name)) {
+            if (isNamedBlock(node.name)) {
                 return null;
             }
-            if ((0, makeTransformer_1.isSemanticBlock)(node)) {
+            if (isSemanticBlock(node)) {
                 return makeComponent(({ key, children }) => {
-                    return React.createElement("div", { key: key },
+                    return (React.createElement("div", { key: key },
                         React.createElement("h1", { className: node.name, key: key }, node.name),
-                        interator(node.content, Object.assign({}, ctx)));
-                }, node, interator(node.content, Object.assign({}, ctx)));
+                        interator(node.content, { ...ctx })));
+                }, node, interator(node.content, { ...ctx }));
             }
             console.warn('[podlite] Not supported: ' + JSON.stringify(node, null, 2));
-            return (0, react_1.createElement)('code', { key: ++i_key_i }, `not supported node:${JSON.stringify(node, null, 2)}`);
-        } })
+            return 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);
 }
 // this is a helper function for using in unit test
-const TestPodlite = (_a) => {
-    var { children } = _a, options = __rest(_a, ["children"]);
-    let podlite = (0, podlite_1.podlite)({ importPlugins: true });
+export const TestPodlite = ({ children, ...options }) => {
+    let podlite = podlite_core({ importPlugins: true });
     // its replace all ids with "id"
-    let treeAfterParsed = (0, podlite_1.frozenIds)()(podlite.parse(children));
+    let treeAfterParsed = frozenIds()(podlite.parse(children));
     const tree = podlite.toAst(treeAfterParsed);
-    return (React.createElement(exports.Podlite, Object.assign({}, Object.assign(Object.assign({ children }, options), { tree: { interator: tree } }))));
+    return React.createElement(Podlite, { ...{ children, ...options, tree: { interator: tree } } });
 };
-exports.TestPodlite = TestPodlite;
-const makeTestPodlite = (podlite = (0, podlite_1.podlite)({ importPlugins: true })) => (_a) => {
-    var { children } = _a, options = __rest(_a, ["children"]);
+export const makeTestPodlite = (podlite = podlite_core({ importPlugins: true })) => ({ children, ...options }) => {
     let treeAfterParsed = podlite.parse(children);
     // its replace all ids with "id"
-    const tree = (0, podlite_1.frozenIds)()(podlite.toAst(treeAfterParsed));
-    return (React.createElement(exports.Podlite, Object.assign({}, Object.assign(Object.assign({ children }, options), { tree: { interator: tree } }))));
+    const tree = frozenIds()(podlite.toAst(treeAfterParsed));
+    return React.createElement(Podlite, { ...{ children, ...options, tree: { interator: tree } } });
 };
-exports.makeTestPodlite = makeTestPodlite;
-exports.default = exports.Podlite;
+export default Podlite;
 //# sourceMappingURL=index.js.map