Extracts tables from Markdown documents and converts to JSON objects. 

icooper

markdown-tables-to-json

var __extends = (this && this.__extends) || (function () {

    var extendStatics = function (d, b) {

        extendStatics = Object.setPrototypeOf ||

            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||

            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };

        function __() { this.constructor = d; }

        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

Object.defineProperty(exports, "__esModule", { value: true });

        var _this = _super.call(this) || this;

    Object.defineProperty(Extractor.prototype, "tables", {

        get: function () { return this.extractedTables; },

    Object.defineProperty(Extractor.prototype, "objects", {

        get: function () { return this.extractedTables.map(function (table) { return Extractor.tableToObject(table); }); },

    Extractor.prototype.reset = function (mode) {

        if (mode === void 0) { mode = 'rows'; }

    Extractor.prototype.table = function (header, body) {

        this.extractedTables.push(this.mode === 'rows'

            : Extractor.transposeTable(this.currentTable));

        return _super.prototype.table.call(this, header, body);

    Extractor.prototype.tablerow = function (content) {

        this.currentTable.push(this.currentRow);

        return _super.prototype.tablerow.call(this, content);

    Extractor.prototype.tablecell = function (content, flags) {

        return _super.prototype.tablecell.call(this, content, flags);

    Extractor.transposeTable = function (table) {

        for (var row = 0; row < rows; row++) {

            for (var col = 0; col < cols; col++) {

                transposed[row].push(table[col][row]);

    Extractor.tableToObject = function (table) {

        var keys = table.shift().slice(1);

            cells.forEach(function (cell, index) {

                rowObj[keys[index]] = cell;

    Extractor.createExtractor = function (markdown, mode) {

        var extractor = new Extractor(mode);

        marked_ts_1.Marked.setOptions({ renderer: extractor });

        marked_ts_1.Marked.parse(markdown);

    Extractor.extractObject = function (markdown, mode) {

        var objects = Extractor.extractAllObjects(markdown, mode);

        return objects.length > 0 ? objects[0] : null;

    Extractor.extractAllObjects = function (markdown, mode) {

        var extractor = Extractor.createExtractor(markdown, mode);

    Extractor.extractTable = function (markdown, mode) {

        var tables = Extractor.extractAllTables(markdown, mode);

        return tables.length > 0 ? tables[0] : null;

    Extractor.extractAllTables = function (markdown, mode) {

    Extractor.extract = function (markdown, mode) {

        return extractor.objects.length > 0 ? JSON.stringify(extractor.objects[0]) : null;

    Extractor.extractAll = function (markdown, mode) {

        return extractor.objects.map(function (obj) { return JSON.stringify(obj); });

    "description": "Extracts tables from Markdown documents and converts to JSON objects.",

    "repository": "https://github.com/icooper/markdown-tables-to-json",

        "build": "./node_modules/.bin/tsc",

        "build:w": "./node_modules/.bin/tsc --watch"

This is a module for extracting tables from Markdown documents and converting them to string arrays or JSON objects.

The following code snippet demonstrates the basic usage of the module and the difference between `'rows'` and `'columns'` modes. Take a look at [src/index.ts](src/index.ts) for additional static methods available.

var { Extractor } = require('markdown-tables-to-json');

// markdown string with a row-oriented table

|----------|-------|-------|-------|-------|

// markdown string with a column-oriented table

console.log(Extractor.extractObject(md_rows));

console.log(Extractor.extractObject(md_cols, 'columns'));

   { name: 'black', head: 'black', body: 'black', tail: 'white' },

   { name: 'white', head: 'white', body: 'black', tail: 'white' },

   { name: 'white', head: 'white', body: 'white', tail: 'white' } }

  mittens: { head: 'black', body: 'black', tail: 'black', paws: 'white' },

  dipstick: { head: 'white', body: 'white', tail: 'black', paws: 'white' },

  snow: { head: 'white', body: 'white', tail: 'white', paws: 'white' }

 * Main class (Extractor) for markdown-tables-to-json. Requires `marked-ts` to

 * A module for extracting tables from Markdown documents.

import { Marked, Renderer, Align } from 'marked-ts';

 * Table mode type definition; `'rows'` or `'columns'`.

export type TableMode = 'rows' | 'columns';

 * Extracts tables from Markdown-formatted strings. Can be used via static methods

export class Extractor extends Renderer {

    protected extractedTables: string[][][];

    get tables(): string[][][] { return this.extractedTables; };

    get objects(): {}[] { return this.extractedTables.map(table => Extractor.tableToObject(table)); };

     * Constructor. Creates the extractor with the specified mode.

     * @param {string} [mode] `'rows'` or `'columns'`

     * Clears the extracted tables and allows the mode to be changed.

     * @param {string} [mode='rows'] `'rows'` or `'columns'`

    reset(mode: TableMode = 'rows'): void {

     * Renders a table (with header and body) into HTML.

     * @param {string} header table header HTML content

     * @param {string} body table body HTML content

     * @returns {string} HTML-formatted table row

    table(header: string, body: string): string {

                : Extractor.transposeTable(this.currentTable)

        return super.table(header, body);

     * @param {string} content table row HTML content

     * @param {string} content table cell HTML content

     * @param {string} flags table cell flags

     * @returns {string} HTML-formatted table cell

    tablecell(content: string, flags: { header?: boolean, align?: Align }): string {

        return super.tablecell(content, flags);

     * Transposes the rows and columns of a table.

     * @param {string[][]} table square 2-dimensional string array

     * @returns {string[][]} transposed table

    static transposeTable(table: string[][]): string[][] {

        for (let row = 0; row < rows; row++) {

        let keys: string[] = table.shift();

        let keys: string[] = table.shift().slice(1);

            cells.forEach((cell, index) => {

     * Parses the provided Markdown input string and returns the associated Extractor.

     * Not public; use the extract* methods to access the extracted tables in various formats.

     * @param {string} markdown Markdown input string

     * @returns {Extractor} an Extractor object after parsing is complete

    protected static createExtractor(markdown: string, mode?: TableMode): Extractor {

        let extractor = new Extractor(mode);

        Marked.setOptions({ renderer: extractor });

     * Extracts the first table in the provided Markdown input string.

     * @returns {Object} object representing the first extracted table, or `null` if there isn't one

    static extractObject(markdown: string, mode?: TableMode): {} {

        let objects = Extractor.extractAllObjects(markdown, mode);

     * Extracts all of the tables in the provided Markdown input string.

     * @returns {Object[]} array of objects representing the extracted tables; might be empty

    static extractAllObjects(markdown: string, mode?: TableMode): {}[] {

        let extractor = Extractor.createExtractor(markdown, mode);

     * @returns {string[][]} 2-dimensional string array representing the first extracted table, or `null` if there isn't one

    static extractTable(markdown: string, mode?: TableMode): string[][] {

        let tables = Extractor.extractAllTables(markdown, mode);

     * @returns {string[][][]} array of 2-dimensional string arrays representing the extracted tables; might be empty

    static extractAllTables(markdown: string, mode?: TableMode): string[][][] {

     * @returns {string} JSON string representing the first extracted table, or `null` if there isn't one

    static extract(markdown: string, mode?: TableMode): string {

     * @returns {string[]} array of JSON strings representing the extracted tables; might be empty

    static extractAll(markdown: string, mode?: TableMode): string[] {

        return extractor.objects.map(obj => JSON.stringify(obj));

 * Run some basic tests on the table extractor.

let json_rows = Extractor.extract(md_rows, 'rows');

let table_rows = Extractor.extractTable(md_rows, 'rows');

let obj_rows = Extractor.extractObject(md_rows, 'rows');

let json_cols = Extractor.extract(md_cols, 'columns');

let table_cols = Extractor.extractTable(md_cols, 'columns');

let obj_cols = Extractor.extractObject(md_cols, 'columns');

// compare the results when parsed by rows and columns in different formats

    { type: 'JSON strings', rows: json_rows,  cols: json_cols  },

    { type: 'tables',       rows: table_rows, cols: table_cols },

    { type: 'objects',      rows: obj_rows,   cols: obj_cols   }

].forEach((test: { type: string, rows: any, cols: any }) => {

    // JSON.stringify is the easiest way to test that the objects are equivalent

    if (JSON.stringify(test.rows) === JSON.stringify(test.cols)) {

        console.log(`PASS: ${test.type} match`);

        // if we fail, print out the non-matching objects

        console.log(`FAIL: discrepency between ${test.type}`);

    console.log("PASS: all tests passed");

    console.log("FAIL: not all tests passed");

		@@ -72,3 +72,3 @@ "use strict";
		Extractor.tableToObject = function (table) {
		var keys = table.shift();
		var keys = table.shift().slice(1);
		var obj = {};
		@@ -75,0 +75,0 @@ table.forEach(function (cells) {

		{
		"name": "markdown-tables-to-json",
		"version": "0.1.4",
		"version": "0.1.5",
		"description": "Extracts tables from Markdown documents and converts to JSON objects.",
		@@ -23,3 +23,3 @@ "main": "./dist/index.js",
		"dependencies": {
		"marked-ts": "^1.0.0-beta.4"
		"marked-ts": "^1.0.0-beta.5"
		},
		@@ -26,0 +26,0 @@ "devDependencies": {

		@@ -8,3 +8,3 @@ /*
		* Ian Cooper
		* 12 September 2018
		* 31 December 2020
		*
		@@ -127,3 +127,3 @@ */

		let keys: string[] = table.shift();
		let keys: string[] = table.shift().slice(1);
		let obj = {};
		@@ -130,0 +130,0 @@

Worsened metrics

Dependency changes

		@@ -41,15 +41,13 @@ # markdown-tables-to-json
		```javascript
		{ mittens:
		{ name: 'black', head: 'black', body: 'black', tail: 'white' },
		dipstick:
		{ name: 'white', head: 'white', body: 'black', tail: 'white' },
		snow:
		{ name: 'white', head: 'white', body: 'white', tail: 'white' } }
		{ mittens:
		{ name: 'black', head: 'black', body: 'black', tail: 'white' },
		dipstick:
		{ name: 'white', head: 'white', body: 'black', tail: 'white' },
		snow:
		{ name: 'white', head: 'white', body: 'white', tail: 'white' } }
		{
		mittens: { head: 'black', body: 'black', tail: 'black', paws: 'white' },
		dipstick: { head: 'white', body: 'white', tail: 'black', paws: 'white' },
		snow: { head: 'white', body: 'white', tail: 'white', paws: 'white' }
		}
		{
		mittens: { head: 'black', body: 'black', tail: 'black', paws: 'white' },
		dipstick: { head: 'white', body: 'white', tail: 'black', paws: 'white' },
		snow: { head: 'white', body: 'white', tail: 'white', paws: 'white' }
		}
		```