tellegram 1.0.0 → 1.1.3

package/README.md

@@ -1,11 +1,23 @@
 # teLLegraM
 
-[![Build](https://img.shields.io/github/actions/workflow/status/skoropadas/telegramify-markdown/release.yml?branch=master)](https://github.com/skoropadas/telegramify-markdown/actions)
-[![codecov](https://codecov.io/gh/skoropadas/telegramify-markdown/branch/master/graph/badge.svg?token=LxCmgGNUHl)](https://codecov.io/gh/skoropadas/telegramify-markdown)
-![License](https://img.shields.io/github/license/skoropadas/telegramify-markdown)
+[![Build](https://img.shields.io/github/actions/workflow/status/leask/tellegram/release.yml?branch=master)](https://github.com/leask/tellegram/actions)
+[![codecov](https://codecov.io/gh/leask/tellegram/branch/master/graph/badge.svg?token=LxCmgGNUHl)](https://codecov.io/gh/leask/tellegram)
+![License](https://img.shields.io/github/license/leask/tellegram)
 
 teLLegraM is a library designed to format LLM (Large Language Model) generated text into [Telegram-specific-markdown (MarkdownV2)](https://core.telegram.org/bots/api#formatting-options), based on [Unified](https://github.com/unifiedjs/unified) and [Remark](https://github.com/remarkjs/remark/). It ensures that complex markdown from AI responses is perfectly interpreted by Telegram clients.
 
+## Acknowledgements
+
+This project is based on [telegramify-markdown](https://github.com/skoropadas/telegramify-markdown) but has been evolved to specifically address the needs of LLM-generated content.
+
+## Why teLLegraM?
+
+While the original library provided a solid foundation, teLLegraM introduces several key optimizations for the "LLM to Telegram" workflow:
+
+1.  **LLM-Specific Optimizations**: Tailored handling of common artifacts found in AI responses, ensuring cleaner output.
+2.  **Lossless Pagination**: Telegram has strict message length limits. teLLegraM includes a smart pagination feature that splits long text into multiple messages *without* breaking MarkdownV2 syntax. It ensures bold, italic, or code blocks are correctly closed in one message and reopened in the next, preventing "unclosed entity" errors.
+3.  **Strict MarkdownV2 Compliance**: Enhanced escaping rules to handle edge cases often produced by generative models.
+
 ## Install
 
 ```bash
@@ -14,8 +26,13 @@ npm install tellegram
 
 ## Usage
 
+### Basic Conversion
+
 ```js
-const teLLegraM = require('tellegram');
+import tellegram from 'tellegram';
+// OR
+// import { convert } from 'tellegram';
+
 const markdown = `
 # Header
 ## Subheader
@@ -29,11 +46,12 @@ const markdown = `
 And simple text with + some - symbols.
 `;
 
-teLLegraM(markdown);
+const result = tellegram(markdown);
+console.log(result);
 /*
  *Header*
  *Subheader*
- 
+
 [1\.0\.0](http://version.com)
 
  • item 1
@@ -44,13 +62,31 @@ And simple text with \+ some \- symbols\.
 */
 ```
 
+### Pagination (Handling Long Messages)
+
+When dealing with verbose LLM outputs, use the `paginate` function to safely split text into chunks that respect Telegram's limits (4096 characters) while preserving formatting context.
+
+```js
+import { paginate } from 'tellegram';
+
+const longLlmOutput = `... extremely long text with **markdown** ...`;
+
+// Split into an array of strings, each safe to send
+const messages = paginate(longLlmOutput);
+
+for (const msg of messages) {
+    // Send each part sequentially
+    await bot.sendMessage(chatId, msg, { parse_mode: 'MarkdownV2' });
+}
+```
+
 ## Possible options
 
 You can also add unsupported tags strategy as a second argument, which can be one of the following:
 
-- `escape` - escape unsupported symbols for unsupported tags
+- `escape` - escape unsupported symbols for unsupported tags (default)
 - `remove` - remove unsupported tags
-- `keep` - ignore unsupported tags (default)
+- `keep` - ignore unsupported tags
 
 ```js
 const teLLegraM = require('teLLegraM');

package/index.mjs

@@ -0,0 +1,5 @@
+import convert from './lib/convert.mjs';
+import paginate from './lib/paginate.mjs';
+
+export { convert, paginate };
+export default convert;

package/lib/convert.mjs

@@ -0,0 +1,25 @@
+import gfm from 'remark-gfm';
+import parse from 'remark-parse';
+import stringify from 'remark-stringify';
+import removeComments from 'remark-remove-comments';
+import unified from 'unified';
+
+import { collectDefinitions, removeDefinitions } from './definitions.mjs';
+import createTellegramOptions from './tellegram.mjs';
+
+export default (markdown, unsupportedTagsStrategy = 'escape') => {
+    const definitions = {};
+
+    const tellegramOptions = createTellegramOptions(definitions, unsupportedTagsStrategy);
+
+    return unified()
+        .use(parse)
+        .use(gfm)
+        .use(removeComments)
+        .use(collectDefinitions, definitions)
+        .use(removeDefinitions)
+        .use(stringify, tellegramOptions)
+        .processSync(markdown)
+        .toString()
+        .replace(/<!---->\n/gi, '').trim();
+};

package/lib/{definitions.js → definitions.mjs}

@@ -8,12 +8,12 @@ import visit from 'unist-util-visit';
  * @param {Record<string, { title: null | string, url: string }>} definitions
  */
 export const collectDefinitions = definitions => tree => {
-	visit(tree, 'definition', node => {
-		definitions[node.identifier] = {
-			title: node.title,
-			url: node.url,
-		};
-	});
+    visit(tree, 'definition', node => {
+        definitions[node.identifier] = {
+            title: node.title,
+            url: node.url,
+        };
+    });
 };
 
 /**
@@ -21,7 +21,5 @@ export const collectDefinitions = definitions => tree => {
  * This avoids unwanted negative space in stringified output.
  */
 export const removeDefinitions = () => tree => {
-	remove(tree, { cascade: true }, 'definition');
+    remove(tree, { cascade: true }, 'definition');
 };
-
-

package/lib/paginate.mjs

@@ -0,0 +1,117 @@
+import assert from 'assert';
+import convert from './convert.mjs';
+
+const MESSAGE_LENGTH_LIMIT = parseInt(4096 * 0.93);   // ~= 3800
+const clarify = str => str.toLowerCase().split(/[^a-zA-Z0-9]+/).filter(x => x);
+const lines = (arr, sep = '\n') => arr.join(sep);
+const extError = (err, status, opt = {}) => Object.assign(err, { status }, opt);
+const newError = (msg, status, opt) => extError(new Error(msg), status, opt);
+const throwError = (msg, status, opt) => { throw newError(msg, status, opt); };
+const trim = (str, opts) => ensureString(str, { trim: true, ...opts || {} });
+
+// Is
+const _is = (type, value) => value?.constructor === type;
+const _type = (any) => typeof any === 'undefined' ? 'Undefined'
+    : Object.prototype.toString.call(any).replace(/^\[[^\ ]*\ (.*)\]$/, '$1');
+[
+    ArrayBuffer, BigInt, Boolean, Error, Number, Object, Set, String, Uint8Array
+].map(type => {
+    const name = `is${type.name}`;
+    type[name] = type[name] || (value => _is(type, value));
+});
+Date.isDate = Date.isDate || ((value, strict) => _is(Date, value) ? (
+    strict ? value.toTimeString().toLowerCase() !== 'invalid date' : true
+) : false);
+Function.isFunction = Function.isFunction
+    || (value => ['Function', 'AsyncFunction'].includes(_type(value)));
+
+const toString = (any, options) => {
+    if (Object.isObject(any)) { return JSON.stringify(any); }
+    else if (Date.isDate(any)) { return any.toISOString(); }
+    else if (Error.isError(any)) { return options?.trace ? any.stack : any.message; }
+    return String(any ?? '');
+};
+
+const ensureString = (str, options) => {
+    str = toString(str, options);
+    if (options?.case) {
+        switch (toString(options?.case).trim().toUpperCase()) {
+            case 'UP':
+                str = str.toUpperCase();
+                break;
+            case 'LOW':
+                str = str.toLowerCase();
+                break;
+            case 'CAP': // capitalize
+                str = `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
+                break;
+            case 'CAMEL':
+                str = clarify(str).map((x, i) => i ? `${x.charAt(0).toUpperCase()}${x.slice(1)}` : x).join('');
+                break;
+            case 'SNAKE':
+                str = clarify(str).join('_');
+                assert(str, 'String can not convert to snake case.', 500);
+                break;
+            default:
+                throwError(`Invalid case option: '${options?.case}'.`, 500);
+        }
+    }
+    options?.trim && (str = str.trim());
+    options?.compact && (str = str.replace(/\s+/g, ' ').trim());
+    options?.limit && (str = str.trim()) && str.length > options.limit
+        && (str = `${str.slice(0, options.limit).trim()}...`);
+    return str;
+};
+
+export default (message, options) => {
+    let [pages, page, size, codeMark, concat, prefix] =
+        [[], [], ~~options?.size || MESSAGE_LENGTH_LIMIT, '', '', ''];
+    const countLength = pos => {
+        const str = prefix + lines(page) + message.substring(0, pos + 1);
+        return Math.max(str.length, convert(str).length);
+    };
+    const submit = () => {
+        const content = trim(lines(page));
+        content && pages.push(prefix + content + concat + (codeMark ? '\n```' : ''));
+        page.length = 0;
+        prefix = '';
+        if (codeMark) {
+            prefix += `${codeMark}\n`;
+        }
+        if (concat) {
+            prefix += concat;
+            concat = '';
+        }
+    };
+    while ((message || '').length) {
+        let nextN = message.indexOf('\n');                    // 獲得下一個換行
+        nextN === -1 && (nextN = message.length);             // 剩下只有一行
+        let cut = nextN;                                      // 初始化當前預測裁切
+        if (countLength(cut) > size && page.length) { submit(); continue; }
+        let high = Math.min(cut, size);
+        cut = 0;
+        while (cut < high) {
+            let mid = Math.ceil((cut + high) / 2);
+            if (countLength(mid) <= size) {
+                cut = mid;
+            } else {
+                high = mid - 1;
+            }
+        }
+        concat = cut < nextN ? '...' : '';
+        const line = message.substring(0, cut + 1).trimEnd();
+        page.push(line);
+        /^```.{0,20}$/.test(line) && (codeMark = codeMark ? '' : line);
+        if (concat) {
+            submit();
+        }
+        message = message.substring(cut + 1);
+    }
+    submit();
+    return pages.map((p, i) => convert((
+        pages.length > 1 && !options?.noPageNum
+            ? `📃 PAGE ${i + 1} / ${pages.length}:\n\n` : ''
+    ) + p));
+};
+
+export { MESSAGE_LENGTH_LIMIT };

package/lib/tellegram.mjs

@@ -0,0 +1,158 @@
+import defaultHandlers from 'mdast-util-to-markdown/lib/handle/index.js';
+import phrasing from 'mdast-util-to-markdown/lib/util/container-phrasing.js';
+import { toMarkdown as gfmTableToMarkdown } from 'mdast-util-gfm-table';
+
+import { wrap, isURL, escapeSymbols, processUnsupportedTags } from './utils.mjs';
+
+/**
+ * Creates custom `mdast-util-to-markdown` handlers that tailor the output for
+ * Telegram Markdown.
+ *
+ * @param {Readonly<Record<string, { title: null | string, url: string }>>} definitions
+ * Record of `Definition`s in the Markdown document, keyed by identifier.
+ *
+ * @returns {import('mdast-util-to-markdown').Handlers}
+ */
+const createHandlers = (definitions, unsupportedTagsStrategy) => ({
+    heading: (node, _parent, context) => {
+        // make headers to be just *strong*
+        const marker = '*';
+
+        const exit = context.enter('heading');
+        const value = phrasing(node, context, { before: marker, after: marker });
+        exit();
+
+        return wrap(value, marker);
+    },
+
+    strong: (node, _parent, context) => {
+        const marker = '*';
+
+        const exit = context.enter('strong');
+        const value = phrasing(node, context, { before: marker, after: marker });
+        exit();
+
+        return wrap(value, marker);
+    },
+
+    delete(node, _parent, context) {
+        const marker = '~';
+
+        const exit = context.enter('delete');
+        const value = phrasing(node, context, { before: marker, after: marker });
+        exit();
+
+        return wrap(value, marker);
+    },
+
+    emphasis: (node, _parent, context) => {
+        const marker = '_';
+
+        const exit = context.enter('emphasis');
+        const value = phrasing(node, context, { before: marker, after: marker });
+        exit();
+
+        return wrap(value, marker);
+    },
+
+    list: (...args) => defaultHandlers.list(...args).replace(/^(\d+)./gm, '$1\\.'),
+
+    listItem: (...args) => defaultHandlers.listItem(...args).replace(/^\*/, '•'),
+
+    code(node, _parent, context) {
+        const exit = context.enter('code');
+        // delete language prefix for deprecated markdown formatters (old Bitbucket Editor)
+        const content = node.value.replace(/^#![a-z]+\n/, ''); // ```\n#!javascript\ncode block\n```
+        exit();
+
+        const language = node.lang || '';
+        return `\`\`\`${language}\n${escapeSymbols(content, 'code')}\n\`\`\``;
+    },
+
+    link: (node, _parent, context) => {
+        const exit = context.enter('link');
+        const text = phrasing(node, context, { before: '|', after: '>' }) || escapeSymbols(node.title);
+        const isUrlEncoded = decodeURI(node.url) !== node.url;
+        const url = isUrlEncoded ? node.url : encodeURI(node.url);
+        exit();
+
+        if (!isURL(url)) return escapeSymbols(text) || escapeSymbols(url);
+
+        return text
+            ? `[${text}](${escapeSymbols(url, 'link')})`
+            : `[${escapeSymbols(url)}](${escapeSymbols(url, 'link')})`;
+    },
+
+    linkReference: (node, _parent, context) => {
+        const exit = context.enter('linkReference');
+        const definition = definitions[node.identifier];
+        const text = phrasing(node, context, { before: '|', after: '>' }) || (definition ? definition.title : null);
+        exit();
+
+        if (!definition || !isURL(definition.url)) return escapeSymbols(text);
+
+        return text
+            ? `[${text}](${escapeSymbols(definition.url, 'link')})`
+            : `[${escapeSymbols(definition.url)}](${escapeSymbols(definition.url, 'link')})`;
+    },
+
+    image: (node, _parent, context) => {
+        const exit = context.enter('image');
+        const text = node.alt || node.title;
+        const url = node.url
+        exit();
+
+        if (!isURL(url)) return escapeSymbols(text) || escapeSymbols(url);
+
+        return text
+            ? `[${escapeSymbols(text)}](${escapeSymbols(url, 'link')})`
+            : `[${escapeSymbols(url)}](${escapeSymbols(url, 'link')})`;
+    },
+
+    imageReference: (node, _parent, context) => {
+        const exit = context.enter('imageReference');
+        const definition = definitions[node.identifier];
+        const text = node.alt || (definition ? definition.title : null);
+        exit();
+
+        if (!definition || !isURL(definition.url)) return escapeSymbols(text);
+
+        return text
+            ? `[${escapeSymbols(text)}](${escapeSymbols(definition.url, 'link')})`
+            : `[${escapeSymbols(definition.url)}](${escapeSymbols(definition.url, 'link')})`;
+    },
+
+    text: (node, _parent, context) => {
+        const exit = context.enter('text');
+        const text = node.value;
+        exit();
+
+        return escapeSymbols(text);
+    },
+
+    blockquote: (node, _parent, context) =>
+        processUnsupportedTags(defaultHandlers.blockquote(node, _parent, context), unsupportedTagsStrategy),
+    html: (node, _parent, context) =>
+        processUnsupportedTags(defaultHandlers.html(node, _parent, context), unsupportedTagsStrategy),
+    table: (node, _parent, context) =>
+        processUnsupportedTags(gfmTableToMarkdown().handlers.table(node, _parent, context), unsupportedTagsStrategy),
+    thematicBreak: (_node, _parent, _context) =>
+        processUnsupportedTags('---', unsupportedTagsStrategy),
+});
+
+/**
+ * Creates options to be passed into a `remark-stringify` processor that tailor
+ * the output for Telegram Markdown.
+ *
+ * @param {Readonly<Record<string, { title: null | string, url: string }>>} definitions
+ * Record of `Definition`s in the Markdown document, keyed by identifier.
+ *
+ * @returns {import('remark-stringify').RemarkStringifyOptions}
+ */
+const createOptions = (definitions, unsupportedTagsStrategy) => ({
+    bullet: '*',
+    tightDefinitions: true,
+    handlers: createHandlers(definitions, unsupportedTagsStrategy),
+});
+
+export default createOptions;

package/lib/utils.mjs

@@ -0,0 +1,74 @@
+import { URL } from 'url';
+
+export function wrap(string, ...wrappers) {
+    return [
+        ...wrappers,
+        string,
+        ...wrappers.reverse(),
+    ].join('');
+}
+
+export function isURL(string) {
+    try {
+        return Boolean(new URL(string));
+    } catch (error) {
+        return false;
+    }
+}
+
+export function escapeSymbols(text, textType = 'text') {
+    if (!text) {
+        return text;
+    }
+    switch (textType) {
+        case 'code':
+            return text
+                .replace(/\\/g, '\\\\')
+                .replace(/`/g, '\\`')
+        case 'link':
+            return text
+                .replace(/\\/g, '\\\\')
+                .replace(/\(/g, '\\(')
+                .replace(/\)/g, '\\)')
+        case 'ignore_escaped':
+            return text.replace(/(\\.)|([_*\[\]()~`>#+\-=|{}.!])/g, (match, escaped, char) => {
+                if (escaped) {
+                    return escaped;
+                }
+                return '\\' + char;
+            });
+        default:
+            return text
+                .replace(/_/g, '\\_')
+                .replace(/\*/g, '\\*')
+                .replace(/\[/g, '\\[')
+                .replace(/]/g, '\\]')
+                .replace(/\(/g, '\\(')
+                .replace(/\)/g, '\\)')
+                .replace(/~/g, '\\~')
+                .replace(/`/g, '\\`')
+                .replace(/>/g, '\\>')
+                .replace(/#/g, '\\#')
+                .replace(/\+/g, '\\+')
+                .replace(/-/g, '\\-')
+                .replace(/=/g, '\\=')
+                .replace(/\|/g, '\\|')
+                .replace(/{/g, '\\{')
+                .replace(/}/g, '\\}')
+                .replace(/\./g, '\\.')
+                .replace(/!/g, '\\!');
+
+    }
+}
+
+export function processUnsupportedTags(content, strategy) {
+    switch (strategy) {
+        case 'escape':
+            return escapeSymbols(content, 'ignore_escaped');
+        case 'remove':
+            return '';
+        case 'keep':
+        default:
+            return content;
+    }
+}

package/package.json

@@ -1,70 +1,71 @@
-{
-	"name": "tellegram",
-	"version": "1.0.0",
-	"description": "Convert LLM-generated markdown into Telegram-specific markdown (MarkdownV2)",
-	"type": "module",
-	"main": "index.js",
-	"scripts": {
-		"test": "NODE_OPTIONS=--experimental-vm-modules npx jest --coverage",
-		"lint": "eslint",
-		"semantic-release": "semantic-release",
-		"prepare": "husky install",
-		"codecov": "codecov"
-	},
-	"files": [
-		"README.md",
-		"LICENSE",
-		"index.js",
-		"lib",
-		"types"
-	],
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/leask/tellegram.git"
-	},
-	"keywords": [
-		"telegram",
-		"markdown",
-		"telegramify",
-		"parser",
-		"remark",
-		"unified"
-	],
-	"types": "types/index.d.ts",
-	"author": "Leask Wong",
-	"license": "MIT",
-	"bugs": {
-		"url": "https://github.com/leask/tellegram/issues"
-	},
-	"homepage": "https://github.com/leask/tellegram#readme",
-	"dependencies": {
-		"mdast-util-gfm-table": "^0.1.6",
-		"mdast-util-to-markdown": "^0.6.2",
-		"remark-gfm": "^1.0.0",
-		"remark-parse": "^9.0.0",
-		"remark-remove-comments": "^0.2.0",
-		"remark-stringify": "^9.0.1",
-		"unified": "^9.0.0",
-		"unist-util-remove": "^2.0.1",
-		"unist-util-visit": "^2.0.3"
-	},
-	"devDependencies": {
-		"@commitlint/cli": "^12.1.1",
-		"@commitlint/config-conventional": "^12.1.1",
-		"codecov": "^3.8.3",
-		"eslint": "^7.24.0",
-		"husky": "^6.0.0",
-		"jest": "^29.3.1",
-		"lint-staged": "^10.5.4",
-		"prettier": "2.2.1",
-		"semantic-release": "^17.4.2"
-	},
-	"lint-staged": {
-		"*.{js,json,md}": [
-			"prettier --write",
-			"git add"
-		],
-		"*.{css,scss,less}": "stylelint --fix",
-		"*.js": "eslint --cache --fix"
-	}
-}
+{
+    "name": "tellegram",
+    "version": "1.1.3",
+    "description": "Convert LLM-generated markdown into Telegram-specific markdown (MarkdownV2)",
+    "type": "module",
+    "main": "index.mjs",
+    "scripts": {
+        "test": "NODE_OPTIONS='--experimental-vm-modules --no-deprecation' npx jest --coverage --verbose",
+        "lint": "eslint",
+        "semantic-release": "semantic-release",
+        "prepare": "husky install",
+        "codecov": "codecov"
+    },
+    "files": [
+        "README.md",
+        "LICENSE",
+        "index.mjs",
+        "lib",
+        "types"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/leask/tellegram.git"
+    },
+    "keywords": [
+        "tellegram",
+        "telegram",
+        "markdown",
+        "telegramify",
+        "parser",
+        "remark",
+        "unified"
+    ],
+    "types": "types/index.d.ts",
+    "author": "Leask Wong",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/leask/tellegram/issues"
+    },
+    "homepage": "https://github.com/leask/tellegram#readme",
+    "dependencies": {
+        "mdast-util-gfm-table": "^0.1.6",
+        "mdast-util-to-markdown": "^0.6.2",
+        "remark-gfm": "^1.0.0",
+        "remark-parse": "^9.0.0",
+        "remark-remove-comments": "^0.2.0",
+        "remark-stringify": "^9.0.1",
+        "unified": "^9.0.0",
+        "unist-util-remove": "^2.0.1",
+        "unist-util-visit": "^2.0.3"
+    },
+    "devDependencies": {
+        "@commitlint/cli": "^12.1.1",
+        "@commitlint/config-conventional": "^12.1.1",
+        "codecov": "^3.8.3",
+        "eslint": "^7.24.0",
+        "husky": "^6.0.0",
+        "jest": "^30.2.0",
+        "lint-staged": "^10.5.4",
+        "prettier": "2.2.1",
+        "semantic-release": "^17.4.2"
+    },
+    "lint-staged": {
+        "*.{js,json,md}": [
+            "prettier --write",
+            "git add"
+        ],
+        "*.{css,scss,less}": "stylelint --fix",
+        "*.js": "eslint --cache --fix"
+    }
+}

package/types/index.d.ts

@@ -1,13 +1,19 @@
-type UnsupportedTagsStrategy = 'escape' | 'remove' | 'keep'
-
-declare module 'tellegram' {
-
-  /**
-   * Converts markdown to Telegram's format.
-   * @param markdown The markdown to convert.
-   * @param unsupportedTagsStrategy The strategy to use for unsupported tags.
-   */
-  function convert(markdown: string, unsupportedTagsStrategy: UnsupportedTagsStrategy): string
-
-  export = convert
-}
+type UnsupportedTagsStrategy = 'escape' | 'remove' | 'keep'
+
+declare module 'tellegram' {
+  /**
+   * Converts markdown to Telegram's format.
+   * @param markdown The markdown to convert.
+   * @param unsupportedTagsStrategy The strategy to use for unsupported tags.
+   */
+  export function convert(markdown: string, unsupportedTagsStrategy?: UnsupportedTagsStrategy): string;
+
+  /**
+   * Paginates text (placeholder).
+   * @param text The text to paginate.
+   */
+  export function paginate(text: string): string;
+
+  const defaultExport: typeof convert;
+  export default defaultExport;
+}

package/index.js

@@ -1,2 +0,0 @@
-import convert from './lib/convert.js';
-export default convert;

package/lib/convert.js

@@ -1,25 +0,0 @@
-import gfm from 'remark-gfm';
-import parse from 'remark-parse';
-import stringify from 'remark-stringify';
-import removeComments from 'remark-remove-comments';
-import unified from 'unified';
-
-import { collectDefinitions, removeDefinitions } from './definitions.js';
-import createTelegramifyOptions from './telegramify.js';
-
-export default (markdown, unsupportedTagsStrategy) => {
-	const definitions = {};
-
-	const telegramifyOptions = createTelegramifyOptions(definitions, unsupportedTagsStrategy);
-
-	return unified()
-		.use(parse)
-		.use(gfm)
-		.use(removeComments)
-		.use(collectDefinitions, definitions)
-		.use(removeDefinitions)
-		.use(stringify, telegramifyOptions)
-		.processSync(markdown)
-		.toString()
-		.replace(/<!---->\n/gi, '');
-};

package/lib/telegramify.js

@@ -1,158 +0,0 @@
-import defaultHandlers from 'mdast-util-to-markdown/lib/handle/index.js';
-import phrasing from 'mdast-util-to-markdown/lib/util/container-phrasing.js';
-import {toMarkdown as gfmTableToMarkdown} from 'mdast-util-gfm-table';
-
-import {wrap, isURL, escapeSymbols, processUnsupportedTags} from './utils.js';
-
-/**
- * Creates custom `mdast-util-to-markdown` handlers that tailor the output for
- * Telegram Markdown.
- *
- * @param {Readonly<Record<string, { title: null | string, url: string }>>} definitions
- * Record of `Definition`s in the Markdown document, keyed by identifier.
- *
- * @returns {import('mdast-util-to-markdown').Handlers}
- */
-const createHandlers = (definitions, unsupportedTagsStrategy) => ({
-	heading: (node, _parent, context) => {
-		// make headers to be just *strong*
-		const marker = '*';
-
-		const exit = context.enter('heading');
-		const value = phrasing(node, context, {before: marker, after: marker});
-		exit();
-
-		return wrap(value, marker);
-	},
-
-	strong: (node, _parent, context) => {
-		const marker = '*';
-
-		const exit = context.enter('strong');
-		const value = phrasing(node, context, {before: marker, after: marker});
-		exit();
-
-		return wrap(value, marker);
-	},
-
-	delete(node, _parent, context) {
-		const marker = '~';
-
-		const exit = context.enter('delete');
-		const value = phrasing(node, context, {before: marker, after: marker});
-		exit();
-
-		return wrap(value, marker);
-	},
-
-	emphasis: (node, _parent, context) => {
-		const marker = '_';
-
-		const exit = context.enter('emphasis');
-		const value = phrasing(node, context, {before: marker, after: marker});
-		exit();
-
-		return wrap(value, marker);
-	},
-
-	list: (...args) => defaultHandlers.list(...args).replace(/^(\d+)./gm, '$1\\.'),
-
-	listItem: (...args) => defaultHandlers.listItem(...args).replace(/^\*/, '•'),
-
-	code(node, _parent, context) {
-		const exit = context.enter('code');
-		// delete language prefix for deprecated markdown formatters (old Bitbucket Editor)
-		const content = node.value.replace(/^#![a-z]+\n/, ''); // ```\n#!javascript\ncode block\n```
-		exit();
-
-		const language = node.lang || '';
-		return `\`\`\`${language}\n${escapeSymbols(content, 'code')}\n\`\`\``;
-	},
-
-	link: (node, _parent, context) => {
-		const exit = context.enter('link');
-		const text = phrasing(node, context, {before: '|', after: '>'}) || escapeSymbols(node.title);
-		const isUrlEncoded = decodeURI(node.url) !== node.url;
-		const url = isUrlEncoded ? node.url : encodeURI(node.url);
-		exit();
-
-		if (!isURL(url)) return escapeSymbols(text) || escapeSymbols(url);
-
-		return text
-			? `[${text}](${escapeSymbols(url, 'link')})`
-			: `[${escapeSymbols(url)}](${escapeSymbols(url, 'link')})`;
-	},
-
-	linkReference: (node, _parent, context) => {
-		const exit = context.enter('linkReference');
-		const definition = definitions[node.identifier];
-		const text = phrasing(node, context, {before: '|', after: '>'}) || (definition ? definition.title : null);
-		exit();
-
-		if (!definition || !isURL(definition.url)) return escapeSymbols(text);
-
-		return text
-			? `[${text}](${escapeSymbols(definition.url, 'link')})`
-			: `[${escapeSymbols(definition.url)}](${escapeSymbols(definition.url, 'link')})`;
-	},
-
-	image: (node, _parent, context) => {
-		const exit = context.enter('image');
-		const text = node.alt || node.title;
-		const url = node.url
-		exit();
-
-		if (!isURL(url)) return escapeSymbols(text) || escapeSymbols(url);
-
-		return text
-			? `[${escapeSymbols(text)}](${escapeSymbols(url, 'link')})`
-			: `[${escapeSymbols(url)}](${escapeSymbols(url, 'link')})`;
-	},
-
-	imageReference: (node, _parent, context) => {
-		const exit = context.enter('imageReference');
-		const definition = definitions[node.identifier];
-		const text = node.alt || (definition ? definition.title : null);
-		exit();
-
-		if (!definition || !isURL(definition.url)) return escapeSymbols(text);
-
-		return text
-			? `[${escapeSymbols(text)}](${escapeSymbols(definition.url, 'link')})`
-			: `[${escapeSymbols(definition.url)}](${escapeSymbols(definition.url, 'link')})`;
-	},
-
-	text: (node, _parent, context) => {
-		const exit = context.enter('text');
-		const text = node.value;
-		exit();
-
-		return escapeSymbols(text);
-	},
-
-	blockquote: (node, _parent, context) =>
-		processUnsupportedTags(defaultHandlers.blockquote(node, _parent, context), unsupportedTagsStrategy),
-	html: (node, _parent, context) =>
-		processUnsupportedTags(defaultHandlers.html(node, _parent, context), unsupportedTagsStrategy),
-	table: (node, _parent, context) =>
-		processUnsupportedTags(gfmTableToMarkdown().handlers.table(node, _parent, context), unsupportedTagsStrategy),
-	thematicBreak: (_node, _parent, _context) =>
-		processUnsupportedTags('---', unsupportedTagsStrategy),
-});
-
-/**
- * Creates options to be passed into a `remark-stringify` processor that tailor
- * the output for Telegram Markdown.
- *
- * @param {Readonly<Record<string, { title: null | string, url: string }>>} definitions
- * Record of `Definition`s in the Markdown document, keyed by identifier.
- *
- * @returns {import('remark-stringify').RemarkStringifyOptions}
- */
-const createOptions = (definitions, unsupportedTagsStrategy) => ({
-	bullet: '*',
-	tightDefinitions: true,
-	handlers: createHandlers(definitions, unsupportedTagsStrategy),
-});
-
-export default createOptions;

package/lib/utils.js

@@ -1,76 +0,0 @@
-import { URL } from 'url';
-
-export function wrap(string, ...wrappers) {
-	return [
-		...wrappers,
-		string,
-		...wrappers.reverse(),
-	].join('');
-}
-
-export function isURL(string) {
-	try {
-		return Boolean(new URL(string));
-	} catch (error) {
-		return false;
-	}
-}
-
-export function escapeSymbols(text, textType = 'text') {
-	if (!text) {
-		return text;
-	}
-	switch (textType) {
-		case 'code':
-			return text
-				.replace(/\\/g, '\\\\')
-				.replace(/`/g, '\\`')
-		case 'link':
-			return text
-				.replace(/\\/g, '\\\\')
-				.replace(/\(/g, '\\(')
-				.replace(/\)/g, '\\)')
-		case 'ignore_escaped':
-			return text.replace(/(\\.)|([_*\[\]()~`>#+\-=|{}.!])/g, (match, escaped, char) => {
-				if (escaped) {
-					return escaped;
-				}
-				return '\\' + char;
-			});
-		default:
-			return text
-				.replace(/_/g, '\\_')
-				.replace(/\*/g, '\\*')
-				.replace(/\[/g, '\\[')
-				.replace(/]/g, '\\]')
-				.replace(/\(/g, '\\(')
-				.replace(/\)/g, '\\)')
-				.replace(/~/g, '\\~')
-				.replace(/`/g, '\\`')
-				.replace(/>/g, '\\>')
-				.replace(/#/g, '\\#')
-				.replace(/\+/g, '\\+')
-				.replace(/-/g, '\\-')
-				.replace(/=/g, '\\=')
-				.replace(/\|/g, '\\|')
-				.replace(/{/g, '\\{')
-				.replace(/}/g, '\\}')
-				.replace(/\./g, '\\.')
-				.replace(/!/g, '\\!');
-
-	}
-}
-
-export function processUnsupportedTags(content, strategy) {
-	switch (strategy) {
-		case 'escape':
-			return escapeSymbols(content, 'ignore_escaped');
-		case 'remove':
-			return '';
-		case 'keep':
-		default:
-			return content;
-	}
-}
-
-