markdown-it-adv-table 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yamavol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# markdown-it-adv-table
+

package/dist/adv-table.d.ts

@@ -0,0 +1,12 @@
+import type { StateBlock } from "markdown-it/index.js";
+import { TableAttr } from "./table.js";
+/**
+ * AdvTableParser delegates parsing to the appropriate parser
+ * based on the format option specified.
+ */
+export declare class AdvTableParser {
+    readonly attrs: TableAttr;
+    readonly params: string;
+    constructor(param: string);
+    parse(state: StateBlock, startLine: number, endLine: number): void;
+}

package/dist/adv-table.js

@@ -0,0 +1,29 @@
+import { CsvTableParser } from "./csv-table.js";
+import { FlatTableParser } from "./flat-table.js";
+import { TableSpec } from "./table.js";
+/**
+ * AdvTableParser delegates parsing to the appropriate parser
+ * based on the format option specified.
+ */
+export class AdvTableParser {
+    attrs;
+    params;
+    constructor(param) {
+        this.params = param;
+        this.attrs = TableSpec.parseInfoString(this.params);
+    }
+    parse(state, startLine, endLine) {
+        if (this.attrs.format === "csv") {
+            const parser = CsvTableParser.new(this.params, ",");
+            parser.parse(state, startLine, endLine);
+        }
+        else if (this.attrs.format === "tsv") {
+            const parser = CsvTableParser.new(this.params, "\t");
+            parser.parse(state, startLine, endLine);
+        }
+        else {
+            const parser = FlatTableParser.new(this.params, state, startLine, endLine);
+            parser.parse(state, startLine, endLine);
+        }
+    }
+}

package/dist/cell.d.ts

@@ -0,0 +1,33 @@
+type HAlign = "left" | "center" | "right";
+/**
+ * A state machine to track cell position and its attributes
+ */
+export declare class CellState {
+    private static readonly _initialPos;
+    private _pos;
+    private _numCols;
+    private _colsAttr;
+    private _cells;
+    constructor(columns: number);
+    get numCols(): number;
+    get pos(): [number, number];
+    get row(): number;
+    set row(num: number);
+    get col(): number;
+    set col(num: number);
+    init(numCols: number): void;
+    setColWidth(col: number, width?: string): void;
+    setColAlign(col: number, align?: HAlign): void;
+    setColSpan(row: number, col: number, cspan: number): void;
+    setRowSpan(row: number, col: number, rspan: number): void;
+    /**
+     * Return the next available cell
+     */
+    next(): {
+        row: number;
+        col: number;
+    };
+    isUsed(row: number, col: number): boolean;
+    private markUsed;
+}
+export {};

package/dist/cell.js

@@ -0,0 +1,105 @@
+/**
+ * A state machine to track cell position and its attributes
+ */
+export class CellState {
+    static _initialPos = [-1, -1];
+    _pos;
+    _numCols;
+    _colsAttr;
+    _cells;
+    constructor(columns) {
+        this._numCols = Math.max(columns, 1);
+        this._pos = [...CellState._initialPos];
+        this._colsAttr = Array(this._numCols).fill({});
+        this._cells = {};
+    }
+    get numCols() {
+        return this._numCols;
+    }
+    get pos() {
+        return this._pos;
+    }
+    get row() {
+        return this._pos[0];
+    }
+    set row(num) {
+        this._pos[0] = num;
+    }
+    get col() {
+        return this._pos[1];
+    }
+    set col(num) {
+        this._pos[1] = num;
+    }
+    init(numCols) {
+        this._numCols = numCols;
+        this._pos = [...CellState._initialPos];
+        this._cells = {};
+    }
+    setColWidth(col, width) {
+        this._colsAttr[col].width = width;
+    }
+    setColAlign(col, align) {
+        this._colsAttr[col].align = align;
+    }
+    setColSpan(row, col, cspan) {
+        const key = mapKey(row, col);
+        this._cells[key].colspan = cspan;
+        for (let c = col; c < col + cspan; c++) {
+            const key = mapKey(row, c);
+            const cell = this._cells[key];
+            cell.assigned = true;
+        }
+    }
+    setRowSpan(row, col, rspan) {
+        const key = mapKey(row, col);
+        this._cells[key].rowspan = rspan;
+        for (let r = row; r < row + rspan; r++) {
+            const key = mapKey(r, col);
+            const cell = this._cells[key];
+            cell.assigned = true;
+        }
+    }
+    /**
+     * Return the next available cell
+     */
+    next() {
+        if (this.row === -1) {
+            this.row = 0;
+            this.col = 0;
+        }
+        else {
+            // skip reserved cells for cspan/rspan, and return next valid cell. WIP
+            while (this.isUsed(this.row, this.col)) {
+                this.col++;
+                if (this.col >= this._numCols) {
+                    this.col = 0;
+                    this.row++;
+                }
+            }
+        }
+        this.markUsed(this.row, this.col);
+        return {
+            row: this.row,
+            col: this.col,
+        };
+    }
+    isUsed(row, col) {
+        const key = mapKey(row, col);
+        return this._cells[key]?.assigned === true;
+    }
+    markUsed(row, col) {
+        const key = mapKey(row, col);
+        const map = this._cells[key];
+        if (map === undefined) {
+            this._cells[key] = { assigned: true };
+        }
+        else {
+            map.assigned = true;
+        }
+    }
+}
+function mapKey(row, column) {
+    return `${row}-${column}`;
+}
+//# sourceMappingURL=cell.js.map

