telegram-writer 0.0.0-stage → 1.0.0

package/build/index.cjs

@@ -0,0 +1,1132 @@
+'use strict';
+
+var diKit = require('di-kit');
+var readline = require('readline');
+var promises = require('fs/promises');
+var qrcodeTerminal = require('qrcode-terminal');
+var functoolsKit = require('functools-kit');
+var sharp = require('sharp');
+
+const { init, inject, provide } = diKit.createActivator("tg-writer");
+
+const baseServices$1 = {
+    authService: Symbol('authService'),
+    loggerService: Symbol('loggerService'),
+    markdownService: Symbol('markdownService'),
+    writerService: Symbol('writerService'),
+};
+const globalServices$1 = {
+    telegramGlobalService: Symbol('telegramGlobalService'),
+};
+const TYPES = {
+    ...baseServices$1,
+    ...globalServices$1,
+};
+
+const GLOBAL_CONFIG = {
+    CC_TELEGRAM_API_ID: 0,
+    CC_TELEGRAM_API_HASH: "",
+    /** Max characters of a plain text message. Telegram hard limit is 4096 */
+    CC_TELEGRAM_MESSAGE_LIMIT: 0,
+    /** Max characters of a photo caption. Telegram limit is 1024 (4096 for premium accounts) */
+    CC_TELEGRAM_CAPTION_LIMIT: 0,
+};
+Object.freeze({ ...GLOBAL_CONFIG });
+const getConfig = () => {
+    const config = {
+        CC_TELEGRAM_API_ID: parseInt(process.env.CC_TELEGRAM_API_ID) || 31861455,
+        CC_TELEGRAM_API_HASH: process.env.CC_TELEGRAM_API_HASH || "ca60446c67ce250ee4e789c730163449",
+        CC_TELEGRAM_MESSAGE_LIMIT: parseInt(process.env.CC_TELEGRAM_MESSAGE_LIMIT) || 4096,
+        CC_TELEGRAM_CAPTION_LIMIT: parseInt(process.env.CC_TELEGRAM_CAPTION_LIMIT) || 1024,
+    };
+    if (GLOBAL_CONFIG.CC_TELEGRAM_API_ID) {
+        config.CC_TELEGRAM_API_ID = GLOBAL_CONFIG.CC_TELEGRAM_API_ID;
+    }
+    if (GLOBAL_CONFIG.CC_TELEGRAM_API_HASH) {
+        config.CC_TELEGRAM_API_HASH = GLOBAL_CONFIG.CC_TELEGRAM_API_HASH;
+    }
+    if (GLOBAL_CONFIG.CC_TELEGRAM_MESSAGE_LIMIT) {
+        config.CC_TELEGRAM_MESSAGE_LIMIT = GLOBAL_CONFIG.CC_TELEGRAM_MESSAGE_LIMIT;
+    }
+    if (GLOBAL_CONFIG.CC_TELEGRAM_CAPTION_LIMIT) {
+        config.CC_TELEGRAM_CAPTION_LIMIT = GLOBAL_CONFIG.CC_TELEGRAM_CAPTION_LIMIT;
+    }
+    return config;
+};
+const setConfig = (config) => {
+    Object.assign(GLOBAL_CONFIG, config);
+};
+
+const HANDLE_SIGNIN_FN = async () => {
+    // Ленивый импорт: у gramjs нет exports-карты, подпути в ESM резолвятся
+    // только по полному пути с расширением
+    const { TelegramClient } = await import('telegram');
+    const { StringSession } = await import('telegram/sessions/index.js');
+    const { CC_TELEGRAM_API_ID, CC_TELEGRAM_API_HASH } = getConfig();
+    const stringSession = new StringSession("");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const client = new TelegramClient(stringSession, CC_TELEGRAM_API_ID, CC_TELEGRAM_API_HASH, {
+        connectionRetries: 5,
+        systemVersion: "Windows 10",
+        deviceModel: "Desktop",
+        appVersion: "1.0.0",
+    });
+    await client.connect();
+    await client.signInUserWithQrCode({ apiId: CC_TELEGRAM_API_ID, apiHash: CC_TELEGRAM_API_HASH }, {
+        qrCode: async ({ token }) => {
+            const url = `tg://login?token=${token.toString("base64url")}`;
+            console.clear();
+            console.log("Scan this QR code in Telegram app (Settings -> Devices -> Link Desktop Device):\n");
+            qrcodeTerminal.generate(url, { small: true });
+        },
+        password: async () => new Promise((resolve) => rl.question("Enter your 2FA password: ", resolve)),
+        onError: async (err) => {
+            console.error(err.message);
+            return false;
+        },
+    });
+    console.log("Connected!");
+    {
+        const sessionString = stringSession.save();
+        await promises.writeFile("./session.txt", sessionString, "utf-8");
+    }
+    console.log("Session saved to ./session.txt");
+    rl.close();
+};
+class AuthService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.signIn = async () => {
+            this.loggerService.log("authService signIn");
+            await HANDLE_SIGNIN_FN();
+        };
+    }
+}
+
+const NOOP_LOGGER = {
+    log() {
+    },
+    debug() {
+    },
+    info() {
+    },
+    warn() {
+    },
+};
+class LoggerService {
+    constructor() {
+        this._commonLogger = NOOP_LOGGER;
+        this.log = async (topic, ...args) => {
+            await this._commonLogger.log(topic, ...args);
+        };
+        this.debug = async (topic, ...args) => {
+            await this._commonLogger.debug(topic, ...args);
+        };
+        this.info = async (topic, ...args) => {
+            await this._commonLogger.info(topic, ...args);
+        };
+        this.warn = async (topic, ...args) => {
+            await this._commonLogger.warn(topic, ...args);
+        };
+        this.setLogger = (logger) => {
+            this._commonLogger = logger;
+        };
+    }
+}
+
+// Разделитель блоков в итоговом сообщении: пустая строка между абзацами
+const SEPARATOR = "\n\n";
+// Маркер ненумерованного списка и отступ вложенного уровня. Telegram сохраняет
+// пробелы как есть, так что вложенность видна без спецсимволов
+const BULLET = "• ";
+const LIST_INDENT = "    ";
+// Telegram принимает в ссылках только абсолютные URL этих схем; относительные
+// и javascript: ссылки разворачиваем до простого текста
+const ALLOWED_URL = /^(https?:\/\/|tg:\/\/|mailto:)/i;
+// Язык подсветки в ```lang — только безопасные символы, иначе атрибут class
+// можно было бы сломать кавычкой
+const LANGUAGE_PATTERN = /(?:^|\s)language-([\w+#.-]+)/;
+// Заголовки: в Telegram нет h1-h6, рендерим жирной строкой
+const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+// Блочные теги HTML: при встрече инлайн-поток переносится на новую строку
+const BLOCK_TAGS = new Set([
+    "p", "div", "section", "article", "header", "footer", "main", "aside", "nav",
+    "figure", "figcaption", "details", "summary", "address", "form", "fieldset",
+    "dl", "dt", "dd", "li", "center", "body", "html",
+]);
+// Содержимое этих тегов в тексте поста не нужно никогда
+const SKIP_TAGS = new Set([
+    "script", "style", "template", "head", "title", "meta", "link", "noscript",
+    "iframe", "object", "embed", "svg", "math", "canvas", "video", "audio",
+]);
+// Ленивые импорты: marked>=16 и htmlparser2>=11 собраны только как ESM.
+// Через await import они одинаково работают и из cjs-, и из esm-сборки.
+const getMarked = functoolsKit.singleshot(async () => {
+    const { Marked } = await import('marked');
+    // breaks: одиночный перенос строки становится <br>. В чате перенос ожидают
+    // буквально, а не как «мягкий» пробел по спецификации CommonMark
+    return new Marked({ gfm: true, breaks: true });
+});
+const getParseDocument = functoolsKit.singleshot(async () => {
+    const { parseDocument } = await import('htmlparser2');
+    return parseDocument;
+});
+const isElement = (node) => node.type === "tag" || node.type === "script" || node.type === "style";
+const isText = (node) => node.type === "text";
+const tagName = (node) => (node.name || "").toLowerCase();
+const escapeHtml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const escapeAttr = (text) => escapeHtml(text).replace(/"/g, "&quot;");
+const charCount = (text) => Array.from(text).length;
+const textContent = (node) => {
+    if (isText(node)) {
+        return node.data || "";
+    }
+    if (isElement(node) && SKIP_TAGS.has(tagName(node))) {
+        return "";
+    }
+    return (node.children || []).map(textContent).join("");
+};
+const sanitizeUrl = (url) => {
+    if (!url) {
+        return undefined;
+    }
+    const trimmed = url.trim();
+    return ALLOWED_URL.test(trimmed) ? trimmed : undefined;
+};
+const sameStyle = (a, b) => !!a.bold === !!b.bold &&
+    !!a.italic === !!b.italic &&
+    !!a.underline === !!b.underline &&
+    !!a.strike === !!b.strike &&
+    !!a.spoiler === !!b.spoiler &&
+    !!a.code === !!b.code &&
+    (a.href || "") === (b.href || "");
+const runsLength = (runs) => runs.reduce((acc, run) => acc + run.text.length, 0);
+/**
+ * Убирает пустые отрезки и пробельные края списка отрезков, не трогая
+ * внутренние переносы (отступы вложенных списков начинаются с пробелов).
+ */
+const trimEdges = (runs) => {
+    const result = runs.filter((run) => run.text);
+    while (result.length && !result[0].text.trim()) {
+        result.shift();
+    }
+    if (result.length) {
+        result[0] = { ...result[0], text: result[0].text.replace(/^\s+/, "") };
+    }
+    while (result.length && !result[result.length - 1].text.trim()) {
+        result.pop();
+    }
+    if (result.length) {
+        const last = result.length - 1;
+        result[last] = { ...result[last], text: result[last].text.replace(/\s+$/, "") };
+    }
+    return result;
+};
+/**
+ * Склеивает соседние отрезки с одинаковым стилем, убирает хвостовые пробелы
+ * перед переносами, схлопывает три и более переносов до пустой строки и
+ * обрезает края. Результат — канонический вид блока: один тег на стиль,
+ * без вложенных одноимённых тегов, которые парсер gramjs не различает.
+ */
+const normalizeRuns = (runs) => {
+    const merged = [];
+    for (const run of runs) {
+        if (!run.text) {
+            continue;
+        }
+        const prev = merged[merged.length - 1];
+        if (prev && sameStyle(prev, run)) {
+            prev.text += run.text;
+            continue;
+        }
+        merged.push({ ...run });
+    }
+    let newlines = 0;
+    for (const run of merged) {
+        let out = "";
+        for (const ch of run.text.replace(/[ \t]+\n/g, "\n")) {
+            if (ch === "\n") {
+                newlines += 1;
+                if (newlines <= 2) {
+                    out += ch;
+                }
+                continue;
+            }
+            newlines = 0;
+            out += ch;
+        }
+        run.text = out;
+    }
+    return trimEdges(merged);
+};
+const isEmptyBlock = (block) => block.type === "pre" ? !block.text.trim() : block.runs.length === 0;
+/**
+ * Накопитель блоков. Инлайновые узлы верхнего уровня (сырой HTML вроде
+ * <b>x</b> вне абзаца) собираются в неявный абзац, который закрывается
+ * ближайшим блочным элементом.
+ */
+class BlockCollector {
+    constructor() {
+        this.blocks = [];
+        this.pending = null;
+    }
+    get hasPending() {
+        return this.pending !== null;
+    }
+    inline(runs) {
+        if (!this.pending) {
+            this.pending = [];
+        }
+        this.pending.push(...runs);
+    }
+    flush() {
+        if (!this.pending) {
+            return;
+        }
+        const runs = normalizeRuns(this.pending);
+        this.pending = null;
+        if (runs.length) {
+            this.blocks.push({ type: "paragraph", runs });
+        }
+    }
+    push(block) {
+        this.flush();
+        if (!isEmptyBlock(block)) {
+            this.blocks.push(block);
+        }
+    }
+}
+/**
+ * Собирает инлайновое содержимое узлов в отрезки текста. Блочные элементы,
+ * встреченные внутри инлайна (например <p> в <li>), становятся переносами строк.
+ */
+const collectInline = (nodes, style) => {
+    const out = [];
+    const text = (value, override = style) => {
+        if (value) {
+            out.push({ ...override, text: value });
+        }
+    };
+    // Гарантирует, что дальнейший текст начнётся с новой строки, но не
+    // добавляет перенос в самое начало и не дублирует уже стоящий
+    const newline = () => {
+        const tail = out.map((run) => run.text).join("").replace(/[ \t]+$/, "");
+        if (!tail.trim() || tail.endsWith("\n")) {
+            return;
+        }
+        out.push({ text: "\n" });
+    };
+    for (const node of nodes) {
+        if (isText(node)) {
+            text(node.data || "");
+            continue;
+        }
+        if (!isElement(node)) {
+            continue;
+        }
+        const name = tagName(node);
+        const children = node.children || [];
+        const attribs = node.attribs || {};
+        if (SKIP_TAGS.has(name)) {
+            continue;
+        }
+        switch (name) {
+            case "br":
+                out.push({ text: "\n" });
+                break;
+            case "strong":
+            case "b":
+                out.push(...collectInline(children, { ...style, bold: true }));
+                break;
+            case "em":
+            case "i":
+                out.push(...collectInline(children, { ...style, italic: true }));
+                break;
+            case "u":
+            case "ins":
+                out.push(...collectInline(children, { ...style, underline: true }));
+                break;
+            case "s":
+            case "del":
+            case "strike":
+                out.push(...collectInline(children, { ...style, strike: true }));
+                break;
+            case "code":
+            case "kbd":
+            case "samp":
+            case "tt":
+                out.push(...collectInline(children, { ...style, code: true }));
+                break;
+            case "spoiler":
+            case "tg-spoiler":
+                out.push(...collectInline(children, { ...style, spoiler: true }));
+                break;
+            case "span": {
+                const classes = (attribs.class || "").split(/\s+/);
+                const spoiler = classes.includes("tg-spoiler");
+                out.push(...collectInline(children, spoiler ? { ...style, spoiler: true } : style));
+                break;
+            }
+            case "a": {
+                const href = sanitizeUrl(attribs.href);
+                out.push(...collectInline(children, href ? { ...style, href } : style));
+                break;
+            }
+            case "img": {
+                // Картинку внутрь текста Telegram не вставит: оставляем подпись
+                // ссылкой на источник, чтобы читатель мог её открыть
+                const src = sanitizeUrl(attribs.src);
+                const alt = (attribs.alt || "").trim();
+                const label = alt || src || "";
+                text(label, src ? { ...style, href: src } : style);
+                break;
+            }
+            case "input":
+                if ((attribs.type || "").toLowerCase() === "checkbox") {
+                    text("checked" in attribs ? "☑" : "☐");
+                }
+                break;
+            case "ul":
+            case "ol":
+                newline();
+                out.push(...collectList(node, style, 0));
+                newline();
+                break;
+            case "pre":
+                newline();
+                text(collectPre(node).text, { ...style, code: true });
+                newline();
+                break;
+            case "table":
+                newline();
+                text(renderTable(node), { ...style, code: true });
+                newline();
+                break;
+            case "hr":
+                newline();
+                break;
+            default:
+                if (HEADING_TAGS.has(name)) {
+                    newline();
+                    out.push(...collectInline(children, { ...style, bold: true }));
+                    newline();
+                    break;
+                }
+                if (BLOCK_TAGS.has(name) || name === "blockquote") {
+                    newline();
+                    out.push(...collectInline(children, style));
+                    newline();
+                    break;
+                }
+                // Неизвестный инлайн-тег: тег выбрасываем, текст оставляем
+                out.push(...collectInline(children, style));
+        }
+    }
+    return out;
+};
+/**
+ * Список в строки с маркерами. Вложенные списки получают отступ по уровню,
+ * нумерация учитывает атрибут start.
+ */
+const collectList = (list, style, depth) => {
+    const ordered = tagName(list) === "ol";
+    let index = parseInt((list.attribs || {}).start || "1", 10) || 1;
+    const out = [];
+    const items = (list.children || []).filter((node) => isElement(node) && tagName(node) === "li");
+    for (const item of items) {
+        if (out.length) {
+            out.push({ text: "\n" });
+        }
+        const marker = ordered ? `${index}. ` : BULLET;
+        index += 1;
+        out.push({ text: LIST_INDENT.repeat(depth) + marker });
+        const content = [];
+        let segment = [];
+        const flushSegment = () => {
+            if (segment.length) {
+                content.push(...collectInline(segment, style));
+                segment = [];
+            }
+        };
+        for (const child of item.children || []) {
+            const name = isElement(child) ? tagName(child) : "";
+            if (name === "ul" || name === "ol") {
+                flushSegment();
+                content.push({ text: "\n" });
+                content.push(...collectList(child, style, depth + 1));
+                continue;
+            }
+            segment.push(child);
+        }
+        flushSegment();
+        out.push(...trimEdges(content));
+    }
+    return out;
+};
+const collectPre = (node) => {
+    const findCode = (current) => {
+        for (const child of current.children || []) {
+            if (!isElement(child)) {
+                continue;
+            }
+            if (tagName(child) === "code") {
+                return child;
+            }
+            const nested = findCode(child);
+            if (nested) {
+                return nested;
+            }
+        }
+        return null;
+    };
+    const code = findCode(node);
+    const match = LANGUAGE_PATTERN.exec((code && code.attribs && code.attribs.class) || "");
+    return {
+        type: "pre",
+        text: textContent(node).replace(/\n$/, ""),
+        language: match ? match[1] : "",
+    };
+};
+/**
+ * Таблицу Telegram не отобразит, поэтому выравниваем колонки пробелами и
+ * отдаём моноширинным блоком: в <pre> ширина символов одинаковая.
+ */
+const renderTable = (table) => {
+    const rows = [];
+    let headerRows = 0;
+    const walk = (node, inHead) => {
+        for (const child of node.children || []) {
+            if (!isElement(child)) {
+                continue;
+            }
+            const name = tagName(child);
+            if (name === "tr") {
+                const cells = (child.children || []).filter((cell) => isElement(cell) && (tagName(cell) === "td" || tagName(cell) === "th"));
+                if (!cells.length) {
+                    continue;
+                }
+                rows.push(cells.map((cell) => textContent(cell).replace(/\s+/g, " ").trim()));
+                const isHeader = inHead || cells.every((cell) => tagName(cell) === "th");
+                if (isHeader && headerRows === rows.length - 1) {
+                    headerRows = rows.length;
+                }
+                continue;
+            }
+            if (name === "thead" || name === "tbody" || name === "tfoot") {
+                walk(child, name === "thead");
+            }
+        }
+    };
+    walk(table, false);
+    if (!rows.length) {
+        return "";
+    }
+    const columns = Math.max(...rows.map((row) => row.length));
+    const widths = Array.from({ length: columns }, (_, i) => Math.max(...rows.map((row) => charCount(row[i] || ""))));
+    const pad = (value, width) => value + " ".repeat(Math.max(0, width - charCount(value)));
+    const lines = [];
+    rows.forEach((row, i) => {
+        lines.push(widths.map((width, j) => pad(row[j] || "", width)).join(" | ").replace(/\s+$/, ""));
+        if (i + 1 === headerRows) {
+            lines.push(widths.map((width) => "-".repeat(width)).join("-+-"));
+        }
+    });
+    return lines.join("\n");
+};
+const paragraph = (runs) => ({
+    type: "paragraph",
+    runs: normalizeRuns(runs),
+});
+/**
+ * Цитата: вложенные блоки сплющиваются в один, потому что Telegram не
+ * допускает blockquote внутри blockquote; код внутри цитаты становится
+ * инлайновым <code>, так как <pre> в цитате тоже запрещён.
+ */
+const collectBlockquote = (children, style, expandable) => {
+    const inner = new BlockCollector();
+    collectBlocks(children, inner, style);
+    inner.flush();
+    const runs = [];
+    for (const block of inner.blocks) {
+        if (runs.length) {
+            runs.push({ text: "\n" });
+        }
+        if (block.type === "pre") {
+            runs.push({ text: block.text, code: true });
+            continue;
+        }
+        runs.push(...block.runs);
+    }
+    return { type: "blockquote", runs: normalizeRuns(runs), expandable };
+};
+const collectBlocks = (nodes, collector, style) => {
+    for (const node of nodes) {
+        if (isText(node)) {
+            const data = node.data || "";
+            if (data.trim()) {
+                collector.inline([{ ...style, text: data }]);
+            }
+            else if (collector.hasPending) {
+                // Пробел между инлайновыми соседями значим, между блоками — нет
+                collector.inline([{ text: data }]);
+            }
+            continue;
+        }
+        if (!isElement(node)) {
+            continue;
+        }
+        const name = tagName(node);
+        const children = node.children || [];
+        const attribs = node.attribs || {};
+        if (SKIP_TAGS.has(name)) {
+            continue;
+        }
+        if (HEADING_TAGS.has(name)) {
+            collector.push(paragraph(collectInline(children, { ...style, bold: true })));
+            continue;
+        }
+        switch (name) {
+            case "p":
+                collector.push(paragraph(collectInline(children, style)));
+                break;
+            case "ul":
+            case "ol":
+                collector.push(paragraph(collectList(node, style, 0)));
+                break;
+            case "blockquote":
+                collector.push(collectBlockquote(children, style, "expandable" in attribs));
+                break;
+            case "pre":
+                collector.push(collectPre(node));
+                break;
+            case "table":
+                collector.push({ type: "pre", text: renderTable(node), language: "" });
+                break;
+            case "hr":
+                // Горизонтальной линии в Telegram нет: оставляем только границу абзацев
+                collector.flush();
+                break;
+            case "br":
+                collector.inline([{ text: "\n" }]);
+                break;
+            default:
+                if (BLOCK_TAGS.has(name)) {
+                    collector.flush();
+                    collectBlocks(children, collector, style);
+                    collector.flush();
+                    break;
+                }
+                collector.inline(collectInline([node], style));
+        }
+    }
+};
+/**
+ * Один отрезок в HTML. Порядок обёрток фиксирован (a > b > i > u > s > spoiler),
+ * code исключает остальные стили: Telegram не допускает другие сущности
+ * внутри code и code внутри других сущностей.
+ */
+const runToHtml = (run) => {
+    const text = escapeHtml(run.text);
+    if (run.code) {
+        return `<code>${text}</code>`;
+    }
+    if (!run.text.trim()) {
+        return text;
+    }
+    let html = text;
+    if (run.spoiler) {
+        html = `<spoiler>${html}</spoiler>`;
+    }
+    if (run.strike) {
+        html = `<s>${html}</s>`;
+    }
+    if (run.underline) {
+        html = `<u>${html}</u>`;
+    }
+    if (run.italic) {
+        html = `<i>${html}</i>`;
+    }
+    if (run.bold) {
+        html = `<b>${html}</b>`;
+    }
+    if (run.href) {
+        html = `<a href="${escapeAttr(run.href)}">${html}</a>`;
+    }
+    return html;
+};
+const blockToHtml = (block) => {
+    if (block.type === "pre") {
+        const text = escapeHtml(block.text);
+        if (block.language) {
+            return `<pre><code class="language-${escapeAttr(block.language)}">${text}</code></pre>`;
+        }
+        return `<pre>${text}</pre>`;
+    }
+    const html = block.runs.map(runToHtml).join("");
+    if (block.type === "blockquote") {
+        return block.expandable
+            ? `<blockquote expandable>${html}</blockquote>`
+            : `<blockquote>${html}</blockquote>`;
+    }
+    return html;
+};
+const blocksToHtml = (blocks) => blocks.map(blockToHtml).join(SEPARATOR);
+// Длина блока в символах видимого текста: именно её Telegram сравнивает с
+// лимитом сообщения, теги в длину не входят
+const blockLength = (block) => block.type === "pre" ? block.text.length : runsLength(block.runs);
+/**
+ * Точка разреза текста в пределах limit: предпочтительно по переносу строки,
+ * затем по пробелу, но не раньше половины лимита, чтобы не плодить огрызки.
+ */
+const findBreak = (text, limit) => {
+    const slice = text.slice(0, limit);
+    const minimum = Math.floor(limit / 2);
+    const newline = slice.lastIndexOf("\n");
+    if (newline >= minimum) {
+        return newline + 1;
+    }
+    const space = slice.lastIndexOf(" ");
+    if (space >= minimum) {
+        return space + 1;
+    }
+    return limit;
+};
+const splitRuns = (runs, limit) => {
+    const pieces = [];
+    let current = [];
+    let length = 0;
+    const queue = [...runs];
+    while (queue.length) {
+        const run = queue.shift();
+        const room = limit - length;
+        if (run.text.length <= room) {
+            current.push(run);
+            length += run.text.length;
+            continue;
+        }
+        // Места почти не осталось: не режем отрезок ради пары символов, а
+        // начинаем новый кусок целиком с него
+        if (current.length && room < Math.floor(limit / 4)) {
+            pieces.push(current);
+            current = [];
+            length = 0;
+            queue.unshift(run);
+            continue;
+        }
+        const cut = findBreak(run.text, room);
+        current.push({ ...run, text: run.text.slice(0, cut) });
+        pieces.push(current);
+        current = [];
+        length = 0;
+        queue.unshift({ ...run, text: run.text.slice(cut) });
+    }
+    if (current.length) {
+        pieces.push(current);
+    }
+    return pieces;
+};
+const splitBlock = (block, limit) => {
+    if (blockLength(block) <= limit) {
+        return [block];
+    }
+    if (block.type === "pre") {
+        const pieces = [];
+        let rest = block.text;
+        while (rest.length > limit) {
+            const cut = findBreak(rest, limit);
+            pieces.push({ ...block, text: rest.slice(0, cut).replace(/\n$/, "") });
+            rest = rest.slice(cut);
+        }
+        if (rest.trim()) {
+            pieces.push({ ...block, text: rest });
+        }
+        return pieces;
+    }
+    return splitRuns(block.runs, limit)
+        .map((runs) => ({ ...block, runs: normalizeRuns(runs) }))
+        .filter((piece) => !isEmptyBlock(piece));
+};
+/**
+ * Раскладывает блоки по сообщениям не длиннее limit символов видимого текста.
+ * Блок, не влезающий целиком, режется по отрезкам, так что ни один тег не
+ * оказывается разорванным между сообщениями.
+ */
+const splitBlocks = (blocks, limit) => {
+    const safeLimit = Math.max(1, Math.floor(limit));
+    const chunks = [];
+    let current = [];
+    let length = 0;
+    for (const block of blocks) {
+        for (const piece of splitBlock(block, safeLimit)) {
+            const size = blockLength(piece);
+            if (current.length && length + SEPARATOR.length + size > safeLimit) {
+                chunks.push(current);
+                current = [];
+                length = 0;
+            }
+            current.push(piece);
+            length += (current.length > 1 ? SEPARATOR.length : 0) + size;
+        }
+    }
+    if (current.length) {
+        chunks.push(current);
+    }
+    return chunks;
+};
+class MarkdownService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Markdown в «сырой» HTML от marked, ещё со всеми тегами (p, ul, h1...).
+         */
+        this.renderHtml = async (markdown) => {
+            const marked = await getMarked();
+            return String(await marked.parse(markdown || ""));
+        };
+        /**
+         * Любой HTML в блоки: остаётся только то, что Telegram умеет показать.
+         */
+        this.htmlToBlocks = async (html) => {
+            const parseDocument = await getParseDocument();
+            const document = parseDocument(html || "");
+            const collector = new BlockCollector();
+            collectBlocks(document.children, collector, {});
+            collector.flush();
+            return collector.blocks;
+        };
+        this.markdownToBlocks = async (markdown) => {
+            return await this.htmlToBlocks(await this.renderHtml(markdown));
+        };
+        this.blocksToHtml = (blocks) => {
+            return blocksToHtml(blocks);
+        };
+        /**
+         * Markdown в HTML только с тегами, которые принимает Telegram
+         * (b, i, u, s, spoiler, code, pre, blockquote, a).
+         */
+        this.markdownToHtml = async (markdown) => {
+            this.loggerService.log("markdownService markdownToHtml", {
+                length: (markdown || "").length,
+            });
+            return blocksToHtml(await this.markdownToBlocks(markdown));
+        };
+        /**
+         * Markdown в список HTML-сообщений, каждое не длиннее limit символов
+         * видимого текста. Пустой Markdown даёт пустой список.
+         */
+        this.markdownToChunks = async (markdown, limit) => {
+            this.loggerService.log("markdownService markdownToChunks", {
+                length: (markdown || "").length,
+                limit,
+            });
+            const blocks = await this.markdownToBlocks(markdown);
+            return splitBlocks(blocks, limit)
+                .map(blocksToHtml)
+                .filter((chunk) => chunk.trim());
+        };
+    }
+}
+
+/**
+ * Перенаправляет внутренние логи gramjs (TelegramClient) в lib.loggerService
+ * вместо stdout. По умолчанию LoggerService содержит noop-логгер, так что
+ * клиент молчит, пока потребитель не вызовет setLogger.
+ *
+ * Модуль telegram/extensions/Logger не имеет exports-карты, в ESM он
+ * резолвится только по полному пути с расширением, поэтому грузим его
+ * лениво через await import.
+ *
+ * Вместо class extends — Reflect.construct с переопределением log на
+ * инстансе: анонимный класс с приватными полями Logger не попадает в
+ * публичный тип фабрики, иначе declaration emit падает с TS4094.
+ */
+const createTelegramLogger = functoolsKit.singleshot(async () => {
+    const { Logger, LogLevel } = await import('telegram/extensions/Logger.js');
+    const logger = Reflect.construct(Logger, [LogLevel.INFO]);
+    logger.log = (level, message, _color) => {
+        if (level === LogLevel.ERROR || level === LogLevel.WARN) {
+            lib.loggerService.warn(`telegram ${level}`, message);
+            return;
+        }
+        if (level === LogLevel.DEBUG) {
+            lib.loggerService.debug(`telegram ${level}`, message);
+            return;
+        }
+        lib.loggerService.info(`telegram ${level}`, message);
+    };
+    return logger;
+});
+
+const getTelegram = functoolsKit.singleshot(async () => {
+    try {
+        // Ленивый импорт: у gramjs нет exports-карты, подпути в ESM резолвятся
+        // только по полному пути с расширением
+        const { TelegramClient } = await import('telegram');
+        const { StringSession } = await import('telegram/sessions/index.js');
+        lib.loggerService.log("getTelegram connect");
+        const { CC_TELEGRAM_API_ID, CC_TELEGRAM_API_HASH } = getConfig();
+        const session = await promises.readFile("./session.txt", "utf-8");
+        const stringSession = new StringSession(session);
+        const client = new TelegramClient(stringSession, CC_TELEGRAM_API_ID, CC_TELEGRAM_API_HASH, {
+            connectionRetries: 5,
+            systemVersion: "Windows 10",
+            deviceModel: "Desktop",
+            appVersion: "1.0.0",
+            baseLogger: await createTelegramLogger(),
+        });
+        {
+            await client.connect();
+            await client.getMe();
+        }
+        return client;
+    }
+    catch (error) {
+        lib.loggerService.log(`getTelegram failed: no session found. Please run 'require("telegram-writer").signIn()' to create a session.`, error);
+        throw error;
+    }
+});
+
+// Длинная сторона фото: 2560px — самый крупный размер, который Telegram
+// хранит для фото сам; всё, что больше, сервер ужмёт, трафик уйдёт зря.
+// Заодно гарантируется лимит фото «ширина + высота <= 10000»
+const PHOTO_MAX_SIDE = 2560;
+// Качество JPEG. Сервер Telegram пережимает фото повторно, выше 85 разницы
+// на выходе нет, а вес растёт
+const PHOTO_JPEG_QUALITY = 85;
+// Telegram принимает не больше 10 медиа в одном альбоме
+const ALBUM_MAX_FILES = 10;
+// Ограничение одновременной обработки фото, чтобы не получить OOM на слабом железе
+const MAX_EXEC = 5;
+// Даем задержку чтобы кластер пришел в норму
+const EXEC_DELAY = 100;
+// Base64 (в том виде, как его отдаёт telegram-reader) либо data-URL либо байты
+const toBuffer = (photo) => {
+    if (Buffer.isBuffer(photo)) {
+        return photo;
+    }
+    const base64 = photo.replace(/^data:[^,]*;base64,/, "").replace(/\s+/g, "");
+    return Buffer.from(base64, "base64");
+};
+const chunkArray = (items, size) => {
+    const out = [];
+    for (let i = 0; i < items.length; i += size) {
+        out.push(items.slice(i, i + size));
+    }
+    return out;
+};
+const toWriterMessage = (chat, message) => ({
+    id: message.id,
+    chat,
+    date: new Date(message.date * 1000),
+});
+/**
+ * Приводит фото к виду, который Telegram точно примет как фото: поворот по
+ * EXIF, длинная сторона не больше PHOTO_MAX_SIDE, JPEG.
+ *
+ * Расширение .jpg в имени CustomFile — единственный признак, по которому
+ * gramjs отправит буфер как фото, а не как документ. Если sharp не смог
+ * прочитать данные, отправляем как есть: пусть сервер решит, фото это или нет.
+ *
+ * @param photo - base64, data-URL или Buffer с изображением
+ * @param index - Порядковый номер в посте, идёт в имя файла
+ * @returns CustomFile для client.sendFile
+ */
+const PREPARE_PHOTO_FN = functoolsKit.execpool(async (self, photo, index) => {
+    // Ленивый импорт: у gramjs нет exports-карты, подпути в ESM резолвятся
+    // только по полному пути с расширением
+    const { CustomFile } = await import('telegram/client/uploads.js');
+    const source = toBuffer(photo);
+    let data = source;
+    try {
+        data = await sharp(source)
+            .rotate()
+            .resize({
+            width: PHOTO_MAX_SIDE,
+            height: PHOTO_MAX_SIDE,
+            fit: "inside",
+            withoutEnlargement: true,
+        })
+            .jpeg({ quality: PHOTO_JPEG_QUALITY })
+            .toBuffer();
+    }
+    catch (error) {
+        self.loggerService.warn(`writerService photo normalize failed index=${index}, using original`, error);
+    }
+    return new CustomFile(`photo_${index + 1}.jpg`, data.length, "", data);
+}, {
+    maxExec: MAX_EXEC,
+    delay: EXEC_DELAY,
+});
+class WriterService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.markdownService = inject(TYPES.markdownService);
+        this.sendMessage = async (dto) => {
+            this.loggerService.log("writerService sendMessage", {
+                chat: dto.chat,
+                length: (dto.content || "").length,
+                photos: (dto.photos || []).length,
+            });
+            const client = await getTelegram();
+            const { CC_TELEGRAM_MESSAGE_LIMIT, CC_TELEGRAM_CAPTION_LIMIT } = getConfig();
+            const photos = dto.photos || [];
+            const silent = !!dto.silent;
+            const linkPreview = !!dto.linkPreview;
+            const sent = [];
+            const sendText = async (limit) => {
+                const chunks = await this.markdownService.markdownToChunks(dto.content, limit);
+                for (const chunk of chunks) {
+                    const message = await client.sendMessage(dto.chat, {
+                        message: chunk,
+                        parseMode: "html",
+                        silent,
+                        linkPreview,
+                        // Отвечаем только первым сообщением: остальные идут продолжением
+                        replyTo: sent.length ? undefined : dto.replyTo,
+                    });
+                    sent.push(message);
+                }
+            };
+            if (!photos.length) {
+                await sendText(CC_TELEGRAM_MESSAGE_LIMIT);
+                if (!sent.length) {
+                    this.loggerService.warn("writerService sendMessage nothing to send: empty content and no photos");
+                }
+                return sent.map((message) => toWriterMessage(dto.chat, message));
+            }
+            const files = await Promise.all(photos.map((photo, index) => PREPARE_PHOTO_FN(this, photo, index)));
+            // Текст идёт подписью к первому альбому, если влезает в лимит подписи.
+            // Иначе сначала уходят фото без подписи, затем текст отдельными сообщениями
+            const captionChunks = await this.markdownService.markdownToChunks(dto.content, CC_TELEGRAM_CAPTION_LIMIT);
+            const fitsCaption = captionChunks.length <= 1;
+            const albums = chunkArray(files, ALBUM_MAX_FILES);
+            for (const [albumIndex, album] of albums.entries()) {
+                const caption = albumIndex === 0 && fitsCaption ? captionChunks[0] || "" : "";
+                const result = (await client.sendFile(dto.chat, {
+                    file: album.length === 1 ? album[0] : album,
+                    caption: album.length === 1 ? caption : [caption, ...album.slice(1).map(() => "")],
+                    parseMode: "html",
+                    silent,
+                    replyTo: albumIndex === 0 ? dto.replyTo : undefined,
+                }));
+                sent.push(...(Array.isArray(result) ? result : [result]).filter(Boolean));
+            }
+            if (!fitsCaption) {
+                await sendText(CC_TELEGRAM_MESSAGE_LIMIT);
+            }
+            return sent.map((message) => toWriterMessage(dto.chat, message));
+        };
+    }
+}
+
+class TelegramGlobalService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.authService = inject(TYPES.authService);
+        this.writerService = inject(TYPES.writerService);
+        this.signIn = async () => {
+            this.loggerService.log("telegramGlobalService signIn");
+            await this.authService.signIn();
+        };
+        this.sendMessage = async (dto) => {
+            this.loggerService.log("telegramGlobalService sendMessage", {
+                chat: dto.chat,
+                length: (dto.content || "").length,
+                photos: (dto.photos || []).length,
+            });
+            return await this.writerService.sendMessage(dto);
+        };
+    }
+}
+
+{
+    provide(TYPES.authService, () => new AuthService());
+    provide(TYPES.loggerService, () => new LoggerService());
+    provide(TYPES.markdownService, () => new MarkdownService());
+    provide(TYPES.writerService, () => new WriterService());
+}
+{
+    provide(TYPES.telegramGlobalService, () => new TelegramGlobalService());
+}
+
+const baseServices = {
+    authService: inject(TYPES.authService),
+    loggerService: inject(TYPES.loggerService),
+    markdownService: inject(TYPES.markdownService),
+    writerService: inject(TYPES.writerService),
+};
+const globalServices = {
+    telegramGlobalService: inject(TYPES.telegramGlobalService),
+};
+const lib = {
+    ...baseServices,
+    ...globalServices,
+};
+init();
+
+/**
+ * Signs the client in to Telegram, establishing an authorized MTProto session.
+ *
+ * Delegates to the auth service, which drives the interactive authentication
+ * flow (QR code, then the 2FA password if enabled) and persists the resulting
+ * session to `./session.txt` so that subsequent {@link sendMessage} calls can
+ * reuse it without re-authenticating.
+ *
+ * Must be called once before {@link sendMessage} when no saved session exists.
+ *
+ * @returns Promise that resolves once the session is authorized
+ */
+async function signIn() {
+    lib.loggerService.log("functions.signIn");
+    return await lib.telegramGlobalService.signIn();
+}
+
+/**
+ * Publishes a Markdown post, optionally with photos, to a Telegram chat or channel.
+ *
+ * The Markdown is rendered to HTML, then reduced to the tags Telegram accepts
+ * (`b`, `i`, `u`, `s`, `spoiler`, `code`, `pre`, `blockquote`, `a`); block
+ * structure that Telegram cannot display is flattened into text (headings become
+ * bold lines, lists become bullet lines, tables become monospace blocks, images
+ * become links). The conversion happens inside; raw Markdown never reaches Telegram.
+ *
+ * Delivery rules:
+ * - Without photos the text is sent as one or more messages, each within the
+ *   message limit (`CC_TELEGRAM_MESSAGE_LIMIT`, 4096 by default). A long post is
+ *   split between paragraphs, or inside a paragraph at a line/word boundary;
+ *   formatting never breaks across messages.
+ * - With photos the photos are sent first as albums of up to 10 items. The text
+ *   becomes the caption of the first album when it fits the caption limit
+ *   (`CC_TELEGRAM_CAPTION_LIMIT`, 1024 by default); otherwise the albums go
+ *   without a caption and the text follows as separate messages.
+ * - Photos are accepted as base64 strings (the format `telegram-reader` returns),
+ *   data-URLs or Buffers. Each is rotated by EXIF, downsized to at most 2560px on
+ *   the long side and re-encoded as JPEG so Telegram treats it as a photo.
+ *
+ * @param dto - Send parameters
+ * @param dto.chat - Chat username (`"channel"`, `"@channel"`), numeric id as a string, or `"me"`
+ * @param dto.content - Post body in Markdown (GFM; single newlines are line breaks)
+ * @param dto.photos - Photos to attach: base64, data-URL or Buffer each
+ * @param dto.silent - Send without notifying the chat members
+ * @param dto.replyTo - Id of the message to reply to (applied to the first sent message)
+ * @param dto.linkPreview - Show a link preview for the first URL (defaults to `false`)
+ * @returns Promise resolving to the sent messages in send order
+ */
+async function sendMessage(dto) {
+    lib.loggerService.log("functions.sendMessage", {
+        chat: dto.chat,
+        length: (dto.content || "").length,
+        photos: (dto.photos || []).length,
+    });
+    return await lib.telegramGlobalService.sendMessage(dto);
+}
+
+exports.getConfig = getConfig;
+exports.getTelegram = getTelegram;
+exports.lib = lib;
+exports.sendMessage = sendMessage;
+exports.setConfig = setConfig;
+exports.signIn = signIn;