@podlite/schema 0.0.33 → 0.0.35

package/lib/exportMarkdown.js

@@ -0,0 +1,346 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const exportAny_1 = __importDefault(require("./exportAny"));
+const handlers_1 = require("./helpers/handlers");
+const makeTransformer_1 = require("./helpers/makeTransformer");
+const config_1 = __importDefault(require("./helpers/config"));
+const writerMarkdown_1 = __importDefault(require("./writerMarkdown"));
+const plugin_clean_location_1 = __importDefault(require("./plugin-clean-location"));
+const rules = {
+    ':text': (writer, processor) => (node, ctx, interator) => {
+        if (node.value) {
+            writer.write(node.value);
+        }
+        else {
+            interator(node.content, ctx);
+        }
+    },
+    // Formatting codes
+    'A<>': (writer, processor) => (node, ctx, interator) => {
+        if (!(ctx.alias && ctx.alias.hasOwnProperty(node.content))) {
+            writer.writeRaw(`A<${node.content}>`);
+        }
+        else {
+            const src = ctx.alias[node.content].join('\n');
+            const tree_1 = processor(src);
+            const tree = (0, plugin_clean_location_1.default)()(tree_1);
+            if (tree[0].type === 'para') {
+                interator(tree[0].content, ctx);
+            }
+            else {
+                interator(tree, ctx);
+            }
+        }
+    },
+    'C<>': (0, handlers_1.wrapContent)('`', '`'),
+    'D<>': (writer, processor) => (node, ctx, interator) => {
+        if (!writer.hasOwnProperty('DEFINITIONS')) {
+            writer.DEFINITIONS = [];
+        }
+        writer.DEFINITIONS.push({ definition: [node.content[0]] });
+        writer.writeRaw('**');
+        interator(node.content, ctx);
+        writer.writeRaw('**');
+    },
+    'B<>': (0, handlers_1.wrapContent)('**', '**'),
+    'I<>': (0, handlers_1.wrapContent)('*', '*'),
+    'R<>': (0, handlers_1.wrapContent)('*', '*'),
+    'K<>': (0, handlers_1.wrapContent)('`', '`'),
+    'L<>': (0, handlers_1.setFn)((node, ctx) => {
+        let { meta } = node;
+        if (meta === null) {
+            meta = node.content;
+        }
+        return (0, handlers_1.wrapContent)(`[`, `](${meta})`);
+    }),
+    'N<>': (writer, processor) => {
+        writer.addListener('end', () => {
+            if (!writer.hasOwnProperty('FOOTNOTES')) {
+                return;
+            }
+            const footnotes = writer.FOOTNOTES;
+            if (footnotes.length < 1) {
+                return;
+            }
+            writer.writeRaw('\n\n---\n\n');
+            footnotes.map(footnote => {
+                writer.writeRaw(`[^${footnote.gid}]: `);
+                footnote.make();
+                writer.writeRaw('\n');
+            });
+        });
+        return (node, ctx, interator) => {
+            if (node.content.length < 1) {
+                return;
+            }
+            if (!writer.hasOwnProperty('gid')) {
+                writer.gid = 1;
+            }
+            const gid = writer.gid++;
+            writer.writeRaw(`[^${gid}]`);
+            if (!writer.hasOwnProperty('FOOTNOTES')) {
+                writer.FOOTNOTES = [];
+            }
+            writer.FOOTNOTES.push({
+                gid,
+                fnRefId: `fnref:${gid}`,
+                fnId: `fn:${gid}`,
+                make: () => {
+                    interator(node.content, ctx);
+                },
+            });
+        };
+    },
+    'S<>': (writer, processor) => (node, ctx, interator) => {
+        const content = node.content || '';
+        // preserve spaces and newlines
+        writer.writeRaw(content.replace(/ /g, '&nbsp;').replace(/\n/g, '  \n'));
+    },
+    'T<>': (0, handlers_1.wrapContent)('`', '`'),
+    'U<>': (0, handlers_1.wrapContent)('', ''),
+    'V<>': handlers_1.content,
+    'X<>': (writer, processor) => (node, ctx, interator) => {
+        interator(node.content, ctx);
+        let { entry } = node;
+        if (entry === null && node.content.length > 0) {
+            //@ts-ignore
+            entry = [node.content[0]];
+        }
+        else {
+            return;
+        }
+        if (!writer.hasOwnProperty('INDEXTERMS')) {
+            writer.INDEXTERMS = [];
+        }
+        writer.INDEXTERMS.push({ entry });
+    },
+    'Z<>': handlers_1.emptyContent,
+    pod: handlers_1.content,
+    ':code': (writer, processor) => (node, ctx, interator) => {
+        const conf = (0, config_1.default)(node, ctx);
+        const lang = conf.exists('lang') ? conf.getFirstValue('lang') : '';
+        writer.writeRaw('```' + lang + '\n');
+        // inside code blocks, write text without escaping
+        if (node.content) {
+            node.content.forEach(child => {
+                if (typeof child === 'string') {
+                    writer.writeRaw(child);
+                }
+                else if (child.type === 'verbatim') {
+                    writer.writeRaw(child.value);
+                }
+                else {
+                    interator([child], ctx);
+                }
+            });
+        }
+        writer.writeRaw('```\n');
+    },
+    code: (0, handlers_1.handleNested)((writer, processor) => (node, ctx, interator) => {
+        const conf = (0, config_1.default)(node, ctx);
+        const lang = conf.exists('lang') ? conf.getFirstValue('lang') : '';
+        writer.writeRaw('```' + lang + '\n');
+        if (node.content) {
+            node.content.forEach(child => {
+                if (typeof child === 'string') {
+                    writer.writeRaw(child);
+                }
+                else if (child.type === 'verbatim') {
+                    writer.writeRaw(child.value);
+                }
+                else {
+                    interator([child], ctx);
+                }
+            });
+        }
+        writer.writeRaw('```\n');
+    }),
+    data: handlers_1.emptyContent,
+    ':verbatim': (writer, processor) => (node, ctx, interator) => {
+        if (node.error) {
+            writer.emit('errors', node.location);
+        }
+        writer.writeRaw(node.value);
+    },
+    ':blankline': handlers_1.emptyContent,
+    ':ambient': handlers_1.emptyContent,
+    // Directives
+    ':config': (0, handlers_1.setFn)((node, ctx) => {
+        if (!ctx.hasOwnProperty('config'))
+            ctx.config = {};
+        ctx.config[node.name] = node.config;
+        return handlers_1.emptyContent;
+    }),
+    ':alias': (0, handlers_1.setFn)((node, ctx) => {
+        if (!ctx.hasOwnProperty('alias'))
+            ctx.alias = {};
+        ctx.alias[node.name] = node.replacement;
+        return handlers_1.emptyContent;
+    }),
+    // block =para
+    para: (0, handlers_1.handleNested)(handlers_1.content),
+    ':para': (writer, processor) => (node, ctx, interator) => {
+        if (node.content)
+            interator(node.content, ctx);
+        writer.writeRaw('\n');
+    },
+    'head:block': (0, handlers_1.subUse)({
+        ':para': handlers_1.content,
+    }, (0, handlers_1.setFn)((node, ctx) => {
+        const { level } = node;
+        const prefix = '#'.repeat(level) + ' ';
+        return (writer, processor) => (node, ctx, interator) => {
+            writer.writeRaw(prefix);
+            if (node.content)
+                interator(node.content, ctx);
+            writer.writeRaw('\n');
+        };
+    })),
+    ':list': (0, handlers_1.setFn)((node, ctx) => {
+        return (writer, processor) => (node, ctx, interator) => {
+            // pass list type through context
+            const newCtx = {
+                ...ctx,
+                listType: node.list,
+                listCounter: { value: 1 },
+                listDepth: (ctx.listDepth || 0) + 1,
+            };
+            if (node.content)
+                interator(node.content, newCtx);
+        };
+    }),
+    'item:block': (writer, processor) => (node, ctx, interator) => {
+        const indent = '  '.repeat(Math.max(0, (ctx.listDepth || 1) - 1));
+        const listType = ctx.listType || 'unordered';
+        let prefix;
+        if (listType === 'ordered') {
+            const counter = ctx.listCounter || { value: 1 };
+            prefix = `${counter.value}. `;
+            counter.value++;
+        }
+        else if (listType === 'variable') {
+            prefix = '- ';
+        }
+        else {
+            prefix = '- ';
+        }
+        writer.writeRaw(indent + prefix);
+        if (node.content)
+            interator(node.content, ctx);
+    },
+    'comment:block': handlers_1.emptyContent,
+    defn: (writer, processor) => (node, ctx, interator) => {
+        if (node.content)
+            interator(node.content, ctx);
+        writer.writeRaw('\n');
+    },
+    'term:para': (writer, processor) => (node, ctx, interator) => {
+        writer.writeRaw('**');
+        if (node.content)
+            interator(node.content, ctx);
+        writer.writeRaw(':** ');
+    },
+    nested: (0, handlers_1.handleNested)(handlers_1.content, 1),
+    output: (0, handlers_1.handleNested)((writer, processor) => (node, ctx, interator) => {
+        writer.writeRaw('```\n');
+        if (node.content)
+            interator(node.content, ctx);
+        writer.writeRaw('```\n');
+    }, 1),
+    input: (0, handlers_1.handleNested)((writer, processor) => (node, ctx, interator) => {
+        writer.writeRaw('```\n');
+        if (node.content)
+            interator(node.content, ctx);
+        writer.writeRaw('```\n');
+    }, 1),
+    // table section
+    'table:block': (0, handlers_1.handleNested)((writer, processor) => (node, ctx, interator) => {
+        const conf = (0, config_1.default)(node, ctx);
+        if (conf.exists('caption')) {
+            writer.writeRaw('**');
+            writer.write(conf.getFirstValue('caption'));
+            writer.writeRaw('**\n\n');
+        }
+        // collect rows data for proper Markdown table rendering
+        const rows = (node.content || []).filter(child => child.name === 'table_row' || child.name === 'table_head');
+        if (rows.length === 0)
+            return;
+        const hasHeader = rows[0].name === 'table_head';
+        // render each row
+        rows.forEach((row, rowIndex) => {
+            const cells = (row.content || []).filter(c => c.name === 'table_cell');
+            writer.writeRaw('|');
+            cells.forEach(cell => {
+                writer.writeRaw(' ');
+                if (cell.content) {
+                    cell.content.forEach(c => {
+                        if (typeof c === 'string') {
+                            writer.write(c.trim());
+                        }
+                        else {
+                            interator([c], ctx);
+                        }
+                    });
+                }
+                writer.writeRaw(' |');
+            });
+            writer.writeRaw('\n');
+            // add separator after header row
+            if (rowIndex === 0 && hasHeader) {
+                writer.writeRaw('|');
+                cells.forEach(() => {
+                    writer.writeRaw(' --- |');
+                });
+                writer.writeRaw('\n');
+            }
+            // if no header, add separator after first row
+            if (rowIndex === 0 && !hasHeader) {
+                writer.writeRaw('|');
+                cells.forEach(() => {
+                    writer.writeRaw(' --- |');
+                });
+                writer.writeRaw('\n');
+            }
+        });
+        writer.writeRaw('\n');
+    }),
+    ':separator': handlers_1.emptyContent,
+    table_row: handlers_1.emptyContent,
+    table_cell: handlers_1.emptyContent,
+    table_head: handlers_1.emptyContent,
+    // Toc
+    ':toc': handlers_1.emptyContent,
+    ':toc-list': handlers_1.emptyContent,
+    ':toc-item': handlers_1.emptyContent,
+    ':image': (writer, processor) => (node, ctx, interator) => {
+        writer.writeRaw(`![${node.alt || ''}](${node.src})`);
+    },
+};
+const toMarkdown = opt => (0, exportAny_1.default)({ writer: writerMarkdown_1.default, ...opt })
+    .use('*', (writer, processor) => {
+    return (node, ctx, interator) => {
+        const isSemanticBlock = node => {
+            const name = node.name || '';
+            const isTypeBlock = (node.type || '') === 'block';
+            return isTypeBlock && name === name.toUpperCase();
+        };
+        if ((0, makeTransformer_1.isNamedBlock)(node.name)) {
+            return true;
+        }
+        if (isSemanticBlock(node)) {
+            const name = node.name;
+            writer.writeRaw('# ');
+            writer.write(name);
+            writer.writeRaw('\n\n');
+        }
+        if (node.hasOwnProperty('content')) {
+            interator(node.content, ctx);
+        }
+    };
+})
+    .use(rules);
+exports.default = toMarkdown;
+//# sourceMappingURL=exportMarkdown.js.map

