@podlite/schema 0.0.11 → 0.0.13

package/lib/helpers/makeTransformer.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTransformer = exports.isSemanticBlock = exports.isNamedBlock = void 0;
+const makeQuery_1 = require("./makeQuery");
+// the following names: MyBlock, myBlock are use for extending pod6
+function isNamedBlock(name) {
+    return name && name !== name.toLowerCase() && name !== name.toUpperCase();
+}
+exports.isNamedBlock = isNamedBlock;
+// skip warnings for semantic blocks
+function isSemanticBlock(node) {
+    const name = node.name || '';
+    const isTypeBlock = (node.type || '') === 'block';
+    return isTypeBlock && name === name.toUpperCase();
+}
+exports.isSemanticBlock = isSemanticBlock;
+function flattenDeep(arr) {
+    return arr.reduce((acc, val) => (Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val)), []);
+}
+const makeTransformer = rule => {
+    let rules = [];
+    function use(key, fn) {
+        if (key instanceof Array) {
+            console.warn(`[pod] Unsupported param for ${key}`);
+        }
+        if (key instanceof Object) {
+            for (var prop in key) {
+                if (key.hasOwnProperty(prop)) {
+                    use(prop, key[prop]);
+                }
+            }
+            return [];
+        }
+        rules.push((0, makeQuery_1.makeRule)((0, makeQuery_1.makePlug)(key), fn));
+    }
+    function visiter(node, context = {}) {
+        if (node instanceof Array) {
+            return flattenDeep(node.map(item => visiter(item, context)));
+        }
+        if ('string' === typeof node) {
+            // convert string to lex node with type
+            //return visiter({type:'text', value:node}, context)
+            return node;
+        }
+        // get first rule for this node
+        const reversed = rules.slice();
+        reversed.reverse();
+        const ruleIndex = reversed.findIndex(rule => rule.isFor(node));
+        if (ruleIndex !== -1) {
+            return reversed[ruleIndex].fn(node, context, visiter);
+        }
+        else {
+            // not found rule
+            const newNode = { ...node };
+            if (newNode.hasOwnProperty('content')) {
+                newNode.content = visiter(newNode.content, context);
+            }
+            return newNode;
+        }
+    }
+    use(rule);
+    visiter.rules = rules;
+    return visiter;
+};
+exports.makeTransformer = makeTransformer;
+exports.default = exports.makeTransformer;
+//# sourceMappingURL=makeTransformer.js.map

package/lib/helpers/plugins.d.ts

@@ -0,0 +1,2 @@
+import { Plugins } from '..';
+export declare const toAnyRules: (method: any, allplugins: Plugins[]) => {};

package/lib/helpers/plugins.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnyRules = void 0;
+const toAnyRules = (method, allplugins) => {
+    // make uniq plugins
+    const resultMap = allplugins.reverse().reduce((result, plugins) => {
+        for (const plugin of Object.entries(plugins)) {
+            const [key, val] = plugin;
+            if (!(key in result)) {
+                result[key] = val;
+            }
+        }
+        return result;
+    }, {});
+    let result = {};
+    // prepare plugins for export <method>
+    for (const plugin of Object.entries(resultMap)) {
+        const [key, val = {}] = plugin;
+        //@ts-ignore
+        if (method in val) {
+            result[key] = val[method];
+        }
+    }
+    return result;
+};
+exports.toAnyRules = toAnyRules;
+//# sourceMappingURL=plugins.js.map

package/lib/index.d.ts

@@ -1,11 +1,19 @@
 import { ErrorObject } from 'ajv';
 import { PodNode } from './types';
+export { PodliteDocument } from './types';
 export { AstTree } from './types';
 export * from './types';
 export * from './blocks-helpers';
 export * from './query-helpers';
 export * from './ast-helpers';
+export * from './helpers/handlers';
 export { makeInterator } from './ast-inerator';
