@podlite/schema 0.0.10 → 0.0.12

package/lib/index.js

@@ -25,7 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidateError = exports.validateAst = exports.validateAstTree = exports.validatePodliteAst = exports.getTextContentFromNode = exports.toAst = exports.makeInterator = void 0;
+exports.version = exports.Writer = exports.toHtml = exports.parse = exports.toTree = exports.isValidateError = exports.validateAst = exports.validateAstTree = exports.validatePodliteAst = exports.getTextContentFromNode = exports.toAst = exports.pluginCleanLocation = exports.makeAttrs = exports.toAny = exports.isSemanticBlock = exports.isNamedBlock = exports.makeTransformer = exports.makeInterator = void 0;
 const ajv_1 = __importDefault(require("ajv"));
 const pointer = __importStar(require("json-pointer"));
 const jsonShemes = __importStar(require("../schema"));
@@ -34,8 +34,29 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./blocks-helpers"), exports);
 __exportStar(require("./query-helpers"), exports);
 __exportStar(require("./ast-helpers"), exports);
+__exportStar(require("./helpers/handlers"), exports);
 var ast_inerator_2 = require("./ast-inerator");
 Object.defineProperty(exports, "makeInterator", { enumerable: true, get: function () { return ast_inerator_2.makeInterator; } });
+var makeTransformer_1 = require("./helpers/makeTransformer");
+Object.defineProperty(exports, "makeTransformer", { enumerable: true, get: function () { return makeTransformer_1.makeTransformer; } });
+Object.defineProperty(exports, "isNamedBlock", { enumerable: true, get: function () { return makeTransformer_1.isNamedBlock; } });
+Object.defineProperty(exports, "isSemanticBlock", { enumerable: true, get: function () { return makeTransformer_1.isSemanticBlock; } });
+var exportAny_1 = require("./exportAny");
+Object.defineProperty(exports, "toAny", { enumerable: true, get: function () { return exportAny_1.toAny; } });
+var config_1 = require("./helpers/config");
+Object.defineProperty(exports, "makeAttrs", { enumerable: true, get: function () { return config_1.makeAttrs; } });
+var plugin_clean_location_1 = require("./plugin-clean-location");
+Object.defineProperty(exports, "pluginCleanLocation", { enumerable: true, get: function () { return plugin_clean_location_1.pluginCleanLocation; } });
+// @ts-ignore
+const parser = __importStar(require("./grammar"));
+const plugin_vmargin_1 = __importDefault(require("./plugin-vmargin"));
+const plugin_formatting_codes_1 = __importDefault(require("./plugin-formatting-codes"));
+const plugin_items_1 = __importDefault(require("./plugin-items"));
+const plugin_heading_1 = __importDefault(require("./plugin-heading"));
+const plugin_group_defn_1 = __importDefault(require("./plugin-group-defn"));
+const plugin_group_items_1 = __importDefault(require("./plugin-group-items"));
+const plugin_defn_fill_term_1 = __importDefault(require("./plugin-defn-fill-term"));
+const plugin_tables_1 = __importDefault(require("./plugin-tables"));
 function toAst() {
     return {};
 }
@@ -87,3 +108,52 @@ function isValidateError(result, src) {
     return undefined;
 }
 exports.isValidateError = isValidateError;
