rsshub 1.0.0-master.f9b85f5 → 1.0.0-master.f9c381a

package/lib/routes/telegram/tglib/channel.ts

@@ -1,160 +1,180 @@
-import InvalidParameterError from '@/errors/types/invalid-parameter';
-import { client, decodeMedia, getClient, getFilename, getMediaLink, streamDocument, streamThumbnail } from './client';
-import { returnBigInt } from 'telegram/Helpers.js';
-import { HTMLParser } from 'telegram/extensions/html.js';
+/* eslint-disable no-await-in-loop */
 import { DataItem } from '@/types';
-import type { Api } from 'telegram';
+import { Context } from 'hono';
+import { Api } from 'telegram';
+import { HTMLParser } from 'telegram/extensions/html.js';
+import { getClient, getDocument, getFilename, unwrapMedia } from './client';
+import { getDisplayName } from 'telegram/Utils.js';
+
+export function getGeoLink(geo: Api.GeoPoint) {
+    return `<a href="https://www.google.com/maps/search/?api=1&query=${geo.lat}%2C${geo.long}" target="_blank">Geo LatLon: ${geo.lat}, ${geo.long}</a>`;
+}
+
+export async function getPollResults(client, message, m: Api.MessageMediaPoll) {
+    const resultsUpdateResponse = await client.invoke(new Api.messages.GetPollResults({ peer: message.peerId, msgId: message.id }));
+    let results: Api.PollResults;
+    if (resultsUpdateResponse?.updates[0] instanceof Api.UpdateMessagePoll) {
+        results = resultsUpdateResponse.updates[0].results as Api.PollResults;
+    }
+    const txt = `<h4>${m.poll.quiz ? 'Quiz' : 'Poll'}: ${m.poll.question.text}</h4>
+        <div><ul>${m.poll.answers
+            .map((a) => {
+                let answerTxt = a.text.text;
+                const result = results.results?.find((r) => r.option.buffer === a.option.buffer);
+                if (result && results.totalVoters) {
+                    answerTxt = `<strong>${Math.round((result.voters / results.totalVoters) * 100)}%</strong>: ${answerTxt}`;
+                }
+                return `<li>${answerTxt}</li>`;
+            })
+            .join('')}</ul></div>
+    `;
+    return txt;
+}
+
+export function getMediaLink(src: string, m: Api.TypeMessageMedia) {
+    const doc = getDocument(m);
+    const mime = doc ? doc.mimeType : '';
 
-function parseRange(range, length) {
-    if (!range) {
-        return [];
+    if (m instanceof Api.MessageMediaPhoto || mime.startsWith('image/')) {
+        return `<img src="${src}" alt=""/>`;
     }
-    const [typ, segstr] = range.split('=');
-    if (typ !== 'bytes') {
-        throw new InvalidParameterError(`unsupported range: ${typ}`);
+    if (doc && mime.startsWith('video/')) {
+        const vid = (doc.attributes.find((t) => t instanceof Api.DocumentAttributeVideo) ?? { w: 1080, h: 720 }) as { w: number; h: number };
+        return `<video controls preload="metadata" poster="${src}?thumb" width="${vid.w / 2}" height="${vid.h / 2}"><source src="${src}" type="${mime}"></video>`;
     }
-    const segs = segstr.split(',').map((s) => s.trim());
-    const parsedSegs = [];
-    for (const seg of segs) {
-        const range = seg
-            .split('-', 2)
-            .filter((v) => !!v)
-            .map((elem) => returnBigInt(elem));
-        if (range.length < 2) {
-            if (seg.startsWith('-')) {
-                range.unshift(0);
-            } else {
-                range.push(length);
-            }
-        }
-        parsedSegs.push(range);
+    if (doc && mime.startsWith('audio/')) {
+        return `<div>${getAudioTitle(m)}</div><div><audio src="${src}"></audio></div>`;
     }
-    return parsedSegs;
-}
 
-async function getMedia(ctx) {
-    const media = await decodeMedia(ctx.req.param('username'), ctx.req.param('media'));
-    if (!media) {
-        ctx.status = 500;
-        return ctx.res.end();
+    if (doc && mime.startsWith('application/')) {
+        let linkText = `${getFilename(m)} (${humanFileSize(doc.size.valueOf())})`;
+        if (mime.endsWith('x-tgsticker')) {
+            linkText = ''; // remove filename, it's only an animated sticker
+        }
+        if ((doc.thumbs?.length ?? 0) > 0) {
+            linkText = `<div><img src="${src}?thumb" alt=""/></div><div>${linkText}</div>`;
+        }
+        return `<a href="${src}" target="_blank">${linkText}</a>`;
+    }
+    if ((m instanceof Api.MessageMediaGeo || m instanceof Api.MessageMediaGeoLive) && m.geo instanceof Api.GeoPoint) {
+        return getGeoLink(m.geo);
     }
-    if (ctx.res.closed) {
-        // console.log(`prematurely closed ${ctx.req.param('media')}`);
-        return;
+    if (m instanceof Api.MessageMediaWebPage) {
+        return ''; // a link without a document attach, usually is in the message text, so we can skip here
+    }
+    if (m instanceof Api.MessageMediaContact) {
+        return `Contact: <a href="tel:${m.phoneNumber}" target="_blank">${m.firstName} ${m.lastName} ${m.phoneNumber}</a>`;
+        // TODO: download vCard as media ?
+    }
+    if (m instanceof Api.MessageMediaInvoice) {
+        let description = m.description;
+        if (m.photo?.url) {
+            description = `<img src="${m.photo?.url}" /><br />${description}`;
+        }
+        return `<h4>${m.test ? 'TEST ' : ''}Invoice: ${m.title}</h4><div>${description}</div>`;
     }
 
-    if (media.document) {
-        ctx.status = 200;
-        let stream;
-        if ('thumb' in ctx.req.query()) {
-            try {
-                stream = streamThumbnail(media);
-                ctx.set('Content-Type', 'image/jpeg');
-            } catch {
-                ctx.status = 404;
-                return ctx.res.end();
-            }
-        } else {
-            ctx.set('Content-Type', media.document.mimeType);
-
-            ctx.set('Accept-Ranges', 'bytes');
-            const range = parseRange(ctx.get('Range'), media.document.size - 1);
-            if (range.length > 1) {
-                ctx.status = 416; // range not satisfiable
-                return ctx.res.end();
-            }
-            if (range.length === 1) {
-                // console.log(`${ctx.method} ${ctx.req.url} Range: ${ctx.get('Range')}`);
-                ctx.status = 206; // partial content
-                const [offset, limit] = range[0];
-                ctx.set('Content-Length', limit - offset + 1);
-                ctx.set('Content-Range', `bytes ${offset}-${limit}/${media.document.size}`);
-
-                const stream = streamDocument(media.document, '', offset, limit);
-                for await (const chunk of stream) {
-                    ctx.res.write(chunk);
-                    if (ctx.res.closed) {
-                        break;
-                    }
-                }
-                return ctx.res.end();
-            }
+    return m.className;
+}
 
-            ctx.set('Content-Length', media.document.size);
-            if (media.document.mimeType.startsWith('application/')) {
-                ctx.set('Content-Disposition', `attachment; filename="${encodeURIComponent(getFilename(media))}"`);
-            }
-            stream = streamDocument(media.document);
-        }
-        // const addr = JSON.stringify(ctx.res.socket.address());
-        // console.log(`streaming ${ctx.req.param('media')} to ${addr}`);
+function humanFileSize(size: number) {
+    const i = size === 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+    return (size / Math.pow(1024, i)).toFixed(2) + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
+}
 
-        for await (const chunk of stream) {
-            if (ctx.res.closed) {
-                // console.log(`closed ${addr}`);
-                break;
-            }
-            // console.log(`writing ${chunk.length / 1024} to ${addr}`);
-            ctx.res.write(chunk);
-        }
-        if ('close' in stream) {
-            stream.close();
+export function getAudioTitle(x: Api.TypeMessageMedia) {
+    if (x instanceof Api.MessageMediaDocument && x.document instanceof Api.Document) {
+        const attr = x.document.attributes.find((x) => x instanceof Api.DocumentAttributeAudio);
+        if (attr) {
+            return `${attr.performer} - ${attr.title} (${humanDuration(attr.duration)})`;
         }
-    } else if (media.photo) {
-        ctx.status = 200;
-        ctx.set('Content-Type', 'image/jpeg');
-        const buf = await client.downloadMedia(media);
-        ctx.res.write(buf);
-    } else {
-        ctx.status = 415;
-        ctx.write(media.className);
     }
-    return ctx.res.end();
+    return getFilename(x);
 }
 
-export default async function handler(ctx) {
-    const { username } = ctx.req.param();
-    const client = await getClient();
+export function humanDuration(seconds: number) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const remainingSeconds = seconds % 60;
 
-    const item: DataItem[] = [];
-    const chat = (await client.getInputEntity(username)) as Api.InputPeerChannel;
-    const channelInfo = await client.getEntity(chat);
+    // Format time components with leading zeros if necessary
+    const paddedMinutes = String(minutes).padStart(2, '0');
+    const paddedSeconds = String(remainingSeconds).padStart(2, '0');
 
-    if (channelInfo.className !== 'Channel') {
-        throw new Error(`${username} is not a channel`);
+    // Construct the time string conditionally
+    if (hours > 0) {
+        return `${hours}:${paddedMinutes}:${paddedSeconds}`; // Show hours, minutes, and seconds
+    } else if (minutes > 0) {
+        return `${minutes}:${paddedSeconds}`; // Show minutes and seconds
+    } else {
+        return `0:${paddedSeconds}`; // Show only seconds
     }
+}
+
+export default async function handler(ctx: Context) {
+    const client = await getClient();
+    const username = ctx.req.param('username');
+    const peer = await client.getInputEntity(username);
+    const entity = await client.getEntity(peer);
 
     let attachments: string[] = [];
-    const messages = await client.getMessages(chat, { limit: 50 });
+    const messages = await client.getMessages(peer, { limit: 50 });
 
+    let i = 0;
+    const item: DataItem[] = [];
     for (const message of messages) {
-        if (message.media) {
+        let text = message.text; // must not be HTML
+
+        if (message.fwdFrom?.fromId) {
+            const fwdFrom = await client.getEntity(message.fwdFrom.fromId);
+            text = `Forwarded From: ${getDisplayName(fwdFrom)}: ${text}`;
+        }
+        const media = await unwrapMedia(message.media, message.peerId);
+        if (message.media instanceof Api.MessageMediaStory && media) {
+            // if successfully loaded the story
+            const storyFrom = await client.getEntity(message.media.peer);
+            text = `Story From: ${getDisplayName(storyFrom)}: ${text}`;
+        }
+        if (media) {
+            if (media instanceof Api.MessageMediaPoll) {
+                attachments.push(await getPollResults(client, message, media));
+                continue;
+            }
             // messages that have no text are shown as if they're one post
             // because in TG only 1 attachment per message is possible
-            attachments.push(getMediaLink(ctx, chat, username, message));
+            const src = `${new URL(ctx.req.url).origin}/telegram/media/${username}/${message.id}`;
+            attachments.push(getMediaLink(src, media));
         }
-        if (message.text !== '') {
-            let description = attachments.join('\n');
+        if (message.replyMarkup instanceof Api.ReplyInlineMarkup) {
+            for (const buttonRow of message.replyMarkup.rows) {
+                for (const button of buttonRow.buttons) {
+                    if (button instanceof Api.KeyboardButtonUrl) {
+                        attachments.push(`<div><a href="${button.url}" target="_blank">${button.text}</a></div>`);
+                    }
+                }
+            }
+        }
+        if (text !== '' || ++i === messages.length - 1) {
+            let description = attachments.join('<br/>\n');
             attachments = []; // emitting these, buffer other ones
 
-            if (message.text) {
+            if (text) {
                 description += `<p>${HTMLParser.unparse(message.message, message.entities).replaceAll('\n', '<br/>')}</p>`;
             }
 
             const title = message.text ? message.text.slice(0, 80) + (message.text.length > 80 ? '...' : '') : new Date(message.date * 1000).toUTCString();
-
             item.push({
                 title,
                 description,
                 pubDate: new Date(message.date * 1000).toUTCString(),
                 link: `https://t.me/s/${username}/${message.id}`,
-                author: `${channelInfo.title} (@${username})`,
+                author: getDisplayName(message.sender ?? entity),
             });
         }
     }
 
     return {
-        title: channelInfo.title,
+        title: getDisplayName(entity),
         language: null,
         link: `https://t.me/${username}`,
         item,
@@ -162,5 +182,3 @@ export default async function handler(ctx) {
         description: `@${username} on Telegram`,
     };
 }
-
-export { getMedia };

package/lib/routes/telegram/tglib/client.ts

@@ -1,7 +1,6 @@
 import { Api, TelegramClient } from 'telegram';
 import { UserAuthParams } from 'telegram/client/auth';
 import { StringSession } from 'telegram/sessions/index.js';
-import { getAppropriatedPartSize } from 'telegram/Utils.js';
 
 import { config } from '@/config';
 import ConfigNotFoundError from '@/errors/types/config-not-found';
@@ -34,160 +33,59 @@ export async function getClient(authParams?: UserAuthParams, session?: string) {
                 : undefined,
     });
 
-    await client.connect();
+    await client.start(
+        Object.assign(authParams ?? {}, {
+            onError: (err: Error) => {
+                throw new Error('Cannot start TG: ' + err);
+            },
+        }) as any
+    );
     return client;
 }
 
-function humanFileSize(size) {
-    const i = size === 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
-    return (size / Math.pow(1024, i)).toFixed(2) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
-}
-
-/**
- * https://core.telegram.org/api/files#stripped-thumbnails
- * @param bytes Buffer
- * @returns Buffer jpeg
- */
-function ExpandInlineBytes(bytes) {
-    if (bytes.length < 3 || bytes[0] !== 0x1) {
-        return [];
-    }
-    const header = Buffer.from([
-        0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x28, 0x1C, 0x1E, 0x23, 0x1E, 0x19, 0x28, 0x23, 0x21, 0x23, 0x2D, 0x2B,
-        0x28, 0x30, 0x3C, 0x64, 0x41, 0x3C, 0x37, 0x37, 0x3C, 0x7B, 0x58, 0x5D, 0x49, 0x64, 0x91, 0x80, 0x99, 0x96, 0x8F, 0x80, 0x8C, 0x8A, 0xA0, 0xB4, 0xE6, 0xC3, 0xA0, 0xAA, 0xDA, 0xAD, 0x8A, 0x8C, 0xC8, 0xFF, 0xCB, 0xDA, 0xEE,
-        0xF5, 0xFF, 0xFF, 0xFF, 0x9B, 0xC1, 0xFF, 0xFF, 0xFF, 0xFA, 0xFF, 0xE6, 0xFD, 0xFF, 0xF8, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x2B, 0x2D, 0x2D, 0x3C, 0x35, 0x3C, 0x76, 0x41, 0x41, 0x76, 0xF8, 0xA5, 0x8C, 0xA5, 0xF8, 0xF8, 0xF8,
-        0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8,
-        0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05,
-        0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04,
-        0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1,
-        0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
-        0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
-        0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
-        0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-        0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00,
-        0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62,
-        0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
-        0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
-        0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2,
-        0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3F, 0x00,
-    ]);
-    const footer = Buffer.from([0xFF, 0xD9]);
-    const real = Buffer.alloc(header.length + bytes.length + footer.length);
-    header.copy(real);
-    bytes.copy(real, header.length, 3);
-    bytes.copy(real, 164, 1, 2);
-    bytes.copy(real, 166, 2, 3);
-    footer.copy(real, header.length + bytes.length, 0);
-    return real;
-}
-
-function getMediaLink(ctx, channel: Api.InputPeerChannel, channelName: string, message: Api.Message) {
-    const base = `${ctx.protocol}://${ctx.host}/telegram/channel/${channelName}`;
-    const src = base + `${channel.channelId}_${message.id}`;
-
-    const x = message.media;
-    if (x instanceof Api.MessageMediaPhoto || (x instanceof Api.MessageMediaDocument && x.document.mimeType.startsWith('image/'))) {
-        return `<img src="${src}" alt=""/>`;
-    }
-    if (x instanceof Api.MessageMediaDocument && x.document.mimeType.startsWith('video/')) {
-        const vid = x.document.attributes.find((t) => t.className === 'DocumentAttributeVideo') ?? { w: 1080, h: 720 };
-        return `<video controls preload="metadata" poster="${src}?thumb" width="${vid.w / 2}" height="${vid.h / 2}"><source src="${src}" type="${x.document.mimeType}"></video>`;
-    }
-    if (x instanceof Api.MessageMediaDocument && x.document.mimeType.startsWith('audio/')) {
-        return `<audio src="${src}"></audio>`;
-    }
-
-    let linkText = getFilename(x);
-    if (x instanceof Api.MessageMediaDocument) {
-        linkText += ` (${humanFileSize(x.document.size)})`;
-        return `<a href="${src}" target="_blank"><img src="${src}?thumb" alt=""/><br/>${linkText}</a>`;
-    }
-    return '';
-}
-function getFilename(x) {
+export function getFilename(x: Api.TypeMessageMedia) {
     if (x instanceof Api.MessageMediaDocument) {
-        const docFilename = x.document.attributes.find((a) => a.className === 'DocumentAttributeFilename');
-        if (docFilename) {
-            return docFilename.fileName;
+        for (const a of (x.document as Api.Document).attributes) {
+            if (a instanceof Api.DocumentAttributeFilename) {
+                return a.fileName;
+            }
         }
     }
     return x.className;
 }
 
-function sortThumb(thumb) {
-    if (thumb instanceof Api.PhotoStrippedSize) {
-        return thumb.bytes.length;
+export function getDocument(m: Api.TypeMessageMedia) {
+    if (m instanceof Api.MessageMediaDocument && m.document && !(m.document instanceof Api.DocumentEmpty)) {
+        return m.document;
     }
-    if (thumb instanceof Api.PhotoCachedSize) {
-        return thumb.bytes.length;
+    if (m instanceof Api.MessageMediaWebPage && m.webpage instanceof Api.WebPage && m.webpage.document instanceof Api.Document) {
+        return m.webpage.document;
     }
-    if (thumb instanceof Api.PhotoSize) {
-        return thumb.size;
-    }
-    if (thumb instanceof Api.PhotoSizeProgressive) {
-        return Math.max(...thumb.sizes);
-    }
-    if (thumb instanceof Api.VideoSize) {
-        return thumb.size;
-    }
-    return 0;
 }
 
-function chooseLargestThumb(thumbs) {
-    thumbs = [...thumbs].sort((a, b) => sortThumb(a) - sortThumb(b));
-    return thumbs.pop();
+export async function getStory(entity: Api.TypeEntityLike, id: number) {
+    const result = await (
+        await getClient()
+    ).invoke(
+        new Api.stories.GetStoriesByID({
+            id: [id],
+            peer: entity,
+        })
+    );
+    return result.stories[0] as Api.StoryItem;
 }
 
-function streamThumbnail(x) {
-    if (x instanceof Api.MessageMediaDocument && x.document.thumbs.length > 0) {
-        const size = chooseLargestThumb(x.document.thumbs);
-        if (size instanceof Api.PhotoCachedSize || size instanceof Api.PhotoStrippedSize) {
-            return (function* () {
-                yield ExpandInlineBytes(size.bytes);
-            })();
+export async function unwrapMedia(media: Api.TypeMessageMedia | undefined, backupPeerId?: Api.TypePeer) {
+    if (media instanceof Api.MessageMediaStory) {
+        if (media.story instanceof Api.StoryItem && media.story.media) {
+            return media.story.media;
         }
-        return streamDocument(x.document, size && 'type' in size ? size.type : '');
-    }
-    throw 'not supported';
-}
-
-async function decodeMedia(channelName, x, retry = false) {
-    const [channel, msg] = x.split('_');
-
-    try {
-        const msgs = await client.getMessages(channel, {
-            ids: [Number(msg)],
-        });
-        return msgs[0]?.media;
-    } catch (error) {
-        if (!retry) {
-            // channel likely not seen before, we need to resolve ID and retry
-            await client.getInputEntity(channelName);
-            return decodeMedia(channelName, x, true);
+        let storyItem = await getStory(media.peer, media.id);
+        if (!storyItem?.media && backupPeerId) {
+            // it's possible the story got hidden by the original user, but we've saved it into Saved Messages - we can still get it
+            storyItem = await getStory(backupPeerId, media.id);
         }
-        throw error;
-    }
-}
-
-function streamDocument(obj, thumbSize = '', offset, limit) {
-    const chunkSize = (obj.size ? getAppropriatedPartSize(obj.size) : 64) * 1024;
-    const iterFileParams = {
-        file: new Api.InputDocumentFileLocation({
-            id: obj.id,
-            accessHash: obj.accessHash,
-            fileReference: obj.fileReference,
-            thumbSize,
-        }),
-        chunkSize,
-        dcId: obj.dcId,
-    };
-    if (offset) {
-        iterFileParams.offset = offset;
-    }
-    if (limit) {
-        iterFileParams.limit = limit;
+        return storyItem?.media;
     }
-    return client.iterDownload(iterFileParams);
+    return media;
 }
-
-export { client, getMediaLink, decodeMedia, getFilename, streamDocument, streamThumbnail };

package/lib/routes/tesla/cx.ts

@@ -147,7 +147,7 @@ async function handler(ctx) {
                       alt: item.venueName ?? item.title,
                   }
                 : undefined,
-            description: item.description?.replace(/\["|"]/g, '') ?? undefined,
+            description: item.description?.replaceAll(/\["|"]/g, '') ?? undefined,
             data: item.parkingLocationId
                 ? {
                       title: item.venueName ?? item.title,

package/lib/routes/theverge/index.ts

@@ -6,6 +6,10 @@ import { load } from 'cheerio';
 import path from 'node:path';
 import { art } from '@/utils/render';
 
+const excludeTypes = new Set(['NewsletterBlockType', 'RelatedPostsBlockType', 'ProductsTableBlockType', 'TableOfContentsBlockType']);
+
+const shouldKeep = (b: any) => !excludeTypes.has(b.__typename.trim());
+
 export const route: Route = {
     path: '/:hub?',
     categories: ['new-media'],
@@ -46,6 +50,9 @@ export const route: Route = {
 };
 
 const renderBlock = (b) => {
+    if (!shouldKeep(b)) {
+        return '';
+    }
     switch (b.__typename) {
         case 'CoreEmbedBlockType':
             return b.embedHtml;
@@ -60,7 +67,7 @@ const renderBlock = (b) => {
         case 'CoreListBlockType':
             return `${b.ordered ? '<ol>' : '<ul>'}${b.items.map((i) => `<li>${i.contents.html}</li>`).join('')}${b.ordered ? '</ol>' : '</ul>'}`;
         case 'CoreParagraphBlockType':
-            return b.contents.html;
+            return b.tempContents.map((c) => c.html).join('');
         case 'CorePullquoteBlockType':
             return `<blockquote>${b.contents.html}</blockquote>`;
         case 'CoreQuoteBlockType':
@@ -69,15 +76,25 @@ const renderBlock = (b) => {
             return '<hr>';
         case 'HighlightBlockType':
             return b.children.map((c) => renderBlock(c)).join('');
+        case 'ImageCompareBlockType':
+            return `<figure><img src="${b.leftImage.thumbnails.horizontal.url.split('?')[0]}" alt="${b.leftImage.alt}" /><img src="${b.rightImage.thumbnails.horizontal.url.split('?')[0]}" alt="${b.rightImage.alt}" /><figcaption>${b.caption.html}</figcaption></figure>`;
+        case 'ImageSliderBlockType':
+            return b.images.map((i) => `<figure><img src="${i.image.originalUrl.split('?')[0]}" alt="${i.alt}" /><figcaption>${i.caption.html}</figcaption></figure>`).join('');
         case 'MethodologyAccordionBlockType':
             return `<h2>${b.heading.html}</h2>${b.sections.map((s) => `<h3>${s.heading.html}</h3>${s.content.html}`).join('')}`;
+        case 'ProductBlockType': {
+            const product = b.product;
+            return `<div><figure><img src="${product.image.thumbnails.horizontal.url.split('?')[0]}" alt="${product.image.alt}" /><figcaption>${product.image.alt}</figcaption></figure><br><a href="${product.bestRetailLink.url}">${product.title} $${product.bestRetailLink.price}</a><br>${product.description.html}${product.pros.html ? `<br>The Good${product.pros.html}The Bad${product.cons.html}` : ''}</div>`;
+        }
+        case 'TableBlockType':
+            return `<table><tr>${b.header.map((cell) => `<th>${cell}</th>`).join('')}</tr>${b.rows.map((row) => `<tr>${row.map((cell) => `<td>${cell}</td>`).join('')}</tr>`).join('')}</table>`;
         default:
             throw new Error(`Unsupported block type: ${b.__typename}`);
     }
 };
 
 async function handler(ctx) {
-    const link = ctx.req.param('hub') ? `https://www.theverge.com/${ctx.req.param('hub')}/rss/index.xml` : 'https://www.theverge.com/rss/index.xml';
+    const link = ctx.req.param('hub') ? `https://www.theverge.com/rss/${ctx.req.param('hub')}/index.xml` : 'https://www.theverge.com/rss/index.xml';
 
     const feed = await parser.parseURL(link);
 
@@ -96,10 +113,7 @@ async function handler(ctx) {
                     ledeMediaData: node.ledeMediaData,
                 });
 
-                description += node.blocks
-                    .filter((b) => b.__typename !== 'NewsletterBlockType' && b.__typename !== 'RelatedPostsBlockType' && b.__typename !== 'ProductBlockType' && b.__typename !== 'TableOfContentsBlockType')
-                    .map((b) => renderBlock(b))
-                    .join('<br><br>');
+                description += node.blocks.map((b) => renderBlock(b)).join('<br><br>');
 
                 if (node.__typename === 'StreamResourceType') {
                     description += node.posts.edges

package/lib/routes/threads/utils.ts

@@ -78,10 +78,14 @@ const getUserId = (user: string): Promise<string> =>
             throw new NotFoundError('User ID not found');
         })
         .then((result): string => {
-            if (!result || typeof result !== 'string') {
-                throw new TypeError('Invalid user ID type');
+            if (result) {
+                if (typeof result === 'string') {
+                    return result;
+                } else if (typeof result === 'number') {
+                    return result.toString();
+                }
             }
-            return result;
+            throw new TypeError('Invalid user ID type');
         });
 
 const hasMedia = (post) => post.image_versions2 || post.carousel_media || post.video_versions;

package/lib/routes/tidb/blog.ts

@@ -7,7 +7,7 @@ import { parseDate } from '@/utils/parse-date';
 import { type CheerioAPI, load } from 'cheerio';
 import { type Context } from 'hono';
 
-const escapeHtml = (text: string): string => text?.replace(/&/g, '&amp;')?.replace(/</g, '&lt;')?.replace(/>/g, '&gt;')?.replace(/'/g, '&quot;')?.replace(/'/g, '&#039;') ?? text;
+const escapeHtml = (text: string): string => text?.replaceAll('&', '&amp;')?.replaceAll('<', '&lt;')?.replaceAll('>', '&gt;')?.replaceAll("'", '&quot;')?.replaceAll("'", '&#039;') ?? text;
 
 const parseTextChildren = (children: any[]): string => children.map((child: any) => escapeHtml(child.text)).join('');
 

package/lib/routes/toutiao/user.ts

@@ -57,12 +57,12 @@ async function handler(ctx) {
         switch (item.cell_type) {
             case 0:
             case 49: {
-                const video = item.video.play_addr_list.sort((a, b) => b.bitrate - a.bitrate)[0];
+                const video = item.video.play_addr_list.toSorted((a, b) => b.bitrate - a.bitrate)[0];
                 return {
                     title: item.title,
                     description: art(path.join(__dirname, 'templates/video.art'), {
                         poster: item.video.origin_cover.url_list[0],
-                        url: item.video.play_addr_list.sort((a, b) => b.bitrate - a.bitrate)[0].play_url_list[0],
+                        url: item.video.play_addr_list.toSorted((a, b) => b.bitrate - a.bitrate)[0].play_url_list[0],
                     }),
                     link: `https://www.toutiao.com/video/${item.id}/`,
                     pubDate: parseDate(item.publish_time, 'X'),

package/lib/routes/twitter/api/mobile-api/api.ts

@@ -280,7 +280,7 @@ const getUserTweets = async (id, params = {}) => {
             return !idSet.has(id_str) && idSet.add(id_str) && tweet;
         }) // deduplicate
         .filter(Boolean) // remove null
-        .sort((a, b) => (b.id_str || b.conversation_id_str) - (a.id_str || a.conversation_id_str)) // desc
+        .toSorted((a, b) => (b.id_str || b.conversation_id_str) - (a.id_str || a.conversation_id_str)) // desc
         .slice(0, 20);
     cache.set(cacheKey, JSON.stringify(tweets));
     return tweets;