simple-customize-markdown-converter 1.0.2 → 1.0.4

package/README.md

@@ -2,13 +2,21 @@
 This simple library help you convert Markdown to HTML and customize it.
 
 ## Feature
-Currently, this lib only supports:
-- Headings (#, ##, …)
+This library currently supports the most common Markdown syntaxes:
+- Headings (`#, ##, …`)
 - Paragraphs
-- Bold (\*\*text\*\*)
-- Italic (\*text\* or \_text\_)
-- Inline code (\`code\`)
-- Code blocks (\`\`\`lang ... \`\`\`)
+- Bold (`\*\*text\*\*`)
+- Italic (`\*text\* or \_text\_`)
+- Strikethrough (`\~\~text\~\~`)
+- Inline code (`\`code\``)
+- Code blocks (`\`\`\`lang ... \`\`\``)
+- Quotes (`> text`)
+- Lists (`- Item 1,...`)
+- Tasklists (`- [ ], - \[x\]`)
+- Links (`\[link\]\(url\)`)
+- Images (`\[alt\]\(url\)`)
+- Horizontal lines (`---` or `***` or `___`)
+- Tables
 
 And customizable renderer for all elements
 

package/dist/lexer.d.ts

@@ -3,25 +3,38 @@ export default class Lexer {
     input: string;
     pos: number;
     listToken: Token[];
+    listLevelFlag: number;
     constructor(input: string);
+    setInput(input: string): void;
     /**
      * Tokenize the markdown into a list of tokens.
+     * @param isEof - `True` when input is whole markdown, `False` if input is just a part of markdown.
      * @returns List of tokens
      */
-    tokenize(): Token[];
+    tokenize(isEof?: boolean): Token[];
     private peek;
     private next;
     private startsWith;
     private isEndOfFile;
     private getLastToken;
+    private handleTable;
     private handleHeader;
     private handleCodeBlock;
     private handleTextBlock;
     private handleItalic;
     private handleBold;
+    private handleStrikethrough;
     private handleInlineBlock;
     private handleQuoteBlock;
+    private handleList;
+    private handleStartList;
+    private handleListItem;
+    private handleTaskItem;
+    private handleEndList;
     private handleLink;
     private handleImage;
+    private handleHorizontalLine;
     private readUntil;
+    private peekUntil;
+    private isStartOfLine;
 }

package/dist/lexer.js

@@ -4,16 +4,66 @@ class Lexer {
     constructor(input) {
         this.pos = 0;
         this.listToken = [];
+        // Flag for handle special syntax
+        this.listLevelFlag = 0;
         this.input = input;
     }
+    //Reset input and other attribute
+    setInput(input) {
+        this.input = input;
+        this.pos = 0;
+        this.listLevelFlag = 0;
+        this.listToken = [];
+    }
     /**
      * Tokenize the markdown into a list of tokens.
+     * @param isEof - `True` when input is whole markdown, `False` if input is just a part of markdown.
      * @returns List of tokens
      */
-    tokenize() {
+    tokenize(isEof = true) {
         const TOKEN_HANDLER = [
+            //Handle escape character first
+            {
+                match: (lex) => lex.peek() === "\\" && lex.peek(1) !== undefined,
+                emit: (lex) => {
+                    lex.next(1);
+                    lex.handleTextBlock();
+                }
+            },
+            {
+                //Regex: if line started with at least 3 characters: -, *, _
+                match: (lex) => /^([-*_])\1{2,}$/.test(lex.peekUntil("\n").trim()) && this.getLastToken()?.type === "NewLine",
+                emit: (lex) => lex.handleHorizontalLine()
+            },
             { match: (lex) => lex.startsWith("```"), emit: (lex) => lex.handleCodeBlock() },
             { match: (lex) => lex.startsWith("**"), emit: (lex) => lex.handleBold() },
+            { match: (lex) => lex.startsWith("~~"), emit: (lex) => lex.handleStrikethrough() },
+            //For List
+            {
+                match: (lex) => lex.isStartOfLine() && /^(\s*)([-*+]) \[( |x|X)\] /.test(lex.peekUntil("\n")),
+                emit: (lex) => lex.handleList(false, true)
+            },
+            {
+                //Regex: if line started with zero or more spaces, then have - or + or * + 1 space
+                match: (lex) => lex.isStartOfLine() && /^(\s*)([-*+]) /.test(lex.peekUntil("\n")),
+                emit: (lex) => lex.handleList(false, false)
+            },
+            {
+                //Regex: if line started with zero or more spaces, then have number. character + 1 space
+                match: (lex) => lex.isStartOfLine() && /^(\s*)(\d+)\. /.test(lex.peekUntil("\n")),
+                emit: (lex) => lex.handleList(true, false)
+            },
+            {
+                match: (lex) => lex.listLevelFlag > 0 && lex.isStartOfLine() && !/^(\s*)([-+*]|\d+\.) /.test(lex.peekUntil("\n")),
+                emit: (lex) => {
+                    while (lex.listLevelFlag > 0) {
+                        lex.handleEndList();
+                    }
+                }
+            },
+            //For table
+            { match: (lex) => lex.isStartOfLine() && /^\s*\|.*\|\s*$/.test(lex.peekUntil("\n")), emit: (lex) => lex.handleTable() },
+            //For common syntax
             { match: (lex) => lex.peek() === "`", emit: (lex) => lex.handleInlineBlock() },
             { match: (lex) => lex.peek() === "#", emit: (lex) => lex.handleHeader() },
             { match: (lex) => lex.peek() === "*" || lex.peek() === "_", emit: (lex) => lex.handleItalic() },
@@ -36,7 +86,11 @@ class Lexer {
             }
             this.next();
         }
-        this.listToken.push({ type: "EOF" });
+        while (this.listLevelFlag > 0) {
+            this.handleEndList();
+        }
+        if (isEof)
+            this.listToken.push({ type: "EOF" });
         return this.listToken;
     }
     //Get current character with offset
@@ -58,6 +112,59 @@ class Lexer {
     getLastToken() {
         return this.listToken[this.listToken.length - 1];
     }
+    handleTable() {
+        const tokenizeResult = [];
+        const handler = new Lexer("");
+        const header = this.readUntil("\n", true);
+        const headerDetails = header.trim().replace(/^ *\|/, "").replace(/\| *$/, "").split("|");
+        const align = this.readUntil("\n", true);
+        const alignDetails = align.trim().replace(/^ *\|/, "").replace(/\| *$/, "").split("|");
+        if (alignDetails.length !== headerDetails.length || !alignDetails.every(c => /^:?-{3,}:?$/.test(c))) {
+            this.listToken.push({ type: "Text", value: `${header}\n${align}\n` });
+            return;
+        }
+        else {
+            //Handle alignment
+            const normalizeAlign = alignDetails.map(value => {
+                if (value.startsWith(":") && value.endsWith(":"))
+                    return "center";
+                else if (value.endsWith(":"))
+                    return "right";
+                else
+                    return "left";
+            });
+            tokenizeResult.push({ type: "TableStart" });
+            //Handle header
+            tokenizeResult.push({ type: "RowStart", isHeader: true });
+            headerDetails.forEach((cell, index) => {
+                tokenizeResult.push({ type: "CellStart", align: normalizeAlign[index] ?? "left" });
+                handler.setInput(cell.trim());
+                tokenizeResult.push(...handler.tokenize(false));
+                tokenizeResult.push({ type: "CellEnd" });
+            });
+            tokenizeResult.push({ type: "RowEnd" });
+            //Handle body
+            while (!this.isEndOfFile()) {
+                const body = this.readUntil("\n", true);
+                if (!body)
+                    break;
+                const line = body.trim();
+                if (!line.startsWith("|") || !line.endsWith("|"))
+                    break; //End of table
+                const bodyDetail = body.trim().replace(/^ *\|/, "").replace(/\| *$/, "").split("|");
+                tokenizeResult.push({ type: "RowStart", isHeader: false });
+                bodyDetail.forEach((cell, index) => {
+                    tokenizeResult.push({ type: "CellStart", align: normalizeAlign[index] ?? "left" });
+                    handler.setInput(cell.trim());
+                    tokenizeResult.push(...handler.tokenize(false));
+                    tokenizeResult.push({ type: "CellEnd" });
+                });
+                tokenizeResult.push({ type: "RowEnd" });
+            }
+            tokenizeResult.push({ type: "TableEnd" });
+            this.listToken.push(...tokenizeResult);
+        }
+    }
     handleHeader() {
         let level = 0;
         while (this.peek() === "#") {
@@ -101,7 +208,11 @@ class Lexer {
     }
     handleBold() {
         this.listToken.push({ type: "Bold" });
-        this.next(); //Skip *
+        this.next(); //Skip remain *
+    }
+    handleStrikethrough() {
+        this.listToken.push({ type: "Strikethrough" });
+        this.next(); //Skip remain ~
     }
     handleInlineBlock() {
         let content = "";
@@ -110,12 +221,51 @@ class Lexer {
             content += this.peek();
             this.next();
         }
-        // this.next() //Skip close block
         this.listToken.push({ "type": "InlineCode", content: content });
     }
     handleQuoteBlock() {
         this.listToken.push({ type: "Quote" });
     }
+    handleList(isOrdered, isTask) {
+        const line = this.peekUntil("\n");
+        if (isTask) {
+            const m = line.match(/^(\s*)([-*+]) \[( |x|X)\] (.*)$/);
+            const indent = Math.floor(m[1].length / 2) + 1;
+            while (this.listLevelFlag < indent)
+                this.handleStartList(false);
+            while (this.listLevelFlag > indent)
+                this.handleEndList();
+            this.next(m[1].length + 4);
+            this.handleTaskItem(m[3].toLowerCase() === "x");
+        }
+        else {
+            //Regex: line started with: Group 1: zero or more spaces, group 2: (- or + or * + 1 space) or (number with . character), group 3: everything else in line
+            const m = isOrdered ? line.match(/^(\s*)(\d+)\. (.*)$/) : line.match(/^(\s*)([-*+]) (.*)$/);
+            const indent = Math.floor(m[1].length / 2) + 1; //m[1] to get the spaces in group 1
+            while (this.listLevelFlag < indent)
+                this.handleStartList(isOrdered);
+            while (this.listLevelFlag > indent)
+                this.handleEndList();
+            this.next(m[1].length + (isOrdered ? 1 : 0)); //+1 due to marker have 2 characters (e.g: 1.) instead 1 like unordered list
+            this.handleListItem();
+        }
+    }
+    handleStartList(isOrder) {
+        this.listLevelFlag++;
+        this.listToken.push({ type: "ListStart", level: this.listLevelFlag, ordered: isOrder });
+    }
+    handleListItem() {
+        this.next(); // Skip space between - and text
+        this.listToken.push({ type: "ListItem" });
+    }
+    handleTaskItem(isChecked) {
+        this.next(); // Skip space between last ] and text
+        this.listToken.push({ type: "TaskItem", checked: isChecked });
+    }
+    handleEndList() {
+        this.listLevelFlag === 0 ? 0 : this.listLevelFlag--;
+        this.listToken.push({ type: "ListEnd" });
+    }
     handleLink() {
         this.next(); //Skip [
         const text = this.readUntil("]");
@@ -145,13 +295,38 @@ class Lexer {
         else
             this.listToken.push({ type: "Text", value: `![${alt}]` });
     }
-    readUntil(char) {
+    handleHorizontalLine() {
+        this.next(2); //Skip two first characters, remain will be skiped after loop
+        this.listToken.push({ type: "HorizontalLine" });
+    }
+    //Utilities function
+    readUntil(char, isConsumeChar = false) {
         let result = "";
         while (this.peek() !== char) {
             result += this.peek();
             this.next();
+            if (this.isEndOfFile())
+                break;
+        }
+        if (isConsumeChar)
+            this.next(char.length); //Make cursor skip the char
+        return result;
+    }
+    peekUntil(char) {
+        let result = "";
+        let i = 0;
+        while (true) {
+            const current = this.peek(i++);
+            if (current == null)
+                break;
+            if (current == char)
+                break;
+            result += current;
         }
         return result;
     }
+    isStartOfLine() {
+        return this.pos === 0 || this.peek(-1) === "\n";
+    }
 }
 exports.default = Lexer;

package/dist/parser.d.ts

@@ -18,9 +18,14 @@ export declare class Parser {
     private parseHeader;
     private parseBold;
     private parseItalic;
+    private parseStrikethrough;
     private parseInlineCode;
     private parseQuote;
+    private parseList;
+    private parseListItem;
     private parseLink;
     private parseImage;
+    private parseTable;
+    private parseHorizontalLine;
     private parseInlineUntil;
 }

package/dist/parser.js

@@ -49,6 +49,18 @@ class Parser {
                     listNode.push(this.parseImage());
                     break;
                 }
+                case "HorizontalLine": {
+                    listNode.push(this.parseHorizontalLine());
+                    break;
+                }
+                case "ListStart": {
+                    listNode.push(this.parseList());
+                    break;
+                }
+                case "TableStart": {
+                    listNode.push(this.parseTable());
+                    break;
+                }
                 case "NewLine": {
                     this.next(); // skip
                     break;
@@ -90,6 +102,10 @@ class Parser {
         this.next(); // skip marker
         return { type: "Italic", children: this.parseInlineUntil("Italic") };
     }
+    parseStrikethrough() {
+        this.next(); // skip marker
+        return { type: "Strikethrough", children: this.parseInlineUntil("Strikethrough") };
+    }
     parseInlineCode() {
         const tok = this.peek();
         this.next();
@@ -102,6 +118,70 @@ class Parser {
         this.next(); //skip marker
         return { type: "Quote", children: [{ type: "Paragraph", children: this.parseInlineUntil("NewLine") }] };
     }
+    parseList() {
+        const tok = this.peek();
+        if (tok?.type === "ListStart") {
+            this.next(); //skip marker
+            const result = {
+                type: "List",
+                level: tok.level,
+                ordered: tok.ordered,
+                children: [],
+            };
+            let nextToken = this.peek();
+            while (!this.isEnd()) {
+                if (nextToken?.type === "ListItem" || nextToken?.type === "TaskItem") {
+                    result.children.push(this.parseListItem());
+                    nextToken = this.peek();
+                }
+                else if (nextToken?.type === "ListEnd") {
+                    this.next();
+                    break;
+                }
+                else
+                    break;
+            }
+            return result;
+        }
+        //Temp return
+        return {
+            type: "Text",
+            value: ""
+        };
+    }
+    parseListItem() {
+        const currentToken = this.peek();
+        this.next(); // skip marker   
+        const children = [];
+        while (!this.isEnd()) {
+            const tok = this.peek();
+            if (!tok)
+                break;
+            if (tok.type === "NewLine") {
+                this.next();
+                continue;
+            }
+            if (tok.type === "ListStart") {
+                children.push(this.parseList());
+                continue;
+            }
+            if (["ListItem", "TaskItem", "ListEnd"].includes(tok.type)) {
+                break;
+            }
+            children.push({
+                type: "Paragraph",
+                children: this.parseInlineUntil("NewLine")
+            });
+        }
+        return currentToken?.type === "TaskItem" ? {
+            type: "TaskItem",
+            checked: currentToken.type === "TaskItem" ? currentToken.checked : false,
+            children: children
+        } : {
+            type: "ListItem",
+            children: children
+        };
+    }
     parseLink() {
         const tok = this.peek();
         this.next();
@@ -127,12 +207,60 @@ class Parser {
         else
             return { type: "Image", src: "", alt: "" };
     }
+    parseTable() {
+        this.next(); // skip TableStart token
+        const parseRow = () => {
+            const rowStartToken = this.peek();
+            if (rowStartToken?.type !== "RowStart")
+                return { isHeader: false, cells: [] };
+            this.next(); // skip RowStart token
+            const cells = [];
+            while (this.peek() && this.peek().type !== "RowEnd") {
+                cells.push(parseCell());
+            }
+            this.next(); // skip RowEnd token
+            return {
+                isHeader: rowStartToken.isHeader,
+                cells: cells
+            };
+        };
+        const parseCell = () => {
+            const cellStartToken = this.peek();
+            if (cellStartToken?.type !== "CellStart")
+                return { align: "left", chlidren: [] };
+            this.next(); // skip CellStart token
+            const childrens = this.parseInlineUntil("CellEnd");
+            return {
+                align: cellStartToken.align,
+                chlidren: [{ type: "Paragraph", children: childrens }]
+            };
+        };
+        const rows = [];
+        while (this.peek()?.type !== "TableEnd") {
+            rows.push(parseRow());
+            if (this.isEnd())
+                break;
+        }
+        this.next();
+        return {
+            type: "Table",
+            rows: rows
+        };
+    }
+    parseHorizontalLine() {
+        const tok = this.peek();
+        this.next(); // skip marker
+        return { type: "HorizontalLine" };
+    }
     parseInlineUntil(stopType) {
+        const stop = Array.isArray(stopType) ? stopType : [stopType];
         const listNode = [];
-        while (!this.isEnd() && this.peek()?.type !== stopType) {
+        while (!this.isEnd()) {
             const currentNode = this.peek();
             if (!currentNode)
                 break;
+            if (stop.includes(currentNode.type))
+                break;
             switch (currentNode.type) {
                 case "Bold": {
                     listNode.push(this.parseBold());
@@ -142,6 +270,10 @@ class Parser {
                     listNode.push(this.parseItalic());
                     break;
                 }
+                case "Strikethrough": {
+                    listNode.push(this.parseStrikethrough());
+                    break;
+                }
                 case "InlineCode": {
                     listNode.push(this.parseInlineCode());
                     break;

package/dist/renderer.d.ts

@@ -11,5 +11,6 @@ export default class Renderer {
      */
     render(node: Node): string;
     private handleRender;
+    private renderTable;
     private escapeHtml;
 }

package/dist/renderer.js

@@ -19,20 +19,52 @@ class Renderer {
     }
     handleRender(type) {
         const defaultRender = {
+            //Base structural nodes
             Document: (_node, children) => children.join(""),
             Paragraph: (_node, children) => `<p>${children.join("")}</p>`,
-            Header: (node, children) => `<h${node.level}>${children.join("")}</h${node.level}>`,
-            InlineCode: (node) => `<code>${this.escapeHtml(node.content)}</code>`,
+            //Container nodes
             CodeBlock: (node) => `<pre><code class="lang-${node.lang}">${this.escapeHtml(node.content)}</code></pre>`,
+            Header: (node, children) => `<h${node.level}${node.level <= 2 ? ' style="border-bottom: 1px solid #d1d9e0b3"' : ''}>${children.join("")}</h${node.level}>`,
+            Quote: (_node, children) => `<blockquote>${children.join("")}</blockquote>`,
+            //For list nodes
+            List: (node, children) => node.ordered ? `<ol>${children.join("")}</ol>` : `<ul>${children.join("")}</ul>`,
+            ListItem: (_node, children) => `<li>${children.join("")}</li>`,
+            TaskItem: (node, children) => `<li><input type="checkbox" disabled ${node.checked ? "checked" : ""}>${children.join("")}</li>`,
+            //Styling nodes
             Bold: (_node, children) => `<strong>${children.join("")}</strong>`,
             Italic: (_node, children) => `<em>${children.join("")}</em>`,
-            Quote: (_node, children) => `<blockquote>${children.join("")}</blockquote>`,
+            Strikethrough: (_node, children) => `<s>${children.join("")}</s>`,
+            InlineCode: (node) => `<code>${this.escapeHtml(node.content)}</code>`,
+            //Media nodes
             Link: (node) => `<a href="${node.href}">${node.text}</a>`,
             Image: (node) => `<img src="${node.src}" alt="${node.alt}"/>`,
+            //Leaf nodes
+            HorizontalLine: (_node) => `<hr>`,
             Text: (node) => node.value,
+            //For table nodes
+            Table: (node, children) => this.renderTable(node, children),
         };
         return this.option.elements?.[type] ?? defaultRender[type];
     }
+    renderTable(node, children) {
+        if (node.type === "Table") {
+            const header = node.rows.filter(row => row.isHeader);
+            const body = node.rows.filter(row => !row.isHeader);
+            const renderRows = (row) => {
+                const tag = row.isHeader ? "th" : "td";
+                const cells = row.cells.map(cell => {
+                    const align = `style="text-align:${cell.align}"`;
+                    return `<${tag} ${align}>${cell.chlidren.map(c => this.render(c)).join("")}</${tag}>`;
+                }).join("");
+                return `<tr>${cells}</tr>`;
+            };
+            const tHead = header.length ? `<thead>${header.map(renderRows).join("")}</thead>` : "";
+            const tBody = body.length ? `<tbody>${body.map(renderRows).join("")}</tbody>` : "";
+            return `<table>${tHead}${tBody}</table>`;
+        }
+        else
+            return `<p>${children.join("\n")}</p>`;
+    }
     escapeHtml(str) {
         return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
     }

package/dist/types/node.d.ts

@@ -10,11 +10,16 @@
  * - Header: A header with given `level` (1-6)
  * - Bold: Bold text
  * - Italic: Italic text
+ * - Strikethrough: Strilethrough text
  * - InlineCode: Inline code snippet, with it's `content`
  * - Quote: A quote block
  * - CodeBlock: A code block, with it's `lang` and `content`
+ * - List: A list, with it's level and children
+ * - ListItem: An item of a list, with it's children
+ * - TaskItem: An item for tasklist, with it's checked state
  * - Link: A link, with it's `text` and `href`
  * - Image: An image, with it's `src` and `alt`
+ * - HorizontalLine: A horizontal line
  * - Text: Raw text content.
  */
 export type Node = {
@@ -33,6 +38,9 @@ export type Node = {
 } | {
     type: "Italic";
     children: Node[];
+} | {
+    type: "Strikethrough";
+    children: Node[];
 } | {
     type: "InlineCode";
     content: string;
@@ -43,6 +51,18 @@ export type Node = {
 } | {
     type: "Quote";
     children: Node[];
+} | {
+    type: "List";
+    ordered: boolean;
+    level: number;
+    children: Node[];
+} | {
+    type: "ListItem";
+    children: Node[];
+} | {
+    type: "TaskItem";
+    checked: boolean;
+    children: Node[];
 } | {
     type: "Link";
     href: string;
@@ -51,7 +71,20 @@ export type Node = {
     type: "Image";
     src: string;
     alt: string;
+} | {
+    type: "HorizontalLine";
 } | {
     type: "Text";
     value: string;
+} | {
+    type: "Table";
+    rows: TableRow[];
+};
+export type TableRow = {
+    isHeader: boolean;
+    cells: TableCell[];
+};
+export type TableCell = {
+    align: "left" | "center" | "right";
+    chlidren: Node[];
 };

package/dist/types/token.d.ts

@@ -8,13 +8,19 @@
  * - Header: Markdown header (`#`), with a `level` (1–6).
  * - CodeBlock: Fenced code block (` ``` `), with optional `lang` and its `content`.
  * - NewLine: Line break (`\n`).
- * - Text: Plain text content.
  * - Bold: Bold marker (`**`).
  * - Italic: Italic marker (`*` or `_`).
+ * - Strikethrough: Strikethrough marker (`~~`)
  * - InlineCode: Inline code snippet (`` ` ``), with its `content`.
  * - Quote: A quote block (`>`).
+ * - ListStart: Start a list
+ * - ListItem: A list's item (`* ` or `+ ` or `- ` or `number with dot`)
+ * - TaskItem: A task item in a list (`- [ ]` or `- [x]`)
+ * - ListEnd: End a list
  * - Link: A link (`[text](url)`)
  * - Image: An image (`![alt](url)`)
+ * - HorizontalLine: A horizontal line (`---` or `___` or `***`)
+ * - Text: Plain text content.
  * - EOF: A special token, this is the end of input.
  */
 export type Token = {
@@ -26,18 +32,28 @@ export type Token = {
     content: string;
 } | {
     type: "NewLine";
-} | {
-    type: "Text";
-    value: string;
 } | {
     type: "Bold";
 } | {
     type: "Italic";
+} | {
+    type: "Strikethrough";
 } | {
     type: "InlineCode";
     content: string;
 } | {
     type: "Quote";
+} | {
+    type: "ListStart";
+    ordered: boolean;
+    level: number;
+} | {
+    type: "ListItem";
+} | {
+    type: "TaskItem";
+    checked: boolean;
+} | {
+    type: "ListEnd";
 } | {
     type: "Link";
     text: string;
@@ -46,6 +62,25 @@ export type Token = {
     type: "Image";
     src: string;
     alt: string;
+} | {
+    type: "HorizontalLine";
+} | {
+    type: "Text";
+    value: string;
 } | {
     type: "EOF";
+} | {
+    type: "TableStart";
+} | {
+    type: "TableEnd";
+} | {
+    type: "RowStart";
+    isHeader: boolean;
+} | {
+    type: "RowEnd";
+} | {
+    type: "CellStart";
+    align: "left" | "center" | "right";
+} | {
+    type: "CellEnd";
 };

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "simple-customize-markdown-converter",
-  "version": "1.0.2",
-  "description": "Convert Markdown to your customize HTML",
-  "keywords": [
-    "markdown",
-    "html",
-    "converter"
-  ],
-  "author": "Regiko04",
-  "license": "MIT",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "LICENSE",
-    "README.md"
-  ],
-  "scripts": {
-    "test": "jest",
-    "build": "tsc",
-    "start": "ts-node src/index.ts"
-  },
-  "devDependencies": {
-    "@types/jest": "^30.0.0",
-    "@types/node": "^24.3.3",
-    "jest": "^30.1.3",
-    "ts-jest": "^29.4.1",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.9.2"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Riiichan04/simple-custom-markdown-converter.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Riiichan04/simple-custom-markdown-converter/issues"
-  },
-  "homepage": "https://github.com/Riiichan04/simple-custom-markdown-converter#readme"
+{
+  "name": "simple-customize-markdown-converter",
+  "version": "1.0.4",
+  "description": "Convert Markdown to your customize HTML",
+  "keywords": [
+    "markdown",
+    "html",
+    "converter"
+  ],
+  "author": "Regiko04",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "tsc",
+    "start": "ts-node src/index.ts"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.3.3",
+    "jest": "^30.1.3",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Riiichan04/simple-custom-markdown-converter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Riiichan04/simple-custom-markdown-converter/issues"
+  },
+  "homepage": "https://github.com/Riiichan04/simple-custom-markdown-converter#readme"
 }