package/dist/csv-table.d.ts

@@ -0,0 +1,11 @@
+import { StateBlock } from "markdown-it/index.js";
+import { TableSpec } from "./table.js";
+export declare class CsvTableParser {
+    private _tableSpec;
+    readonly delim: string;
+    constructor(tableSpec: TableSpec, delimitor?: string);
+    static new(params: string, delim: string): CsvTableParser;
+    parse(state: StateBlock, startLine: number, endLine: number): void;
+    static numCols(cells: string[][]): number;
+    static parsecsv(text: String, delim?: string): string[][];
+}

package/dist/csv-table.js

@@ -0,0 +1,86 @@
+import { Lexer, unwrapLiteral } from "./lexer.js";
+import { TableBuilder } from "./table-builder.js";
+import { TableSpec } from "./table.js";
+export class CsvTableParser {
+    _tableSpec;
+    delim;
+    constructor(tableSpec, delimitor = ",") {
+        this._tableSpec = tableSpec;
+        this.delim = delimitor;
+    }
+    static new(params, delim) {
+        const attr = TableSpec.parseInfoString(params);
+        const tablespec = new TableSpec(attr);
+        return new CsvTableParser(tablespec, delim);
+    }
+    parse(state, startLine, endLine) {
+        const lines = state.getLines(startLine, endLine, state.blkIndent, false);
+        const cells = CsvTableParser.parsecsv(lines, this.delim);
+        if (this._tableSpec.attr.cols === undefined) {
+            const numCols = CsvTableParser.numCols(cells);
+            this._tableSpec.colspecs.lazyInit(numCols);
+        }
+        const builder = new TableBuilder(state, this._tableSpec);
+        const md = state.md;
+        const istate = new md.inline.State("", md, state.env, []);
+        builder.startTable();
+        for (let row = 0; row < cells.length; row++) {
+            for (let col = 0; col < cells[row].length; col++) {
+                const itoken = istate.push("text", "", 0);
+                itoken.content = cells[row][col];
+                // manually assign inline token to disable being inline-processed.
+                builder.insertCell(state => {
+                    const token = state.push("inline", "", 0);
+                    token.content = "";
+                    token.children = [itoken];
+                });
+            }
+        }
+        builder.endTable();
+    }
+    static numCols(cells) {
+        let colMax = 1;
+        for (let row = 0; row < cells.length; row++) {
+            colMax = Math.max(colMax, cells[row].length);
+        }
+        return colMax;
+    }
+    static parsecsv(text, delim = ",") {
+        const lines = text.split("\n");
+        let result = [];
+        for (const line of lines) {
+            // skip empty line
+            if (line.trim().length === 0) {
+                continue;
+            }
+            const lexer = new Lexer(line);
+            const columns = [];
+            let cp = 0;
+            while (cp != Lexer.EOF) {
+                lexer.skipWhitespace();
+                cp = lexer.peek();
+                if (Lexer.cmp(cp, "\"")) {
+                    let literal = lexer.consumeLiteral("\"");
+                    literal = unwrapLiteral(literal, "\"");
+                    columns.push(literal);
+                }
+                else if (Lexer.cmp(cp, delim)) {
+                    lexer.skipWhitespace();
+                    // if next letter is "," insert empty column
+                    if (Lexer.cmp(lexer.peekNext(), delim)) {
+                        columns.push("");
+                    }
+                    lexer.next();
+                }
+                else if (!Lexer.isEOF(cp)) {
+                    columns.push(lexer.consumeRe(/^[^,]+/));
+                }
+                else {
+                    break;
+                }
+            }
+            result.push(columns);
+        }
+        return result;
+    }
+}

