simple-customize-markdown-converter 1.0.7 → 1.2.0

package/dist/core/parser/handler.js

@@ -0,0 +1,254 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableHandler = exports.StrikethroughHandler = exports.QuoteHandler = exports.NewLineHandler = exports.ListHandler = exports.LinkHandler = exports.ItalicHandler = exports.InlineHandler = exports.ImageHandler = exports.HtmlInlineHandler = exports.HtmlBlockHandler = exports.HorizontalLineHandler = exports.HeaderHandler = exports.FootnoteRefHandler = exports.FootnoteDefHandler = exports.CodeBlockHandler = exports.BoldHandler = void 0;
+const utils = __importStar(require("../../utilities/parser-utils"));
+const CodeBlockHandler = {
+    type: "CodeBlock",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        return {
+            type: "CodeBlock",
+            lang: tok?.type === "CodeBlock" ? tok.lang : "",
+            content: tok?.type === "CodeBlock" ? tok.content : ""
+        };
+    }
+};
+exports.CodeBlockHandler = CodeBlockHandler;
+const HeaderHandler = {
+    type: "Header",
+    execute: (parser, _token) => {
+        const currentNode = parser.peek(0);
+        parser.next(1);
+        return {
+            type: "Header",
+            level: currentNode?.type === "Header" ? currentNode.level : 1,
+            children: parser.parseInlineUntil("NewLine", true) //Temp
+        };
+    },
+};
+exports.HeaderHandler = HeaderHandler;
+const BoldHandler = {
+    type: "Bold",
+    execute: (parser, _token) => {
+        parser.next(1); // skip marker
+        return { type: "Bold", children: parser.parseInlineUntil("Bold", true) };
+    },
+};
+exports.BoldHandler = BoldHandler;
+const ItalicHandler = {
+    type: "Italic",
+    execute: (parser, _token) => {
+        parser.next(1); // skip marker
+        return { type: "Italic", children: parser.parseInlineUntil("Italic", true) };
+    },
+};
+exports.ItalicHandler = ItalicHandler;
+const StrikethroughHandler = {
+    type: "Strikethrough",
+    execute: (parser, _token) => {
+        parser.next(1); // skip marker
+        return { type: "Strikethrough", children: parser.parseInlineUntil("Strikethrough", true) };
+    },
+};
+exports.StrikethroughHandler = StrikethroughHandler;
+const InlineHandler = {
+    type: "InlineCode",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        return {
+            type: "InlineCode",
+            content: tok?.type === "InlineCode" ? tok.content : ""
+        };
+    },
+};
+exports.InlineHandler = InlineHandler;
+const QuoteHandler = {
+    type: "Quote",
+    execute: (parser, _token) => {
+        parser.next(1); //skip marker
+        return { type: "Quote", children: [{ type: "Paragraph", children: parser.parseInlineUntil("NewLine", true) }] };
+    },
+};
+exports.QuoteHandler = QuoteHandler;
+const ListHandler = {
+    type: "ListStart",
+    execute: (parser, _token) => utils.parseList(parser)
+};
+exports.ListHandler = ListHandler;
+const LinkHandler = {
+    type: "Link",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        if (tok?.type === "Link") {
+            return {
+                type: "Link",
+                href: tok.href,
+                text: tok.text
+            };
+        }
+        return { type: "Link", href: "", text: "" };
+    },
+};
+exports.LinkHandler = LinkHandler;
+const ImageHandler = {
+    type: "Image",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        if (tok?.type === "Image") {
+            return {
+                type: "Image",
+                src: tok.src,
+                alt: tok.alt
+            };
+        }
+        else
+            return { type: "Image", src: "", alt: "" };
+    },
+};
+exports.ImageHandler = ImageHandler;
+const TableHandler = {
+    type: "TableStart",
+    execute: (parser, _token) => {
+        parser.next(1); // skip TableStart token
+        const parseRow = () => {
+            const rowStartToken = parser.peek(0);
+            if (rowStartToken?.type !== "RowStart")
+                return { isHeader: false, cells: [] };
+            parser.next(1); // skip RowStart token
+            const cells = [];
+            while (parser.peek(0) && parser.peek(0).type !== "RowEnd") {
+                cells.push(parseCell());
+            }
+            parser.next(1); // skip RowEnd token
+            return {
+                isHeader: rowStartToken.isHeader,
+                cells: cells
+            };
+        };
+        const parseCell = () => {
+            const cellStartToken = parser.peek(0);
+            if (cellStartToken?.type !== "CellStart") {
+                return { align: "left", children: [] };
+            }
+            parser.next(1); // skip CellStart token
+            const childrens = parser.parseInlineUntil("CellEnd", true);
+            return {
+                align: cellStartToken.align || "left",
+                children: childrens
+            };
+        };
+        const rows = [];
+        while (parser.peek(0)?.type !== "TableEnd") {
+            rows.push(parseRow());
+            if (parser.isEnd())
+                break;
+        }
+        parser.next(1);
+        return {
+            type: "Table",
+            rows: rows
+        };
+    },
+};
+exports.TableHandler = TableHandler;
+const HtmlBlockHandler = {
+    type: "HTMLBlock",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1); // skip marker
+        if (tok?.type === "HTMLBlock") {
+            return { type: "HTMLBlock", value: tok.value };
+        }
+        else
+            return { type: "Text", value: "" };
+    },
+};
+exports.HtmlBlockHandler = HtmlBlockHandler;
+const HtmlInlineHandler = {
+    type: "HTMLInline",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1); // skip marker
+        if (tok?.type === "HTMLInline") {
+            return { type: "HTMLInline", value: tok.value };
+        }
+        else
+            return { type: "Text", value: "" };
+    },
+};
+exports.HtmlInlineHandler = HtmlInlineHandler;
+const HorizontalLineHandler = {
+    type: "HorizontalLine",
+    execute: (parser, _token) => {
+        parser.next(1); // skip marker
+        return { type: "HorizontalLine" };
+    },
+};
+exports.HorizontalLineHandler = HorizontalLineHandler;
+const FootnoteDefHandler = {
+    type: "FootnoteDef",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        if (tok?.type === "FootnoteDef" && tok.id) {
+            parser.footNoteResolver.addDef(tok.id, tok.content || "");
+        }
+        parser.next(1);
+    },
+};
+exports.FootnoteDefHandler = FootnoteDefHandler;
+const FootnoteRefHandler = {
+    type: "FootnoteRef",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        if (tok?.type !== "FootnoteRef" || !tok.id)
+            return { type: "Text", value: "" };
+        parser.footNoteResolver.addUsedRef(tok.id);
+        return { type: "FootnoteRef", id: tok.id };
+    },
+};
+exports.FootnoteRefHandler = FootnoteRefHandler;
+const NewLineHandler = {
+    type: "NewLine",
+    execute: (parser, _token) => {
+        parser.next(1);
+    },
+};
+exports.NewLineHandler = NewLineHandler;

