pantsdown 1.0.1

package/src/parser.ts

@@ -0,0 +1,216 @@
+import { Renderer } from "./renderer.ts";
+import { type RendererProps, type Token, type Tokens } from "./types.ts";
+
+/**
+ * Parsing & Compiling
+ */
+export class Parser {
+    private renderer: Renderer;
+
+    constructor({ renderer }: { renderer: RendererProps }) {
+        this.renderer = new Renderer(renderer);
+    }
+
+    /**
+     * Parse Loop
+     */
+    parse(tokens: Token[], top = true): string {
+        let out = "";
+
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const token = tokens[i]!;
+
+            switch (token.type) {
+                case "space": {
+                    continue;
+                }
+                case "hr": {
+                    out += this.renderer.hr();
+                    continue;
+                }
+                case "heading": {
+                    out += this.renderer.heading(this.parseInline(token.tokens), token.depth);
+                    continue;
+                }
+                case "code": {
+                    out += this.renderer.code(token.text, token.lang);
+                    continue;
+                }
+                case "table": {
+                    let header = "";
+
+                    // header
+                    let cell = "";
+                    for (let j = 0, len = token.header.length; j < len; j++) {
+                        cell += this.renderer.tablecell(this.parseInline(token.header[j]!.tokens), {
+                            header: true,
+                            align: token.align[j]!,
+                        });
+                    }
+                    header += this.renderer.tablerow(cell);
+
+                    let body = "";
+                    for (let j = 0, rowsLen = token.rows.length; j < rowsLen; j++) {
+                        const row = token.rows[j]!;
+
+                        cell = "";
+                        for (let k = 0, rowLen = row.length; k < rowLen; k++) {
+                            cell += this.renderer.tablecell(this.parseInline(row[k]!.tokens), {
+                                header: false,
+                                align: token.align[k]!,
+                            });
+                        }
+
+                        body += this.renderer.tablerow(cell);
+                    }
+                    out += this.renderer.table(header, body);
+                    continue;
+                }
+                case "blockquote": {
+                    const body = this.parse(token.tokens);
+                    out += this.renderer.blockquote(body);
+                    continue;
+                }
+                case "list": {
+                    const ordered = token.ordered;
+                    const start = token.start;
+                    const loose = token.loose;
+
+                    let body = "";
+                    for (let j = 0, itemsLen = token.items.length; j < itemsLen; j++) {
+                        const item = token.items[j]!;
+                        const checked = item.checked;
+                        const task = item.task;
+
+                        let itemBody = "";
+                        if (item.task) {
+                            const checkbox = this.renderer.checkbox(!!checked);
+                            if (loose) {
+                                if (
+                                    item.tokens.length > 0 &&
+                                    item.tokens[0]!.type === "paragraph"
+                                ) {
+                                    item.tokens[0]!.text = checkbox + " " + item.tokens[0]!.text;
+                                    if (
+                                        item.tokens[0]!.tokens.length > 0 &&
+                                        item.tokens[0]!.tokens[0]!.type === "text"
+                                    ) {
+                                        item.tokens[0]!.tokens[0]!.text =
+                                            checkbox + " " + item.tokens[0]!.tokens[0]!.text;
+                                    }
+                                } else {
+                                    item.tokens.unshift({
+                                        type: "text",
+                                        text: checkbox + " ",
+                                    } as Tokens["Text"]);
+                                }
+                            } else {
+                                itemBody += checkbox + " ";
+                            }
+                        }
+
+                        itemBody += this.parse(item.tokens, loose);
+                        body += this.renderer.listitem(itemBody, task, !!checked);
+                    }
+
+                    out += this.renderer.list(body, ordered, start);
+                    continue;
+                }
+                case "html": {
+                    out += this.renderer.html(token.text, token.block);
+                    continue;
+                }
+                case "paragraph": {
+                    out += this.renderer.paragraph(this.parseInline(token.tokens));
+                    continue;
+                }
+                case "text": {
+                    let textToken = token as Tokens["Text"];
+                    let body = textToken.tokens
+                        ? this.parseInline(textToken.tokens)
+                        : textToken.text;
+                    while (i + 1 < tokens.length && tokens[i + 1]?.type === "text") {
+                        textToken = tokens[++i] as Tokens["Text"];
+                        body +=
+                            "\n" +
+                            (textToken.tokens
+                                ? this.parseInline(textToken.tokens)
+                                : textToken.text);
+                    }
+                    out += top ? this.renderer.paragraph(body) : body;
+                    continue;
+                }
+
+                default: {
+                    const errMsg = 'Token with "' + token.type + '" type was not found.';
+                    throw new Error(errMsg);
+                }
+            }
+        }
+
+        return out;
+    }
+
+    /**
+     * Parse Inline Tokens
+     */
+    parseInline(tokens: Token[]): string {
+        let out = "";
+
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const token = tokens[i]!;
+
+            switch (token.type) {
+                case "escape": {
+                    out += this.renderer.text(token.text);
+                    break;
+                }
+                case "html": {
+                    out += this.renderer.html(token.text);
+                    break;
+                }
+                case "link": {
+                    out += this.renderer.link(
+                        token.href,
+                        token.title,
+                        this.parseInline(token.tokens),
+                    );
+                    break;
+                }
+                case "image": {
+                    out += this.renderer.image(token.href, token.title, token.text);
+                    break;
+                }
+                case "strong": {
+                    out += this.renderer.strong(this.parseInline(token.tokens));
+                    break;
+                }
+                case "em": {
+                    out += this.renderer.em(this.parseInline(token.tokens));
+                    break;
+                }
+                case "codespan": {
+                    out += this.renderer.codespan(token.text);
+                    break;
+                }
+                case "br": {
+                    out += this.renderer.br();
+                    break;
+                }
+                case "del": {
+                    out += this.renderer.del(this.parseInline(token.tokens));
+                    break;
+                }
+                case "text": {
+                    out += this.renderer.text(token.text);
+                    break;
+                }
+                default: {
+                    const errMsg = 'Token with "' + token.type + '" type was not found.';
+                    throw new Error(errMsg);
+                }
+            }
+        }
+        return out;
+    }
+}