package/dist/debug.d.ts

@@ -0,0 +1,7 @@
+interface DebugFunction {
+    (...args: any[]): void;
+    isEnabled(): boolean;
+}
+export declare function createDebug(namespace: string): DebugFunction;
+export declare const debug: DebugFunction;
+export default debug;

package/dist/debug.js

@@ -0,0 +1,27 @@
+;
+export function createDebug(namespace) {
+    const nsList = process.env.DEBUG?.split(",").map((s) => s.trim()) ?? [];
+    const isEnabled = nsList.some((ns) => {
+        // if (ns === "*") {  // Intentionally disabled because this output
+        //   return true;     // should not be mixed with other libraries. 
+        // }
+        if (ns === namespace) {
+            return true;
+        }
+        if (ns.endsWith("*")) {
+            return namespace.startsWith(ns.slice(0, -1));
+        }
+        return ns === namespace;
+    });
+    const debug = (...args) => {
+        if (isEnabled) {
+            const fmtArgs = args.map(arg => ` ${arg}`).join("");
+            process.stderr.write(`${fmtArgs}\n`);
+        }
+    };
+    debug.isEnabled = () => isEnabled;
+    return debug;
+}
+;
+export const debug = createDebug("adv-table:d");
+export default debug;

package/dist/fence.d.ts

@@ -0,0 +1,8 @@
+import type { StateBlock } from "markdown-it/index.js";
+import type { RuleBlock } from "markdown-it/lib/parser_block.mjs";
+export type Parser = (info: string, state: StateBlock, startLine: number, endLine: number) => void;
+/**
+ * Parse fenced code block and if the name matches, the content is passed to
+ * the custom parser.
+ */
+export declare function fence_custom(names: string | string[], parser: Parser): RuleBlock;

package/dist/fence.js

@@ -0,0 +1,97 @@
+/**
+ * Parse fenced code block and if the name matches, the content is passed to
+ * the custom parser.
+ */
+export function fence_custom(names, parser) {
+    if (typeof names === "string") {
+        names = [names];
+    }
+    return (state, startLine, endLine, silent) => {
+        let pos = state.bMarks[startLine] + state.tShift[startLine];
+        let max = state.eMarks[startLine];
+        // if it's indented more than 3 spaces, it should be a code block
+        if (state.sCount[startLine] - state.blkIndent >= 4) {
+            return false;
+        }
+        if (pos + 3 > max) {
+            return false;
+        }
+        const marker = state.src.charCodeAt(pos);
+        if (marker !== 0x7E /* ~ */ && marker !== 0x60 /* ` */) {
+            return false;
+        }
+        // scan marker length
+        let mem = pos;
+        pos = state.skipChars(pos, marker);
+        let len = pos - mem;
+        if (len < 3) {
+            return false;
+        }
+        const markup = state.src.slice(mem, pos);
+        const params = state.src.slice(pos, max);
+        if (marker === 0x60 /* ` */) {
+            if (params.indexOf(String.fromCharCode(marker)) >= 0) {
+                return false;
+            }
+        }
+        if (!names.some(name => params.startsWith(name))) {
+            return false;
+        }
+        // Since start is found, we can report success here in validation mode
+        if (silent) {
+            return true;
+        }
+        // search end of block
+        let nextLine = startLine;
+        let haveEndMarker = false;
+        for (;;) {
+            nextLine++;
+            if (nextLine >= endLine) {
+                // unclosed block should be autoclosed by end of document.
+                // also block seems to be autoclosed by end of parent
+                break;
+            }
+            pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
+            max = state.eMarks[nextLine];
+            if (pos < max && state.sCount[nextLine] < state.blkIndent) {
+                // non-empty line with negative indent should stop the list:
+                // - ```
+                //  test
+                break;
+            }
+            if (state.src.charCodeAt(pos) !== marker) {
+                continue;
+            }
+            if (state.sCount[nextLine] - state.blkIndent >= 4) {
+                // closing fence should be indented less than 4 spaces
+                continue;
+            }
+            pos = state.skipChars(pos, marker);
+            // closing code fence must be at least as long as the opening one
+            if (pos - mem < len) {
+                continue;
+            }
+            // make sure tail has spaces only
+            pos = state.skipSpaces(pos);
+            if (pos < max) {
+                continue;
+            }
+            haveEndMarker = true;
+            // found!
+            break;
+        }
+        len = state.sCount[startLine];
+        state.line = nextLine + (haveEndMarker ? 1 : 0);
+        if (parser !== undefined) {
+            parser(params, state, startLine, nextLine);
+        }
+        else {
+            const token = state.push("fence", "code", 0);
+            token.info = params;
+            token.content = state.getLines(startLine + 1, nextLine, len, true);
+            token.markup = markup;
+            token.map = [startLine, state.line];
+        }
+        return true;
+    };
+}