+function makeTree() {
+    var plugins = [];
+    chain.use = use;
+    chain.parse = parse;
+    chain.use(plugin_vmargin_1.default);
+    chain.use(plugin_items_1.default);
+    chain.use(plugin_heading_1.default);
+    chain.use(plugin_defn_fill_term_1.default);
+    chain.use(plugin_tables_1.default);
+    chain.use(plugin_formatting_codes_1.default);
+    // save order for the next two plugins
+    chain.use(plugin_group_items_1.default);
+    chain.use(plugin_group_defn_1.default);
+    return chain;
+    function chain() {
+        return;
+    }
+    function use(plugin) {
+        if (!["function"].includes(typeof plugin)) {
+            throw (plugin);
+        }
+        plugins.push(plugin);
+        return chain;
+    }
+    function parse(src, opt = { skipChain: 0, podMode: 1 }) {
+        let tree = parser.parse(src, { podMode: opt.podMode });
+        if (!opt.skipChain) {
+            for (let i = 0; i < plugins.length; i++) {
+                const plugin = plugins[i];
+                // init
+                const visitor = plugin(opt);
+                // process tree
+                tree = visitor(tree);
+            }
+        }
+        return tree;
+    }
+}
+exports.toTree = makeTree;
+const parse = makeTree().parse;
+exports.parse = parse;
+var exportHtml_1 = require("./exportHtml");
+Object.defineProperty(exports, "toHtml", { enumerable: true, get: function () { return __importDefault(exportHtml_1).default; } });
+var writer_1 = require("./writer");
+Object.defineProperty(exports, "Writer", { enumerable: true, get: function () { return __importDefault(writer_1).default; } });
+// Cannot be `import` as it's not under TS root dir
+// https://stackoverflow.com/questions/51070138/how-to-import-package-json-into-typescript-file-without-including-it-in-the-comp
+const { version: VERSION } = require('../package.json');
+exports.version = VERSION;

package/lib/plugin-clean-location.d.ts

@@ -0,0 +1,2 @@
+export declare const pluginCleanLocation: () => (tree: any) => any;
+export default pluginCleanLocation;

package/lib/plugin-clean-location.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginCleanLocation = void 0;
+/**
+ * Delete location attribute
+ * use in test suite
+ */
+const makeTransformer_1 = __importDefault(require("./helpers/makeTransformer"));
+const pluginCleanLocation = () => (tree) => {
+    const transformer = (0, makeTransformer_1.default)({ '*': (node, ctx, visiter) => {
+            if (node.content) {
+                node.content = visiter(node.content, ctx, visiter);
+            }
+            delete node.location;
+            return node;
+        } });
+    return transformer(tree, {});
+};
+exports.pluginCleanLocation = pluginCleanLocation;
+exports.default = exports.pluginCleanLocation;

package/lib/plugin-defn-fill-term.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (tree: any) => any;
+export default _default;

package/lib/plugin-defn-fill-term.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Plugin for fill term's for defn. From S26:
+ * The first non-blank line of content is treated as a term being defined,
+ * and the remaining content is treated as the definition for the term.
+ */
+const makeTransformer_1 = __importDefault(require("./helpers/makeTransformer"));
+exports.default = () => (tree) => {
+    const transformer = (0, makeTransformer_1.default)({ 'defn': (node) => {
+            // get first non blank block
+            const content = node.content;
+            // skip all blank blocks
+            const count = content.length;
+            let newContent = [];
+            let isFirstParaProcessed = false;
+            for (let i = 0; i < count; i++) {
+                const item = content[i];
+                if (item.type === 'para' && !isFirstParaProcessed) {
+                    // get text content
+                    const textNode = item.content[0];
+                    const text = textNode.value;
+                    // split text by lines
+                    // get first line
+                    const splited = text.split('\n');
+                    const term = splited.shift();
+                    const newTermPara = {
+                        type: 'para',
+                        name: 'term',
+                        text: term,
+                        content: [{ type: 'text', value: term }]
+                    };
+                    newContent.push(newTermPara);
+                    if (!(splited.length == 1 && splited[0] === '')) {
+                        textNode.value = splited.join('\n');
+                        item.text = textNode.value;
+                        newContent.push(item);
+                    }
+                    isFirstParaProcessed = true;
+                }
+                else {
+                    newContent.push(item);
+                }
+            }
+            node.content = newContent;
+            return node;
+        } });
+    return transformer(tree, {});
+};

package/lib/plugin-formatting-codes.d.ts

@@ -0,0 +1,3 @@
+import { ParserPlugin } from './';
+declare const middle: ParserPlugin;
+export default middle;

