markdown-it-adv-table 0.1.1 → 0.1.2

package/{dist → lib}/adv-table.d.ts

@@ -1,9 +1,5 @@
 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;

package/{dist → lib}/adv-table.js

@@ -1,10 +1,6 @@
 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;

package/{dist → lib}/csv-table.js

@@ -28,7 +28,6 @@ export class CsvTableParser {
             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 = "";
@@ -49,7 +48,6 @@ export class CsvTableParser {
         const lines = text.split("\n");
         let result = [];
         for (const line of lines) {
-            // skip empty line
             if (line.trim().length === 0) {
                 continue;
             }
@@ -66,7 +64,6 @@ export class CsvTableParser {
                 }
                 else if (Lexer.cmp(cp, delim)) {
                     lexer.skipWhitespace();
-                    // if next letter is "," insert empty column
                     if (Lexer.cmp(lexer.peekNext(), delim)) {
                         columns.push("");
                     }

package/{dist → lib}/debug.js

@@ -2,9 +2,6 @@
 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;
         }

package/{dist → lib}/fence.d.ts

@@ -1,8 +1,4 @@
 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 → lib}/fence.js

@@ -1,7 +1,3 @@
-/**
- * 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];
@@ -9,7 +5,6 @@ export function fence_custom(names, parser) {
     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;
         }
@@ -17,10 +12,9 @@ export function fence_custom(names, parser) {
             return false;
         }
         const marker = state.src.charCodeAt(pos);
-        if (marker !== 0x7E /* ~ */ && marker !== 0x60 /* ` */) {
+        if (marker !== 0x7E && marker !== 0x60) {
             return false;
         }
-        // scan marker length
         let mem = pos;
         pos = state.skipChars(pos, marker);
         let len = pos - mem;
@@ -29,7 +23,7 @@ export function fence_custom(names, parser) {
         }
         const markup = state.src.slice(mem, pos);
         const params = state.src.slice(pos, max);
-        if (marker === 0x60 /* ` */) {
+        if (marker === 0x60) {
             if (params.indexOf(String.fromCharCode(marker)) >= 0) {
                 return false;
             }
@@ -37,47 +31,36 @@ export function fence_custom(names, parser) {
         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];

package/{dist → lib}/flat-table.d.ts

@@ -1,24 +1,13 @@
 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 → lib}/flat-table.js

@@ -1,8 +1,5 @@
 import { TableBuilder } from "./table-builder.js";
 import { TableSpec } from "./table.js";
-/**
- * FlatTableParser parses the flat-table syntax.
- */
 export class FlatTableParser {
     _tableSpec;
     constructor(tableSpec) {
@@ -16,33 +13,22 @@ export class FlatTableParser {
         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);
@@ -74,7 +60,7 @@ export class FlatTableParser {
     }
     static getCellIndent(state, line) {
         const cellStart = line.search(/\|/);
-        const numSpaces = line.slice(cellStart + 1).search(/\S|$/); // number of spaces between symbol and text
+        const numSpaces = line.slice(cellStart + 1).search(/\S|$/);
         const userIndent = Math.max(0, Math.min(1 + numSpaces, 4));
         return state.blkIndent + userIndent;
     }
@@ -85,7 +71,6 @@ export class FlatTableParser {
             return true;
         return false;
     }
-    /** extract cellspec from line */
     static cellspec(line) {
         const match = /^((r\d+|c\d+|\<|\^|\>|h)*)\|/.exec(line);
         if (match === null) {
@@ -144,7 +129,6 @@ export class FlatTableParser {
         }
     }
     static inferColCount(state, lineStart, lineEnd) {
-        // TBD: does not handle colspan, rowspan
         let contLen = 0;
         let contLenMax = 0;
         for (let line = lineStart; line < lineEnd; line++) {

package/{dist → lib}/lexer.d.ts

@@ -6,39 +6,22 @@ export declare class Lexer {
     input: string;
     pos: number;
     constructor(input: string);
-    /** Return current char */
     get char(): string;
-    /** Return remaining string */
     get str(): string;
-    /** Return current charcode */
     peek(): number;
-    /** Return next charcode */
     peekNext(): number;
-    /** test against upcoming string  */
     match(ptn: string): boolean;
-    /** Return current charcode and advance cursor by one */
     next(): number;
-    /** Return true if cursor is at the end of input */
     eof(): boolean;
-    /** Peek letters and skip input */
     skip(re: RegExp): void;
-    /** Skip whitespaces */
     skipWhitespace(): void;
-    /** Consume single letter */
     consume(): string;
-    /** Consume a sequence of letters  */
     consumeRe(re: RegExp): string;
-    /** Consume word (/^[a-zA-Z_][a-zA-Z0-9_]+/) */
     consumeWord(): string;
-    /** Consume quote enclosed literal  */
     consumeLiteral(quote: string): string;
-    /** Return codepoint of a letter, or EOF if input string is empty */
     static cp(ch: string): number;
-    /** Return true if the codepoint matches the string */
     static cmp(cp: number, ch: string): boolean;
-    /** Return true if the codepoint matches our EOF number */
     static isEOF(cp: number): boolean;
-    /** Return true if the codepint is likely to be whitespace */
     static isWhitespace(cp: number): boolean;
     static isAlphabet(cp: number): boolean;
     static isNumber(cp: number): boolean;

package/{dist → lib}/lexer.js

@@ -9,54 +9,43 @@ export class Lexer {
         this.input = input;
         this.pos = 0;
     }
-    /** Return current char */
     get char() {
         return this.input[this.pos] || Lexer.EMPTY;
     }
-    /** Return remaining string */
     get str() {
         return this.input.slice(this.pos);
     }
-    /** Return current charcode */
     peek() {
         return this.input.codePointAt(this.pos) || Lexer.EOF;
     }
-    /** Return next charcode */
     peekNext() {
         return this.input.codePointAt(this.pos + 1) || Lexer.EOF;
         ;
     }
-    /** test against upcoming string  */
     match(ptn) {
         return this.str.startsWith(ptn);
     }
-    /** Return current charcode and advance cursor by one */
     next() {
         const char = this.peek();
         this.pos++;
         return char;
     }
-    /** Return true if cursor is at the end of input */
     eof() {
         return this.pos >= this.input.length;
     }
-    /** Peek letters and skip input */
     skip(re) {
         while (re.test(this.char)) {
             this.pos++;
         }
     }
-    /** Skip whitespaces */
     skipWhitespace() {
         this.skip(Lexer.WHITESPACE);
     }
-    /** Consume single letter */
     consume() {
         const result = this.char;
         this.pos++;
         return result;
     }
-    /** Consume a sequence of letters  */
     consumeRe(re) {
         const match = re.exec(this.str);
         if (!match) {
@@ -66,11 +55,9 @@ export class Lexer {
         this.pos += word.length;
         return word;
     }
-    /** Consume word (/^[a-zA-Z_][a-zA-Z0-9_]+/) */
     consumeWord() {
         return this.consumeRe(/^[a-zA-Z_][a-zA-Z0-9_]+/);
     }
-    /** Consume quote enclosed literal  */
     consumeLiteral(quote) {
         const q = quote.codePointAt(0);
         const escape = "\\".codePointAt(0);
@@ -94,7 +81,6 @@ export class Lexer {
                 }
             }
             else if (cp === Lexer.EOF) {
-                // unenclosed quote
                 break;
             }
             else {
@@ -103,30 +89,22 @@ export class Lexer {
         }
         return String.fromCodePoint(...result);
     }
-    /** Return codepoint of a letter, or EOF if input string is empty */
     static cp(ch) {
         return ch.codePointAt(0) || Lexer.EOF;
     }
-    /** Return true if the codepoint matches the string */
     static cmp(cp, ch) {
         return cp === ch.codePointAt(0);
     }
-    /** Return true if the codepoint matches our EOF number */
     static isEOF(cp) {
         return cp === Lexer.EOF;
     }
-    /** Return true if the codepint is likely to be whitespace */
     static isWhitespace(cp) {
-        // return this.WHITESPACE.test(String.fromCodePoint(cp));
         return cp === " ".codePointAt(0) || cp === "\t".codePointAt(0);
     }
     static isAlphabet(cp) {
-        // return cp >= "a".codePointAt(0)! && cp <= "z".codePointAt(0)! ||
-        //        cp >= "A".codePointAt(0)! && cp <= "Z".codePointAt(0)!;
         return (cp >= 97 && cp <= 122) || (cp >= 65 && cp <= 90);
     }
     static isNumber(cp) {
-        // return cp >= "0".codePointAt(0)! && cp <= "9".codePointAt(0)!;
         return cp >= 48 && cp <= 57;
     }
     static isAlnum(cp) {

package/{dist → lib}/merge.d.ts

@@ -8,19 +8,5 @@ type DeepMerged<T, U> = {
 };
 export declare function isPrimitive(value: unknown): value is Primitive;
 export declare function isFunction(value: unknown): value is Function;
-/**
- * merge, a deepmerge implementation.
- *
- * - target immutable
- * - prototype aware
- * - circular ref aware
- * - replace array (no-join)
- * - ignore unenumerable properties
- * - ignore undefined
- *
- * @param target target type
- * @param source source type
- * @returns merged object (target + source)
- */
 export declare function merge<T, U>(target: Partial<T>, source?: Partial<U>): DeepMerged<T, U>;
 export {};

package/{dist → lib}/merge.js

@@ -10,20 +10,6 @@ export function isPrimitive(value) {
 export function isFunction(value) {
     return typeof value === "function";
 }
-/**
- * merge, a deepmerge implementation.
- *
- * - target immutable
- * - prototype aware
- * - circular ref aware
- * - replace array (no-join)
- * - ignore unenumerable properties
- * - ignore undefined
- *
- * @param target target type
- * @param source source type
- * @returns merged object (target + source)
- */
 export function merge(target, source) {
     const seen = new WeakMap();
     function _merge(target, source) {
@@ -42,7 +28,6 @@ export function merge(target, source) {
             const result = { ...target };
             seen.set(source, result);
             for (const key of Object.keys(source)) {
-                // Skip dangerous keys
                 if (key === "__proto__" || key === "constructor" || key === "prototype") {
                     continue;
                 }
@@ -55,7 +40,7 @@ export function merge(target, source) {
             return result;
         }
         else {
-            return undefined; // ?
+            return undefined;
         }
     }
     const merged = _merge(target, source);

package/{dist → lib}/table-builder.d.ts

@@ -6,9 +6,6 @@ interface ITableBuilder {
     endTable(): void;
     insertCell(fn: TokenAppendor, attr?: CellAttr): void;
 }
-/**
- * Constructs a table token stream
- */
 export declare class TableBuilder implements ITableBuilder {
     readonly state: StateBlock;
     readonly tableSpec: TableSpec;

package/{dist → lib}/table-builder.js

@@ -1,8 +1,5 @@
 import { debug } from "./debug.js";
 import { CellState } from "./table.js";
-/**
- * Constructs a table token stream
- */
 export class TableBuilder {
     state;
     tableSpec;

package/{dist → lib}/table.d.ts

@@ -15,9 +15,6 @@ export type CellAttr = {
     rowspan?: number;
     header?: boolean;
 };
-/**
- * TableSpec keeps table attributes
- */
 export declare class TableSpec {
     readonly attr: TableAttr;
     readonly classes: string[];
@@ -30,9 +27,6 @@ export declare class TableSpec {
     static parseInfoString(info: string): TableAttr;
     static awareKeys(): TableAttrKeys[];
 }
-/**
- * ColSpecs keeps all column specifications
- */
 export declare class ColSpecs {
     readonly numCols: number;
     readonly specs: readonly ColumnAttr[];
@@ -40,9 +34,7 @@ export declare class ColSpecs {
     colSpec(col: number): ColumnAttr;
     colWidth(col: number): number;
     colWidthRatio(col: number): number;
-    /** Forcefully re-initailize this instance. */
     lazyInit(cols: number): void;
-    /** Parse colspec for single column */
     static parseColSpec(spec: string): ColumnAttr;
 }
 export declare class TableCell {
@@ -58,9 +50,6 @@ export declare class TableCell {
     isIn(row: number, col: number, rspan: number, cspan: number): boolean;
     contains(row: number, col: number): boolean;
 }
-/**
- * A state machine to track cell position and its attributes
- */
 export declare class CellState {
     private static readonly _initialPos;
     private readonly _tableSpec;
@@ -73,28 +62,15 @@ export declare class CellState {
     set row(num: number);
     get col(): number;
     set col(num: number);
-    /** Starting from the top-left cell, find the next free cell. **/
     next(): {
         row: number;
         col: number;
     };
-    /**
-     * Get cell attribute. If the cell is spanned by the other, it will return
-     * the belonging cell. Returns undefined if no attribute is set.
-     */
     get(row: number, col: number): TableCell | undefined;
-    /**
-     * Set cell attribute. If the cell is already spanned by the other,
-     * it will update the belonging cell. Modifying the span size will
-     * wipe attributes from the cells being affected.
-     */
     set(row: number, col: number, attr: CellAttr): void;
     wipe(row: number, col: number, rowspan: number, colspan: number, keepOrigin?: boolean): void;
-    /** Return true if this cell is spanned (includes self spanning) */
     isSpanned(row: number, col: number): boolean;
-    /** Return the cell which covers the given cell (excludes self span)*/
     spannedBy(row: number, col: number): TableCell | undefined;
-    /** Return true if this cell is the left most cell **/
     isLeftMost(row: number, col: number): boolean;
     isRightMost(row: number, col: number): boolean;
     isRowFirst(row: number, col: number): boolean;

package/{dist → lib}/table.js

@@ -1,7 +1,4 @@
 import { Lexer, unwrapLiteral } from "./lexer.js";
-/**
- * TableSpec keeps table attributes
- */
 export class TableSpec {
     attr;
     classes;
@@ -23,7 +20,7 @@ export class TableSpec {
             .split(",")
             .map((s) => s.trim())
             .filter(s => s.length > 0)
-            .filter((s, i, arr) => arr.indexOf(s) === i); // uniq
+            .filter((s, i, arr) => arr.indexOf(s) === i);
     }
     static parseInfoString(info) {
         const lexer = new Lexer(info);
@@ -47,7 +44,6 @@ export class TableSpec {
                 break;
             }
             else {
-                // unknown symbol?
                 tokens.push(lexer.consume());
             }
         }
@@ -63,12 +59,10 @@ export class TableSpec {
                 result[key] = value;
             }
             else {
-                // ignore unknown token
                 consume();
             }
         }
         return result;
-        /** consume one token from token stream */
         function consume(text) {
             const token = tokens[lc];
             if (text && token !== text) {
@@ -90,17 +84,11 @@ export class TableSpec {
         return Object.keys(k);
     }
 }
-/**
- * ColSpecs keeps all column specifications
- */
 export class ColSpecs {
     numCols;
     specs;
     constructor(colspec) {
         if (colspec.startsWith("\"") || colspec.includes(",")) {
-            // colspec must be "1,1,1" not 1,1,1
-            // we can try parse 1,1,1 .... but since this is an invalid syntax, 
-            // the parser won't recognize unwrapped commma-separated values.
             const specs = unwrapLiteral(colspec, "\"").split(",");
             this.numCols = Math.max(1, specs.length);
             this.specs = specs.map(ColSpecs.parseColSpec);
@@ -131,12 +119,10 @@ export class ColSpecs {
         }
         return this.colWidth(col) / totalWidth;
     }
-    /** Forcefully re-initailize this instance. */
     lazyInit(cols) {
         this.numCols = cols;
         this.specs = Array(cols).fill({});
     }
-    /** Parse colspec for single column */
     static parseColSpec(spec) {
         let pos = 0;
         const attr = {};
@@ -207,9 +193,6 @@ export class TableCell {
             this.col <= col && this.col + this.colspan > col);
     }
 }
-/**
- * A state machine to track cell position and its attributes
- */
 export class CellState {
     static _initialPos = [-1, -1];
     _tableSpec;
@@ -238,7 +221,6 @@ export class CellState {
     set col(num) {
         this._pos[1] = num;
     }
-    /** Starting from the top-left cell, find the next free cell. **/
     next() {
         if (this.row === -1) {
             this.row = 0;
@@ -258,10 +240,6 @@ export class CellState {
             col: this.col,
         };
     }
-    /**
-     * Get cell attribute. If the cell is spanned by the other, it will return
-     * the belonging cell. Returns undefined if no attribute is set.
-     */
     get(row, col) {
         for (const span of this._cells) {
             if (span.contains(row, col)) {
@@ -270,11 +248,6 @@ export class CellState {
         }
         return undefined;
     }
-    /**
-     * Set cell attribute. If the cell is already spanned by the other,
-     * it will update the belonging cell. Modifying the span size will
-     * wipe attributes from the cells being affected.
-     */
     set(row, col, attr) {
         for (const span of this._cells) {
             if (span.contains(row, col)) {
@@ -292,7 +265,6 @@ export class CellState {
                 : c.isIn(row, col, rowspan, colspan);
         });
     }
-    /** Return true if this cell is spanned (includes self spanning) */
     isSpanned(row, col) {
         for (const span of this._cells) {
             if (!span.is(row, col) && span.contains(row, col)) {
@@ -301,7 +273,6 @@ export class CellState {
         }
         return false;
     }
-    /** Return the cell which covers the given cell (excludes self span)*/
     spannedBy(row, col) {
         for (const span of this._cells) {
             if (!span.is(row, col) && span.contains(row, col)) {
@@ -310,10 +281,9 @@ export class CellState {
         }
         return undefined;
     }
-    /** Return true if this cell is the left most cell **/
     isLeftMost(row, col) {
         if (col <= 0) {
-            return true; // left most, or out of range
+            return true;
         }
         else {
             const span = this.get(row, col);
@@ -322,7 +292,7 @@ export class CellState {
     }
     isRightMost(row, col) {
         if (col >= this.numCols - 1) {
-            return true; // right most, or out of range
+            return true;
         }
         else {
             const span = this.get(row, col);
@@ -333,21 +303,17 @@ export class CellState {
         if (col < 0)
             return false;
         if (col === 0) {
-            // If this cell is spanned by the other cell, it is not a row starter
             return this.spannedBy(row, col) === undefined;
         }
-        // if this cell is spanned by the other cell, 
-        // always return false. 
         if (this.spannedBy(row, col) !== undefined) {
             return false;
         }
         while (col > 0) {
             const span = this.spannedBy(row, col - 1);
-            // recursively check left cell
             if (span !== undefined) {
                 if (span.col < col) {
                     if (span.row === row) {
-                        return false; // spanning cell is in the same row
+                        return false;
                     }
                     else {
                         col = span.col;
@@ -361,24 +327,19 @@ export class CellState {
                 return false;
             }
         }
-        // all cells in left are spanned, so this cell is the row-first cell
         return true;
     }
     isRowLast(row, col) {
         if (col >= this.numCols)
             return false;
         if (col === this.numCols - 1) {
-            // If this cell is spanned by the other cell, it is not a row closer.
             return this.spannedBy(row, col) === undefined;
         }
-        // if this cell is spanned by the other cell, 
-        // always return false. 
         if (this.spannedBy(row, col) !== undefined) {
             return false;
         }
         while (col < this.numCols - 1) {
             const span = this.spannedBy(row, col + 1);
-            // recursively check right cell
             if (span !== undefined) {
                 if (span.endcol > col) {
                     col = span.endcol;
@@ -391,7 +352,6 @@ export class CellState {
                 return false;
             }
         }
-        // all cells in right are spanned, so this cell is the row-last cell
         return true;
     }
 }

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "markdown-it-adv-table",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Markdown syntax extension for better table support",
   "keywords": [
     "markdown",
     "markdown-it",
     "markdown-it-plugin",
-    "table",
-    "csv"
+    "table"
   ],
   "homepage": "https://github.com/yamavol/markdown-it-adv-table#readme",
   "bugs": {
@@ -20,34 +19,28 @@
   "license": "MIT",
   "author": "yamavol",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "directories": {
-    "doc": "docs",
-    "test": "test"
-  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts"
+    "lib/**/*.js",
+    "lib/**/*.d.ts"
   ],
   "scripts": {
     "build": "tsc",
-    "build:dist": "tsc --build tsconfig.dist.json",
+    "build:dev": "tsc --build tsconfig.dev.json",
     "test": "vitest",
     "coverage": "vitest run --coverage",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix"
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "^4.2.0",
+    "@cobapen/eslint-config": "^0.4.0",
     "@types/markdown-it": "^14.1.2",
     "@types/node": "^22.14.1",
     "@vitest/coverage-v8": "^3.1.1",
     "eslint": "^9.24.0",
-    "eslint-plugin-import": "^2.31.0",
     "markdown-it": "^14.1.0",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.29.1",
     "vitest": "^3.1.1"
   }
 }

package/dist/cell.d.ts

@@ -1,33 +0,0 @@
-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

@@ -1,105 +0,0 @@
-/**
- * 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/utils.d.ts

@@ -1,4 +0,0 @@
-export type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends object ? T[P] extends Function ? T[P] : DeepPartial<T[P]> : T[P];
-};
-export declare function deepmerge<T, U>(target: Partial<T>, source?: Partial<U>): T & U;

package/dist/utils.js

@@ -1,47 +0,0 @@
-function isPrimitive(value) {
-    return (value === null
-        || typeof value === "string"
-        || typeof value === "number"
-        || typeof value === "boolean"
-        || typeof value === "symbol"
-        || typeof value === "bigint"
-        || typeof value === "undefined");
-}
-function isPlainObject(obj) {
-    return Object.prototype.toString.call(obj) === "[object Object]"
-        && Object.getPrototypeOf(obj) === Object.prototype;
-}
-export function deepmerge(target, source) {
-    const seen = new WeakSet();
-    function merge(target, source) {
-        if (seen.has(source)) {
-            return undefined;
-        }
-        if (isPrimitive(source)) {
-            return source;
-        }
-        if (Array.isArray(source)) {
-            seen.add(source);
-            return source.map(item => merge(undefined, item));
-        }
-        if (isPlainObject(source)) {
-            seen.add(source);
-            const result = isPlainObject(target) ? { ...target } : {};
-            for (const key of Object.keys(source)) {
-                // Skip dangerous keys
-                if (key === "__proto__" || key === "constructor" || key === "prototype") {
-                    continue;
-                }
-                const value = source[key];
-                const merged = merge(result[key], value);
-                if (merged !== undefined) {
-                    result[key] = merged;
-                }
-            }
-            return result;
-        }
-        return undefined;
-    }
-    return merge(target, source);
-}
-//# sourceMappingURL=utils.js.map