package/src/renderer.ts

@@ -0,0 +1,145 @@
+import hljs from "highlight.js";
+import { type RendererProps } from "./types.ts";
+import { cleanUrl, escape, fixHtmlLocalImageHref, fixLocalImageHref } from "./utils.ts";
+
+/**
+ * An object containing functions to render tokens to HTML.
+ */
+export class Renderer {
+    private props: RendererProps;
+
+    constructor(props: RendererProps) {
+        this.props = props;
+    }
+
+    code(code: string, infostring: string | undefined): string {
+        const lang = (infostring ?? "").match(/^\S*/)?.[0];
+
+        code = code.replace(/\n$/, "") + "\n";
+
+        const language = lang && hljs.getLanguage(lang) ? lang : "plaintext";
+        const highlightedCode = hljs.highlight(code, { language }).value;
+
+        return (
+            '<pre><code class="hljs language-' +
+            escape(language) +
+            '">' +
+            highlightedCode +
+            "</code></pre>\n"
+        );
+    }
+
+    blockquote(quote: string): string {
+        return `<blockquote>\n${quote}</blockquote>\n`;
+    }
+
+    html(html: string, _block?: boolean): string {
+        return fixHtmlLocalImageHref(html, this.props.localImageUrlPrefix);
+    }
+
+    heading(text: string, level: number): string {
+        // ignore IDs
+        return `<h${level}>${text}</h${level}>\n`;
+    }
+
+    hr(): string {
+        return "<hr>\n";
+    }
+
+    list(body: string, ordered: boolean, start: number | ""): string {
+        const type = ordered ? "ol" : "ul";
+        const startatt = ordered && start !== 1 ? ' start="' + start + '"' : "";
+        return "<" + type + startatt + ">\n" + body + "</" + type + ">\n";
+    }
+
+    listitem(text: string, _task: boolean, _checked: boolean): string {
+        return `<li>${text}</li>\n`;
+    }
+
+    checkbox(checked: boolean): string {
+        return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+    }
+
+    paragraph(text: string): string {
+        return `<p>${text}</p>\n`;
+    }
+
+    table(header: string, body: string): string {
+        if (body) body = `<tbody>${body}</tbody>`;
+
+        return "<table>\n" + "<thead>\n" + header + "</thead>\n" + body + "</table>\n";
+    }
+
+    tablerow(content: string): string {
+        return `<tr>\n${content}</tr>\n`;
+    }
+
+    tablecell(
+        content: string,
+        flags: {
+            header: boolean;
+            align: "center" | "left" | "right" | null;
+        },
+    ): string {
+        const type = flags.header ? "th" : "td";
+        const tag = flags.align ? `<${type} align="${flags.align}">` : `<${type}>`;
+        return tag + content + `</${type}>\n`;
+    }
+
+    /**
+     * span level renderer
+     */
+    strong(text: string): string {
+        return `<strong>${text}</strong>`;
+    }
+
+    em(text: string): string {
+        return `<em>${text}</em>`;
+    }
+
+    codespan(text: string): string {
+        return `<code>${text}</code>`;
+    }
+
+    br(): string {
+        return "<br>";
+    }
+
+    del(text: string): string {
+        return `<del>${text}</del>`;
+    }
+
+    link(href: string, title: string | null | undefined, text: string): string {
+        const cleanHref = cleanUrl(href);
+        if (cleanHref === null) {
+            return text;
+        }
+        href = cleanHref;
+        let out = '<a href="' + href + '"';
+        if (title) {
+            out += ' title="' + title + '"';
+        }
+        out += ">" + text + "</a>";
+        return out;
+    }
+
+    image(href: string, title: string | null, text: string): string {
+        const cleanHref = cleanUrl(href);
+        if (cleanHref === null) {
+            return text;
+        }
+        href = fixLocalImageHref(cleanHref, this.props.localImageUrlPrefix);
+
+        let out = `<img src="${href}" alt="${text}"`;
+
+        if (title) {
+            out += ` title="${title}"`;
+        }
+        out += ">";
+        return out;
+    }
+
+    text(text: string): string {
+        return text;
+    }
+}