package/lib/plugin-formatting-codes.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fcparser = require("./grammarfc");
+const makeTransformer_1 = __importDefault(require("./helpers/makeTransformer"));
+const makeTransformer_2 = require("./helpers/makeTransformer");
+const config_1 = __importDefault(require("./helpers/config"));
+const middle = () => (tree) => {
+    const transformerBlocks = (0, makeTransformer_1.default)({
+        ':para': (n, ctx, visiter) => {
+            return (0, makeTransformer_1.default)({
+                ':text': (n, ctx) => { return fcparser.parse(n.value); },
+                ':verbatim': (n, ctx) => { return fcparser.parse(n.value); },
+            })(n, { ...ctx });
+            return n;
+        },
+        ':block': (n, ctx, visiter) => {
+            // only =pod may have childs blocks
+            if ("name" in n && n.name === 'pod')
+                return {
+                    ...n,
+                    content: visiter(n.content, ctx, visiter)
+                };
+            const conf = (0, config_1.default)(n, ctx);
+            const isCodeBlock = "name" in n && n.name === 'code';
+            const isDataBlock = "name" in n && n.name === 'data';
+            const allowValues = conf.getAllValues('allow');
+            // for code block not parse content by default
+            if ((isCodeBlock || isDataBlock) && allowValues.length == 0)
+                return n;
+            const allowed = allowValues.sort();
+            const transformer = (0, makeTransformer_1.default)({
+                ':verbatim': (n, ctx) => { return fcparser.parse(n.value, { allowed }); },
+                ':text': (n, ctx) => { return fcparser.parse(n.value, { allowed }); },
+                ':block': (n, ctx) => {
+                    if ((0, makeTransformer_2.isNamedBlock)(n.name))
+                        return n;
+                    return { ...n, content: transformer(n.content, { ...ctx }) };
+                }
+            });
+            return transformer(n, { ...ctx });
+        },
+    });
+    return transformerBlocks(tree, {});
+};
+exports.default = middle;

package/lib/plugin-group-defn.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (tree: any) => any;
+export default _default;

package/lib/plugin-group-defn.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => (tree) => {
+    const isNodesEqual = (n1, n2) => (
+    // if nodes items 
+    (n1.name === 'item' || n1.name === 'defn') &&
+        n2.name === n1.name &&
+        n1['level'] === n2.level &&
+        isNumbered(n1) === isNumbered(n2));
+    const isNumbered = (node) => Boolean(node.config && node.config.numbered);
+    const group = (a) => {
+        let lastItem = {};
+        let result = a.reduce((a, i) => {
+            if (i.name === 'defn') {
+                if (isNodesEqual(lastItem, i)) {
+                    // group items into arrays
+                    a[a.length - 1].push(i);
+                }
+                else {
+                    // group items into arrays
+                    a.push([i]);
+                }
+            }
+            else {
+                // save not 'item' elements as is
+                a.push(i);
+            }
+            lastItem = i;
+            return a;
+        }, []);
+        // convert grouped items into object 'itemlist'
+        /**
+         * { type = 'list',
+         *   ordered = [true, false]
+         *   content = [ .... ]
+         *   list = ['ordered', 'variable', 'itemized']
+         */
+        return result.map(item => {
+            if (item instanceof Array) {
+                if (item[0].name !== 'defn') {
+                    return item;
+                }
+                // get type of list
+                const list = item[0].name === 'defn' ? 'variable' :
+                    isNumbered(item[0]) ? 'ordered' : 'itemized';
+                // create items container
+                return {
+                    type: 'list',
+                    list,
+                    level: 1,
+                    content: [...item]
+                };
+            }
+            if (item.content && item.type !== 'fcode') {
+                item.content = group(item.content);
+            }
+            return item;
+        });
+    };
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            return group(node);
+        }
+        else {
+            if (node.type === 'block' && node.name !== 'table') {
+                node.content = group(node.content);
+            }
+        }
+        return node;
+    };
+    tree = visit(tree);
+    return tree;
+};

