rsshub 1.0.0-master.fe69819 → 1.0.0-master.febd623

package/lib/utils/parse-date.js

@@ -1,42 +1,199 @@
 const dayjs = require('dayjs');
 dayjs.extend(require('dayjs/plugin/customParseFormat'));
+dayjs.extend(require('dayjs/plugin/duration'));
+dayjs.extend(require('dayjs/plugin/isSameOrBefore'));
+dayjs.extend(require('dayjs/plugin/weekday'));
+
+const words = [
+    {
+        startAt: dayjs(),
+        regExp: /^(?:今(?:天|日)|t(?:o)?da(?:y)?)(.*)/,
+    },
+    {
+        startAt: dayjs().subtract(1, 'days'),
+        regExp: /^(?:昨(?:天|日)|y(?:ester)?da(?:y)?)(.*)/,
+    },
+    {
+        startAt: dayjs().subtract(2, 'days'),
+        regExp: /^(?:前天|(?:the)?d(?:ay)?b(?:eforeyesterda)?y)(.*)/,
+    },
+    {
+        startAt: dayjs().isSameOrBefore(dayjs().weekday(1)) ? dayjs().weekday(1).subtract(1, 'week') : dayjs().weekday(1),
+        regExp: /^(?:周|星期)一(.*)/,
+    },
+    {
+        startAt: dayjs().isSameOrBefore(dayjs().weekday(2)) ? dayjs().weekday(2).subtract(1, 'week') : dayjs().weekday(2),
+        regExp: /^(?:周|星期)二(.*)/,
+    },
+    {
+        startAt: dayjs().isSameOrBefore(dayjs().weekday(3)) ? dayjs().weekday(3).subtract(1, 'week') : dayjs().weekday(3),
+        regExp: /^(?:周|星期)三(.*)/,
+    },
+    {
+        startAt: dayjs().isSameOrBefore(dayjs().weekday(4)) ? dayjs().weekday(4).subtract(1, 'week') : dayjs().weekday(4),
+        regExp: /^(?:周|星期)四(.*)/,
+    },
+    {
+        startAt: dayjs().isSameOrBefore(dayjs().weekday(5)) ? dayjs().weekday(5).subtract(1, 'week') : dayjs().weekday(5),
+        regExp: /^(?:周|星期)五(.*)/,
+    },
+    {
+        startAt: dayjs().isSameOrBefore(dayjs().weekday(6)) ? dayjs().weekday(6).subtract(1, 'week') : dayjs().weekday(6),
+        regExp: /^(?:周|星期)六(.*)/,
+    },
+    {
+        startAt: dayjs().isSameOrBefore(dayjs().weekday(7)) ? dayjs().weekday(7).subtract(1, 'week') : dayjs().weekday(7),
+        regExp: /^(?:周|星期)(?:日|天)(.*)/,
+    },
+    {
+        startAt: dayjs().add(1, 'days'),
+        regExp: /^(?:明(?:天|日)|y(?:ester)?da(?:y)?)(.*)/,
+    },
+    {
+        startAt: dayjs().add(2, 'days'),
+        regExp: /^(?:(?:后|後)(?:天|日)|(?:the)?d(?:ay)?a(?:fter)?t(?:omrrow)?)(.*)/,
+    },
+];
 
 const patterns = [
     {
-        regexp: /^(\d+)分钟前$/,
-        handler: (minute) => dayjs().subtract(minute, 'minutes'),
+        unit: 'years',
+        regExp: /(\d+)(?:年|y(?:ea)?r(?:s)?)/,
+    },
+    {
+        unit: 'months',
+        regExp: /(\d+)(?:(?:个|個)?月|month(?:s)?)/,
     },
     {
-        regexp: /^(\d+)小时前$/,
-        handler: (hour) => dayjs().subtract(hour, 'hours'),
+        unit: 'weeks',
+        regExp: /(\d+)(?:周|(?:个|個)?星期|week(?:s)?)/,
     },
     {
-        regexp: /^(\d+)天前$/,
-        handler: (day) => dayjs().subtract(day, 'days'),
+        unit: 'days',
+        regExp: /(\d+)(?:天|日|day(?:s)?)/,
     },
     {
-        regexp: /^今天\s*((\d+:\d+)?)$/,
-        handler: (hm) => dayjs(hm || '0:0', ['HH:m', 'HH:mm', 'H:m', 'H:mm']),
+        unit: 'hours',
+        regExp: /(\d+)(?:(?:个|個)?(?:(?:小)?时|時|点|點)|h(?:ou)?r(?:s)?)/,
     },
     {
-        regexp: /^昨天\s*((\d+:\d+)?)$/,
-        handler: (hm) => dayjs(hm || '0:0', ['HH:m', 'HH:mm', 'H:m', 'H:mm']).subtract(1, 'day'),
+        unit: 'minutes',
+        regExp: /(\d+)(?:分(?:钟|鐘)?|min(?:ute)?(?:s)?)/,
     },
     {
-        regexp: /^前天\s*((\d+:\d+)?)$/,
-        handler: (hm) => dayjs(hm || '0:0', ['HH:m', 'HH:mm', 'H:m', 'H:mm']).subtract(2, 'day'),
+        unit: 'seconds',
+        regExp: /(\d+)(?:秒(?:钟|鐘)?|sec(?:ond)?(?:s)?)/,
     },
 ];
 