package/src/rules/block.ts

@@ -0,0 +1,129 @@
+import { edit } from "./utils.ts";
+
+type BlockRuleNames =
+    | "newline"
+    | "code"
+    | "fences"
+    | "hr"
+    | "heading"
+    | "blockquote"
+    | "list"
+    | "html"
+    | "def"
+    | "table"
+    | "lheading"
+    | "text"
+    | "bullet"
+    | "listItemStart"
+    | "paragraph";
+
+export const label = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+
+const tag =
+    "address|article|aside|base|basefont|blockquote|body|caption" +
+    "|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption" +
+    "|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe" +
+    "|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option" +
+    "|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr" +
+    "|track|ul";
+
+const title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
+
+const block_def = edit(
+    /^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/,
+)
+    .replace("label", label)
+    .replace("title", title)
+    .getRegex();
+
+const block_bullet = /(?:[*+-]|\d{1,9}[.)])/;
+
+const block_listItemStart = edit(/^( *)(bull) */)
+    .replace("bull", block_bullet)
+    .getRegex();
+
+const block_list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/)
+    .replace(/bull/g, block_bullet)
+    .replace("hr", "\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))")
+    .replace("def", "\\n+(?=" + block_def.source + ")")
+    .getRegex();
+
+export const comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
+
+const block_html = edit(
+    "^ {0,3}(?:" + // optional indentation
+        "<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)" + // (1)
+        "|comment[^\\n]*(\\n+|$)" + // (2)
+        "|<\\?[\\s\\S]*?(?:\\?>\\n*|$)" + // (3)
+        "|<![A-Z][\\s\\S]*?(?:>\\n*|$)" + // (4)
+        "|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)" + // (5)
+        "|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)" + // (6)
+        "|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)" + // (7) open tag
+        "|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)" + // (7) closing tag
+        ")",
+    "i",
+)
+    .replace("comment", comment)
+    .replace("tag", tag)
+    .replace(
+        "attribute",
+        / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/,
+    )
+    .getRegex();
+
+const block_lheading = edit(/^(?!bull )((?:.|\n(?!\s*?\n|bull ))+?)\n {0,3}(=+|-+) *(?:\n+|$)/)
+    .replace(/bull/g, block_bullet) // lists can interrupt
+    .getRegex();
+
+const block_hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+
+const block_table = edit(
+    "^ *([^\\n ].*)\\n" + // Header
+        " {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)" + // Align
+        "(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)", // Cells
+)
+    .replace("hr", block_hr)
+    .replace("heading", " {0,3}#{1,6} ")
+    .replace("blockquote", " {0,3}>")
+    .replace("code", " {4}[^\\n]")
+    .replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n")
+    .replace("list", " {0,3}(?:[*+-]|1[.)]) ") // only lists starting from 1 can interrupt
+    .replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)")
+    .replace("tag", tag) // tables can be interrupted by type (6) html blocks
+    .getRegex();
+
+const block_paragraph = edit(
+    /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,
+)
+    .replace("hr", block_hr)
+    .replace("heading", " {0,3}#{1,6} ")
+    .replace("|lheading", "") // setex headings don't interrupt commonmark paragraphs
+    .replace("table", block_table) // interrupt paragraphs with table
+    .replace("blockquote", " {0,3}>")
+    .replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n")
+    .replace("list", " {0,3}(?:[*+-]|1[.)]) ") // only lists starting from 1 can interrupt
+    .replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)")
+    .replace("tag", tag) // pars can be interrupted by type (6) html blocks
+    .getRegex();
+
+const block_blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/)
+    .replace("paragraph", block_paragraph)
+    .getRegex();
+
+export const block: Record<BlockRuleNames, RegExp> = {
+    newline: /^(?: *(?:\n|$))+/,
+    code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
+    fences: /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
+    hr: block_hr,
+    heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
+    blockquote: block_blockquote,
+    list: block_list,
+    html: block_html,
+    bullet: block_bullet,
+    listItemStart: block_listItemStart,
+    def: block_def,
+    table: block_table,
+    lheading: block_lheading,
+    paragraph: block_paragraph,
+    text: /^[^\n]+/,
+};