+export { makeTransformer, isNamedBlock, isSemanticBlock } from './helpers/makeTransformer';
+export { toAny } from './exportAny';
+export { makeAttrs } from './helpers/config';
+export { pluginCleanLocation } from './plugin-clean-location';
+export { toAnyRules } from './helpers/plugins';
+export { podlitePluggable, Podlite, PodliteExport, cleanIds, frozenIds } from './pluggableParser';
 export declare function toAst(): {};
 export declare type SchemaValidationError = ErrorObject<string, Record<string, any>>;
 export declare function getTextContentFromNode(node: PodNode): string;
@@ -16,3 +24,59 @@ export declare function isValidateError(result: SchemaValidationError[], src: an
 export interface Test {
     ters: string;
 }
+export interface nBlock {
+    type: 'block';
+    name: 'pod';
+    content: AST;
+    margin: string;
+}
+export interface nCode {
+    type: 'code';
+    content: [];
+    name: string;
+    margin: string;
+    config: [];
+    text: string;
+}
+export interface nText {
+    type: 'text';
+    content: [];
+    name: string;
+    margin: string;
+    config: [];
+    value: string;
+}
+export interface nPara {
+    type: 'para';
+    content: [];
+    name: string;
+    margin: string;
+    config: [];
+}
+export interface nVerbatim {
+    type: 'verbatim';
+    value: string;
+    margin: string;
+    text: string;
+}
+export declare type Node = nBlock | nCode | nText | nPara | nVerbatim;
+export declare type AST = Array<Node>;
+export declare type ParserPlugin = (opt: {
+    skipChain: number;
+    podMode: number;
+}) => (param: AST) => AST;
+declare function makeTree(): {
+    (): void;
+    use: (plugin: ParserPlugin) => any;
+    parse: (src: string, opt?: {
+        skipChain: number;
+        podMode: number;
+    }) => AST;
+};
+export { makeTree as toTree };
+declare const parse: Function;
+export { parse as parse };
+export { default as toHtml } from './exportHtml';
+export { default as Writer } from './writer';
+declare const VERSION: any;
+export { VERSION as version };

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.frozenIds = exports.cleanIds = exports.podlitePluggable = exports.toAnyRules = 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,34 @@ __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; } });
+var plugins_1 = require("./helpers/plugins");
+Object.defineProperty(exports, "toAnyRules", { enumerable: true, get: function () { return plugins_1.toAnyRules; } });
+var pluggableParser_1 = require("./pluggableParser");
+Object.defineProperty(exports, "podlitePluggable", { enumerable: true, get: function () { return pluggableParser_1.podlitePluggable; } });
+Object.defineProperty(exports, "cleanIds", { enumerable: true, get: function () { return pluggableParser_1.cleanIds; } });
+Object.defineProperty(exports, "frozenIds", { enumerable: true, get: function () { return pluggableParser_1.frozenIds; } });
+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 {};
 }