+const patternSize = Object.keys(patterns).length;
+
+/**
+ * 预处理日期字符串
+ * @param {String} date 原始日期字符串
+ */
+const toDate = (date) =>
+    date
+        .toLowerCase()
+        .replace(/(^a(?:n)?\s)|(\sa(?:n)?\s)/g, '1') // 替换 `a` 和 `an` 为 `1`
+        .replace(/几|幾/g, '3') // 如 `几秒钟前` 视作 `3秒钟前`
+        .replace(/[\s,]/g, ''); // 移除所有空格
+
+/**
+ * 将 `['\d+时', ..., '\d+秒']` 转换为 `{ hours: \d+, ..., seconds: \d+ }`
+ * 用于描述时间长度
+ * @param {Array.<String>} matches 所有匹配结果
+ */
+const toDurations = (matches) => {
+    const durations = {};
+
+    let p = 0;
+    for (const m of matches) {
+        for (; p <= patternSize; p++) {
+            const match = patterns[p].regExp.exec(m);
+            if (match) {
+                durations[patterns[p].unit] = match[1];
+                break;
+            }
+        }
+    }
+    return durations;
+};
+
 module.exports = {
     parseDate: (date, ...options) => dayjs(date, ...options).toDate(),
     parseRelativeDate: (date) => {
-        for (const pattern of patterns) {
-            const match = pattern.regexp.exec(date);
-            if (match !== null) {
-                return pattern.handler(match[1]).toDate();
+        // 预处理日期字符串 date
+
+        const theDate = toDate(date);
+
+        // 将 `\d+年\d+月...\d+秒前` 分割成 `['\d+年', ..., '\d+秒前']`
+
+        const matches = theDate.match(/(?:\D+)?\d+(?!:|-|\/|(a|p)m)\D+/g);
+
+        if (matches) {
+            // 获得最后的时间单元，如 `\d+秒前`
+
+            const lastMatch = matches.pop();
+
+            // 若最后的时间单元含有 `前`、`以前`、`之前` 等标识字段，减去相应的时间长度
+            // 如 `1分10秒前`
+
+            const beforeMatches = /(.*)(?:(?:之|以)?前|ago)$/.exec(lastMatch);
+            if (beforeMatches) {
+                matches.push(beforeMatches[1]);
+                return dayjs()
+                    .subtract(dayjs.duration(toDurations(matches)))
+                    .toDate();
+            }
+
+            // 若最后的时间单元含有 `后`、`以后`、`之后` 等标识字段，加上相应的时间长度
+            // 如 `1分10秒后`
+
+            const afterMatches = /(?:^in(.*)|(.*)(?:之|以)?(?:后|後))$/.exec(lastMatch);
+            if (afterMatches) {
+                matches.push(afterMatches[1] ?? afterMatches[2]);
+                return dayjs()
+                    .add(dayjs.duration(toDurations(matches)))
+                    .toDate();
+            }
+
+            // 以下处理日期字符串 date 含有特殊词的情形
+            // 如 `今天1点10分`
+
+            matches.push(lastMatch);
+            const firstMatch = matches.shift();
+
+            for (const w of words) {
+                const wordMatches = w.regExp.exec(firstMatch);
+                if (wordMatches) {
+                    matches.unshift(wordMatches[1]);
+
+                    // 取特殊词对应日零时为起点，加上相应的时间长度
+
+                    return w.startAt
+                        .set('hour', 0)
+                        .set('minute', 0)
+                        .set('second', 0)
+                        .set('millisecond', 0)
+                        .add(dayjs.duration(toDurations(matches)))
+                        .toDate();
+                }
+            }
+        } else {
+            // 若日期字符串 date 不匹配 patterns 中所有模式，则默认为 `特殊词 + 标准时间格式` 的情形，此时直接将特殊词替换为对应日期
+            // 如今天为 `2022-03-22`，则 `今天 20:00` => `2022-03-22 20:00`
+
+            for (const w of words) {
+                const wordMatches = w.regExp.exec(theDate);
+                if (wordMatches) {
+                    // The default parser of dayjs() can parse '8:00 pm' but not '8:00pm'
+                    // so we need to insert a space in between
+                    return dayjs(`${w.startAt.format('YYYY-MM-DD')} ${/a|pm$/.test(wordMatches[1]) ? wordMatches[1].replace(/a|pm/, ' $&') : wordMatches[1]}`).toDate();
+                }
             }
         }
-        return null;
+
+        return date;
     },
 };

package/lib/utils/puppeteer.js

@@ -1,20 +1,59 @@
 const config = require('@/config').value;
-const puppeteer = require('puppeteer');
+let puppeteer = require('puppeteer');
 
 const options = {
-    args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-infobars', '--window-position=0,0', '--ignore-certifcate-errors', '--ignore-certifcate-errors-spki-list', `--user-agent=${config.ua}`],
+    args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-infobars', '--window-position=0,0', '--ignore-certificate-errors', '--ignore-certificate-errors-spki-list', `--user-agent=${config.ua}`],
     headless: true,
     ignoreHTTPSErrors: true,
 };
 
-module.exports = async () => {
+/**
+ * @param {Object} extraOptions
+ * @param {boolean} extraOptions.stealth - Use puppeteer-extra-plugin-stealth
+ * @returns Puppeteer browser
+ */
+module.exports = async (extraOptions = {}) => {
+    if (extraOptions.stealth) {
+        const { addExtra } = require('puppeteer-extra');
+        puppeteer = addExtra(puppeteer);
+
+        // workaround for vercel/nft #54 and #283
+        require('puppeteer-extra-plugin-stealth/evasions/chrome.app');
+        require('puppeteer-extra-plugin-stealth/evasions/chrome.csi');
+        require('puppeteer-extra-plugin-stealth/evasions/chrome.loadTimes');
+        require('puppeteer-extra-plugin-stealth/evasions/chrome.runtime');
+        require('puppeteer-extra-plugin-stealth/evasions/defaultArgs');
+        require('puppeteer-extra-plugin-stealth/evasions/iframe.contentWindow');
+        require('puppeteer-extra-plugin-stealth/evasions/media.codecs');
+        require('puppeteer-extra-plugin-stealth/evasions/navigator.hardwareConcurrency');
+        require('puppeteer-extra-plugin-stealth/evasions/navigator.languages');
+        require('puppeteer-extra-plugin-stealth/evasions/navigator.permissions');
+        require('puppeteer-extra-plugin-stealth/evasions/navigator.plugins');
+        require('puppeteer-extra-plugin-stealth/evasions/navigator.vendor');
+        require('puppeteer-extra-plugin-stealth/evasions/navigator.webdriver');
+        require('puppeteer-extra-plugin-stealth/evasions/sourceurl');
+        require('puppeteer-extra-plugin-stealth/evasions/user-agent-override');
+        require('puppeteer-extra-plugin-stealth/evasions/webgl.vendor');
+        require('puppeteer-extra-plugin-stealth/evasions/window.outerdimensions');
+        require('puppeteer-extra-plugin-user-preferences');
+        require('puppeteer-extra-plugin-user-data-dir');
+
+        puppeteer.use(require('puppeteer-extra-plugin-stealth')());
+    }
     let browser;
     if (config.puppeteerWSEndpoint) {
         browser = await puppeteer.connect({
             browserWSEndpoint: config.puppeteerWSEndpoint,
         });
     } else {
-        browser = await puppeteer.launch(options);
+        browser = await puppeteer.launch(
+            config.chromiumExecutablePath
+                ? {
+                      executablePath: config.chromiumExecutablePath,
+                      ...options,
+                  }
+                : options
+        );
     }
     setTimeout(() => {
         browser.close();

package/lib/utils/rand-user-agent.js

@@ -0,0 +1,29 @@
+const randUserAgent = require('rand-user-agent');
+
+/**
+ * A handy function to help generate a legit useragent.
+ *
+ * @param {Object} randUserAgent
+ * @param {string} randUserAgent.browser Name of a browser, case-insensitive. `chrome`, `edge`, `firefox`, `mobile safari`(ios only) or `safari`.
+ * @param {string} randUserAgent.os Name of an OS, case-insensitive. `android`, `ios`, `mac os`, `linux` or `windows`.
+ * @param {string} randUserAgent.device Name of a device, case-insensitive. `desktop`, `mobile` or `tablet`.
+ * @returns A random useragent for the given specifications.
+ */
+module.exports = ({ browser = 'chrome', os = 'mac os', device = 'desktop' }) => {
+    device = device.toLowerCase();
+    browser = browser.toLowerCase();
+    os = os.toLowerCase();
+    let UA = randUserAgent(device, browser, os);
+
+    if (browser === 'chrome') {
+        while (UA.includes('Chrome-Lighthouse') || UA.includes('Gener8') || UA.includes('HeadlessChrome') || UA.includes('SMTBot')) {
+            UA = randUserAgent(device, browser, os);
+        }
+    }
+    if (browser === 'safari') {
+        while (UA.includes('Applebot')) {
+            UA = randUserAgent(device, browser, os);
+        }
+    }
+    return UA;
+};

package/lib/utils/request-wrapper.js

@@ -14,7 +14,7 @@ if (config.proxyUri && typeof config.proxyUri === 'string') {
         HttpsProxyAgent = HttpsProxyAgent || require('https-proxy-agent');
         proxy = new HttpsProxyAgent(config.proxyUri);
     } else if (config.proxyUri.startsWith('socks')) {
-        SocksProxyAgent = SocksProxyAgent || require('socks-proxy-agent');
+        SocksProxyAgent = SocksProxyAgent || require('socks-proxy-agent').SocksProxyAgent;
         proxy = new SocksProxyAgent(config.proxyUri);
     } else {
         throw 'Unknown proxy-uri format';
@@ -30,7 +30,7 @@ if (config.proxyUri && typeof config.proxyUri === 'string') {
 
     switch (config.proxy.protocol) {
         case 'socks':
-            SocksProxyAgent = SocksProxyAgent || require('socks-proxy-agent');
+            SocksProxyAgent = SocksProxyAgent || require('socks-proxy-agent').SocksProxyAgent;
             agent.http = new SocksProxyAgent(proxyUrl);
             agent.https = new SocksProxyAgent(proxyUrl);
             break;
@@ -86,6 +86,8 @@ const requestWrapper = (url, options) => {
             options.headers['Proxy-Authorization'] = `Basic ${config.proxy.auth}`;
         }
         logger.info(`Proxy for ${url}`);
+    } else {
+        logger.debug(`Requesting ${url}`);
     }
 
     // ua
@@ -102,9 +104,6 @@ const requestWrapper = (url, options) => {
         options.headers['user-agent'] = config.ua;
     }
 
-    // server
-    options.headers.server = 'RSSHub';
-
     try {
         const urlHandler = new URL(url);
         // referer
@@ -128,7 +127,7 @@ const httpWrap = (func) => {
                 requestWrapper(url.toString(), request);
             } else {
                 const req = url;
-                requestWrapper(req.url || req.href || `${req.protocol}//${req.hostname}${req.path}`, req);
+                requestWrapper(req.url || req.href || `${req.protocol}//${req.hostname || req.host}${req.path}`, req);
             }
         } else {
             requestWrapper(url, request);

package/lib/utils/torrent.js

@@ -60,6 +60,7 @@ class HDHome extends TorrentProvider {
         );
     }
 }
+
 TorrentSearchApi.loadProvider(HDHome);
 
 const allProviders = ['HDHome', 'Rarbg', '1337x', 'Yts', 'Eztv'];
@@ -119,7 +120,14 @@ module.exports = {
 
         const keyword = keywords[0];
         const normalizeKeyword = normalize(keyword);
-        const torrents = await TorrentSearchApi.search(providers, keywords.join(' '), category);
+        let torrents;
+        try {
+            torrents = await TorrentSearchApi.search(providers, keywords.join(' '), category);
+        } catch (e) {
+            // expect a status code error, but we don't mind catching all errors here
+            // logger.debug(e);
+            return {};
+        }
         if (torrents && torrents.length > 0) {
             let bestRating = 0;
             let bestSize = 0;

package/lib/utils/wechat-mp.js

@@ -0,0 +1,261 @@
+/**
+ * Author: @Rongronggg9
+ *
+ * There are at least three folders which are relevant with WeChat MP (Official Account Platform / Media Platform):
+ * lib/v2/wechat
+ * lib/v2/gzh360
+ * lib/v2/pku/nsd/gd
+ * lib/v2/sdu/cs
+ *
+ * If your new route is not in the above folders, please add it to the list.
+ *
+ * If your route needs to fetch MP articles from mp.weixin.qq.com, you SHOULD use `finishArticleItem`.
+ * However, if your route need to determine some metadata by itself, you MAY use `fetchArticle`.
+ * If you find more metadata on the webpage, consider modifying `fetchArticle` to include them.
+ * NEVER fetch MP articles from mp.weixin.qq.com in your route in order to avoid cache key collision.
+ * NO NEED TO use cache if you are using `finishArticleItem` or `fetchArticle`, they will handle cache for you.
+ *
+ * If your route fetches MP articles from other websites, you SHOULD use `fixArticleContent` to fix the content format.
+ * If you find more fixes that should be applied, consider modifying `fixArticleContent` to include them.
+ *
+ * For more details of these functions, please refer to the jsDoc in the source code.
+ */
+
+const got = require('@/utils/got');
+const cheerio = require('cheerio');
+const { parseDate } = require('@/utils/parse-date');
+
+const replaceTag = ($, oldTag, newTagName) => {
+    oldTag = $(oldTag);
+    const NewTag = $($(`<${newTagName} />`));
+    const oldTagAttr = oldTag.attr();
+    for (const key in oldTagAttr) {
+        NewTag.attr(key, oldTagAttr[key]);
+    }
+    NewTag.append(oldTag.contents());
+    oldTag.replaceWith(NewTag);
+};
+
+const detectOriginalArticleUrl = ($) => {
+    // No article content get, try the original url
+    // example: https://mp.weixin.qq.com/s/f6sKObaZZhADTYU2Jl5Bnw
+    if (!$('#js_content').text()) {
+        return $('#js_share_source').attr('data-url');
+    }
+    // Article content is too short, try the first link
+    // example: https://mp.weixin.qq.com/s/9saVB4KaolRyJfpajzeFRg
+    if ($('#js_content').text().length < 80) {
+        return $('#js_content a').attr('href');
+    }
+    return null;
+};
+
+const detectSourceUrl = ($) => {
+    const matchs = $.root()
+        .html()
+        .match(/msg_source_url = '(.+)';/);
+
+    if (matchs) {
+        return matchs[1];
+    }
+    return null;
+};
+
+/**
+ * Articles from WeChat MP have weird formats, this function is used to fix them.
+ *
+ * Even though your content are not directly fetched from WeChat MP, you SHOULD still call this function.
+ * Calling this function is safe in most situations.
+ *
+ * Example usage: item.description = fixArticleContent($('div#js_content.rich_media_content'));
+ * @param {*} html - The html to be fixed, a string or a cheerio object.
+ * @param {boolean} skipImg - Whether to skip fixing images.
+ * @return {string} - The fixed html, a string.
+ */
+const fixArticleContent = (html, skipImg = false) => {
+    html = html && html.html ? html.html() : html; // do not disturb the original tree
+    if (!html) {
+        return '';
+    }
+    const $ = cheerio.load(html, undefined, false);
+    if (!skipImg) {
+        // fix img lazy loading
+        $('img[data-src]').each((_, img) => {
+            img = $(img);
+            const realSrc = img.attr('data-src');
+            if (realSrc) {
+                img.attr('src', realSrc);
+                img.removeAttr('data-src');
+            }
+        });
+    }
+    // fix section
+    $('section').each((_, section) => {
+        section = $(section);
+        const p_count = section.find('p').length;
+        const div_count = section.find('div').length;
+        const section_count = section.find('section').length;
+        if (p_count + div_count + section_count === 0) {
+            // make it a p
+            replaceTag($, section, 'p');
+        } else {
+            // make it a div
+            replaceTag($, section, 'div');
+        }
+    });
+
+    // fix single picture article
+    // example: https://mp.weixin.qq.com/s/4p5YmYuASiQSYFiy7KqydQ
+    $('script').each((_, script) => {
+        script = $(script);
+        const matchs = script.html().match(/document\.getElementById\('js_image_desc'\)\.innerHTML = "(.*)"\.replace/);
+
+        if (matchs) {
+            script.replaceWith(matchs[1].replace(/\r/g, '').replace(/\n/g, '<br>').replace(/\\x0d/g, '').replace(/\\x0a/g, '<br>'));
+        }
+    });
+
+    // clean scripts
+    $('script').remove();
+    return $.html();
+};
+
+// Ref:
+// https://soaked.in/2020/08/wechat-platform-url/
+// Known params (permanent long link):
+// __biz (essential), mid (essential), idx (essential), sn (essential), chksm, mpshare, scene, ascene, subscene, srcid,
+// lang, sharer_sharetime, sharer_shareid, version, exportkey, pass_ticket, clicktime, enterid, devicetype, nettype,
+// abtest_cookie, wx_header
+// Known params (temporary link):
+// src, timestamp, ver, signature, new (unessential)
+const normalizeUrl = (url, bypassHostCheck = false) => {
+    const oriUrl = url;
+    const urlObj = new URL(url);
+    if (!bypassHostCheck && urlObj.host !== 'mp.weixin.qq.com') {
+        throw new Error('wechat-mp: URL host must be "mp.weixin.qq.com", but got ' + oriUrl);
+    }
+    urlObj.protocol = 'https:';
+    urlObj.hash = ''; // remove hash
+    if (urlObj.pathname.match(/^\/s\/.+/)) {
+        // a short link, just remove all the params
+        urlObj.search = '';
+    } else if (urlObj.pathname.match(/^\/s$/)) {
+        const biz = urlObj.searchParams.get('__biz');
+        const mid = urlObj.searchParams.get('mid') || urlObj.searchParams.get('appmsgid');
+        const idx = urlObj.searchParams.get('idx') || urlObj.searchParams.get('itemidx');
+        const sn = urlObj.searchParams.get('sn') || urlObj.searchParams.get('sign');
+        if (biz && mid && idx && sn) {
+            // a permanent long link, remove all unessential params
+            // no need to escape anything so no need to use `new URLSearchParams({...}).toString()`
+            urlObj.search = `?__biz=${biz}&mid=${mid}&idx=${idx}&sn=${sn}`;
+        } else {
+            const src = urlObj.searchParams.get('src');
+            const timestamp = urlObj.searchParams.get('timestamp');
+            const ver = urlObj.searchParams.get('ver');
+            const signature = urlObj.searchParams.get('signature');
+            if (src && timestamp && ver && signature) {
+                // a temporary link, remove all unessential params
+                urlObj.search = `?src=${src}&timestamp=${timestamp}&ver=${ver}&signature=${signature}`;
+            } else {
+                // unknown link, just let it go
+            }
+        }
+    } else {
+        // IDK what it is, just let it go
+    }
+    return urlObj.href;
+};
+
+/**
+ * Fetch article and its metadata from WeChat MP (mp.weixin.qq.com).
+ *
+ * If you use this function, no need to call `fixArticleContent`
+ * @param {object} ctx - The context object.
+ * @param {string} url - The url of the article.
+ * @param {boolean} bypassHostCheck - Whether to bypass host check.
+ * @return {Promise<object>} - An object containing the article and its metadata.
+ */
+const fetchArticle = async (ctx, url, bypassHostCheck = false) => {
+    url = normalizeUrl(url, bypassHostCheck);
+    return await ctx.cache.tryGet(url, async () => {
+        const response = await got(url);
+        const $ = cheerio.load(response.data);
+
+        const title = ($('meta[property="og:title"]').attr('content') || '').replace(/\\r/g, '').replace(/\\n/g, ' ');
+        const author = $('meta[name=author]').attr('content');
+        let summary = $('meta[name=description]').attr('content');
+        summary = summary !== title ? summary : '';
+        let description = fixArticleContent($('#js_content'));
+
+        // No article get or article is too short, try the original url
+        const originalUrl = detectOriginalArticleUrl($);
+        if (originalUrl) {
+            // try to fetch the description from the original article
+            const originalResponse = await got(normalizeUrl(originalUrl, bypassHostCheck));
+            const original$ = cheerio.load(originalResponse.data);
+            description += fixArticleContent(original$('#js_content'));
+        }
+
+        const sourceUrl = detectSourceUrl($);
+        if (sourceUrl) {
+            description += `<a href="${sourceUrl}">阅读原文</a>`;
+        }
+
+        let pubDate;
+        const publish_time_script = $('script[nonce][type="text/javascript"]:contains("var ct")').first().html();
+        const publish_time_match = publish_time_script && publish_time_script.match(/var ct *= *"?(\d{10})"?/);
+        const publish_timestamp = publish_time_match && publish_time_match[1];
+        if (publish_timestamp) {
+            pubDate = parseDate(publish_timestamp * 1000);
+        }
+
+        let mpName = $('.profile_nickname').first().text();
+        mpName = mpName && mpName.trim();
+
+        return { title, author, description, summary, pubDate, mpName, link: url };
+    });
+};
+
+/**
+ * Fetch article and its metadata from WeChat MP (mp.weixin.qq.com), then fill the `item` object with the result.
+ *
+ * If you use this function, no need to call `fetchArticle` or `fixArticleContent`
+ *
+ * A new route SHOULD use this function instead of manually calling the above functions
+ *
+ * An existing route adopting this function SHOULD either:
+ * - set `skipLink` to true (not recommended)
+ * - set `item.guid` to `item.link` BEFORE calling this function
+ * @param {object} ctx - The context object.
+ * @param {object} item - The item object to be filled.
+ * @param {boolean} setMpNameAsAuthor - If `true`, `author` will be the MP itself, otherwise the real author of the article.
+ * @param {boolean} skipLink - Whether to skip overriding `item.link` with the normalized url.
+ * @return {Promise<object>} - The incoming `item` object, with the article and its metadata filled in.
+ */
+const finishArticleItem = async (ctx, item, setMpNameAsAuthor = false, skipLink = false) => {
+    const { title, author, description, summary, pubDate, mpName, link } = await fetchArticle(ctx, item.link);
+    item.title = title || item.title;
+    item.description = description || item.description;
+    item.summary = summary || item.summary;
+    item.pubDate = pubDate || item.pubDate;
+    if (setMpNameAsAuthor) {
+        // the Official Account itself. if your route return articles from different accounts, you may want to use this
+        item.author = mpName || item.author;
+    } else {
+        // the real author of the article. if your route return articles from a certain account, use this
+        item.author = author || item.author;
+    }
+    if (!skipLink) {
+        item.link = link || item.link;
+    }
+    return item;
+};
+
+module.exports = {
+    fixArticleContent,
+    fetchArticle,
+    finishArticleItem, // a new route SHOULD use this function instead of manually calling the above functions
+    _internal: {
+        normalizeUrl, // for internal use only, exported for testing
+    },
+};

package/lib/v2/35photo/actual.js

@@ -0,0 +1,7 @@
+const { rootUrl, ProcessItems } = require('./utils');
+
+module.exports = async (ctx) => {
+    const currentUrl = `${rootUrl}/new/actual`;
+
+    ctx.state.data = await ProcessItems(currentUrl);
+};

package/lib/v2/35photo/author.js

@@ -0,0 +1,9 @@
+const { rootUrl, ProcessItems } = require('./utils');
+
+module.exports = async (ctx) => {
+    const id = ctx.params.id;
+
+    const currentUrl = `${rootUrl}/${id}`;
+
+    ctx.state.data = await ProcessItems(currentUrl);
+};

package/lib/v2/35photo/genre.js

@@ -0,0 +1,9 @@
+const { rootUrl, ProcessItems } = require('./utils');
+
+module.exports = async (ctx) => {
+    const id = ctx.params.id;
+
+    const currentUrl = `${rootUrl}/genre_${id}`;
+
+    ctx.state.data = await ProcessItems(currentUrl);
+};