package/lib/plugin-group-items.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (tree: any) => any;
+export default _default;

package/lib/plugin-group-items.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("./helpers/config"));
+exports.default = () => (tree) => {
+    const isNodesEqual = (n1, n2) => (
+    // if nodes items 
+    (n1.name === 'item' || n1.name === 'defn') &&
+        n2.name === n1.name &&
+        n1['level'] === n2.level &&
+        isNumbered(n1) === isNumbered(n2));
+    const isNumbered = (node) => Boolean((0, config_1.default)(node, {}).exists('numbered'));
+    const group = (a, level = 1) => {
+        const isInListMode = (a) => { return a.length > 0 && a[a.length - 1].type === 'list'; };
+        const getList = (a) => { if (isInListMode(a))
+            return a[a.length - 1]; };
+        const isInsertableToList = (l, i) => (i.name && i.name === 'item' && i.type && i.type === 'block'
+            ||
+                i.type === 'blankline');
+        let lastItem = {};
+        let result = a.reduce((a, i) => {
+            // skip items out of level
+            if (i.name === 'item' && i.type === 'block' && i.level < level) {
+                return [...a, i];
+            }
+            if (i.name === 'item' && i.type === 'block' && (!isInListMode(a)
+                ||
+                    // different type of list and item
+                    // at the same  level
+                    (i.level === level
+                        &&
+                            getList(a).list !== (isNumbered(i) ? 'ordered' : 'itemized')))) {
+                // create empty list
+                // list = ['ordered', 'variable', 'itemized']
+                a.push({
+                    type: 'list',
+                    level: i.level,
+                    content: [],
+                    list: isNumbered(i) ? 'ordered' : 'itemized'
+                });
+            }
+            // main logic
+            if (isInListMode(a)
+                && isInsertableToList(getList(a), i)) { // getlist and push item to them
+                getList(a).content.push(i);
+            }
+            else {
+                a.push(i);
+            }
+            return a;
+        }, []);
+        // convert grouped items into object 'itemlist'
+        /**
+         * { type = 'list',
+         *   ordered = [true, false]
+         *   content = [ .... ]
+         *   list = ['ordered', 'variable', 'itemized']
+         */
+        return result.map(item => {
+            // process any item with content ( except formatting codes)
+            if (item.content && item.type !== 'fcode') {
+                item.content = group(item.content, item.level + 1);
+            }
+            return item;
+        });
+    };
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            node = group(node);
+        }
+        else {
+            if (node.type === 'block' && node.name !== 'table') {
+                node.content = group(node.content);
+            }
+        }
+        return node;
+    };
+    tree = visit(tree);
+    return tree;
+};

package/lib/plugin-heading.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (tree: any) => any;
+export default _default;

package/lib/plugin-heading.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => (tree) => {
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            node.forEach(i => { visit(i); });
+        }
+        else {
+            if (node && node.type === 'block') {
+                const matchHead = /^head(\d+)?/.exec(node.name);
+                if (matchHead) {
+                    node.name = 'head';
+                    node.level = matchHead[1] || 1;
+                    if (node.content[0]) {
+                        const startText = node.content[0];
+                        if (startText.text) {
+                            let re = /(\s*#\s*)/;
+                            const match = re.exec(startText.text);
+                            if (match) {
+                                startText.text = startText.text.replace(re, '');
+                                node.config = { ...node.config, ...{ numbered: true } };
+                            }
+                        }
+                    }
+                }
+                visit(node.content);
+            }
+        }
+    };
+    visit(tree);
+    return tree;
+};

package/lib/plugin-items.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (tree: any) => any;
+export default _default;