@@ -44,10 +70,10 @@ const ajv = new ajv_1.default({ strict: true, allowUnionTypes: true });
 function getTextContentFromNode(node) {
     let text = '';
     const rules = {
-        ":text": (node) => {
+        ':text': node => {
             text += node.value;
         },
-        ":verbatim": (node) => {
+        ':verbatim': node => {
             text += node.value;
         },
     };
@@ -56,9 +82,13 @@ function getTextContentFromNode(node) {
     return text;
 }
 exports.getTextContentFromNode = getTextContentFromNode;
-function validatePodliteAst(data) { return validateAst(data, 'PodliteDocument'); }
+function validatePodliteAst(data) {
+    return validateAst(data, 'PodliteDocument');
+}
 exports.validatePodliteAst = validatePodliteAst;
-function validateAstTree(data) { return validateAst(data, 'AstTree'); }
+function validateAstTree(data) {
+    return validateAst(data, 'AstTree');
+}
 exports.validateAstTree = validateAstTree;
 function validateAst(data, Name = 'AstTree') {
     const AstTreeSchema = jsonShemes[Name];
@@ -87,3 +117,53 @@ 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;
+//# sourceMappingURL=index.js.map

package/lib/pluggableParser.d.ts

@@ -0,0 +1,27 @@
+import { Plugins, PodliteDocument } from '.';
+export { cleanIds, frozenIds } from './helpers/ids';
+export interface podlitePluggableOpt {
+    plugins?: Plugins;
+}
+export interface PodliteExport {
+    errors: any;
+    toString: () => string;
+    valueOf: () => string;
+    indexingTerms: any;
+    annotations: any;
+    defenitions: any;
+    interator: any;
+}
+export interface Podlite {
+    toAstResult: (ast: PodliteDocument) => PodliteExport;
+    (): any;
+    use: (plugin: Plugins) => Podlite;
+    parse: (text: string, opt?: {
+        skipChain: number;
+        podMode: number;
+    }) => PodliteDocument;
+    toHtml: (ast: PodliteDocument) => PodliteExport;
+    toAst: (ast: PodliteDocument) => PodliteDocument;
+    getPlugins: () => Array<Plugins>;
+}
+export declare const podlitePluggable: (params?: podlitePluggableOpt) => Podlite;

package/lib/pluggableParser.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.podlitePluggable = exports.frozenIds = exports.cleanIds = void 0;
+const _1 = require(".");
+const ids_1 = __importDefault(require("./helpers/ids"));
+const corePlugins_1 = __importDefault(require("./helpers/corePlugins"));
+var ids_2 = require("./helpers/ids");
+Object.defineProperty(exports, "cleanIds", { enumerable: true, get: function () { return ids_2.cleanIds; } });
+Object.defineProperty(exports, "frozenIds", { enumerable: true, get: function () { return ids_2.frozenIds; } });
+const podlitePluggable = ({ plugins = {} } = {}) => {
+    let instance = function () { };
+    let _plugins = [];
+    instance.use = (onj) => {
+        for (const plugin of Object.entries(onj)) {
+            const [key, val] = plugin;
+            if (typeof val === 'function') {
+                _plugins.push({ [key]: { toAst: val } });
+            }
+            else {
+                _plugins.push({ [key]: val });
+            }
+        }
+        return instance;
+    };
+    instance.parse = (text, opt = { skipChain: 0, podMode: 1 }) => {
+        const rawTree = (0, _1.toTree)().use(ids_1.default).parse(text, opt);
+        const root = (0, _1.mkRootBlock)({ margin: '' }, rawTree);
+        return root;
+    };
+    instance.toAst = ast => {
+        return instance.toAstResult(ast).interator;
+    };
+    instance.toAstResult = ast => {
+        // get plugins  for Ast
+        const toAstPlugins = (0, _1.toAnyRules)('toAst', instance.getPlugins());
+        const result = (0, _1.toAny)()
+            .use({
+            '*': () => (node, ctx, interator) => {
+                if ('content' in node) {
+                    node.content = interator(node.content, ctx);
+                }
+                return node;
+            },
+        })
+            .use(toAstPlugins)
+            .run(ast);
+        // add second pass
+        const toAstAfterPlugins = (0, _1.toAnyRules)('toAstAfter', instance.getPlugins());
+        if (Object.keys(toAstAfterPlugins).length) {
+            const resultAfter = (0, _1.toAny)()
+                .use({
+                '*': () => (node, ctx, interator) => {
+                    if ('content' in node) {
+                        node.content = interator(node.content, ctx);
+                    }
+                    return node;
+                },
+            })
+                .use(toAstAfterPlugins)
+                .run(ast);
+            return resultAfter;
+        }
+        return result;
+    };
+    instance.toHtml = ast => {
+        const toHtmlPlugins = (0, _1.toAnyRules)('toHtml', instance.getPlugins());
+        return (0, _1.toHtml)({}).use(toHtmlPlugins).run(ast, null);
+    };
+    instance.getPlugins = () => _plugins;
+    // init core plugins
+    instance.use(corePlugins_1.default);
+    // init external plugins
+    instance.use(plugins);
+    return instance;
+};
+exports.podlitePluggable = podlitePluggable;
+//# sourceMappingURL=pluggableParser.js.map

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,26 @@
+"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;
+//# sourceMappingURL=plugin-clean-location.js.map

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,55 @@
+"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, {});
+};
+//# sourceMappingURL=plugin-defn-fill-term.js.map

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,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fcparser = __importStar(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;
+//# sourceMappingURL=plugin-formatting-codes.js.map

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;
+};
+//# sourceMappingURL=plugin-group-defn.js.map

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

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