package/dist/core/parser/index.d.ts

@@ -0,0 +1,33 @@
+import { ASTNode } from '../../types/parser';
+import { Token } from '../../types/token';
+import { FootnoteResolver } from '../resolver/footnote-resolver';
+export interface IParser {
+    listToken: Token[];
+    pos: number;
+    footNoteResolver: FootnoteResolver;
+    peek(offset: number): Token | null;
+    next(amount: number): void;
+    isEnd(): boolean;
+    parseBlocks(): ASTNode[];
+    parseInlineUntil(stopType: Token["type"] | Token["type"][], isConsumeStopToken: boolean): ASTNode[];
+}
+export declare class Parser implements IParser {
+    listToken: Token[];
+    pos: number;
+    footNoteResolver: FootnoteResolver;
+    private inlineStrategies;
+    private blockStrategies;
+    constructor(listToken: Token[], footNoteResolver: FootnoteResolver);
+    peek(offset?: number): Token | null;
+    next(amount?: number): void;
+    isEnd(): boolean;
+    /**
+         * Parse a list token to a node
+         * @return A parsed abstract syntax tree (AST)
+         */
+    parse(): ASTNode;
+    parseBlocks(): ASTNode[];
+    parseInlineUntil(stopType: Token["type"] | Token["type"][], isConsumeStopToken?: boolean): ASTNode[];
+    private parseParagraph;
+    private parseText;
+}