package/lib/plugin-items.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => (tree) => {
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            node.forEach(i => { visit(i); });
+        }
+        else {
+            if (node && node.type === 'block') {
+                const matchItem = /^item(\d+)?/.exec(node.name);
+                if (matchItem) {
+                    node.name = 'item';
+                    node.level = matchItem[1] || 1;
+                    if (node.content[0]) {
+                        const startText = node.content[0];
+                        if (startText.text) {
+                            let re = /^(\s*#\s*)/;
+                            const match = re.exec(startText.text);
+                            if (match) {
+                                startText.text = startText.text.replace(re, '');
+                                if (startText.type === 'para') {
+                                    startText.content = [startText.text];
+                                }
+                                node.config = node.config || [];
+                                node.config.push({
+                                    "name": "numbered",
+                                    "value": true,
+                                    "type": "boolean"
+                                });
+                            }
+                        }
+                    }
+                }
+                visit(node.content);
+            }
+        }
+    };
+    visit(tree);
+    return tree;
+};

package/lib/plugin-tables.d.ts

@@ -0,0 +1,5 @@
+declare const _default: () => (tree: any) => any;
+/**
+ *  Main transforms
+ */
+export default _default;

package/lib/plugin-tables.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Plugin for fill term's for defn. From S26:
+ * The first non-blank line of content is treated as a term being defined,
+ * and the remaining content is treated as the definition for the term.
+ */
+const makeTransformer_1 = __importDefault(require("./helpers/makeTransformer"));
+function flattenDeep(arr) {
+    return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
+}
+/**
+ *  Helpers section
+ */
+// run cb in symbols pair        
+const strbin = (str1, str2, cb) => {
+    let res = [];
+    for (let i = 0; str1.length > i; i++) {
+        res.push(cb(parseInt(str1[i], 10), parseInt(str2[i], 10)));
+    }
+    return res.join('');
+};
+// Create mask for extract columns
+const makeMask = (lines, separators) => {
+    // calculate template length
+    const tmplLength = Math.max(...[...lines, ...separators].map(s => s.length));
+    // make bin mask for each string
+    const masks = lines.map((str) => {
+        /** make mask for each line
+          '        The Shoveller | Eddie Stevens   | King Arthur\'s singing shovel',
+          '0000000011111111111110001111111111111000001111111111111111111111111111' ]
+          then  not(mask) ... then  & masks
+         */
+        // enlarge string to tmplLength
+        let tstr = str + " ".repeat(tmplLength - str.length);
+        let mask = [];
+        const re = /\s+[+|\s]\s/g;
+        let match;
+        while ((match = re.exec(tstr)) != null) {
+            const tmpMask = '1'.repeat(match.index) +
+                '0'.repeat(match[0].length);
+            mask.push(tmpMask + '1'.repeat(tmplLength - tmpMask.length));
+        }
+        return mask.reduce((a, b) => { return strbin(a, b, (i1, i2) => i1 & i2); }, '1'.repeat(tmplLength));
+    });
+    // make result mask
+    const inverted = masks.map(m => strbin(m, '', (i1) => i1 == 0 ? 1 : 0));
+    const columnTemplate = inverted.reduce((a, b) => { return strbin(a, b, (i1, i2) => i1 & i2); }, '1'.repeat(tmplLength));
+    return columnTemplate;
+};
+const extractColumnsByTemplate = (text, template) => {
+    const lines = flattenDeep(text.split(/\n/) // split each row by eol
+        .filter((str) => str.length > 0) // filter empty strings ( after slit )
+    );
+    const cols = lines.map(line => {
+        const re = /((1+|0+))/g;
+        let columns = [];
+        let match;
+        while ((match = re.exec(template)) != null) {
+            if (match[0][0] == 1)
+                continue;
+            const s = line.substring(match.index, match.index + match[0].length);
+            columns.push(s);
+        }
+        return columns;
+    });
+    let result = [];
+    result = cols.reduce((a, b) => {
+        for (let i = 0; i < b.length; i++) {
+            a[i] = (a[i] === undefined ? '' : a[i]) + ' ' + b[i];
+        }
+        return a;
+    }, []);
+    return result;
+};
+/**
+ *  Main transforms
+ */
+exports.default = () => (tree) => {
+    const transformer = (0, makeTransformer_1.default)({ 'table': (node) => {
+            let rows = [];
+            const collectValues = (row) => { rows.push(row.value); };
+            // collect separators for calculate max length of rows
+            let seps = [];
+            (0, makeTransformer_1.default)({
+                'row:text': collectValues,
+                'head:text': collectValues,
+                ':separator': (sep) => { seps.push(sep.text); }
+            })(node);
+            // add table-caption
+            // if table empty return node as is
+            if (!rows.length)
+                return node;
+            const splitToLines = (row) => row.split(/\n/) // split each row by eol
+                .filter((str) => str.length > 0); // filter empty strings ( after slit )
+            // split each row into lines
+            const lines = flattenDeep(rows.map(splitToLines));
+            const separators = flattenDeep(seps.map(splitToLines));
+            // collect text rows
+            let textRows = [];
+            (0, makeTransformer_1.default)({
+                'row:text': (row) => { textRows.push(row.value); }
+            })(node);
+            const columnTemplate = makeMask(lines, separators);
+            const makeBlock = (name, content, ...attr) => { return { ...attr, name, type: 'block', content: Array.isArray(content) ? content : [content] }; };
+            // make columns
+            const res = (0, makeTransformer_1.default)({
+                'row:text': (row) => {
+                    if (textRows.length == 1) {
+                        // split each text row into lines
+                        const textRowsLines = flattenDeep([row.value].map(splitToLines));
+                        return textRowsLines.map((rowValue) => {
+                            const res = extractColumnsByTemplate(rowValue, columnTemplate);
+                            return makeBlock('table_row', res.map((col) => makeBlock('table_cell', { type: 'text', value: col })));
+                        });
+                    }
+                    const res = extractColumnsByTemplate(row.value, columnTemplate);
+                    return makeBlock('table_row', res.map((col) => makeBlock('table_cell', { type: 'text', value: col })));
+                },
+                'head:text': (head) => {
+                    const res = extractColumnsByTemplate(head.value, columnTemplate);
+                    return makeBlock('table_head', res.map((col) => makeBlock('table_cell', { type: 'text', value: col })));
+                },
+            })(node);
+            return res;
+        } });
+    return transformer(tree, {});
+};