package/src/rules/inline.ts

@@ -0,0 +1,146 @@
+import { comment as blockComment, label as blockLabel } from "./block.ts";
+import { edit } from "./utils.ts";
+
+type InlineRuleNames =
+    | "escape"
+    | "autolink"
+    | "tag"
+    | "link"
+    | "reflink"
+    | "nolink"
+    | "reflinkSearch"
+    | "code"
+    | "br"
+    | "del"
+    | "url"
+    | "text"
+    | "emStrong"
+    | "anyPunctuation"
+    | "punctuation"
+    | "blockSkip"
+    | "escapes"
+    | "backpedal";
+
+// list of unicode punctuation marks, plus any missing characters from CommonMark spec
+const punctuation = "\\p{P}$+<=>`^|~";
+const title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;
+const href = /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/;
+const scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
+const comment = edit(blockComment).replace("(?:-->|$)", "-->").getRegex();
+const attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/;
+const label = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+const email =
+    /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
+const extended_email = /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/;
+
+const inline_punctuation = edit(/^((?![*_])[\spunctuation])/, "u")
+    .replace(/punctuation/g, punctuation)
+    .getRegex();
+
+// sequences em should skip over [title](link), `code`, <html>
+const inline_blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
+
+const inline_emStrong = {
+    lDelim: edit(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u")
+        .replace(/punct/g, punctuation)
+        .getRegex(),
+    // (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
+    // | Skip orphan inside strong      | Consume to delim | (1) #***              | (2) a***#, a***                    | (3) #***a, ***a                  | (4) ***#                 | (5) #***#                         | (6) a***a
+    rDelimAst: edit(
+        /^[^_*]*?__[^_*]*?\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\*)[punct](\*+)(?=[\s]|$)|[^punct\s](\*+)(?!\*)(?=[punct\s]|$)|(?!\*)[punct\s](\*+)(?=[^punct\s])|[\s](\*+)(?!\*)(?=[punct])|(?!\*)[punct](\*+)(?!\*)(?=[punct])|[^punct\s](\*+)(?=[^punct\s])/,
+        "gu",
+    )
+        .replace(/punct/g, punctuation)
+        .getRegex(),
+    rDelimUnd: edit(
+        // ^- Not allowed for _
+        /^[^_*]*?\*\*[^_*]*?_[^_*]*?(?=\*\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\s]|$)|[^punct\s](_+)(?!_)(?=[punct\s]|$)|(?!_)[punct\s](_+)(?=[^punct\s])|[\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])/,
+        "gu",
+    )
+        .replace(/punct/g, punctuation)
+        .getRegex(),
+};
+
+const inline_anyPunctuation = edit(/\\[punct]/g, "gu")
+    .replace(/punct/g, punctuation)
+    .getRegex();
+
+const inline_escapes = edit(/\\([punct])/g, "gu")
+    .replace(/punct/g, punctuation)
+    .getRegex();
+
+const inline_autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/)
+    .replace("scheme", scheme)
+    .replace("email", email)
+    .getRegex();
+
+const inline_tag = edit(
+    "^comment" +
+        "|^</[a-zA-Z][\\w:-]*\\s*>" + // self-closing tag
+        "|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>" + // open tag
+        "|^<\\?[\\s\\S]*?\\?>" + // processing instruction, e.g. <?php ?>
+        "|^<![a-zA-Z]+\\s[\\s\\S]*?>" + // declaration, e.g. <!DOCTYPE html>
+        "|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>", // CDATA section
+)
+    .replace("comment", comment)
+    .replace("attribute", attribute)
+    .getRegex();
+
+const inline_link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/)
+    .replace("label", label)
+    .replace("href", href)
+    .replace("title", title)
+    .getRegex();
+
+const inline_reflink = edit(/^!?\[(label)\]\[(ref)\]/)
+    .replace("label", label)
+    .replace("ref", blockLabel)
+    .getRegex();
+
+const inline_nolink = edit(/^!?\[(ref)\](?:\[\])?/)
+    .replace("ref", blockLabel)
+    .getRegex();
+
+const inline_reflinkSearch = edit("reflink|nolink(?!\\()", "g")
+    .replace("reflink", inline_reflink)
+    .replace("nolink", inline_nolink)
+    .getRegex();
+
+const inline_escape = edit(/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/)
+    .replace("])", "~|])")
+    .getRegex();
+
+const inline_backpedal =
+    /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/;
+
+const inline_del = /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/;
+
+const inline_text =
+    /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/;
+
+const inline_url = edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i")
+    .replace("email", extended_email)
+    .getRegex();
+
+export const inline: Omit<Record<InlineRuleNames, RegExp>, "emStrong"> & {
+    ["emStrong"]: Record<keyof typeof inline_emStrong, RegExp>;
+} = {
+    escape: inline_escape,
+    autolink: inline_autolink,
+    url: inline_url,
+    tag: inline_tag,
+    link: inline_link,
+    reflink: inline_reflink,
+    nolink: inline_nolink,
+    reflinkSearch: inline_reflinkSearch,
+    anyPunctuation: inline_anyPunctuation,
+    emStrong: inline_emStrong,
+    code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
+    br: /^( {2,}|\\)\n(?!\s*$)/,
+    del: inline_del,
+    text: inline_text,
+    punctuation: inline_punctuation,
+    blockSkip: inline_blockSkip,
+    escapes: inline_escapes,
+    backpedal: inline_backpedal,
+};

package/src/rules/utils.ts

@@ -0,0 +1,18 @@
+const caret = /(^|[^\[])\^/g;
+
+export function edit(rule: RegExp | string, opt?: string) {
+    rule = typeof rule === "string" ? rule : rule.source;
+    opt = opt ?? "";
+    const obj = {
+        replace: (name: string | RegExp, val: string | RegExp) => {
+            val = typeof val === "object" && "source" in val ? val.source : val;
+            val = val.replace(caret, "$1");
+            rule = (rule as string).replace(name, val);
+            return obj;
+        },
+        getRegex: () => {
+            return new RegExp(rule, opt);
+        },
+    };
+    return obj;
+}

package/src/sample.test.ts

@@ -0,0 +1,5 @@
+import { expect, test } from "bun:test";
+
+test("2 + 2", () => {
+    expect(1 + 3).toBe(4);
+});