package/dist/core/parser/index.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const Handler = __importStar(require("./handler"));
+class Parser {
+    constructor(listToken, footNoteResolver) {
+        this.pos = 0;
+        this.listToken = listToken;
+        this.footNoteResolver = footNoteResolver;
+        this.blockStrategies = new Map([
+            Handler.HeaderHandler,
+            Handler.CodeBlockHandler,
+            Handler.QuoteHandler,
+            Handler.ImageHandler,
+            Handler.HorizontalLineHandler,
+            Handler.ListHandler,
+            Handler.TableHandler,
+            Handler.HtmlBlockHandler,
+            Handler.FootnoteDefHandler,
+            Handler.NewLineHandler
+        ].map(ele => [ele.type, ele]));
+        this.inlineStrategies = new Map([
+            Handler.BoldHandler,
+            Handler.ItalicHandler,
+            Handler.StrikethroughHandler,
+            Handler.InlineHandler,
+            Handler.LinkHandler,
+            Handler.HtmlInlineHandler,
+            Handler.FootnoteRefHandler,
+        ].map(ele => [ele.type, ele]));
+    }
+    peek(offset = 0) {
+        const i = this.pos + offset;
+        return i < this.listToken.length ? this.listToken[i] : null;
+    }
+    next(amount = 1) {
+        this.pos += amount;
+    }
+    isEnd() {
+        return this.peek()?.type === "EOF";
+    }
+    /**
+         * Parse a list token to a node
+         * @return A parsed abstract syntax tree (AST)
+         */
+    parse() {
+        return {
+            type: "Document",
+            children: this.parseBlocks()
+        };
+    }
+    parseBlocks() {
+        const listNode = [];
+        while (!this.isEnd()) {
+            const token = this.peek();
+            if (!token)
+                break;
+            const strategy = this.blockStrategies.get(token?.type || "");
+            if (strategy) {
+                const result = strategy.execute(this, token);
+                if (result)
+                    listNode.push(result);
+            }
+            else {
+                //Fallback to Paragraph node
+                const pNode = this.parseParagraph();
+                if (pNode.children && pNode.children.length > 0) {
+                    listNode.push(pNode);
+                }
+                else {
+                    this.next();
+                }
+            }
+        }
+        return listNode;
+    }
+    parseInlineUntil(stopType, isConsumeStopToken = false) {
+        const stop = Array.isArray(stopType) ? stopType : [stopType];
+        const nodes = [];
+        while (!this.isEnd()) {
+            const currentNode = this.peek();
+            if (!currentNode || stop.includes(currentNode.type))
+                break;
+            if (this.blockStrategies.get(currentNode.type)) {
+                break;
+            }
+            const strategy = this.inlineStrategies.get(currentNode.type);
+            if (strategy) {
+                const result = strategy.execute(this, currentNode);
+                if (result)
+                    nodes.push(result);
+            }
+            else {
+                //Fallback to Text node
+                nodes.push(this.parseText(currentNode));
+                this.next();
+            }
+        }
+        if (isConsumeStopToken)
+            this.next(); //Skip stop token
+        return nodes;
+    }
+    parseParagraph() {
+        return {
+            type: "Paragraph",
+            children: this.parseInlineUntil("NewLine", true)
+        };
+    }
+    parseText(currentNode) {
+        return {
+            type: "Text",
+            value: currentNode.value || ""
+        };
+    }
+}
+exports.Parser = Parser;

package/dist/core/parser.d.ts

@@ -0,0 +1,37 @@
+import { FootnoteResolver } from "../core/resolver";
+import { Node } from "../types/node";
+import { Token } from "../types/token";
+export declare class Parser {
+    listToken: Token[];
+    pos: number;
+    footNoteResolver: FootnoteResolver;
+    constructor(listToken: Token[], footNoteResolver: FootnoteResolver);
+    /**
+     * Parse a list token to a node
+     * @return A parsed abstract syntax tree (AST)
+     */
+    parse(): Node;
+    private peek;
+    private next;
+    private isEnd;
+    private parseBlocks;
+    private parseParagraph;
+    private parseCodeBlock;
+    private parseHeader;
+    private parseBold;
+    private parseItalic;
+    private parseStrikethrough;
+    private parseInlineCode;
+    private parseQuote;
+    private parseList;
+    private parseListItem;
+    private parseLink;
+    private parseImage;
+    private parseTable;
+    private parseHtmlBlock;
+    private parseHtmlInline;
+    private parseHorizontalLine;
+    private parseFootnoteDef;
+    private parseFootnoteRef;
+    private parseInlineUntil;
+}