package/lib/plugin-vmargin.d.ts

@@ -0,0 +1,3 @@
+import { ParserPlugin } from './';
+declare const middle: ParserPlugin;
+export default middle;

package/lib/plugin-vmargin.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const middle = () => (tree) => {
+    const visit_node = (node, context = {}) => {
+        // if( (node.type || "").match(/(code|text)/) ) {
+        if (node.type == 'code' || node.type == 'text') {
+            if (node.margin && context.margin && context.margin.length > 0 && context.margin.length == node.margin.length) {
+                node.type = 'para';
+            }
+            if (node.type === 'code') {
+                // remove parent margin
+                var regex = new RegExp(`^[ \t]{0,${node.margin.length}}`, 'gm');
+                node.text = node.text.replace(regex, '');
+            }
+        }
+        if (node.type === 'block') {
+            context.margin = typeof node.margin !== 'string' ? '' : node.margin;
+            let newctx = { ...context };
+            newctx.nest = (newctx.nest || 0) + 1;
+            node.content.map((n) => {
+                visit_node(n, context);
+            });
+        }
+    };
+    var ctx = {};
+    tree.forEach((n) => visit_node(n, ctx));
+    return tree;
+};
+exports.default = middle;

package/lib/query-helpers.d.ts

@@ -1,3 +1,4 @@
+import { PodNode } from './types';
 declare type Query = ((par: Object) => Boolean) | any;
 /**
  * compileQuery - compile a query to a function
@@ -23,5 +24,5 @@ export declare const compileQuery: (...obj: Query[]) => (any: any) => any;
  * @param queries
  * @returns array of matched nodes
  */
-export declare const getFromTree: (tree: any, ...queries: string[] | any) => any;
+export declare const getFromTree: (tree: any, ...queries: string[] | any) => PodNode[];
 export {};