package/dist/flat-table.d.ts

@@ -0,0 +1,25 @@
+import type { StateBlock } from "markdown-it/index.js";
+import { CellAttr, TableSpec } from "./table.js";
+/**
+ * FlatTableParser parses the flat-table syntax.
+ */
+export declare class FlatTableParser {
+    private _tableSpec;
+    constructor(tableSpec: TableSpec);
+    static new(params: string, state: StateBlock, startLine: number, endLine: number): FlatTableParser;
+    /**
+     * Parse custom table syntax into tokens.
+     *
+     * @param state markdown-it parser state
+     * @param startLine the first line which contains the table syntax.
+     * @param endLine the last line which contains the table syntax.
+     */
+    parse(state: StateBlock, startLine: number, endLine: number): void;
+    getline(state: StateBlock, lineNumber: number): string;
+    static getCellIndent(state: StateBlock, line: string): number;
+    static isCellStart(line: string): boolean;
+    /** extract cellspec from line */
+    static cellspec(line: string): string;
+    static parseCellspec(line: string): CellAttr;
+    static inferColCount(state: StateBlock, lineStart: number, lineEnd: number): number;
+}

package/dist/flat-table.js

@@ -0,0 +1,162 @@
+import { TableBuilder } from "./table-builder.js";
+import { TableSpec } from "./table.js";
+/**
+ * FlatTableParser parses the flat-table syntax.
+ */
+export class FlatTableParser {
+    _tableSpec;
+    constructor(tableSpec) {
+        this._tableSpec = tableSpec;
+    }
+    static new(params, state, startLine, endLine) {
+        const attr = TableSpec.parseInfoString(params);
+        if (attr.cols === undefined) {
+            attr.cols = FlatTableParser.inferColCount(state, startLine, endLine).toString();
+        }
+        const tableSpec = new TableSpec(attr);
+        return new FlatTableParser(tableSpec);
+    }
+    /**
+     * Parse custom table syntax into tokens.
+     *
+     * @param state markdown-it parser state
+     * @param startLine the first line which contains the table syntax.
+     * @param endLine the last line which contains the table syntax.
+     */
+    parse(state, startLine, endLine) {
+        const builder = new TableBuilder(state, this._tableSpec);
+        builder.startTable();
+        let currentLine = startLine;
+        while (currentLine < endLine) {
+            const line = state.getLines(currentLine, currentLine + 1, state.blkIndent, false);
+            // skip empty line
+            if (line.trim().length === 0) {
+                currentLine++;
+                continue;
+            }
+            // cell starter
+            if (FlatTableParser.isCellStart(line)) {
+                // find cell content range
+                const cellStart = currentLine;
+                while (currentLine + 1 < endLine && !FlatTableParser.isCellStart(this.getline(state, currentLine + 1))) {
+                    currentLine++;
+                }
+                const cellEnd = currentLine;
+                // parse cell content as document
+                const md = state.md;
+                const cellIndent = FlatTableParser.getCellIndent(state, line);
+                const cellSpec = FlatTableParser.cellspec(line);
+                const cellAttr = FlatTableParser.parseCellspec(cellSpec);
+                const cellContent = state.getLines(cellStart, cellEnd + 1, cellIndent, false).slice(cellSpec.length + cellIndent);
+                const cstate = new md.block.State(cellContent, md, state.env, []);
+                md.block.tokenize(cstate, 0, cellEnd + 1 - cellStart);
+                if (cstate.tokens.length === 3
+                    && cstate.tokens[0].type.startsWith("paragraph_open")
+                    && cstate.tokens[1].type.startsWith("inline")
+                    && cstate.tokens[2].type.startsWith("paragraph_close")) {
+                    cstate.tokens[0].hidden = true;
+                    cstate.tokens[2].hidden = true;
+                }
+                builder.insertCell(state => {
+                    state.tokens.push(...cstate.tokens);
+                }, cellAttr);
+                currentLine++;
+            }
+            else {
+                const shortline = line.length > 10 ? line.slice(0, 10) + "..." : line;
+                throw new Error(`parse error: invalid syntax: ${shortline}`);
+            }
+        }
+        builder.endTable();
+    }
+    getline(state, lineNumber) {
+        return state.getLines(lineNumber, lineNumber + 1, state.blkIndent, false);
+    }
+    static getCellIndent(state, line) {
+        const cellStart = line.search(/\|/);
+        const numSpaces = line.slice(cellStart + 1).search(/\S|$/); // number of spaces between symbol and text
+        const userIndent = Math.max(0, Math.min(1 + numSpaces, 4));
+        return state.blkIndent + userIndent;
+    }
+    static isCellStart(line) {
+        if (line.startsWith("|"))
+            return true;
+        if (FlatTableParser.cellspec(line).length > 0)
+            return true;
+        return false;
+    }
+    /** extract cellspec from line */
+    static cellspec(line) {
+        const match = /^((r\d+|c\d+|\<|\^|\>|h)*)\|/.exec(line);
+        if (match === null) {
+            return "";
+        }
+        else {
+            return match[1];
+        }
+    }
+    static parseCellspec(line) {
+        let pos = 0;
+        const attr = {};
+        while (pos < line.length) {
+            const char = line[pos];
+            if (char === undefined) {
+                break;
+            }
+            else if (char === "^") {
+                consume();
+                attr.align = "center";
+            }
+            else if (char === "<") {
+                consume();
+                attr.align = "left";
+            }
+            else if (char === ">") {
+                consume();
+                attr.align = "right";
+            }
+            else if (char === "r") {
+                consume();
+                attr.rowspan = parseInt(consumeNumber());
+            }
+            else if (char === "c") {
+                consume();
+                attr.colspan = parseInt(consumeNumber());
+            }
+            else if (char === "h") {
+                consume();
+                attr.header = true;
+            }
+            else {
+                consume();
+            }
+        }
+        return attr;
+        function consume() {
+            return line[pos++];
+        }
+        function consumeNumber() {
+            const match = line.slice(pos).match(/^\d+/);
+            if (!match)
+                throw new Error("cannot consume number");
+            pos += match[0].length;
+            return match[0];
+        }
+    }
+    static inferColCount(state, lineStart, lineEnd) {
+        // TBD: does not handle colspan, rowspan
+        let contLen = 0;
+        let contLenMax = 0;
+        for (let line = lineStart; line < lineEnd; line++) {
+            const linetext = state.getLines(line, line + 1, state.blkIndent, false);
+            if (FlatTableParser.isCellStart(linetext)) {
+                contLen++;
+                contLenMax = Math.max(contLenMax, contLen);
+            }
+            else {
+                contLen = 0;
+            }
+        }
+        return contLenMax;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { PluginWithOptions } from "markdown-it";
+import { Parser } from "./fence.js";
+export interface PluginOption {
+    names: {
+        adv: string;
+        flat: string;
+        csv: string;
+        tsv: string;
+    };
+}
+export interface PluginOptionSingle {
+    name: string;
+}
+export declare function createParser(option: PluginOption): Parser;
+export declare const advTable: PluginWithOptions<PluginOption>;
+export declare const flatTable: PluginWithOptions<PluginOptionSingle>;
+export declare const csvTable: PluginWithOptions<PluginOptionSingle>;
+export declare const tsvTable: PluginWithOptions<PluginOptionSingle>;
+export default advTable;