package/lib/grammar.js

@@ -1,7 +1,7 @@
 /*
- * Generated by PEG.js 0.10.0.
+ * Generated by Pegmill 0.1.0
  *
- * http://pegjs.org/
+ * https://github.com/zag/pegmill
  */
 "use strict";
 function peg$subclass(child, parent) {
@@ -152,7 +152,7 @@ function peg$parse(input, options) {
             config,
             location: location()
         };
-    }, peg$c125 = /^[+-=_|]/, peg$c126 = peg$classExpectation([["+", "="], "_", "|"], false, false), peg$c127 = function () { return { type: 'separator', text: text() }; }, peg$c128 = function () { return options.isDelimited; }, peg$c129 = function () {
+    }, peg$c125 = /^[\-+=_|]/, peg$c126 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c127 = function () { return { type: 'separator', text: text() }; }, peg$c128 = function () { return options.isDelimited; }, peg$c129 = function () {
         return {
             type: 'separator',
             text: text()

package/lib/grammarfc.js

@@ -1,7 +1,7 @@
 /*
- * Generated by PEG.js 0.10.0.
+ * Generated by Pegmill 0.1.0
  *
- * http://pegjs.org/
+ * https://github.com/zag/pegmill
  */
 "use strict";
 function peg$subclass(child, parent) {

package/lib/index.d.ts

@@ -17,6 +17,7 @@ export { podlitePluggable, Podlite, PodliteExport, cleanIds, frozenIds } from '.
 export declare function toAst(): {};
 export declare type SchemaValidationError = ErrorObject<string, Record<string, any>>;
 export declare function getTextContentFromNode(node: PodNode): string;
+export declare function getPodContentFromNode(node: PodNode): string;
 export declare function validatePodliteAst(data: unknown): SchemaValidationError[];
 export declare function validateAstTree(data: unknown): SchemaValidationError[];
 export declare function validateAst(data: unknown, Name?: string): SchemaValidationError[];
@@ -75,6 +76,7 @@ export { makeTree as toTree };
 declare const parse: Function;
 export { parse as parse };
 export { default as toHtml } from './exportHtml';
+export { default as toMarkdown } from './exportMarkdown';
 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.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;
+exports.version = exports.Writer = exports.toMarkdown = exports.toHtml = exports.parse = exports.toTree = exports.isValidateError = exports.validateAst = exports.validateAstTree = exports.validatePodliteAst = exports.getPodContentFromNode = 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"));
@@ -82,6 +82,30 @@ function getTextContentFromNode(node) {
     return text;
 }
 exports.getTextContentFromNode = getTextContentFromNode;
+function getPodContentFromNode(node) {
+    let text = '';
+    const rules = {
+        '*': (node, ctx, visiter) => {
+            if (node.type === 'blankline') {
+                text += '\n';
+                return;
+            }
+            if (node.text) {
+                text += node.text;
+                return;
+            }
+            text += `=${node.name} `;
+            if ('content' in node) {
+                visiter(node.content, ctx);
+            }
+            return node;
+        },
+    };
+    const transformer = (0, ast_inerator_1.makeInterator)(rules);
+    const res = transformer(node, {});
+    return text;
+}
+exports.getPodContentFromNode = getPodContentFromNode;
 function validatePodliteAst(data) {
     return validateAst(data, 'PodliteDocument');
 }
@@ -161,6 +185,8 @@ 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 exportMarkdown_1 = require("./exportMarkdown");
+Object.defineProperty(exports, "toMarkdown", { enumerable: true, get: function () { return __importDefault(exportMarkdown_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

package/lib/pluggableParser.d.ts

@@ -18,6 +18,7 @@ export interface Podlite {
     use: (plugin: Plugins) => Podlite;
     parse: (text: string, opt?: parseOpt) => PodliteDocument;
     toHtml: (ast: PodliteDocument) => PodliteExport;
+    toMarkdown: (ast: PodliteDocument) => PodliteExport;
     toAst: (ast: PodliteDocument) => PodliteDocument;
     getPlugins: () => Array<Plugins>;
 }

package/lib/pluggableParser.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.podlitePluggable = exports.frozenIds = exports.cleanIds = void 0;
 const _1 = require(".");
+const exportMarkdown_1 = __importDefault(require("./exportMarkdown"));
 const ids_1 = __importDefault(require("./helpers/ids"));
 const corePlugins_1 = __importDefault(require("./helpers/corePlugins"));
 var ids_2 = require("./helpers/ids");
@@ -69,6 +70,10 @@ const podlitePluggable = ({ plugins = {} } = {}) => {
         const toHtmlPlugins = (0, _1.toAnyRules)('toHtml', instance.getPlugins());
         return (0, _1.toHtml)({}).use(toHtmlPlugins).run(ast, null);
     };
+    instance.toMarkdown = ast => {
+        const toMarkdownPlugins = (0, _1.toAnyRules)('toMarkdown', instance.getPlugins());
+        return (0, exportMarkdown_1.default)({}).use(toMarkdownPlugins).run(ast, null);
+    };
     instance.getPlugins = () => _plugins;
     // init core plugins
     instance.use(corePlugins_1.default);

package/lib/plugin-group-items.js

@@ -10,8 +10,10 @@ exports.default = () => tree => {
     (n1.name === 'item' || n1.name === 'defn') &&
         n2.name === n1.name &&
         n1['level'] === n2.level &&
-        isNumbered(n1) === isNumbered(n2);
+        isNumbered(n1) === isNumbered(n2) &&
+        isChecked(n1) === isChecked(n2);
     const isNumbered = node => Boolean((0, config_1.default)(node, {}).exists('numbered'));
+    const isChecked = node => node.checked !== undefined;
     const group = (a, level = 1) => {
         const isInListMode = a => {
             return a.length > 0 && a[a.length - 1].type === 'list';
@@ -32,14 +34,15 @@ exports.default = () => tree => {
                 (!isInListMode(a) ||
                     // different type of list and item
                     // at the same  level
-                    (i.level === level && getList(a).list !== (isNumbered(i) ? 'ordered' : 'itemized')))) {
+                    (Number(i.level) === level &&
+                        getList(a).list !== (isNumbered(i) ? 'ordered' : isChecked(i) ? 'task' : 'itemized')))) {
                 // create empty list
                 // list = ['ordered', 'variable', 'itemized']
                 a.push({
                     type: 'list',
                     level: i.level,
                     content: [],
-                    list: isNumbered(i) ? 'ordered' : 'itemized',
+                    list: isNumbered(i) ? 'ordered' : isChecked(i) ? 'task' : 'itemized',
                 });
             }
             // main logic
@@ -57,12 +60,12 @@ exports.default = () => tree => {
          * { type = 'list',
          *   ordered = [true, false]
          *   content = [ .... ]
-         *   list = ['ordered', 'variable', 'itemized']
+         *   list = ['ordered', 'variable', 'task', '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);
+                item.content = group(item.content, Number(item.level || 0) + 1);
             }
             return item;
         });

package/lib/plugin-items.js

@@ -13,9 +13,32 @@ exports.default = () => tree => {
                 if (matchItem) {
                     node.name = 'item';
                     node.level = matchItem[1] || 1;
+                    // Check :checked / :!checked config attribute
+                    const checkedConfig = (node.config || []).find(c => c.name === 'checked');
+                    if (checkedConfig) {
+                        node.checked = checkedConfig.value !== false && checkedConfig.value !== 0 && checkedConfig.value !== '0';
+                    }
                     if (node.content[0]) {
                         const startText = node.content[0];
                         if (startText.text) {
+                            // Check for checkbox syntax [x] or [ ] at start of text
+                            if (!checkedConfig) {
+                                const checkboxRe = /^\[( |x)\]\s*/;
+                                const checkboxMatch = checkboxRe.exec(startText.text);
+                                if (checkboxMatch) {
+                                    node.checked = checkboxMatch[1] === 'x';
+                                    startText.text = startText.text.replace(checkboxRe, '');
+                                    if (startText.type === 'para') {
+                                        startText.content = [startText.text];
+                                    }
+                                    node.config = node.config || [];
+                                    node.config.push({
+                                        name: 'checked',
+                                        value: node.checked,
+                                        type: 'boolean',
+                                    });
+                                }
+                            }
                             let re = /^(\s*#\s*)/;
                             const match = re.exec(startText.text);
                             if (match) {

package/lib/types.d.ts

@@ -100,6 +100,7 @@ export interface Image {
 export interface Toc {
     type: 'toc';
     title?: string;
+    foldedLevels?: Record<number, boolean>;
     content: TocList;
 }
 export interface TocList {
@@ -304,6 +305,7 @@ export interface BlockItem extends Block {
     name: 'item';
     content: Array<Node>;
     level: string | number;
+    checked?: boolean;
 }
 export interface BlockOutput extends Block {
     name: 'output';

package/lib/writerMarkdown.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Markdown writer
+ */
+import Writer from './writer';
+declare class WriterMarkdown extends Writer {
+    constructor(output?: any);
+    escape(string: any): string;
+    _add_nesting(n: any): void;
+    _remove_nesting(n: any): void;
+}
+export default WriterMarkdown;

package/lib/writerMarkdown.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Markdown writer
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const writer_1 = __importDefault(require("./writer"));
+class WriterMarkdown extends writer_1.default {
+    constructor(output) {
+        super(output);
+    }
+    escape(string) {
+        return (string + '').replace(/([\\`*_\[\]#|])/g, '\\$1');
+    }
+    _add_nesting(n) {
+        this.writeRaw('> '.repeat(n));
+    }
+    _remove_nesting(n) {
+        // no closing tag needed for Markdown blockquotes
+    }
+}
+exports.default = WriterMarkdown;
+//# sourceMappingURL=writerMarkdown.js.map

package/package.json

@@ -1,8 +1,17 @@
 {
   "name": "@podlite/schema",
-  "version": "0.0.33",
-  "description": "AST tools for Podlite markup language",
+  "version": "0.0.35",
+  "description": "AST tools and schema for Podlite markup language — validate, traverse, and transform document trees",
   "main": "lib/index.js",
+  "homepage": "https://podlite.org",
+  "bugs": {
+    "url": "https://github.com/podlite/podlite/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/podlite/podlite.git",
+    "directory": "packages/podlite-schema"
+  },
   "license": "MIT",
   "funding": {
     "type": "opencollective",
@@ -31,16 +40,22 @@
     "build": "run-s build:pegjs build_lib build:ast ",
     "build_lib": "yarn g:build",
     "build:ast": "ts-node scripts/make-ast-scheme.ts",
-    "build:pegjs": "pegjs -o src/grammar.js src/grammar.pegjs && pegjs -o src/grammarfc.js src/grammarfc.pegjs",
+    "build:pegjs": "pegmill -o src/grammar.js src/grammar.pegjs && pegmill -o src/grammarfc.js src/grammarfc.pegjs",
     "watch": "npx nodemon -e js,ts --exec 'yarn' build",
-    "watch:pegjs": "npx nodemon -e pegjs --exec 'yarn' build:pegjs",
+    "watch:pegjs": "npx nodemon -e pegmill --exec 'yarn' build:pegjs",
     "test": "yarn g:jest  --passWithNoTests"
   },
   "keywords": [
-    "markdown",
     "podlite",
-    "markup",
-    "markup-language"
+    "schema",
+    "ast",
+    "syntax-tree",
+    "markup-language",
+    "transform",
+    "visitor",
+    "parser",
+    "markdown",
+    "tree"
   ],
   "dependencies": {
     "ajv": "^7.2.3",
@@ -53,7 +68,7 @@
     "@types/node": "^17.0.7",
     "glob": "^7.2.0",
     "npm-run-all": "^4.1.5",
-    "pegjs": "^0.10.0",
+    "pegmill": "0.1.0",
     "ts-node": "^9.1.1",
     "typescript": "4.5.5",
     "typescript-json-schema": "0.53.0"