☰

NGA Filter

NGA 屏蔽插件，支持用户、标记、关键字、属地、小号、流量号、低声望、匿名过滤。troll must die。

当前为 2024-01-03 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name        NGA Filter
  3. // @namespace   https://greasyfork.org/users/263018
  4. // @version     2.0.1
  5. // @author      snyssss
  6. // @description NGA 屏蔽插件，支持用户、标记、关键字、属地、小号、流量号、低声望、匿名过滤。troll must die。
  7. // @license     MIT
  8.  
  9. // @match       *://bbs.nga.cn/*
  10. // @match       *://ngabbs.com/*
  11. // @match       *://nga.178.com/*
  12.  
  13. // @grant       GM_addStyle
  14. // @grant       GM_setValue
  15. // @grant       GM_getValue
  16. // @grant       GM_registerMenuCommand
  17. // @grant       unsafeWindow
  18.  
  19. // @run-at      document-start
  20. // @noframes
  21. // ==/UserScript==
  22.  
  23. (() => {
  24.   // 声明泥潭主模块、菜单模块、主题模块、回复模块
  25.   let commonui, menuModule, topicModule, replyModule;
  26.  
  27.   // KEY
  28.   const DATA_KEY = "NGAFilter";
  29.   const USER_AGENT_KEY = "USER_AGENT_KEY";
  30.   const PRE_FILTER_KEY = "PRE_FILTER_KEY";
  31.   const CLEAR_TIME_KEY = "CLEAR_TIME_KEY";
  32.  
  33.   // User Agent
  34.   const USER_AGENT = (() => {
  35.     const data = GM_getValue(USER_AGENT_KEY) || "Nga_Official";
  36.  
  37.     GM_registerMenuCommand(`修改UA：${data}`, () => {
  38.       const value = prompt("修改UA", data);
  39.  
  40.       if (value) {
  41.         GM_setValue(USER_AGENT_KEY, value);
  42.  
  43.         location.reload();
  44.       }
  45.     });
  46.  
  47.     return data;
  48.   })();
  49.  
  50.   // 前置过滤
  51.   const preFilter = (() => {
  52.     const data = GM_getValue(PRE_FILTER_KEY);
  53.  
  54.     const value = data === undefined ? true : data;
  55.  
  56.     GM_registerMenuCommand(`前置过滤：${value ? "是" : "否"}`, () => {
  57.       GM_setValue(PRE_FILTER_KEY, !value);
  58.  
  59.       location.reload();
  60.     });
  61.  
  62.     return value;
  63.   })();
  64.  
  65.   // STYLE
  66.   GM_addStyle(`
  67.     .filter-table-wrapper {
  68.         max-height: 80vh;
  69.         overflow-y: auto;
  70.     }
  71.     .filter-table {
  72.         margin: 0;
  73.     }
  74.     .filter-table th,
  75.     .filter-table td {
  76.         position: relative;
  77.         white-space: nowrap;
  78.     }
  79.     .filter-table th {
  80.         position: sticky;
  81.         top: 2px;
  82.         z-index: 1;
  83.     }
  84.     .filter-table input:not([type]), .filter-table input[type="text"] {
  85.         margin: 0;
  86.         box-sizing: border-box;
  87.         height: 100%;
  88.         width: 100%;
  89.     }
  90.     .filter-input-wrapper {
  91.         position: absolute;
  92.         top: 6px;
  93.         right: 6px;
  94.         bottom: 6px;
  95.         left: 6px;
  96.     }
  97.     .filter-text-ellipsis {
  98.         display: flex;
  99.     }
  100.     .filter-text-ellipsis > * {
  101.         flex: 1;
  102.         width: 1px;
  103.         overflow: hidden;
  104.         text-overflow: ellipsis;
  105.     }
  106.     .filter-button-group {
  107.         margin: -.1em -.2em;
  108.     }
  109.     .filter-tags {
  110.         margin: 2px -0.2em 0;
  111.         text-align: left;
  112.     }
  113.     .filter-mask {
  114.         margin: 1px;
  115.         color: #81C7D4;
  116.         background: #81C7D4;
  117.     }
  118.     .filter-mask-block {
  119.         display: block;
  120.         border: 1px solid #66BAB7;
  121.         text-align: center !important;
  122.     }
  123.     .filter-input-wrapper {
  124.       position: absolute;
  125.       top: 6px;
  126.       right: 6px;
  127.       bottom: 6px;
  128.       left: 6px;
  129.     }
  130.   `);
  131.  
  132.   // 重新过滤
  133.   // TODO 暂时全部重新过滤，应该根据修改的设置来过滤相应数据
  134.   const reFilter = async () => {
  135.     listModule.clear();
  136.  
  137.     if (topicModule) {
  138.       await Promise.all(
  139.         Object.values(topicModule.data).map(
  140.           (item) => item.nFilter && item.nFilter.execute()
  141.         )
  142.       );
  143.     }
  144.  
  145.     if (replyModule) {
  146.       await Promise.all(
  147.         Object.values(replyModule.data).map(
  148.           (item) => item.nFilter && item.nFilter.execute()
  149.         )
  150.       );
  151.     }
  152.   };
  153.  
  154.   // 缓存模块
  155.   const cacheModule = (() => {
  156.     // 声明模块集合
  157.     const modules = {};
  158.  
  159.     // IndexedDB 操作
  160.     const db = (() => {
  161.       // 常量
  162.       const VERSION = 1;
  163.       const DB_NAME = "NGA_FILTER_CACHE";
  164.  
  165.       // 是否支持
  166.       const support = unsafeWindow.indexedDB !== undefined;
  167.  
  168.       // 不支持，直接返回
  169.       if (support === false) {
  170.         return {
  171.           support,
  172.         };
  173.       }
  174.  
  175.       // 创建或获取数据库实例
  176.       const getInstance = (() => {
  177.         let instance;
  178.  
  179.         return () =>
  180.           new Promise((resolve) => {
  181.             // 如果已存在实例，直接返回
  182.             if (instance) {
  183.               resolve(instance);
  184.               return;
  185.             }
  186.  
  187.             // 打开 IndexedDB 数据库
  188.             const request = unsafeWindow.indexedDB.open(DB_NAME, VERSION);
  189.  
  190.             // 如果数据库不存在则创建
  191.             request.onupgradeneeded = (event) => {
  192.               Object.entries(modules).map(([name, keyPath]) => {
  193.                 // 创建表
  194.                 const store = event.target.result.createObjectStore(name, {
  195.                   keyPath,
  196.                 });
  197.  
  198.                 // 创建索引，用于清除过期数据
  199.                 store.createIndex("timestamp", "timestamp");
  200.               });
  201.             };
  202.  
  203.             // 成功后写入实例并返回
  204.             request.onsuccess = (event) => {
  205.               instance = event.target.result;
  206.  
  207.               resolve(instance);
  208.             };
  209.           });
  210.       })();
  211.  
  212.       return {
  213.         support,
  214.         getInstance,
  215.       };
  216.     })();
  217.  
  218.     // 删除缓存
  219.     const remove = async (name, key) => {
  220.       // 不支持 IndexedDB，使用 GM_setValue
  221.       if (db.support === false) {
  222.         const cache = GM_getValue(name) || {};
  223.  
  224.         delete cache[key];
  225.  
  226.         GM_setValue(name, cache);
  227.         return;
  228.       }
  229.  
  230.       // 获取实例
  231.       const instance = await db.getInstance();
  232.  
  233.       // 写入 IndexedDB
  234.       await new Promise((resolve) => {
  235.         // 创建事务
  236.         const transaction = instance.transaction([name], "readwrite");
  237.  
  238.         // 获取对象仓库
  239.         const store = transaction.objectStore(name);
  240.  
  241.         // 删除数据
  242.         const r = store.delete(key);
  243.  
  244.         r.onsuccess = () => {
  245.           resolve();
  246.         };
  247.  
  248.         r.onerror = () => {
  249.           resolve();
  250.         };
  251.  
  252.         // 失败后处理
  253.         request.onerror = () => {
  254.           resolve();
  255.         };
  256.       });
  257.     };
  258.  
  259.     // 写入缓存
  260.     const save = async (name, key, value) => {
  261.       // 不支持 IndexedDB，使用 GM_setValue
  262.       if (db.support === false) {
  263.         const cache = GM_getValue(name) || {};
  264.  
  265.         cache[key] = value;
  266.  
  267.         GM_setValue(name, cache);
  268.         return;
  269.       }
  270.  
  271.       // 获取实例
  272.       const instance = await db.getInstance();
  273.  
  274.       // 写入 IndexedDB
  275.       await new Promise((resolve) => {
  276.         // 创建事务
  277.         const transaction = instance.transaction([name], "readwrite");
  278.  
  279.         // 获取对象仓库
  280.         const store = transaction.objectStore(name);
  281.  
  282.         // 插入数据
  283.         const r = store.put({
  284.           ...value,
  285.           timestamp: Date.now(),
  286.         });
  287.  
  288.         r.onsuccess = () => {
  289.           resolve();
  290.         };
  291.  
  292.         r.onerror = () => {
  293.           resolve();
  294.         };
  295.  
  296.         // 失败后处理
  297.         request.onerror = () => {
  298.           resolve();
  299.         };
  300.       });
  301.     };
  302.  
  303.     // 读取缓存
  304.     const load = async (name, key, expireTime) => {
  305.       // 不支持 IndexedDB，使用 GM_getValue
  306.       if (db.support === false) {
  307.         const cache = GM_getValue(name) || {};
  308.  
  309.         if (cache[key]) {
  310.           return cache[key];
  311.         }
  312.  
  313.         return null;
  314.       }
  315.  
  316.       // 获取实例
  317.       const instance = await db.getInstance();
  318.  
  319.       // 查找 IndexedDB
  320.       const result = await new Promise((resolve) => {
  321.         // 创建事务
  322.         const transaction = instance.transaction([name], "readonly");
  323.  
  324.         // 获取对象仓库
  325.         const store = transaction.objectStore(name);
  326.  
  327.         // 获取数据
  328.         const request = store.get(key);
  329.  
  330.         // 成功后处理数据
  331.         request.onsuccess = (event) => {
  332.           const data = event.target.result;
  333.  
  334.           if (data) {
  335.             resolve(data);
  336.             return;
  337.           }
  338.  
  339.           resolve(null);
  340.         };
  341.  
  342.         // 失败后处理
  343.         request.onerror = () => {
  344.           resolve(null);
  345.         };
  346.       });
  347.  
  348.       // 没有数据
  349.       if (result === null) {
  350.         return null;
  351.       }
  352.  
  353.       // 如果已超时则删除
  354.       if (result.timestamp + expireTime < new Date().getTime()) {
  355.         await remove(name, key);
  356.         
  357.         return null;
  358.       }
  359.  
  360.       // 返回结果
  361.       return result;
  362.     };
  363.  
  364.     // 定时清理
  365.     const clear = async (list = Object.keys(modules)) => {
  366.       // 获取实例
  367.       const instance = await db.getInstance();
  368.  
  369.       // 清理 IndexedDB
  370.       list.map((name) => {
  371.         // 创建事务
  372.         const transaction = instance.transaction([name], "readwrite");
  373.  
  374.         // 获取对象仓库
  375.         const store = transaction.objectStore(name);
  376.  
  377.         // 清理数据
  378.         store.clear();
  379.       });
  380.     };
  381.  
  382.     // 初始化，用于写入表信息
  383.     const init = (name, keyPath) => {
  384.       modules[name] = keyPath;
  385.     };
  386.  
  387.     return {
  388.       init,
  389.       save,
  390.       load,
  391.       remove,
  392.       clear,
  393.     };
  394.   })();
  395.  
  396.   // 过滤模块
  397.   const filterModule = (() => {
  398.     // 过滤提示
  399.     const tips =
  400.       "过滤顺序：用户 &gt; 标记 &gt; 关键字 &gt; 属地<br/>过滤级别：显示 &gt; 隐藏 &gt; 遮罩 &gt; 标记 &gt; 继承";
  401.  
  402.     // 过滤方式
  403.     const modes = ["继承", "标记", "遮罩", "隐藏", "显示"];
  404.  
  405.     // 默认过滤方式
  406.     const defaultMode = modes[0];
  407.  
  408.     // 切换过滤方式
  409.     const switchModeByName = (value) =>
  410.       modes[modes.indexOf(value) + 1] || defaultMode;
  411.  
  412.     // 获取当前过滤方式下标
  413.     const getModeByName = (name, defaultValue = 0) => {
  414.       const index = modes.indexOf(name);
  415.  
  416.       if (index < 0) {
  417.         return defaultValue;
  418.       }
  419.  
  420.       return index;
  421.     };
  422.  
  423.     // 获取指定下标过滤方式
  424.     const getNameByMode = (index) => modes[index] || "";
  425.  
  426.     // 折叠样式
  427.     const collapse = (uid, element, content) => {
  428.       element.innerHTML = `
  429.         <div class="lessernuke" style="background: #81C7D4; border-color: #66BAB7;">
  430.             <span class="crimson">Troll must die.</span>
  431.             <a href="javascript:void(0)" onclick="[...document.getElementsByName('troll_${uid}')].forEach(item => item.style.display = '')">点击查看</a>
  432.             <div style="display: none;" name="troll_${uid}">
  433.                 ${content}
  434.             </div>
  435.         </div>`;
  436.     };
  437.  
  438.     return {
  439.       tips,
  440.       modes,
  441.       defaultMode,
  442.       collapse,
  443.       getModeByName,
  444.       getNameByMode,
  445.       switchModeByName,
  446.     };
  447.   })();
  448.  
  449.   // 数据（及配置）模块
  450.   const dataModule = (() => {
  451.     // 合并数据
  452.     const merge = (() => {
  453.       const isObject = (value) => {
  454.         return value !== null && typeof value === "object";
  455.       };
  456.  
  457.       const deepClone = (value) => {
  458.         if (isObject(value)) {
  459.           const clone = Array.isArray(value) ? [] : {};
  460.  
  461.           for (const key in value) {
  462.             if (Object.prototype.hasOwnProperty.call(value, key)) {
  463.               clone[key] = deepClone(value[key]);
  464.             }
  465.           }
  466.  
  467.           return clone;
  468.         }
  469.  
  470.         return value;
  471.       };
  472.  
  473.       return (target, ...sources) => {
  474.         for (const source of sources) {
  475.           for (const key in source) {
  476.             if (isObject(source[key])) {
  477.               if (isObject(target[key])) {
  478.                 merge(target[key], source[key]);
  479.               } else {
  480.                 target[key] = deepClone(source[key]);
  481.               }
  482.             } else {
  483.               target[key] = source[key];
  484.             }
  485.           }
  486.         }
  487.  
  488.         return target;
  489.       };
  490.     })();
  491.  
  492.     // 初始化数据
  493.     const data = (() => {
  494.       // 默认配置
  495.       const defaultData = {
  496.         tags: {},
  497.         users: {},
  498.         keywords: {},
  499.         locations: {},
  500.         options: {
  501.           filterRegdateLimit: 0,
  502.           filterPostnumLimit: 0,
  503.           filterTopicRateLimit: 100,
  504.           filterReputationLimit: NaN,
  505.           filterAnony: false,
  506.           filterMode: "隐藏",
  507.         },
  508.       };
  509.  
  510.       // 读取数据
  511.       const storedData = GM_getValue(DATA_KEY);
  512.  
  513.       // 如果没有数据，则返回默认配置
  514.       if (typeof storedData !== "object") {
  515.         return defaultData;
  516.       }
  517.  
  518.       // 返回数据
  519.       return merge(defaultData, storedData);
  520.     })();
  521.  
  522.     // 保存数据
  523.     const save = (values) => {
  524.       merge(data, values);
  525.  
  526.       GM_setValue(DATA_KEY, data);
  527.     };
  528.  
  529.     // 返回标记列表
  530.     const getTags = () => data.tags;
  531.  
  532.     // 返回用户列表
  533.     const getUsers = () => data.users;
  534.  
  535.     // 返回关键字列表
  536.     const getKeywords = () => data.keywords;
  537.  
  538.     // 返回属地列表
  539.     const getLocations = () => data.locations;
  540.  
  541.     // 获取默认过滤模式
  542.     const getDefaultFilterMode = () => data.options.filterMode;
  543.  
  544.     // 设置默认过滤模式
  545.     const setDefaultFilterMode = (value) => {
  546.       save({
  547.         options: {
  548.           filterMode: value,
  549.         },
  550.       });
  551.     };
  552.  
  553.     // 获取注册时间限制
  554.     const getFilterRegdateLimit = () => data.options.filterRegdateLimit || 0;
  555.  
  556.     // 设置注册时间限制
  557.     const setFilterRegdateLimit = (value) => {
  558.       save({
  559.         options: {
  560.           filterRegdateLimit: value,
  561.         },
  562.       });
  563.     };
  564.  
  565.     // 获取发帖数量限制
  566.     const getFilterPostnumLimit = () => data.options.filterPostnumLimit || 0;
  567.  
  568.     // 设置发帖数量限制
  569.     const setFilterPostnumLimit = (value) => {
  570.       save({
  571.         options: {
  572.           filterPostnumLimit: value,
  573.         },
  574.       });
  575.     };
  576.  
  577.     // 获取发帖比例限制
  578.     const getFilterTopicRateLimit = () =>
  579.       data.options.filterTopicRateLimit || 100;
  580.  
  581.     // 设置发帖比例限制
  582.     const setFilterTopicRateLimit = (value) => {
  583.       save({
  584.         options: {
  585.           filterTopicRateLimit: value,
  586.         },
  587.       });
  588.     };
  589.  
  590.     // 获取用户声望限制
  591.     const getFilterReputationLimit = () =>
  592.       data.options.filterReputationLimit || NaN;
  593.  
  594.     // 设置用户声望限制
  595.     const setFilterReputationLimit = (value) => {
  596.       save({
  597.         options: {
  598.           filterReputationLimit: value,
  599.         },
  600.       });
  601.     };
  602.  
  603.     // 获取是否过滤匿名
  604.     const getFilterAnony = () => data.options.filterAnony || false;
  605.  
  606.     // 设置是否过滤匿名
  607.     const setFilterAnony = (value) => {
  608.       save({
  609.         options: {
  610.           filterAnony: value,
  611.         },
  612.       });
  613.     };
  614.  
  615.     return {
  616.       save,
  617.       getTags,
  618.       getUsers,
  619.       getKeywords,
  620.       getLocations,
  621.       getDefaultFilterMode,
  622.       setDefaultFilterMode,
  623.       getFilterRegdateLimit,
  624.       setFilterRegdateLimit,
  625.       getFilterPostnumLimit,
  626.       setFilterPostnumLimit,
  627.       getFilterTopicRateLimit,
  628.       setFilterTopicRateLimit,
  629.       getFilterReputationLimit,
  630.       setFilterReputationLimit,
  631.       getFilterAnony,
  632.       setFilterAnony,
  633.     };
  634.   })();
  635.  
  636.   // 列表模块
  637.   const listModule = (() => {
  638.     const list = [];
  639.  
  640.     const callback = [];
  641.  
  642.     // UI
  643.     const view = (() => {
  644.       const content = (() => {
  645.         const element = document.createElement("DIV");
  646.  
  647.         element.style = "display: none";
  648.         element.innerHTML = `
  649.           <div class="filter-table-wrapper">
  650.             <table class="filter-table forumbox">
  651.               <thead>
  652.                 <tr class="block_txt_c0">
  653.                   <th class="c1" width="1">用户</th>
  654.                   <th class="c2" width="1">过滤方式</th>
  655.                   <th class="c3">内容</th>
  656.                   <th class="c4" width="1">原因</th>
  657.                 </tr>
  658.               </thead>
  659.               <tbody></tbody>
  660.             </table>
  661.           </div>
  662.         `;
  663.  
  664.         return element;
  665.       })();
  666.  
  667.       const tbody = content.querySelector("TBODY");
  668.  
  669.       const load = ({ user, mode, subject, content, reason }) => {
  670.         const row = document.createElement("TR");
  671.  
  672.         row.className = `row${(tbody.querySelectorAll("TR").length % 2) + 1}`;
  673.  
  674.         row.innerHTML = `
  675.           <td class="c1">${user}</td>
  676.           <td class="c2">${mode}</td>
  677.           <td class="c3">
  678.             <div class="filter-text-ellipsis">
  679.               ${subject || content}
  680.             </div>
  681.           </td>
  682.           <td class="c4">${reason}</td>
  683.         `;
  684.  
  685.         tbody.insertBefore(row, tbody.firstChild);
  686.       };
  687.  
  688.       const refresh = () => {
  689.         tbody.innerHTML = "";
  690.  
  691.         Object.values(list).forEach(load);
  692.       };
  693.  
  694.       return {
  695.         content,
  696.         refresh,
  697.         load,
  698.       };
  699.     })();
  700.  
  701.     const add = (value) => {
  702.       if (
  703.         list.find(
  704.           (item) =>
  705.             item.user === value.user &&
  706.             item.mode === value.mode &&
  707.             item.subject === value.subject &&
  708.             item.content === value.content &&
  709.             item.reason === value.reason
  710.         )
  711.       ) {
  712.         return;
  713.       }
  714.  
  715.       list.push(value);
  716.  
  717.       view.load(value);
  718.  
  719.       callback.forEach((item) => item(list));
  720.     };
  721.  
  722.     const clear = () => {
  723.       list.splice(0, list.length);
  724.  
  725.       view.refresh();
  726.  
  727.       callback.forEach((item) => item(list));
  728.     };
  729.  
  730.     const bindCallback = (func) => {
  731.       func(list);
  732.  
  733.       callback.push(func);
  734.     };
  735.  
  736.     return {
  737.       add,
  738.       clear,
  739.       bindCallback,
  740.       view,
  741.     };
  742.   })();
  743.  
  744.   // 用户模块
  745.   const userModule = (() => {
  746.     // 获取用户列表
  747.     const list = () => dataModule.getUsers();
  748.  
  749.     // 获取用户
  750.     const get = (uid) => {
  751.       // 获取列表
  752.       const users = list();
  753.  
  754.       // 如果已存在，则返回信息
  755.       if (users[uid]) {
  756.         return users[uid];
  757.       }
  758.  
  759.       return null;
  760.     };
  761.  
  762.     // 增加用户
  763.     const add = (uid, username, tags, filterMode) => {
  764.       // 获取对应的用户
  765.       const user = get(uid);
  766.  
  767.       // 如果用户已存在，则返回用户信息，否则增加用户
  768.       if (user) {
  769.         return user;
  770.       }
  771.  
  772.       // 保存用户
  773.       // TODO id 和 name 属于历史遗留问题，应该改为 uid 和 username 以便更好的理解
  774.       dataModule.save({
  775.         users: {
  776.           [uid]: {
  777.             id: uid,
  778.             name: username,
  779.             tags,
  780.             filterMode,
  781.           },
  782.         },
  783.       });
  784.  
  785.       // 返回用户信息
  786.       return get(uid);
  787.     };
  788.  
  789.     // 编辑用户
  790.     const edit = (uid, values) => {
  791.       dataModule.save({
  792.         users: {
  793.           [uid]: values,
  794.         },
  795.       });
  796.     };
  797.  
  798.     // 删除用户
  799.     const remove = (uid) => {
  800.       // TODO 这里不可避免的直接操作了原始数据
  801.       delete list()[uid];
  802.  
  803.       // 保存数据
  804.       dataModule.save({});
  805.     };
  806.  
  807.     // 格式化用户
  808.     const format = (uid, name) => {
  809.       if (uid <= 0) {
  810.         return "";
  811.       }
  812.  
  813.       const user = get(uid);
  814.  
  815.       if (user) {
  816.         name = name || user.name;
  817.       }
  818.  
  819.       const username = name ? "@" + name : "#" + uid;
  820.  
  821.       return `<a href="/nuke.php?func=ucp&uid=${uid}" class="b nobr">[${username}]</a>`;
  822.     };
  823.  
  824.     // UI
  825.     const view = (() => {
  826.       const details = (() => {
  827.         let window;
  828.  
  829.         return (uid, name, callback) => {
  830.           if (window === undefined) {
  831.             window = commonui.createCommmonWindow();
  832.           }
  833.  
  834.           const user = get(uid);
  835.  
  836.           const content = document.createElement("DIV");
  837.  
  838.           const size = Math.floor((screen.width * 0.8) / 200);
  839.  
  840.           const items = Object.values(tagModule.list()).map((tag, index) => {
  841.             const checked = user && user.tags.includes(tag.id) ? "checked" : "";
  842.  
  843.             return `
  844.               <td class="c1">
  845.                 <label for="s-tag-${index}" style="display: block; cursor: pointer;">
  846.                   ${tagModule.format(tag.id)}
  847.                 </label>
  848.               </td>
  849.               <td class="c2" width="1">
  850.                 <input id="s-tag-${index}" type="checkbox" value="${
  851.               tag.id
  852.             }" ${checked}/>
  853.               </td>
  854.             `;
  855.           });
  856.  
  857.           const rows = [...new Array(Math.ceil(items.length / size))].map(
  858.             (_, index) => `
  859.               <tr class="row${(index % 2) + 1}">
  860.                 ${items.slice(size * index, size * (index + 1)).join("")}
  861.               </tr>
  862.             `
  863.           );
  864.  
  865.           content.className = "w100";
  866.           content.innerHTML = `
  867.             <div class="filter-table-wrapper" style="width: 80vw;">
  868.               <table class="filter-table forumbox">
  869.                 <tbody>
  870.                   ${rows.join("")}
  871.                 </tbody>
  872.               </table>
  873.             </div>
  874.             <div style="margin: 10px 0;">
  875.               <input type="text" placeholder="一次性添加多个标记用&quot;|&quot;隔开，不会添加重名标记" style="width: -webkit-fill-available;" />
  876.             </div>
  877.             <div style="margin: 10px 0;">
  878.               <span>过滤方式：</span>
  879.               <button>${
  880.                 (user && user.filterMode) || filterModule.defaultMode
  881.               }</button>
  882.               <div class="right_">
  883.                 <button>删除</button>
  884.                 <button>保存</button>
  885.               </div>
  886.             </div>
  887.             <div class="silver" style="margin-top: 5px;">${
  888.               filterModule.tips
  889.             }</div>
  890.           `;
  891.  
  892.           const actions = content.querySelectorAll("BUTTON");
  893.  
  894.           actions[0].onclick = () => {
  895.             actions[0].innerText = filterModule.switchModeByName(
  896.               actions[0].innerText
  897.             );
  898.           };
  899.  
  900.           actions[1].onclick = () => {
  901.             if (confirm("是否确认?") === false) {
  902.               return;
  903.             }
  904.  
  905.             remove(uid);
  906.             reFilter();
  907.  
  908.             if (callback) {
  909.               callback({
  910.                 id: null,
  911.               });
  912.             }
  913.  
  914.             window._.hide();
  915.           };
  916.  
  917.           actions[2].onclick = () => {
  918.             if (confirm("是否确认?") === false) {
  919.               return;
  920.             }
  921.  
  922.             const filterMode = actions[0].innerText;
  923.  
  924.             const checked = [...content.querySelectorAll("INPUT:checked")].map(
  925.               (input) => parseInt(input.value, 10)
  926.             );
  927.  
  928.             const newTags = content
  929.               .querySelector("INPUT[type='text']")
  930.               .value.split("|")
  931.               .filter((item) => item.length)
  932.               .map((item) => tagModule.add(item));
  933.  
  934.             const tags = [...new Set([...checked, ...newTags])].sort();
  935.  
  936.             if (user) {
  937.               user.tags = tags;
  938.  
  939.               edit(uid, {
  940.                 filterMode,
  941.               });
  942.             } else {
  943.               add(uid, name, tags, filterMode);
  944.             }
  945.  
  946.             reFilter();
  947.  
  948.             if (callback) {
  949.               callback({
  950.                 uid,
  951.                 name,
  952.                 tags,
  953.                 filterMode,
  954.               });
  955.             }
  956.  
  957.             window._.hide();
  958.           };
  959.  
  960.           if (user === null) {
  961.             actions[1].style.display = "none";
  962.           }
  963.  
  964.           window._.addContent(null);
  965.           window._.addTitle(`编辑标记 - ${name ? name : "#" + uid}`);
  966.           window._.addContent(content);
  967.           window._.show();
  968.         };
  969.       })();
  970.  
  971.       const content = (() => {
  972.         const element = document.createElement("DIV");
  973.  
  974.         element.style = "display: none";
  975.         element.innerHTML = `
  976.           <div class="filter-table-wrapper">
  977.             <table class="filter-table forumbox">
  978.               <thead>
  979.                 <tr class="block_txt_c0">
  980.                   <th class="c1" width="1">昵称</th>
  981.                   <th class="c2">标记</th>
  982.                   <th class="c3" width="1">过滤方式</th>
  983.                   <th class="c4" width="1">操作</th>
  984.                 </tr>
  985.               </thead>
  986.               <tbody></tbody>
  987.             </table>
  988.           </div>
  989.         `;
  990.  
  991.         return element;
  992.       })();
  993.  
  994.       let index = 0;
  995.       let size = 50;
  996.       let hasNext = false;
  997.  
  998.       const box = content.querySelector("DIV");
  999.  
  1000.       const tbody = content.querySelector("TBODY");
  1001.  
  1002.       const wrapper = content.querySelector(".filter-table-wrapper");
  1003.  
  1004.       const load = ({ id, name, tags, filterMode }, anchor = null) => {
  1005.         if (id === null) {
  1006.           if (anchor) {
  1007.             tbody.removeChild(anchor);
  1008.           }
  1009.           return;
  1010.         }
  1011.  
  1012.         if (anchor === null) {
  1013.           anchor = document.createElement("TR");
  1014.  
  1015.           anchor.className = `row${
  1016.             (tbody.querySelectorAll("TR").length % 2) + 1
  1017.           }`;
  1018.  
  1019.           tbody.appendChild(anchor);
  1020.         }
  1021.  
  1022.         anchor.innerHTML = `
  1023.           <td class="c1">
  1024.             ${format(id, name)}
  1025.           </td>
  1026.           <td class="c2">
  1027.             ${tags.map(tagModule.format).join("")}
  1028.           </td>
  1029.           <td class="c3">
  1030.             <div class="filter-table-button-group">
  1031.               <button>${filterMode || filterModule.defaultMode}</button>
  1032.             </div>
  1033.           </td>
  1034.           <td class="c4">
  1035.             <div class="filter-table-button-group">
  1036.               <button>编辑</button>
  1037.               <button>删除</button>
  1038.             </div>
  1039.           </td>
  1040.         `;
  1041.  
  1042.         const actions = anchor.querySelectorAll("BUTTON");
  1043.  
  1044.         actions[0].onclick = () => {
  1045.           const filterMode = filterModule.switchModeByName(
  1046.             actions[0].innerHTML
  1047.           );
  1048.  
  1049.           actions[0].innerHTML = filterMode;
  1050.  
  1051.           edit(id, { filterMode });
  1052.           reFilter();
  1053.         };
  1054.  
  1055.         actions[1].onclick = () => {
  1056.           details(id, name, (item) => {
  1057.             load(item, anchor);
  1058.           });
  1059.         };
  1060.  
  1061.         actions[2].onclick = () => {
  1062.           if (confirm("是否确认?") === false) {
  1063.             return;
  1064.           }
  1065.  
  1066.           tbody.removeChild(anchor);
  1067.  
  1068.           remove(id);
  1069.           reFilter();
  1070.         };
  1071.       };
  1072.  
  1073.       const loadNext = () => {
  1074.         hasNext = index + size < Object.keys(list()).length;
  1075.  
  1076.         Object.values(list())
  1077.           .slice(index, index + size)
  1078.           .forEach((item) => load(item));
  1079.  
  1080.         index += size;
  1081.       };
  1082.  
  1083.       box.onscroll = () => {
  1084.         if (hasNext === false) {
  1085.           return;
  1086.         }
  1087.  
  1088.         if (
  1089.           box.scrollHeight - box.scrollTop - box.clientHeight <=
  1090.           wrapper.clientHeight
  1091.         ) {
  1092.           loadNext();
  1093.         }
  1094.       };
  1095.  
  1096.       const refresh = () => {
  1097.         index = 0;
  1098.  
  1099.         tbody.innerHTML = "";
  1100.  
  1101.         loadNext();
  1102.       };
  1103.  
  1104.       return {
  1105.         content,
  1106.         details,
  1107.         refresh,
  1108.       };
  1109.     })();
  1110.  
  1111.     return {
  1112.       list,
  1113.       get,
  1114.       add,
  1115.       edit,
  1116.       remove,
  1117.       format,
  1118.       view,
  1119.     };
  1120.   })();
  1121.  
  1122.   // 标记模块
  1123.   const tagModule = (() => {
  1124.     // 获取标记列表
  1125.     const list = () => dataModule.getTags();
  1126.  
  1127.     // 获取标记
  1128.     const get = ({ id, name }) => {
  1129.       // 获取列表
  1130.       const tags = list();
  1131.  
  1132.       // 通过 ID 获取标记
  1133.       if (tags[id]) {
  1134.         return tags[id];
  1135.       }
  1136.  
  1137.       // 通过名称获取标记
  1138.       if (name) {
  1139.         const tag = Object.values(tags).find((item) => item.name === name);
  1140.  
  1141.         if (tag) {
  1142.           return tag;
  1143.         }
  1144.       }
  1145.  
  1146.       return null;
  1147.     };
  1148.  
  1149.     // 增加标记
  1150.     const add = (name) => {
  1151.       // 获取对应的标记
  1152.       const tag = get({ name });
  1153.  
  1154.       // 如果标记已存在，则返回标记信息，否则增加标记
  1155.       if (tag) {
  1156.         return tag;
  1157.       }
  1158.  
  1159.       // ID 为最大值 + 1
  1160.       const id = Math.max(Object.keys(list()), 0) + 1;
  1161.  
  1162.       // 标记的颜色
  1163.       // 采用的是泥潭的颜色方案，参见 commonui.htmlName
  1164.       const color = (() => {
  1165.         const hash = (() => {
  1166.           let h = 5381;
  1167.  
  1168.           for (var i = 0; i < name.length; i++) {
  1169.             h = ((h << 5) + h + name.charCodeAt(i)) & 0xffffffff;
  1170.           }
  1171.  
  1172.           return h;
  1173.         })();
  1174.  
  1175.         const hex = Math.abs(hash).toString(16) + "000000";
  1176.  
  1177.         const hsv = [
  1178.           `0x${hex.substring(2, 4)}` / 255,
  1179.           `0x${hex.substring(2, 4)}` / 255 / 2 + 0.25,
  1180.           `0x${hex.substring(4, 6)}` / 255 / 2 + 0.25,
  1181.         ];
  1182.  
  1183.         const rgb = commonui.hsvToRgb(hsv[0], hsv[1], hsv[2]);
  1184.  
  1185.         return ["#", ...rgb].reduce((a, b) => {
  1186.           return a + ("0" + b.toString(16)).slice(-2);
  1187.         });
  1188.       })();
  1189.  
  1190.       // 保存标记
  1191.       dataModule.save({
  1192.         tags: {
  1193.           [id]: {
  1194.             id,
  1195.             name,
  1196.             color,
  1197.             filterMode: filterModule.defaultMode,
  1198.           },
  1199.         },
  1200.       });
  1201.  
  1202.       // 返回标记信息
  1203.       return get({ id });
  1204.     };
  1205.  
  1206.     // 编辑标记
  1207.     const edit = (id, values) => {
  1208.       dataModule.save({
  1209.         tags: {
  1210.           [id]: values,
  1211.         },
  1212.       });
  1213.     };
  1214.  
  1215.     // 删除标记
  1216.     const remove = (id) => {
  1217.       // TODO 这里不可避免的直接操作了原始数据
  1218.       delete list()[id];
  1219.  
  1220.       // 删除用户对应的标记
  1221.       Object.values(userModule.list()).forEach((user) => {
  1222.         const index = user.tags.findIndex((tag) => tag === id);
  1223.  
  1224.         if (index >= 0) {
  1225.           user.tags.splice(index, 1);
  1226.         }
  1227.       });
  1228.  
  1229.       // 保存数据
  1230.       dataModule.save({});
  1231.     };
  1232.  
  1233.     // 格式化标记
  1234.     const format = (id) => {
  1235.       const tag = get({ id });
  1236.  
  1237.       if (tag) {
  1238.         return `<b class="block_txt nobr" style="background: ${tag.color}; color: #FFF; margin: 0.1em 0.2em;">${tag.name}</b>`;
  1239.       }
  1240.  
  1241.       return "";
  1242.     };
  1243.  
  1244.     // UI
  1245.     const view = (() => {
  1246.       const content = (() => {
  1247.         const element = document.createElement("DIV");
  1248.  
  1249.         element.style = "display: none";
  1250.         element.innerHTML = `
  1251.           <div class="filter-table-wrapper">
  1252.             <table class="filter-table forumbox">
  1253.               <thead>
  1254.                 <tr class="block_txt_c0">
  1255.                   <th class="c1" width="1">标记</th>
  1256.                   <th class="c2">列表</th>
  1257.                   <th class="c3" width="1">过滤方式</th>
  1258.                   <th class="c4" width="1">操作</th>
  1259.                 </tr>
  1260.               </thead>
  1261.               <tbody></tbody>
  1262.             </table>
  1263.           </div>
  1264.         `;
  1265.  
  1266.         return element;
  1267.       })();
  1268.  
  1269.       let index = 0;
  1270.       let size = 50;
  1271.       let hasNext = false;
  1272.  
  1273.       const box = content.querySelector("DIV");
  1274.  
  1275.       const tbody = content.querySelector("TBODY");
  1276.  
  1277.       const wrapper = content.querySelector(".filter-table-wrapper");
  1278.  
  1279.       const load = ({ id, filterMode }, anchor = null) => {
  1280.         if (id === null) {
  1281.           if (anchor) {
  1282.             tbody.removeChild(anchor);
  1283.           }
  1284.           return;
  1285.         }
  1286.  
  1287.         if (anchor === null) {
  1288.           anchor = document.createElement("TR");
  1289.  
  1290.           anchor.className = `row${
  1291.             (tbody.querySelectorAll("TR").length % 2) + 1
  1292.           }`;
  1293.  
  1294.           tbody.appendChild(anchor);
  1295.         }
  1296.  
  1297.         const users = Object.values(userModule.list());
  1298.  
  1299.         const filteredUsers = users.filter((user) => user.tags.includes(id));
  1300.  
  1301.         anchor.innerHTML = `
  1302.           <td class="c1">
  1303.             ${format(id)}
  1304.           </td>
  1305.           <td class="c2">
  1306.             <button>${filteredUsers.length}</button>
  1307.             <div style="white-space: normal; display: none;">
  1308.               ${filteredUsers
  1309.                 .map((user) => userModule.format(user.id))
  1310.                 .join("")}
  1311.             </div>
  1312.           </td>
  1313.           <td class="c3">
  1314.             <div class="filter-table-button-group">
  1315.               <button>${filterMode || filterModule.defaultMode}</button>
  1316.             </div>
  1317.           </td>
  1318.           <td class="c4">
  1319.             <div class="filter-table-button-group">
  1320.               <button>删除</button>
  1321.             </div>
  1322.           </td>
  1323.         `;
  1324.  
  1325.         const actions = anchor.querySelectorAll("BUTTON");
  1326.  
  1327.         actions[0].onclick = (() => {
  1328.           let hide = true;
  1329.  
  1330.           return () => {
  1331.             hide = !hide;
  1332.  
  1333.             actions[0].nextElementSibling.style.display = hide
  1334.               ? "none"
  1335.               : "block";
  1336.           };
  1337.         })();
  1338.  
  1339.         actions[1].onclick = () => {
  1340.           const filterMode = filterModule.switchModeByName(
  1341.             actions[1].innerHTML
  1342.           );
  1343.  
  1344.           actions[1].innerHTML = filterMode;
  1345.  
  1346.           edit(id, { filterMode });
  1347.           reFilter();
  1348.         };
  1349.  
  1350.         actions[2].onclick = () => {
  1351.           if (confirm("是否确认?") === false) {
  1352.             return;
  1353.           }
  1354.  
  1355.           tbody.removeChild(anchor);
  1356.  
  1357.           remove(id);
  1358.           reFilter();
  1359.         };
  1360.       };
  1361.  
  1362.       const loadNext = () => {
  1363.         hasNext = index + size < Object.keys(list()).length;
  1364.  
  1365.         Object.values(list())
  1366.           .slice(index, index + size)
  1367.           .forEach((item) => load(item));
  1368.  
  1369.         index += size;
  1370.       };
  1371.  
  1372.       box.onscroll = () => {
  1373.         if (hasNext === false) {
  1374.           return;
  1375.         }
  1376.  
  1377.         if (
  1378.           box.scrollHeight - box.scrollTop - box.clientHeight <=
  1379.           wrapper.clientHeight
  1380.         ) {
  1381.           loadNext();
  1382.         }
  1383.       };
  1384.  
  1385.       const refresh = () => {
  1386.         index = 0;
  1387.  
  1388.         tbody.innerHTML = "";
  1389.  
  1390.         loadNext();
  1391.       };
  1392.  
  1393.       return {
  1394.         content,
  1395.         refresh,
  1396.       };
  1397.     })();
  1398.  
  1399.     return {
  1400.       list,
  1401.       get,
  1402.       add,
  1403.       edit,
  1404.       remove,
  1405.       format,
  1406.       view,
  1407.     };
  1408.   })();
  1409.  
  1410.   // 关键字模块
  1411.   const keywordModule = (() => {
  1412.     // 获取关键字列表
  1413.     const list = () => dataModule.getKeywords();
  1414.  
  1415.     // 获取关键字
  1416.     const get = (id) => {
  1417.       // 获取列表
  1418.       const keywords = list();
  1419.  
  1420.       // 如果已存在，则返回信息
  1421.       if (keywords[id]) {
  1422.         return keywords[id];
  1423.       }
  1424.  
  1425.       return null;
  1426.     };
  1427.  
  1428.     // 编辑关键字
  1429.     const edit = (id, values) => {
  1430.       dataModule.save({
  1431.         keywords: {
  1432.           [id]: values,
  1433.         },
  1434.       });
  1435.     };
  1436.  
  1437.     // 增加关键字
  1438.     // filterLevel: 0 - 仅过滤标题; 1 - 过滤标题和内容
  1439.     // 无需判重
  1440.     const add = (keyword, filterMode, filterLevel) => {
  1441.       // ID 为最大值 + 1
  1442.       const id = Math.max(Object.keys(list()), 0) + 1;
  1443.  
  1444.       // 保存关键字
  1445.       dataModule.save({
  1446.         keywords: {
  1447.           [id]: {
  1448.             id,
  1449.             keyword,
  1450.             filterMode,
  1451.             filterLevel,
  1452.           },
  1453.         },
  1454.       });
  1455.  
  1456.       // 返回关键字信息
  1457.       return get(id);
  1458.     };
  1459.  
  1460.     // 删除关键字
  1461.     const remove = (id) => {
  1462.       // TODO 这里不可避免的直接操作了原始数据
  1463.       delete list()[id];
  1464.  
  1465.       // 保存数据
  1466.       dataModule.save({});
  1467.     };
  1468.  
  1469.     // UI
  1470.     const view = (() => {
  1471.       const content = (() => {
  1472.         const element = document.createElement("DIV");
  1473.  
  1474.         element.style = "display: none";
  1475.         element.innerHTML = `
  1476.           <div class="filter-table-wrapper">
  1477.             <table class="filter-table forumbox">
  1478.               <thead>
  1479.                 <tr class="block_txt_c0">
  1480.                   <th class="c1">列表</th>
  1481.                   <th class="c2" width="1">过滤方式</th>
  1482.                   <th class="c3" width="1">包括内容</th>
  1483.                   <th class="c4" width="1">操作</th>
  1484.                 </tr>
  1485.               </thead>
  1486.               <tbody></tbody>
  1487.             </table>
  1488.           </div>
  1489.           <div class="silver" style="margin-top: 10px;">支持正则表达式。比如同类型的可以写在一条规则内用&quot;|&quot;隔开，&quot;ABC|DEF&quot;即为屏蔽带有ABC或者DEF的内容。</div>
  1490.         `;
  1491.  
  1492.         return element;
  1493.       })();
  1494.  
  1495.       let index = 0;
  1496.       let size = 50;
  1497.       let hasNext = false;
  1498.  
  1499.       const box = content.querySelector("DIV");
  1500.  
  1501.       const tbody = content.querySelector("TBODY");
  1502.  
  1503.       const wrapper = content.querySelector(".filter-table-wrapper");
  1504.  
  1505.       const load = (
  1506.         { id, keyword, filterMode, filterLevel },
  1507.         anchor = null
  1508.       ) => {
  1509.         if (keyword === null) {
  1510.           if (anchor) {
  1511.             tbody.removeChild(anchor);
  1512.           }
  1513.           return;
  1514.         }
  1515.  
  1516.         if (anchor === null) {
  1517.           anchor = document.createElement("TR");
  1518.  
  1519.           anchor.className = `row${
  1520.             (tbody.querySelectorAll("TR").length % 2) + 1
  1521.           }`;
  1522.  
  1523.           tbody.appendChild(anchor);
  1524.         }
  1525.  
  1526.         const checked = filterLevel ? "checked" : "";
  1527.  
  1528.         anchor.innerHTML = `
  1529.           <td class="c1">
  1530.             <div class="filter-input-wrapper">
  1531.               <input type="text" value="${keyword || ""}" />
  1532.             </div>
  1533.           </td>
  1534.           <td class="c2">
  1535.             <div class="filter-table-button-group">
  1536.               <button>${filterMode || filterModule.defaultMode}</button>
  1537.             </div>
  1538.           </td>
  1539.           <td class="c3">
  1540.             <div style="text-align: center;">
  1541.               <input type="checkbox" ${checked} />
  1542.             </div>
  1543.           </td>
  1544.           <td class="c4">
  1545.             <div class="filter-table-button-group">
  1546.               <button>保存</button>
  1547.               <button>删除</button>
  1548.             </div>
  1549.           </td>
  1550.         `;
  1551.  
  1552.         const actions = anchor.querySelectorAll("BUTTON");
  1553.  
  1554.         actions[0].onclick = () => {
  1555.           actions[0].innerHTML = filterModule.switchModeByName(
  1556.             actions[0].innerHTML
  1557.           );
  1558.         };
  1559.  
  1560.         actions[1].onclick = () => {
  1561.           const keyword = anchor.querySelector("INPUT[type='text']").value;
  1562.  
  1563.           const filterMode = actions[0].innerHTML;
  1564.  
  1565.           const filterLevel = anchor.querySelector(
  1566.             `INPUT[type="checkbox"]:checked`
  1567.           )
  1568.             ? 1
  1569.             : 0;
  1570.  
  1571.           if (keyword) {
  1572.             edit(id, {
  1573.               keyword,
  1574.               filterMode,
  1575.               filterLevel,
  1576.             });
  1577.             reFilter();
  1578.           }
  1579.         };
  1580.  
  1581.         actions[2].onclick = () => {
  1582.           if (confirm("是否确认?") === false) {
  1583.             return;
  1584.           }
  1585.  
  1586.           tbody.removeChild(anchor);
  1587.  
  1588.           remove(id);
  1589.           reFilter();
  1590.         };
  1591.       };
  1592.  
  1593.       const loadNext = () => {
  1594.         hasNext = index + size < Object.keys(list()).length;
  1595.  
  1596.         Object.values(list())
  1597.           .slice(index, index + size)
  1598.           .forEach((item) => load(item));
  1599.  
  1600.         if (hasNext === false) {
  1601.           const loadNew = () => {
  1602.             const row = document.createElement("TR");
  1603.  
  1604.             row.className = `row${
  1605.               (tbody.querySelectorAll("TR").length % 2) + 1
  1606.             }`;
  1607.  
  1608.             row.innerHTML = `
  1609.               <td class="c1">
  1610.                 <div class="filter-input-wrapper">
  1611.                   <input type="text" value="" />
  1612.                 </div>
  1613.               </td>
  1614.               <td class="c2">
  1615.                 <div class="filter-table-button-group">
  1616.                   <button>${filterModule.defaultMode}</button>
  1617.                 </div>
  1618.               </td>
  1619.               <td class="c3">
  1620.                 <div style="text-align: center;">
  1621.                   <input type="checkbox" />
  1622.                 </div>
  1623.               </td>
  1624.               <td class="c4">
  1625.                 <div class="filter-table-button-group">
  1626.                   <button>添加</button>
  1627.                 </div>
  1628.               </td>
  1629.             `;
  1630.  
  1631.             const actions = row.querySelectorAll("BUTTON");
  1632.  
  1633.             actions[0].onclick = () => {
  1634.               const filterMode = filterModule.switchModeByName(
  1635.                 actions[0].innerHTML
  1636.               );
  1637.  
  1638.               actions[0].innerHTML = filterMode;
  1639.             };
  1640.  
  1641.             actions[1].onclick = () => {
  1642.               const keyword = row.querySelector("INPUT[type='text']").value;
  1643.  
  1644.               const filterMode = actions[0].innerHTML;
  1645.  
  1646.               const filterLevel = row.querySelector(
  1647.                 `INPUT[type="checkbox"]:checked`
  1648.               )
  1649.                 ? 1
  1650.                 : 0;
  1651.  
  1652.               if (keyword) {
  1653.                 const item = add(keyword, filterMode, filterLevel);
  1654.  
  1655.                 load(item, row);
  1656.                 loadNew();
  1657.                 reFilter();
  1658.               }
  1659.             };
  1660.  
  1661.             tbody.appendChild(row);
  1662.           };
  1663.  
  1664.           loadNew();
  1665.         }
  1666.  
  1667.         index += size;
  1668.       };
  1669.  
  1670.       box.onscroll = () => {
  1671.         if (hasNext === false) {
  1672.           return;
  1673.         }
  1674.  
  1675.         if (
  1676.           box.scrollHeight - box.scrollTop - box.clientHeight <=
  1677.           wrapper.clientHeight
  1678.         ) {
  1679.           loadNext();
  1680.         }
  1681.       };
  1682.  
  1683.       const refresh = () => {
  1684.         index = 0;
  1685.  
  1686.         tbody.innerHTML = "";
  1687.  
  1688.         loadNext();
  1689.       };
  1690.  
  1691.       return {
  1692.         content,
  1693.         refresh,
  1694.       };
  1695.     })();
  1696.  
  1697.     return {
  1698.       list,
  1699.       get,
  1700.       add,
  1701.       edit,
  1702.       remove,
  1703.       view,
  1704.     };
  1705.   })();
  1706.  
  1707.   // 属地模块
  1708.   const locationModule = (() => {
  1709.     // 获取属地列表
  1710.     const list = () => dataModule.getLocations();
  1711.  
  1712.     // 获取属地
  1713.     const get = (id) => {
  1714.       // 获取列表
  1715.       const locations = list();
  1716.  
  1717.       // 如果已存在，则返回信息
  1718.       if (locations[id]) {
  1719.         return locations[id];
  1720.       }
  1721.  
  1722.       return null;
  1723.     };
  1724.  
  1725.     // 增加属地
  1726.     // 无需判重
  1727.     const add = (keyword, filterMode) => {
  1728.       // ID 为最大值 + 1
  1729.       const id = Math.max(Object.keys(list()), 0) + 1;
  1730.  
  1731.       // 保存属地
  1732.       dataModule.save({
  1733.         locations: {
  1734.           [id]: {
  1735.             id,
  1736.             keyword,
  1737.             filterMode,
  1738.           },
  1739.         },
  1740.       });
  1741.  
  1742.       // 返回属地信息
  1743.       return get(id);
  1744.     };
  1745.  
  1746.     // 编辑属地
  1747.     const edit = (id, values) => {
  1748.       dataModule.save({
  1749.         locations: {
  1750.           [id]: values,
  1751.         },
  1752.       });
  1753.     };
  1754.  
  1755.     // 删除属地
  1756.     const remove = (id) => {
  1757.       // TODO 这里不可避免的直接操作了原始数据
  1758.       delete list()[id];
  1759.  
  1760.       // 保存数据
  1761.       dataModule.save({});
  1762.     };
  1763.  
  1764.     // UI
  1765.     const view = (() => {
  1766.       const content = (() => {
  1767.         const element = document.createElement("DIV");
  1768.  
  1769.         element.style = "display: none";
  1770.         element.innerHTML = `
  1771.           <div class="filter-table-wrapper">
  1772.             <table class="filter-table forumbox">
  1773.               <thead>
  1774.                 <tr class="block_txt_c0">
  1775.                   <th class="c1">列表</th>
  1776.                   <th class="c2" width="1">过滤方式</th>
  1777.                   <th class="c3" width="1">操作</th>
  1778.                 </tr>
  1779.               </thead>
  1780.               <tbody></tbody>
  1781.             </table>
  1782.           </div>
  1783.           <div class="silver" style="margin-top: 10px;">支持正则表达式。比如同类型的可以写在一条规则内用&quot;|&quot;隔开，&quot;ABC|DEF&quot;即为屏蔽带有ABC或者DEF的内容。<br/>属地过滤功能需要占用额外的资源，请谨慎开启</div>
  1784.         `;
  1785.  
  1786.         return element;
  1787.       })();
  1788.  
  1789.       let index = 0;
  1790.       let size = 50;
  1791.       let hasNext = false;
  1792.  
  1793.       const box = content.querySelector("DIV");
  1794.  
  1795.       const tbody = content.querySelector("TBODY");
  1796.  
  1797.       const wrapper = content.querySelector(".filter-table-wrapper");
  1798.  
  1799.       const load = ({ id, keyword, filterMode }, anchor = null) => {
  1800.         if (keyword === null) {
  1801.           if (anchor) {
  1802.             tbody.removeChild(anchor);
  1803.           }
  1804.           return;
  1805.         }
  1806.  
  1807.         if (anchor === null) {
  1808.           anchor = document.createElement("TR");
  1809.  
  1810.           anchor.className = `row${
  1811.             (tbody.querySelectorAll("TR").length % 2) + 1
  1812.           }`;
  1813.  
  1814.           tbody.appendChild(anchor);
  1815.         }
  1816.  
  1817.         anchor.innerHTML = `
  1818.           <td class="c1">
  1819.             <div class="filter-input-wrapper">
  1820.               <input type="text" value="${keyword || ""}" />
  1821.             </div>
  1822.           </td>
  1823.           <td class="c2">
  1824.             <div class="filter-table-button-group">
  1825.               <button>${filterMode || filterModule.defaultMode}</button>
  1826.             </div>
  1827.           </td>
  1828.           <td class="c3">
  1829.             <div class="filter-table-button-group">
  1830.               <button>保存</button>
  1831.               <button>删除</button>
  1832.             </div>
  1833.           </td>
  1834.         `;
  1835.  
  1836.         const actions = anchor.querySelectorAll("BUTTON");
  1837.  
  1838.         actions[0].onclick = () => {
  1839.           actions[0].innerHTML = filterModule.switchModeByName(
  1840.             actions[0].innerHTML
  1841.           );
  1842.         };
  1843.  
  1844.         actions[1].onclick = () => {
  1845.           const keyword = anchor.querySelector("INPUT[type='text']").value;
  1846.  
  1847.           const filterMode = actions[0].innerHTML;
  1848.  
  1849.           if (keyword) {
  1850.             edit(id, {
  1851.               keyword,
  1852.               filterMode,
  1853.             });
  1854.             reFilter();
  1855.           }
  1856.         };
  1857.  
  1858.         actions[2].onclick = () => {
  1859.           if (confirm("是否确认?") === false) {
  1860.             return;
  1861.           }
  1862.  
  1863.           tbody.removeChild(anchor);
  1864.  
  1865.           remove(id);
  1866.           reFilter();
  1867.         };
  1868.       };
  1869.  
  1870.       const loadNext = () => {
  1871.         hasNext = index + size < Object.keys(list()).length;
  1872.  
  1873.         Object.values(list())
  1874.           .slice(index, index + size)
  1875.           .forEach((item) => load(item));
  1876.  
  1877.         if (hasNext === false) {
  1878.           const loadNew = () => {
  1879.             const row = document.createElement("TR");
  1880.  
  1881.             row.className = `row${
  1882.               (tbody.querySelectorAll("TR").length % 2) + 1
  1883.             }`;
  1884.  
  1885.             row.innerHTML = `
  1886.               <td class="c1">
  1887.                 <div class="filter-input-wrapper">
  1888.                   <input type="text" value="" />
  1889.                 </div>
  1890.               </td>
  1891.               <td class="c2">
  1892.                 <div class="filter-table-button-group">
  1893.                   <button>${filterModule.defaultMode}</button>
  1894.                 </div>
  1895.               </td>
  1896.               <td class="c3">
  1897.                 <div class="filter-table-button-group">
  1898.                   <button>添加</button>
  1899.                 </div>
  1900.               </td>
  1901.             `;
  1902.  
  1903.             const actions = row.querySelectorAll("BUTTON");
  1904.  
  1905.             actions[0].onclick = () => {
  1906.               const filterMode = filterModule.switchModeByName(
  1907.                 actions[0].innerHTML
  1908.               );
  1909.  
  1910.               actions[0].innerHTML = filterMode;
  1911.             };
  1912.  
  1913.             actions[1].onclick = () => {
  1914.               const keyword = row.querySelector("INPUT[type='text']").value;
  1915.  
  1916.               const filterMode = actions[0].innerHTML;
  1917.  
  1918.               if (keyword) {
  1919.                 const item = add(keyword, filterMode);
  1920.  
  1921.                 load(item, row);
  1922.                 loadNew();
  1923.                 reFilter();
  1924.               }
  1925.             };
  1926.  
  1927.             tbody.appendChild(row);
  1928.           };
  1929.  
  1930.           loadNew();
  1931.         }
  1932.  
  1933.         index += size;
  1934.       };
  1935.  
  1936.       box.onscroll = () => {
  1937.         if (hasNext === false) {
  1938.           return;
  1939.         }
  1940.  
  1941.         if (
  1942.           box.scrollHeight - box.scrollTop - box.clientHeight <=
  1943.           wrapper.clientHeight
  1944.         ) {
  1945.           loadNext();
  1946.         }
  1947.       };
  1948.  
  1949.       const refresh = () => {
  1950.         index = 0;
  1951.  
  1952.         tbody.innerHTML = "";
  1953.  
  1954.         loadNext();
  1955.       };
  1956.  
  1957.       return {
  1958.         content,
  1959.         refresh,
  1960.       };
  1961.     })();
  1962.  
  1963.     return {
  1964.       list,
  1965.       get,
  1966.       add,
  1967.       edit,
  1968.       remove,
  1969.       view,
  1970.     };
  1971.   })();
  1972.  
  1973.   // 通用设置
  1974.   const commonModule = (() => {
  1975.     // UI
  1976.     const view = (() => {
  1977.       const content = (() => {
  1978.         const element = document.createElement("DIV");
  1979.  
  1980.         element.style = "display: none";
  1981.  
  1982.         return element;
  1983.       })();
  1984.  
  1985.       const refresh = () => {
  1986.         content.innerHTML = "";
  1987.  
  1988.         // 前置过滤
  1989.         (() => {
  1990.           const checked = preFilter ? "checked" : "";
  1991.  
  1992.           const element = document.createElement("DIV");
  1993.  
  1994.           element.innerHTML += `
  1995.             <div>
  1996.               <label>
  1997.                 前置过滤
  1998.                 <input type="checkbox" ${checked} />
  1999.               </label>
  2000.             </div>
  2001.           `;
  2002.  
  2003.           const checkbox = element.querySelector("INPUT");
  2004.  
  2005.           checkbox.onchange = () => {
  2006.             const newValue = checkbox.checked;
  2007.  
  2008.             GM_setValue(PRE_FILTER_KEY, newValue);
  2009.  
  2010.             location.reload();
  2011.           };
  2012.  
  2013.           content.appendChild(element);
  2014.         })();
  2015.  
  2016.         // 默认过滤方式
  2017.         (() => {
  2018.           const element = document.createElement("DIV");
  2019.  
  2020.           element.innerHTML += `
  2021.             <br/>
  2022.             <div>默认过滤方式</div>
  2023.             <div></div>
  2024.             <div class="silver" style="margin-top: 10px;">${filterModule.tips}</div>
  2025.           `;
  2026.  
  2027.           ["标记", "遮罩", "隐藏"].forEach((item, index) => {
  2028.             const span = document.createElement("SPAN");
  2029.  
  2030.             const checked =
  2031.               dataModule.getDefaultFilterMode() === item ? "checked" : "";
  2032.  
  2033.             span.innerHTML += `
  2034.               <input id="s-fm-${index}" type="radio" name="filterType" ${checked}>
  2035.               <label for="s-fm-${index}" style="cursor: pointer;">${item}</label>
  2036.             `;
  2037.  
  2038.             const input = span.querySelector("INPUT");
  2039.  
  2040.             input.onchange = () => {
  2041.               if (input.checked) {
  2042.                 dataModule.setDefaultFilterMode(item);
  2043.  
  2044.                 reFilter();
  2045.               }
  2046.             };
  2047.  
  2048.             element.querySelectorAll("div")[1].append(span);
  2049.           });
  2050.  
  2051.           content.appendChild(element);
  2052.         })();
  2053.  
  2054.         // 小号过滤（时间）
  2055.         (() => {
  2056.           const value = dataModule.getFilterRegdateLimit() / 86400000;
  2057.  
  2058.           const element = document.createElement("DIV");
  2059.  
  2060.           element.innerHTML += `
  2061.             <br/>
  2062.             <div>
  2063.               隐藏注册时间小于<input value="${value}" maxLength="4" style="width: 48px;" />天的用户
  2064.               <button>确认</button>
  2065.             </div>
  2066.           `;
  2067.  
  2068.           const action = element.querySelector("BUTTON");
  2069.  
  2070.           action.onclick = () => {
  2071.             const newValue =
  2072.               parseInt(element.querySelector("INPUT").value, 10) || 0;
  2073.  
  2074.             dataModule.setFilterRegdateLimit(
  2075.               newValue < 0 ? 0 : newValue * 86400000
  2076.             );
  2077.  
  2078.             reFilter();
  2079.           };
  2080.  
  2081.           content.appendChild(element);
  2082.         })();
  2083.  
  2084.         // 小号过滤（发帖数）
  2085.         (() => {
  2086.           const value = dataModule.getFilterPostnumLimit();
  2087.  
  2088.           const element = document.createElement("DIV");
  2089.  
  2090.           element.innerHTML += `
  2091.             <br/>
  2092.             <div>
  2093.               隐藏发帖数量小于<input value="${value}" maxLength="5" style="width: 48px;" />贴的用户
  2094.               <button>确认</button>
  2095.             </div>
  2096.           `;
  2097.  
  2098.           const action = element.querySelector("BUTTON");
  2099.  
  2100.           action.onclick = () => {
  2101.             const newValue =
  2102.               parseInt(element.querySelector("INPUT").value, 10) || 0;
  2103.  
  2104.             dataModule.setFilterPostnumLimit(newValue < 0 ? 0 : newValue);
  2105.  
  2106.             reFilter();
  2107.           };
  2108.  
  2109.           content.appendChild(element);
  2110.         })();
  2111.  
  2112.         // 流量号过滤（主题比例）
  2113.         (() => {
  2114.           const value = dataModule.getFilterTopicRateLimit();
  2115.  
  2116.           const element = document.createElement("DIV");
  2117.  
  2118.           element.innerHTML += `
  2119.             <br/>
  2120.             <div>
  2121.               隐藏发帖比例大于<input value="${value}" maxLength="3" style="width: 48px;" />%的用户
  2122.               <button>确认</button>
  2123.             </div>
  2124.           `;
  2125.  
  2126.           const action = element.querySelector("BUTTON");
  2127.  
  2128.           action.onclick = () => {
  2129.             const newValue =
  2130.               parseInt(element.querySelector("INPUT").value, 10) || 100;
  2131.  
  2132.             if (newValue <= 0 || newValue > 100) {
  2133.               return;
  2134.             }
  2135.  
  2136.             dataModule.setFilterTopicRateLimit(newValue);
  2137.  
  2138.             reFilter();
  2139.           };
  2140.  
  2141.           content.appendChild(element);
  2142.         })();
  2143.  
  2144.         // 声望过滤
  2145.         (() => {
  2146.           const value = dataModule.getFilterReputationLimit() || "";
  2147.  
  2148.           const element = document.createElement("DIV");
  2149.  
  2150.           element.innerHTML += `
  2151.             <br/>
  2152.             <div>
  2153.               隐藏版面声望低于<input value="${value}" maxLength="5" style="width: 48px;" />点的用户
  2154.               <button>确认</button>
  2155.             </div>
  2156.           `;
  2157.  
  2158.           const action = element.querySelector("BUTTON");
  2159.  
  2160.           action.onclick = () => {
  2161.             const newValue = parseInt(element.querySelector("INPUT").value, 10);
  2162.  
  2163.             dataModule.setFilterReputationLimit(newValue);
  2164.  
  2165.             reFilter();
  2166.           };
  2167.  
  2168.           content.appendChild(element);
  2169.         })();
  2170.  
  2171.         // 匿名过滤
  2172.         (() => {
  2173.           const checked = dataModule.getFilterAnony() ? "checked" : "";
  2174.  
  2175.           const element = document.createElement("DIV");
  2176.  
  2177.           element.innerHTML += `
  2178.             <br/>
  2179.             <div>
  2180.               <label>
  2181.                 隐藏匿名的用户
  2182.                 <input type="checkbox" ${checked} />
  2183.               </label>
  2184.             </div>
  2185.           `;
  2186.  
  2187.           const checkbox = element.querySelector("INPUT");
  2188.  
  2189.           checkbox.onchange = () => {
  2190.             const newValue = checkbox.checked;
  2191.  
  2192.             dataModule.setFilterAnony(newValue);
  2193.  
  2194.             reFilter();
  2195.           };
  2196.  
  2197.           content.appendChild(element);
  2198.         })();
  2199.  
  2200.         // 删除没有标记的用户
  2201.         (() => {
  2202.           const element = document.createElement("DIV");
  2203.  
  2204.           element.innerHTML += `
  2205.             <br/>
  2206.             <div>
  2207.               <button>删除没有标记的用户</button>
  2208.             </div>
  2209.           `;
  2210.  
  2211.           const action = element.querySelector("BUTTON");
  2212.  
  2213.           action.onclick = () => {
  2214.             if (confirm("是否确认?") === false) {
  2215.               return;
  2216.             }
  2217.  
  2218.             Object.values(userModule.list()).forEach(({ id, tags }) => {
  2219.               if (tags.length === 0) {
  2220.                 userModule.remove(id);
  2221.               }
  2222.             });
  2223.  
  2224.             dataModule.save({});
  2225.  
  2226.             reFilter();
  2227.           };
  2228.  
  2229.           content.appendChild(element);
  2230.         })();
  2231.  
  2232.         // 删除没有用户的标记
  2233.         (() => {
  2234.           const element = document.createElement("DIV");
  2235.  
  2236.           element.innerHTML += `
  2237.             <br/>
  2238.             <div>
  2239.               <button>删除没有用户的标记</button>
  2240.             </div>
  2241.           `;
  2242.  
  2243.           const action = element.querySelector("BUTTON");
  2244.  
  2245.           action.onclick = () => {
  2246.             if (confirm("是否确认?") === false) {
  2247.               return;
  2248.             }
  2249.  
  2250.             const users = Object.values(userModule.list());
  2251.  
  2252.             Object.values(tagModule.list()).forEach(({ id }) => {
  2253.               if (users.find(({ tags }) => tags.includes(id))) {
  2254.                 return;
  2255.               }
  2256.  
  2257.               tagModule.remove(id);
  2258.             });
  2259.  
  2260.             dataModule.save({});
  2261.  
  2262.             reFilter();
  2263.           };
  2264.  
  2265.           content.appendChild(element);
  2266.         })();
  2267.  
  2268.         // 删除非激活中的用户
  2269.         (() => {
  2270.           const element = document.createElement("DIV");
  2271.  
  2272.           element.innerHTML += `
  2273.             <br/>
  2274.             <div>
  2275.               <button>删除非激活中的用户</button>
  2276.               <div style="white-space: normal;"></div>
  2277.             </div>
  2278.           `;
  2279.  
  2280.           const action = element.querySelector("BUTTON");
  2281.           const list = action.nextElementSibling;
  2282.  
  2283.           action.onclick = () => {
  2284.             if (confirm("是否确认?") === false) {
  2285.               return;
  2286.             }
  2287.  
  2288.             const users = Object.values(userModule.list());
  2289.  
  2290.             const waitingQueue = users.map(({ id }) => () => {
  2291.               return fetchModule.getUserInfo(id).then(({ bit }) => {
  2292.                 const activeInfo = commonui.activeInfo(0, 0, bit);
  2293.  
  2294.                 const activeType = activeInfo[1];
  2295.  
  2296.                 if (["ACTIVED", "LINKED"].includes(activeType)) {
  2297.                   return;
  2298.                 }
  2299.  
  2300.                 list.innerHTML += userModule.format(id);
  2301.  
  2302.                 userModule.remove(id);
  2303.               });
  2304.             });
  2305.  
  2306.             const queueLength = waitingQueue.length;
  2307.  
  2308.             const execute = () => {
  2309.               if (waitingQueue.length) {
  2310.                 const next = waitingQueue.shift();
  2311.  
  2312.                 action.innerHTML = `删除非激活中的用户 (${
  2313.                   queueLength - waitingQueue.length
  2314.                 }/${queueLength})`;
  2315.                 action.disabled = true;
  2316.  
  2317.                 next().finally(execute);
  2318.               } else {
  2319.                 action.disabled = false;
  2320.  
  2321.                 dataModule.save({});
  2322.  
  2323.                 reFilter();
  2324.               }
  2325.             };
  2326.  
  2327.             execute();
  2328.           };
  2329.  
  2330.           content.appendChild(element);
  2331.         })();
  2332.       };
  2333.  
  2334.       return {
  2335.         content,
  2336.         refresh,
  2337.       };
  2338.     })();
  2339.  
  2340.     return {
  2341.       view,
  2342.     };
  2343.   })();
  2344.  
  2345.   // 额外数据请求模块
  2346.   // 临时的缓存写法
  2347.   const fetchModule = (() => {
  2348.     // 简单的统一请求
  2349.     const request = (url, config = {}) =>
  2350.       fetch(url, {
  2351.         headers: {
  2352.           "X-User-Agent": USER_AGENT,
  2353.         },
  2354.         ...config,
  2355.       });
  2356.  
  2357.     // 获取主题数量
  2358.     // 缓存 1 小时
  2359.     const getTopicNum = (() => {
  2360.       const name = "TOPIC_NUM_CACHE";
  2361.  
  2362.       const expireTime = 60 * 60 * 1000;
  2363.  
  2364.       cacheModule.init(name, "uid");
  2365.  
  2366.       return async (uid) => {
  2367.         const cache = await cacheModule.load(name, uid, expireTime);
  2368.  
  2369.         if (cache) {
  2370.           return cache.count;
  2371.         }
  2372.  
  2373.         const api = `/thread.php?lite=js&authorid=${uid}`;
  2374.  
  2375.         const { __ROWS } = await new Promise((resolve) => {
  2376.           request(api)
  2377.             .then((res) => res.blob())
  2378.             .then((blob) => {
  2379.               const reader = new FileReader();
  2380.  
  2381.               reader.onload = () => {
  2382.                 const text = reader.result;
  2383.                 const result = JSON.parse(
  2384.                   text.replace("window.script_muti_get_var_store=", "")
  2385.                 );
  2386.  
  2387.                 resolve(result.data);
  2388.               };
  2389.  
  2390.               reader.readAsText(blob, "GBK");
  2391.             })
  2392.             .catch(() => {
  2393.               resolve({});
  2394.             });
  2395.         });
  2396.  
  2397.         if (__ROWS > 100) {
  2398.           cacheModule.save(name, uid, {
  2399.             uid,
  2400.             count: __ROWS,
  2401.             timestamp: new Date().getTime(),
  2402.           });
  2403.         }
  2404.  
  2405.         return __ROWS;
  2406.       };
  2407.     })();
  2408.  
  2409.     // 获取用户信息
  2410.     // 缓存 1 小时
  2411.     const getUserInfo = (() => {
  2412.       const name = "USER_INFO_CACHE";
  2413.  
  2414.       const expireTime = 60 * 60 * 1000;
  2415.  
  2416.       cacheModule.init(name, "uid");
  2417.  
  2418.       return async (uid) => {
  2419.         const cache = await cacheModule.load(name, uid, expireTime);
  2420.  
  2421.         if (cache) {
  2422.           return cache.data;
  2423.         }
  2424.  
  2425.         const api = `/nuke.php?lite=js&__lib=ucp&__act=get&uid=${uid}`;
  2426.  
  2427.         const data = await new Promise((resolve) => {
  2428.           request(api)
  2429.             .then((res) => res.blob())
  2430.             .then((blob) => {
  2431.               const reader = new FileReader();
  2432.  
  2433.               reader.onload = () => {
  2434.                 const text = reader.result;
  2435.                 const result = JSON.parse(
  2436.                   text.replace("window.script_muti_get_var_store=", "")
  2437.                 );
  2438.  
  2439.                 resolve(result.data[0] || null);
  2440.               };
  2441.  
  2442.               reader.readAsText(blob, "GBK");
  2443.             })
  2444.             .catch(() => {
  2445.               resolve(null);
  2446.             });
  2447.         });
  2448.  
  2449.         if (data) {
  2450.           cacheModule.save(name, uid, {
  2451.             uid,
  2452.             data,
  2453.             timestamp: new Date().getTime(),
  2454.           });
  2455.         }
  2456.  
  2457.         return data;
  2458.       };
  2459.     })();
  2460.  
  2461.     // 获取顶楼用户信息（主要是发帖数量，常规的获取用户信息方法不一定有结果）、声望
  2462.     // 缓存 10 分钟
  2463.     const getUserInfoAndReputation = (() => {
  2464.       const name = "PAGE_CACHE";
  2465.  
  2466.       const expireTime = 10 * 60 * 1000;
  2467.  
  2468.       cacheModule.init(name, "url");
  2469.  
  2470.       return async (tid, pid) => {
  2471.         if (tid === undefined && pid === undefined) {
  2472.           return;
  2473.         }
  2474.  
  2475.         const api = pid ? `/read.php?pid=${pid}` : `/read.php?tid=${tid}`;
  2476.  
  2477.         const cache = await cacheModule.load(name, api, expireTime);
  2478.  
  2479.         if (cache) {
  2480.           return cache.data;
  2481.         }
  2482.  
  2483.         // 请求数据
  2484.         const data = await new Promise((resolve) => {
  2485.           request(api)
  2486.             .then((res) => res.blob())
  2487.             .then((blob) => {
  2488.               const getLastIndex = (content, position) => {
  2489.                 if (position >= 0) {
  2490.                   let nextIndex = position + 1;
  2491.  
  2492.                   while (nextIndex < content.length) {
  2493.                     if (content[nextIndex] === "}") {
  2494.                       return nextIndex;
  2495.                     }
  2496.  
  2497.                     if (content[nextIndex] === "{") {
  2498.                       nextIndex = getLastIndex(content, nextIndex);
  2499.  
  2500.                       if (nextIndex < 0) {
  2501.                         break;
  2502.                       }
  2503.                     }
  2504.  
  2505.                     nextIndex = nextIndex + 1;
  2506.                   }
  2507.                 }
  2508.  
  2509.                 return -1;
  2510.               };
  2511.  
  2512.               const reader = new FileReader();
  2513.  
  2514.               reader.onload = async () => {
  2515.                 const parser = new DOMParser();
  2516.  
  2517.                 const doc = parser.parseFromString(reader.result, "text/html");
  2518.  
  2519.                 const html = doc.body.innerHTML;
  2520.  
  2521.                 // 验证帖子正常
  2522.                 const verify = doc.querySelector("#m_posts");
  2523.  
  2524.                 if (verify) {
  2525.                   // 取得顶楼 UID
  2526.                   const uid = (() => {
  2527.                     const ele = doc.querySelector("#postauthor0");
  2528.  
  2529.                     if (ele) {
  2530.                       const res = ele.getAttribute("href").match(/uid=(\S+)/);
  2531.  
  2532.                       if (res) {
  2533.                         return res[1];
  2534.                       }
  2535.                     }
  2536.  
  2537.                     return 0;
  2538.                   })();
  2539.  
  2540.                   // 取得顶楼标题
  2541.                   const subject = doc.querySelector("#postsubject0").innerHTML;
  2542.  
  2543.                   // 取得顶楼内容
  2544.                   const content = doc.querySelector("#postcontent0").innerHTML;
  2545.  
  2546.                   // 非匿名用户
  2547.                   if (uid && uid > 0) {
  2548.                     // 取得用户信息
  2549.                     const userInfo = (() => {
  2550.                       // 起始JSON
  2551.                       const str = `"${uid}":{`;
  2552.  
  2553.                       // 起始下标
  2554.                       const index = html.indexOf(str) + str.length;
  2555.  
  2556.                       // 结尾下标
  2557.                       const lastIndex = getLastIndex(html, index);
  2558.  
  2559.                       if (lastIndex >= 0) {
  2560.                         try {
  2561.                           return JSON.parse(
  2562.                             `{${html.substring(index, lastIndex)}}`
  2563.                           );
  2564.                         } catch {}
  2565.                       }
  2566.  
  2567.                       return null;
  2568.                     })();
  2569.  
  2570.                     // 取得用户声望
  2571.                     const reputation = (() => {
  2572.                       const reputations = (() => {
  2573.                         // 起始JSON
  2574.                         const str = `"__REPUTATIONS":{`;
  2575.  
  2576.                         // 起始下标
  2577.                         const index = html.indexOf(str) + str.length;
  2578.  
  2579.                         // 结尾下标
  2580.                         const lastIndex = getLastIndex(html, index);
  2581.  
  2582.                         if (lastIndex >= 0) {
  2583.                           return JSON.parse(
  2584.                             `{${html.substring(index, lastIndex)}}`
  2585.                           );
  2586.                         }
  2587.  
  2588.                         return null;
  2589.                       })();
  2590.  
  2591.                       if (reputations) {
  2592.                         for (let fid in reputations) {
  2593.                           return reputations[fid][uid] || 0;
  2594.                         }
  2595.                       }
  2596.  
  2597.                       return NaN;
  2598.                     })();
  2599.  
  2600.                     resolve({
  2601.                       uid,
  2602.                       subject,
  2603.                       content,
  2604.                       userInfo,
  2605.                       reputation,
  2606.                     });
  2607.                     return;
  2608.                   }
  2609.  
  2610.                   resolve({
  2611.                     uid,
  2612.                     subject,
  2613.                     content,
  2614.                   });
  2615.                   return;
  2616.                 }
  2617.  
  2618.                 resolve(null);
  2619.               };
  2620.  
  2621.               reader.readAsText(blob, "GBK");
  2622.             })
  2623.             .catch(() => {
  2624.               resolve(null);
  2625.             });
  2626.         });
  2627.  
  2628.         if (data) {
  2629.           cacheModule.save(name, api, {
  2630.             url: api,
  2631.             data,
  2632.             timestamp: new Date().getTime(),
  2633.           });
  2634.         }
  2635.  
  2636.         return data;
  2637.       };
  2638.     })();
  2639.  
  2640.     // 每天清理缓存
  2641.     (() => {
  2642.       const today = new Date();
  2643.  
  2644.       const lastTime = new Date(GM_getValue(CLEAR_TIME_KEY) || 0);
  2645.  
  2646.       const isToday =
  2647.         lastTime.getDate() === today.getDate() &&
  2648.         lastTime.getMonth() === today.getMonth() &&
  2649.         lastTime.getFullYear() === today.getFullYear();
  2650.  
  2651.       if (isToday === false) {
  2652.         cacheModule.clear();
  2653.  
  2654.         GM_setValue(CLEAR_TIME_KEY, today.getTime());
  2655.       }
  2656.     })();
  2657.  
  2658.     return {
  2659.       getTopicNum,
  2660.       getUserInfo,
  2661.       getUserInfoAndReputation,
  2662.     };
  2663.   })();
  2664.  
  2665.   // UI
  2666.   const ui = (() => {
  2667.     const modules = {};
  2668.  
  2669.     // 主界面
  2670.     const view = (() => {
  2671.       const tabContainer = (() => {
  2672.         const element = document.createElement("DIV");
  2673.  
  2674.         element.className = "w100";
  2675.         element.innerHTML = `
  2676.           <div class="right_" style="margin-bottom: 5px;">
  2677.             <table class="stdbtn" cellspacing="0">
  2678.               <tbody>
  2679.                 <tr></tr>
  2680.               </tbody>
  2681.             </table>
  2682.           </div>
  2683.           <div class="clear"></div>
  2684.           `;
  2685.  
  2686.         return element;
  2687.       })();
  2688.  
  2689.       const tabPanelContainer = (() => {
  2690.         const element = document.createElement("DIV");
  2691.  
  2692.         element.style = "width: 80vw;";
  2693.  
  2694.         return element;
  2695.       })();
  2696.  
  2697.       const content = (() => {
  2698.         const element = document.createElement("DIV");
  2699.  
  2700.         element.appendChild(tabContainer);
  2701.         element.appendChild(tabPanelContainer);
  2702.  
  2703.         return element;
  2704.       })();
  2705.  
  2706.       const addModule = (() => {
  2707.         const tc = tabContainer.querySelector("TR");
  2708.         const cc = tabPanelContainer;
  2709.  
  2710.         return (name, module) => {
  2711.           const tabBox = document.createElement("TD");
  2712.  
  2713.           tabBox.innerHTML = `<a href="javascript:void(0)" class="nobr silver">${name}</a>`;
  2714.  
  2715.           const tab = tabBox.childNodes[0];
  2716.  
  2717.           const toggle = () => {
  2718.             Object.values(modules).forEach((item) => {
  2719.               if (item.tab === tab) {
  2720.                 item.tab.className = "nobr";
  2721.                 item.content.style = "display: block";
  2722.                 item.refresh();
  2723.               } else {
  2724.                 item.tab.className = "nobr silver";
  2725.                 item.content.style = "display: none";
  2726.               }
  2727.             });
  2728.           };
  2729.  
  2730.           tc.append(tabBox);
  2731.           cc.append(module.content);
  2732.  
  2733.           tab.onclick = toggle;
  2734.  
  2735.           modules[name] = {
  2736.             ...module,
  2737.             tab,
  2738.             toggle,
  2739.           };
  2740.  
  2741.           return modules[name];
  2742.         };
  2743.       })();
  2744.  
  2745.       return {
  2746.         content,
  2747.         addModule,
  2748.       };
  2749.     })();
  2750.  
  2751.     // 右上角菜单
  2752.     const menu = (() => {
  2753.       const container = document.createElement("DIV");
  2754.  
  2755.       container.className = `td`;
  2756.       container.innerHTML = `<a class="mmdefault" href="javascript: void(0);" style="white-space: nowrap;">屏蔽</a>`;
  2757.  
  2758.       const content = container.querySelector("A");
  2759.  
  2760.       const create = (onclick) => {
  2761.         const anchor = document.querySelector("#mainmenu .td:last-child");
  2762.  
  2763.         if (anchor) {
  2764.           anchor.before(container);
  2765.  
  2766.           content.onclick = onclick;
  2767.  
  2768.           return true;
  2769.         }
  2770.  
  2771.         return false;
  2772.       };
  2773.  
  2774.       const update = (list) => {
  2775.         const count = list.length;
  2776.  
  2777.         if (count) {
  2778.           content.innerHTML = `屏蔽 <span class="small_colored_text_btn stxt block_txt_c0 vertmod">${count}</span>`;
  2779.         } else {
  2780.           content.innerHTML = `屏蔽`;
  2781.         }
  2782.       };
  2783.  
  2784.       return {
  2785.         create,
  2786.         update,
  2787.       };
  2788.     })();
  2789.  
  2790.     return {
  2791.       ...view,
  2792.       ...menu,
  2793.     };
  2794.   })();
  2795.  
  2796.   // 判断是否为当前用户 UID
  2797.   const isCurrentUID = (uid) => {
  2798.     return unsafeWindow.__CURRENT_UID === parseInt(uid, 10);
  2799.   };
  2800.  
  2801.   // 获取过滤方式
  2802.   const getFilterMode = async (item) => {
  2803.     // 声明结果
  2804.     const result = {
  2805.       mode: -1,
  2806.       reason: ``,
  2807.     };
  2808.  
  2809.     // 获取 UID
  2810.     const uid = parseInt(item.uid, 10);
  2811.  
  2812.     // 获取链接参数
  2813.     const params = new URLSearchParams(location.search);
  2814.  
  2815.     // 跳过屏蔽（插件自定义）
  2816.     if (params.has("nofilter")) {
  2817.       return;
  2818.     }
  2819.  
  2820.     // 收藏
  2821.     if (params.has("favor")) {
  2822.       return;
  2823.     }
  2824.  
  2825.     // 只看某人
  2826.     if (params.has("authorid")) {
  2827.       return;
  2828.     }
  2829.  
  2830.     // 跳过自己
  2831.     if (isCurrentUID(uid)) {
  2832.       return "";
  2833.     }
  2834.  
  2835.     // 用户过滤
  2836.     (() => {
  2837.       // 获取屏蔽列表里匹配的用户
  2838.       const user = userModule.get(uid);
  2839.  
  2840.       // 没有则跳过
  2841.       if (user === null) {
  2842.         return;
  2843.       }
  2844.  
  2845.       const { filterMode } = user;
  2846.  
  2847.       const mode = filterModule.getModeByName(filterMode);
  2848.  
  2849.       // 低于当前的过滤模式则跳过
  2850.       if (mode <= result.mode) {
  2851.         return;
  2852.       }
  2853.  
  2854.       // 更新过滤模式和原因
  2855.       result.mode = mode;
  2856.       result.reason = `用户模式: ${filterMode}`;
  2857.     })();
  2858.  
  2859.     // 标记过滤
  2860.     (() => {
  2861.       // 获取屏蔽列表里匹配的用户
  2862.       const user = userModule.get(uid);
  2863.  
  2864.       // 获取用户对应的标记，并跳过低于当前的过滤模式
  2865.       const tags = user
  2866.         ? user.tags
  2867.             .map((id) => tagModule.get({ id }))
  2868.             .filter((i) => i !== null)
  2869.             .filter(
  2870.               (i) => filterModule.getModeByName(i.filterMode) > result.mode
  2871.             )
  2872.         : [];
  2873.  
  2874.       // 没有则跳过
  2875.       if (tags.length === 0) {
  2876.         return;
  2877.       }
  2878.  
  2879.       // 取最高的过滤模式
  2880.       const { filterMode, name } = tags.sort(
  2881.         (a, b) =>
  2882.           filterModule.getModeByName(b.filterMode) -
  2883.           filterModule.getModeByName(a.filterMode)
  2884.       )[0];
  2885.  
  2886.       const mode = filterModule.getModeByName(filterMode);
  2887.  
  2888.       // 更新过滤模式和原因
  2889.       result.mode = mode;
  2890.       result.reason = `标记: ${name}`;
  2891.     })();
  2892.  
  2893.     // 关键词过滤
  2894.     await (async () => {
  2895.       const { getContent } = item;
  2896.  
  2897.       // 获取设置里的关键词列表，并跳过低于当前的过滤模式
  2898.       const keywords = Object.values(keywordModule.list()).filter(
  2899.         (i) => filterModule.getModeByName(i.filterMode) > result.mode
  2900.       );
  2901.  
  2902.       // 没有则跳过
  2903.       if (keywords.length === 0) {
  2904.         return;
  2905.       }
  2906.  
  2907.       // 根据过滤等级依次判断
  2908.       const list = keywords.sort(
  2909.         (a, b) =>
  2910.           filterModule.getModeByName(b.filterMode) -
  2911.           filterModule.getModeByName(a.filterMode)
  2912.       );
  2913.  
  2914.       for (let i = 0; i < list.length; i += 1) {
  2915.         const { keyword, filterMode } = list[i];
  2916.  
  2917.         // 过滤等级，0 为只过滤标题，1 为过滤标题和内容
  2918.         const filterLevel = list[i].filterLevel || 0;
  2919.  
  2920.         // 过滤标题
  2921.         if (filterLevel >= 0) {
  2922.           const { subject } = item;
  2923.  
  2924.           const match = subject.match(keyword);
  2925.  
  2926.           if (match) {
  2927.             const mode = filterModule.getModeByName(filterMode);
  2928.  
  2929.             // 更新过滤模式和原因
  2930.             result.mode = mode;
  2931.             result.reason = `关键词: ${match[0]}`;
  2932.             return;
  2933.           }
  2934.         }
  2935.  
  2936.         // 过滤内容
  2937.         if (filterLevel >= 1) {
  2938.           // 如果没有内容，则请求
  2939.           const content = await (async () => {
  2940.             if (item.content === undefined) {
  2941.               await getContent().catch(() => {});
  2942.             }
  2943.  
  2944.             return item.content || null;
  2945.           })();
  2946.  
  2947.           if (content) {
  2948.             const match = content.match(keyword);
  2949.  
  2950.             if (match) {
  2951.               const mode = filterModule.getModeByName(filterMode);
  2952.  
  2953.               // 更新过滤模式和原因
  2954.               result.mode = mode;
  2955.               result.reason = `关键词: ${match[0]}`;
  2956.               return;
  2957.             }
  2958.           }
  2959.         }
  2960.       }
  2961.     })();
  2962.  
  2963.     // 杂项过滤
  2964.     // 放在属地前是因为符合条件的过多，没必要再请求它们的属地
  2965.     await (async () => {
  2966.       const { getUserInfo, getReputation } = item;
  2967.  
  2968.       // 如果当前模式是显示，则跳过
  2969.       if (filterModule.getNameByMode(result.mode) === "显示") {
  2970.         return;
  2971.       }
  2972.  
  2973.       // 获取隐藏模式下标
  2974.       const mode = filterModule.getModeByName("隐藏");
  2975.  
  2976.       // 匿名
  2977.       if (uid <= 0) {
  2978.         const filterAnony = dataModule.getFilterAnony();
  2979.  
  2980.         if (filterAnony) {
  2981.           // 更新过滤模式和原因
  2982.           result.mode = mode;
  2983.           result.reason = "匿名";
  2984.         }
  2985.  
  2986.         return;
  2987.       }
  2988.  
  2989.       // 注册时间过滤
  2990.       await (async () => {
  2991.         const filterRegdateLimit = dataModule.getFilterRegdateLimit();
  2992.  
  2993.         // 如果没有用户信息，则请求
  2994.         const userInfo = await (async () => {
  2995.           if (item.userInfo === undefined) {
  2996.             await getUserInfo().catch(() => {});
  2997.           }
  2998.  
  2999.           return item.userInfo || {};
  3000.         })();
  3001.  
  3002.         const { regdate } = userInfo;
  3003.  
  3004.         if (regdate === undefined) {
  3005.           return;
  3006.         }
  3007.  
  3008.         if (
  3009.           filterRegdateLimit > 0 &&
  3010.           regdate * 1000 > new Date() - filterRegdateLimit
  3011.         ) {
  3012.           // 更新过滤模式和原因
  3013.           result.mode = mode;
  3014.           result.reason = `注册时间: ${new Date(
  3015.             regdate * 1000
  3016.           ).toLocaleDateString()}`;
  3017.           return;
  3018.         }
  3019.       })();
  3020.  
  3021.       // 发帖数量过滤
  3022.       await (async () => {
  3023.         const filterPostnumLimit = dataModule.getFilterPostnumLimit();
  3024.  
  3025.         // 如果没有用户信息，则请求
  3026.         const userInfo = await (async () => {
  3027.           if (item.userInfo === undefined) {
  3028.             await getUserInfo().catch(() => {});
  3029.           }
  3030.  
  3031.           return item.userInfo || {};
  3032.         })();
  3033.  
  3034.         const { postnum } = userInfo;
  3035.  
  3036.         if (postnum === undefined) {
  3037.           return;
  3038.         }
  3039.  
  3040.         if (filterPostnumLimit > 0 && postnum < filterPostnumLimit) {
  3041.           // 更新过滤模式和原因
  3042.           result.mode = mode;
  3043.           result.reason = `发帖数量: ${postnum}`;
  3044.           return;
  3045.         }
  3046.       })();
  3047.  
  3048.       // 发帖比例过滤
  3049.       await (async () => {
  3050.         const filterTopicRateLimit = dataModule.getFilterTopicRateLimit();
  3051.  
  3052.         // 如果没有用户信息，则请求
  3053.         const userInfo = await (async () => {
  3054.           if (item.userInfo === undefined) {
  3055.             await getUserInfo().catch(() => {});
  3056.           }
  3057.  
  3058.           return item.userInfo || {};
  3059.         })();
  3060.  
  3061.         const { postnum } = userInfo;
  3062.  
  3063.         if (postnum === undefined) {
  3064.           return;
  3065.         }
  3066.  
  3067.         if (filterTopicRateLimit > 0 && filterTopicRateLimit < 100) {
  3068.           // 获取主题数量
  3069.           const topicNum = await fetchModule.getTopicNum(uid);
  3070.  
  3071.           // 计算发帖比例
  3072.           const topicRate = (topicNum / postnum) * 100;
  3073.  
  3074.           if (topicRate > filterTopicRateLimit) {
  3075.             // 更新过滤模式和原因
  3076.             result.mode = mode;
  3077.             result.reason = `发帖比例: ${topicRate.toFixed(
  3078.               0
  3079.             )}% (${topicNum}/${postnum})`;
  3080.             return;
  3081.           }
  3082.         }
  3083.       })();
  3084.  
  3085.       // 版面声望过滤
  3086.       await (async () => {
  3087.         const filterReputationLimit = dataModule.getFilterReputationLimit();
  3088.  
  3089.         if (Number.isNaN(filterReputationLimit)) {
  3090.           return;
  3091.         }
  3092.  
  3093.         // 如果没有版面声望，则请求
  3094.         const reputation = await (async () => {
  3095.           if (item.reputation === undefined) {
  3096.             await getReputation().catch(() => {});
  3097.           }
  3098.  
  3099.           return item.reputation || NaN;
  3100.         })();
  3101.  
  3102.         if (reputation < filterReputationLimit) {
  3103.           // 更新过滤模式和原因
  3104.           result.mode = mode;
  3105.           result.reason = `声望: ${reputation}`;
  3106.           return;
  3107.         }
  3108.       })();
  3109.     })();
  3110.  
  3111.     // 属地过滤
  3112.     await (async () => {
  3113.       // 匿名用户则跳过
  3114.       if (uid <= 0) {
  3115.         return;
  3116.       }
  3117.  
  3118.       // 获取设置里的属地列表，并跳过低于当前的过滤模式
  3119.       const locations = Object.values(locationModule.list()).filter(
  3120.         (i) => filterModule.getModeByName(i.filterMode) > result.mode
  3121.       );
  3122.  
  3123.       // 没有则跳过
  3124.       if (locations.length === 0) {
  3125.         return;
  3126.       }
  3127.  
  3128.       // 请求属地
  3129.       const { ipLoc } = await fetchModule.getUserInfo(uid);
  3130.  
  3131.       // 请求失败则跳过
  3132.       if (ipLoc === undefined) {
  3133.         return;
  3134.       }
  3135.  
  3136.       // 根据过滤等级依次判断
  3137.       const list = locations.sort(
  3138.         (a, b) =>
  3139.           filterModule.getModeByName(b.filterMode) -
  3140.           filterModule.getModeByName(a.filterMode)
  3141.       );
  3142.  
  3143.       for (let i = 0; i < list.length; i += 1) {
  3144.         const { keyword, filterMode } = list[i];
  3145.  
  3146.         const match = ipLoc.match(keyword);
  3147.  
  3148.         if (match) {
  3149.           const mode = filterModule.getModeByName(filterMode);
  3150.  
  3151.           // 更新过滤模式和原因
  3152.           result.mode = mode;
  3153.           result.reason = `属地: ${ipLoc}`;
  3154.           return;
  3155.         }
  3156.       }
  3157.     })();
  3158.  
  3159.     // 继承模式下使用默认过滤模式
  3160.     if (result.mode === 0) {
  3161.       result.mode = filterModule.getModeByName(
  3162.         dataModule.getDefaultFilterMode(),
  3163.         -1
  3164.       );
  3165.     }
  3166.  
  3167.     // 返回过滤结果
  3168.     if (result.mode > 0) {
  3169.       const { uid, username, tid, pid } = item;
  3170.  
  3171.       const mode = filterModule.getNameByMode(result.mode);
  3172.  
  3173.       // 非显示模式下，写入列表
  3174.       if (mode !== "显示") {
  3175.         const reason = result.reason;
  3176.  
  3177.         // 用户
  3178.         const user = userModule.format(uid, username);
  3179.  
  3180.         // 移除 BR 标签
  3181.         item.content = (item.content || "").replace(/<br>/g, "");
  3182.  
  3183.         // 主题
  3184.         const subject = (() => {
  3185.           if (tid) {
  3186.             // 如果有 TID 但没有标题，是引用，采用内容逻辑
  3187.             if (item.subject.length === 0) {
  3188.               return `<a href="${`/read.php?tid=${tid}`}&nofilter">${
  3189.                 item.content
  3190.               }</a>`;
  3191.             }
  3192.  
  3193.             return `<a href="${`/read.php?tid=${tid}`}&nofilter" title="${
  3194.               item.content
  3195.             }" class="b nobr">${item.subject}</a>`;
  3196.           }
  3197.  
  3198.           return item.subject;
  3199.         })();
  3200.  
  3201.         // 内容
  3202.         const content = (() => {
  3203.           if (pid) {
  3204.             return `<a href="${`/read.php?pid=${pid}`}&nofilter">${
  3205.               item.content
  3206.             }</a>`;
  3207.           }
  3208.  
  3209.           return item.content;
  3210.         })();
  3211.  
  3212.         listModule.add({
  3213.           user,
  3214.           mode,
  3215.           subject,
  3216.           content,
  3217.           reason,
  3218.         });
  3219.       }
  3220.  
  3221.       return mode;
  3222.     }
  3223.  
  3224.     return "";
  3225.   };
  3226.  
  3227.   // 获取主题过滤方式
  3228.   const getFilterModeByTopic = async (topic) => {
  3229.     const { tid } = topic;
  3230.  
  3231.     // 绑定额外的数据请求方式
  3232.     if (topic.getContent === undefined) {
  3233.       // 获取帖子内容，按需调用
  3234.       const getTopic = () =>
  3235.         new Promise((resolve, reject) => {
  3236.           // 避免重复请求
  3237.           if (topic.content || topic.userInfo || topic.reputation) {
  3238.             resolve(topic);
  3239.             return;
  3240.           }
  3241.  
  3242.           // 请求并写入数据
  3243.           fetchModule
  3244.             .getUserInfoAndReputation(tid, undefined)
  3245.             .then(({ subject, content, userInfo, reputation }) => {
  3246.               // 写入用户名
  3247.               if (userInfo) {
  3248.                 topic.username = userInfo.username;
  3249.               }
  3250.  
  3251.               // 写入用户信息和声望
  3252.               topic.userInfo = userInfo;
  3253.               topic.reputation = reputation;
  3254.  
  3255.               // 写入帖子标题和内容
  3256.               topic.subject = subject;
  3257.               topic.content = content;
  3258.  
  3259.               // 返回结果
  3260.               resolve(topic);
  3261.             })
  3262.             .catch(reject);
  3263.         });
  3264.  
  3265.       // 绑定请求方式
  3266.       topic.getContent = getTopic;
  3267.       topic.getUserInfo = getTopic;
  3268.       topic.getReputation = getTopic;
  3269.     }
  3270.  
  3271.     // 获取过滤模式
  3272.     const filterMode = await getFilterMode(topic);
  3273.  
  3274.     // 返回结果
  3275.     return filterMode;
  3276.   };
  3277.  
  3278.   // 获取回复过滤方式
  3279.   const getFilterModeByReply = async (reply) => {
  3280.     const { tid, pid, uid } = reply;
  3281.  
  3282.     // 回复页面可以直接获取到用户信息和声望
  3283.     if (uid > 0) {
  3284.       // 取得用户信息
  3285.       const userInfo = commonui.userInfo.users[uid];
  3286.  
  3287.       // 取得用户声望
  3288.       const reputation = (() => {
  3289.         const reputations = commonui.userInfo.reputations;
  3290.  
  3291.         if (reputations) {
  3292.           for (let fid in reputations) {
  3293.             return reputations[fid][uid] || 0;
  3294.           }
  3295.         }
  3296.  
  3297.         return NaN;
  3298.       })();
  3299.  
  3300.       // 写入用户名
  3301.       if (userInfo) {
  3302.         reply.username = userInfo.username;
  3303.       }
  3304.  
  3305.       // 写入用户信息和声望
  3306.       reply.userInfo = userInfo;
  3307.       reply.reputation = reputation;
  3308.     }
  3309.  
  3310.     // 绑定额外的数据请求方式
  3311.     if (reply.getContent === undefined) {
  3312.       // 获取帖子内容，按需调用
  3313.       const getReply = () =>
  3314.         new Promise((resolve, reject) => {
  3315.           // 避免重复请求
  3316.           if (reply.userInfo || reply.reputation) {
  3317.             resolve(reply);
  3318.             return;
  3319.           }
  3320.  
  3321.           // 请求并写入数据
  3322.           fetchModule
  3323.             .getUserInfoAndReputation(tid, pid)
  3324.             .then(({ subject, content, userInfo, reputation }) => {
  3325.               // 写入用户名
  3326.               if (userInfo) {
  3327.                 reply.username = userInfo.username;
  3328.               }
  3329.  
  3330.               // 写入用户信息和声望
  3331.               reply.userInfo = userInfo;
  3332.               reply.reputation = reputation;
  3333.  
  3334.               // 写入帖子标题和内容
  3335.               reply.subject = subject;
  3336.               reply.content = content;
  3337.  
  3338.               // 返回结果
  3339.               resolve(reply);
  3340.             })
  3341.             .catch(reject);
  3342.         });
  3343.  
  3344.       // 绑定请求方式
  3345.       reply.getContent = getReply;
  3346.       reply.getUserInfo = getReply;
  3347.       reply.getReputation = getReply;
  3348.     }
  3349.  
  3350.     // 获取过滤模式
  3351.     const filterMode = await getFilterMode(reply);
  3352.  
  3353.     // 返回结果
  3354.     return filterMode;
  3355.   };
  3356.  
  3357.   // 处理引用
  3358.   const handleQuote = async (content) => {
  3359.     const quotes = content.querySelectorAll(".quote");
  3360.  
  3361.     await Promise.all(
  3362.       [...quotes].map(async (quote) => {
  3363.         const uid = (() => {
  3364.           const ele = quote.querySelector("a[href^='/nuke.php']");
  3365.  
  3366.           if (ele) {
  3367.             const res = ele.getAttribute("href").match(/uid=(\S+)/);
  3368.  
  3369.             if (res) {
  3370.               return res[1];
  3371.             }
  3372.           }
  3373.  
  3374.           return 0;
  3375.         })();
  3376.  
  3377.         const { tid, pid } = (() => {
  3378.           const ele = quote.querySelector("[title='快速浏览这个帖子']");
  3379.  
  3380.           if (ele) {
  3381.             const res = ele
  3382.               .getAttribute("onclick")
  3383.               .match(/fastViewPost(.+,(\S+),(\S+|undefined),.+)/);
  3384.  
  3385.             if (res) {
  3386.               return {
  3387.                 tid: parseInt(res[2], 10),
  3388.                 pid: parseInt(res[3], 10) || 0,
  3389.               };
  3390.             }
  3391.           }
  3392.  
  3393.           return {};
  3394.         })();
  3395.  
  3396.         // 获取过滤方式
  3397.         const filterMode = await getFilterModeByReply({
  3398.           uid,
  3399.           tid,
  3400.           pid,
  3401.           subject: "",
  3402.           content: quote.innerText,
  3403.         });
  3404.  
  3405.         (() => {
  3406.           if (filterMode === "标记") {
  3407.             filterModule.collapse(uid, quote, quote.innerHTML);
  3408.             return;
  3409.           }
  3410.  
  3411.           if (filterMode === "遮罩") {
  3412.             const source = document.createElement("DIV");
  3413.  
  3414.             source.innerHTML = quote.innerHTML;
  3415.             source.style.display = "none";
  3416.  
  3417.             const caption = document.createElement("CAPTION");
  3418.  
  3419.             caption.className = "filter-mask filter-mask-block";
  3420.  
  3421.             caption.innerHTML = `<span class="crimson">Troll must die.</span>`;
  3422.             caption.onclick = () => {
  3423.               quote.removeChild(caption);
  3424.  
  3425.               source.style.display = "";
  3426.             };
  3427.  
  3428.             quote.innerHTML = "";
  3429.             quote.appendChild(source);
  3430.             quote.appendChild(caption);
  3431.             return;
  3432.           }
  3433.  
  3434.           if (filterMode === "隐藏") {
  3435.             quote.innerHTML = "";
  3436.             return;
  3437.           }
  3438.         })();
  3439.       })
  3440.     );
  3441.   };
  3442.  
  3443.   // 过滤主题
  3444.   const filterTopic = async (item) => {
  3445.     // 绑定事件
  3446.     if (item.nFilter === undefined) {
  3447.       // 主题 ID
  3448.       const tid = item[8];
  3449.  
  3450.       // 主题标题
  3451.       const title =
  3452.         typeof item[1] === "string"
  3453.           ? document.getElementById(item[1])
  3454.           : item[1];
  3455.       const subject = title.innerText;
  3456.  
  3457.       // 主题作者
  3458.       const author =
  3459.         typeof item[2] === "string"
  3460.           ? document.getElementById(item[2])
  3461.           : item[2];
  3462.       const uid =
  3463.         parseInt(author.getAttribute("href").match(/uid=(\S+)/)[1], 10) || 0;
  3464.       const username = author.innerText;
  3465.  
  3466.       // 主题容器
  3467.       const container = title.closest("tr");
  3468.  
  3469.       // 过滤函数
  3470.       const execute = async () => {
  3471.         // 获取过滤方式
  3472.         const filterMode = await getFilterModeByTopic(item.nFilter);
  3473.  
  3474.         // 样式处理
  3475.         (() => {
  3476.           // 还原样式
  3477.           // TODO 应该整体采用 className 来实现
  3478.           (() => {
  3479.             // 标记模式
  3480.             container.style.removeProperty("textDecoration");
  3481.  
  3482.             // 遮罩模式
  3483.             title.classList.remove("filter-mask");
  3484.             author.classList.remove("filter-mask");
  3485.           })();
  3486.  
  3487.           // 样式处理
  3488.           (() => {
  3489.             // 标记模式下，主题标记会有删除线标识
  3490.             if (filterMode === "标记") {
  3491.               title.style.textDecoration = "line-through";
  3492.               return;
  3493.             }
  3494.  
  3495.             // 遮罩模式下，主题和作者会有遮罩样式
  3496.             if (filterMode === "遮罩") {
  3497.               title.classList.add("filter-mask");
  3498.               author.classList.add("filter-mask");
  3499.               return;
  3500.             }
  3501.  
  3502.             // 隐藏模式下，容器会被隐藏
  3503.             if (filterMode === "隐藏") {
  3504.               container.style.display = "none";
  3505.               return;
  3506.             }
  3507.           })();
  3508.  
  3509.           // 非隐藏模式下，恢复显示
  3510.           if (filterMode !== "隐藏") {
  3511.             container.style.removeProperty("display");
  3512.           }
  3513.         })();
  3514.       };
  3515.  
  3516.       // 绑定事件
  3517.       item.nFilter = {
  3518.         tid,
  3519.         uid,
  3520.         username,
  3521.         container,
  3522.         title,
  3523.         author,
  3524.         subject,
  3525.         execute,
  3526.       };
  3527.     }
  3528.  
  3529.     // 等待过滤完成
  3530.     await item.nFilter.execute();
  3531.   };
  3532.  
  3533.   // 过滤回复
  3534.   const filterReply = async (item) => {
  3535.     // 绑定事件
  3536.     if (item.nFilter === undefined) {
  3537.       // 回复 ID
  3538.       const pid = item.pid;
  3539.  
  3540.       // 判断是否是楼层
  3541.       const isFloor = typeof item.i === "number";
  3542.  
  3543.       // 回复容器
  3544.       const container = isFloor
  3545.         ? item.uInfoC.closest("tr")
  3546.         : item.uInfoC.closest(".comment_c");
  3547.  
  3548.       // 回复标题
  3549.       const title = item.subjectC;
  3550.       const subject = title.innerText;
  3551.  
  3552.       // 回复内容
  3553.       const content = item.contentC;
  3554.       const contentBak = content.innerHTML;
  3555.  
  3556.       // 回复作者
  3557.       const author = container.querySelector(".posterInfoLine") || item.uInfoC;
  3558.       const uid = parseInt(item.pAid, 10) || 0;
  3559.       const username = author.querySelector(".author").innerText;
  3560.       const avatar = author.querySelector(".avatar");
  3561.  
  3562.       // 找到用户 ID，将其视为操作按钮
  3563.       const action = container.querySelector('[name="uid"]');
  3564.  
  3565.       // 创建一个元素，用于展示标记列表
  3566.       // 贴条和高赞不显示
  3567.       const tags = (() => {
  3568.         if (isFloor === false) {
  3569.           return null;
  3570.         }
  3571.  
  3572.         const element = document.createElement("div");
  3573.  
  3574.         element.className = "filter-tags";
  3575.  
  3576.         author.appendChild(element);
  3577.  
  3578.         return element;
  3579.       })();
  3580.  
  3581.       // 过滤函数
  3582.       const execute = async () => {
  3583.         // 获取过滤方式
  3584.         const filterMode = await getFilterModeByReply(item.nFilter);
  3585.  
  3586.         // 样式处理
  3587.         await (async () => {
  3588.           // 还原样式
  3589.           // TODO 应该整体采用 className 来实现
  3590.           (() => {
  3591.             // 标记模式
  3592.             if (avatar) {
  3593.               avatar.style.removeProperty("display");
  3594.             }
  3595.  
  3596.             content.innerHTML = contentBak;
  3597.  
  3598.             // 遮罩模式
  3599.             const caption = container.parentNode.querySelector("CAPTION");
  3600.  
  3601.             if (caption) {
  3602.               container.parentNode.removeChild(caption);
  3603.               container.style.removeProperty("display");
  3604.             }
  3605.           })();
  3606.  
  3607.           // 样式处理
  3608.           (() => {
  3609.             // 标记模式下，隐藏头像，采用泥潭的折叠样式
  3610.             if (filterMode === "标记") {
  3611.               if (avatar) {
  3612.                 avatar.style.display = "none";
  3613.               }
  3614.  
  3615.               filterModule.collapse(uid, content, contentBak);
  3616.               return;
  3617.             }
  3618.  
  3619.             // 遮罩模式下，楼层会有遮罩样式
  3620.             if (filterMode === "遮罩") {
  3621.               const caption = document.createElement("CAPTION");
  3622.  
  3623.               if (isFloor) {
  3624.                 caption.className = "filter-mask filter-mask-block";
  3625.               } else {
  3626.                 caption.className = "filter-mask filter-mask-block left";
  3627.                 caption.style.width = "47%";
  3628.               }
  3629.  
  3630.               caption.innerHTML = `<span class="crimson">Troll must die.</span>`;
  3631.               caption.onclick = () => {
  3632.                 const caption = container.parentNode.querySelector("CAPTION");
  3633.  
  3634.                 if (caption) {
  3635.                   container.parentNode.removeChild(caption);
  3636.                   container.style.removeProperty("display");
  3637.                 }
  3638.               };
  3639.  
  3640.               container.parentNode.insertBefore(caption, container);
  3641.               container.style.display = "none";
  3642.               return;
  3643.             }
  3644.  
  3645.             // 隐藏模式下，容器会被隐藏
  3646.             if (filterMode === "隐藏") {
  3647.               container.style.display = "none";
  3648.               return;
  3649.             }
  3650.           })();
  3651.  
  3652.           // 处理引用
  3653.           await handleQuote(content);
  3654.  
  3655.           // 非隐藏模式下，恢复显示
  3656.           // 如果是隐藏模式，没必要再加载按钮和标记
  3657.           if (filterMode !== "隐藏") {
  3658.             // 获取当前用户
  3659.             const user = userModule.get(uid);
  3660.  
  3661.             // 修改操作按钮颜色
  3662.             if (action) {
  3663.               if (user) {
  3664.                 action.style.background = "#CB4042";
  3665.               } else {
  3666.                 action.style.background = "#AAA";
  3667.               }
  3668.             }
  3669.  
  3670.             // 加载标记
  3671.             if (tags) {
  3672.               const list = user
  3673.                 ? user.tags.map((id) => tagModule.get({ id })) || []
  3674.                 : [];
  3675.  
  3676.               tags.style.display = list.length ? "" : "none";
  3677.               tags.innerHTML = list
  3678.                 .map((tag) => tagModule.format(tag.id))
  3679.                 .join("");
  3680.             }
  3681.  
  3682.             // 恢复显示
  3683.             container.style.removeProperty("display");
  3684.           }
  3685.         })();
  3686.       };
  3687.  
  3688.       // 绑定操作按钮事件
  3689.       (() => {
  3690.         if (action) {
  3691.           // 隐藏匿名操作按钮
  3692.           if (uid <= 0) {
  3693.             action.style.display = "none";
  3694.             return;
  3695.           }
  3696.  
  3697.           action.innerHTML = `屏蔽`;
  3698.           action.onclick = (e) => {
  3699.             const user = userModule.get(uid);
  3700.  
  3701.             if (e.ctrlKey === false) {
  3702.               userModule.view.details(uid, username, () => {
  3703.                 execute();
  3704.               });
  3705.               return;
  3706.             }
  3707.  
  3708.             if (user) {
  3709.               userModule.remove(uid);
  3710.             } else {
  3711.               userModule.add(uid, username, [], filterModule.defaultMode);
  3712.             }
  3713.  
  3714.             execute(true);
  3715.           };
  3716.         }
  3717.       })();
  3718.  
  3719.       // 绑定事件
  3720.       item.nFilter = {
  3721.         pid,
  3722.         uid,
  3723.         username,
  3724.         container,
  3725.         title,
  3726.         author,
  3727.         subject,
  3728.         content: content.innerText,
  3729.         execute,
  3730.       };
  3731.     }
  3732.  
  3733.     // 等待过滤完成
  3734.     await item.nFilter.execute();
  3735.   };
  3736.  
  3737.   // 加载 UI
  3738.   const loadUI = () => {
  3739.     // 右上角菜单
  3740.     const result = (() => {
  3741.       let window;
  3742.  
  3743.       return ui.create(() => {
  3744.         if (window === undefined) {
  3745.           window = commonui.createCommmonWindow();
  3746.         }
  3747.  
  3748.         window._.addContent(null);
  3749.         window._.addTitle(`屏蔽`);
  3750.         window._.addContent(ui.content);
  3751.         window._.show();
  3752.       });
  3753.     })();
  3754.  
  3755.     // 加载失败
  3756.     if (result === false) {
  3757.       return;
  3758.     }
  3759.  
  3760.     // 模块
  3761.     ui.addModule("列表", listModule.view).toggle();
  3762.     ui.addModule("用户", userModule.view);
  3763.     ui.addModule("标记", tagModule.view);
  3764.     ui.addModule("关键字", keywordModule.view);
  3765.     ui.addModule("属地", locationModule.view);
  3766.     ui.addModule("通用设置", commonModule.view);
  3767.  
  3768.     // 绑定列表更新回调
  3769.     listModule.bindCallback(ui.update);
  3770.   };
  3771.  
  3772.   // 处理 mainMenu 模块
  3773.   const handleMenu = () => {
  3774.     let init = menuModule.init;
  3775.  
  3776.     // 劫持 init 函数，这个函数完成后才能添加 UI
  3777.     Object.defineProperty(menuModule, "init", {
  3778.       get: () => {
  3779.         return (...arguments) => {
  3780.           // 等待执行完毕
  3781.           init.apply(menuModule, arguments);
  3782.  
  3783.           // 加载 UI
  3784.           loadUI();
  3785.         };
  3786.       },
  3787.       set: (value) => {
  3788.         init = value;
  3789.       },
  3790.     });
  3791.  
  3792.     // 如果已经有模块，则直接加载 UI
  3793.     if (init) {
  3794.       loadUI();
  3795.     }
  3796.   };
  3797.  
  3798.   // 处理 topicArg 模块
  3799.   const handleTopicModule = async () => {
  3800.     let add = topicModule.add;
  3801.  
  3802.     // 劫持 add 函数，这是泥潭的主题添加事件
  3803.     Object.defineProperty(topicModule, "add", {
  3804.       get: () => {
  3805.         return async (...arguments) => {
  3806.           // 主题 ID
  3807.           const tid = arguments[8];
  3808.  
  3809.           // 先直接隐藏，等过滤完毕后再放出来
  3810.           (() => {
  3811.             // 主题标题
  3812.             const title = document.getElementById(arguments[1]);
  3813.  
  3814.             // 主题容器
  3815.             const container = title.closest("tr");
  3816.  
  3817.             // 隐藏元素
  3818.             container.style.display = "none";
  3819.           })();
  3820.  
  3821.           // 加入列表
  3822.           add.apply(topicModule, arguments);
  3823.  
  3824.           // 找到对应数据
  3825.           const topic = topicModule.data.find((item) => item[8] === tid);
  3826.  
  3827.           // 开始过滤
  3828.           await filterTopic(topic);
  3829.         };
  3830.       },
  3831.       set: (value) => {
  3832.         add = value;
  3833.       },
  3834.     });
  3835.  
  3836.     // 如果已经有数据，则直接过滤
  3837.     if (topicModule.data) {
  3838.       await Promise.all(Object.values(topicModule.data).map(filterTopic));
  3839.     }
  3840.   };
  3841.  
  3842.   // 处理 postArg 模块
  3843.   const handleReplyModule = async () => {
  3844.     let proc = replyModule.proc;
  3845.  
  3846.     // 劫持 proc 函数，这是泥潭的回复添加事件
  3847.     Object.defineProperty(replyModule, "proc", {
  3848.       get: () => {
  3849.         return async (...arguments) => {
  3850.           // 楼层号
  3851.           const index = arguments[0];
  3852.  
  3853.           // 先直接隐藏，等过滤完毕后再放出来
  3854.           (() => {
  3855.             // 判断是否是楼层
  3856.             const isFloor = typeof index === "number";
  3857.  
  3858.             // 评论额外标签
  3859.             const prefix = isFloor ? "" : "comment";
  3860.  
  3861.             // 用户容器
  3862.             const uInfoC = document.querySelector(
  3863.               `#${prefix}posterinfo${index}`
  3864.             );
  3865.  
  3866.             // 回复容器
  3867.             const container = isFloor
  3868.               ? uInfoC.closest("tr")
  3869.               : uInfoC.closest(".comment_c");
  3870.  
  3871.             // 隐藏元素
  3872.             container.style.display = "none";
  3873.           })();
  3874.  
  3875.           // 加入列表
  3876.           proc.apply(replyModule, arguments);
  3877.  
  3878.           // 找到对应数据
  3879.           const reply = replyModule.data[index];
  3880.  
  3881.           // 开始过滤
  3882.           await filterReply(reply);
  3883.         };
  3884.       },
  3885.       set: (value) => {
  3886.         proc = value;
  3887.       },
  3888.     });
  3889.  
  3890.     // 如果已经有数据，则直接过滤
  3891.     if (replyModule.data) {
  3892.       await Promise.all(Object.values(replyModule.data).map(filterReply));
  3893.     }
  3894.   };
  3895.  
  3896.   // 处理 commonui 模块
  3897.   const handleCommonui = () => {
  3898.     // 监听 mainMenu 模块，UI 需要等待这个模块加载完成
  3899.     (() => {
  3900.       if (commonui.mainMenu) {
  3901.         menuModule = commonui.mainMenu;
  3902.  
  3903.         handleMenu();
  3904.         return;
  3905.       }
  3906.  
  3907.       Object.defineProperty(commonui, "mainMenu", {
  3908.         get: () => menuModule,
  3909.         set: (value) => {
  3910.           menuModule = value;
  3911.  
  3912.           handleMenu();
  3913.         },
  3914.       });
  3915.     })();
  3916.  
  3917.     // 监听 topicArg 模块，这是泥潭的主题入口
  3918.     (() => {
  3919.       if (commonui.topicArg) {
  3920.         topicModule = commonui.topicArg;
  3921.  
  3922.         handleTopicModule();
  3923.         return;
  3924.       }
  3925.  
  3926.       Object.defineProperty(commonui, "topicArg", {
  3927.         get: () => topicModule,
  3928.         set: (value) => {
  3929.           topicModule = value;
  3930.  
  3931.           handleTopicModule();
  3932.         },
  3933.       });
  3934.     })();
  3935.  
  3936.     // 监听 postArg 模块，这是泥潭的回复入口
  3937.     (() => {
  3938.       if (commonui.postArg) {
  3939.         replyModule = commonui.postArg;
  3940.  
  3941.         handleReplyModule();
  3942.         return;
  3943.       }
  3944.  
  3945.       Object.defineProperty(commonui, "postArg", {
  3946.         get: () => replyModule,
  3947.         set: (value) => {
  3948.           replyModule = value;
  3949.  
  3950.           handleReplyModule();
  3951.         },
  3952.       });
  3953.     })();
  3954.   };
  3955.  
  3956.   // 前置过滤
  3957.   const handlePreFilter = () => {
  3958.     // 监听 commonui 模块，这是泥潭的主入口
  3959.     (() => {
  3960.       if (unsafeWindow.commonui) {
  3961.         commonui = unsafeWindow.commonui;
  3962.  
  3963.         handleCommonui();
  3964.         return;
  3965.       }
  3966.  
  3967.       Object.defineProperty(unsafeWindow, "commonui", {
  3968.         get: () => commonui,
  3969.         set: (value) => {
  3970.           commonui = value;
  3971.  
  3972.           handleCommonui();
  3973.         },
  3974.       });
  3975.     })();
  3976.   };
  3977.  
  3978.   // 普通过滤
  3979.   const handleFilter = () => {
  3980.     const runFilter = async () => {
  3981.       if (topicModule) {
  3982.         await Promise.all(
  3983.           Object.values(topicModule.data).map((item) => {
  3984.             if (item.executed) {
  3985.               return;
  3986.             }
  3987.  
  3988.             item.executed = true;
  3989.  
  3990.             filterTopic(item);
  3991.           })
  3992.         );
  3993.       }
  3994.  
  3995.       if (replyModule) {
  3996.         await Promise.all(
  3997.           Object.values(replyModule.data).map((item) => {
  3998.             if (item.executed) {
  3999.               return;
  4000.             }
  4001.  
  4002.             item.executed = true;
  4003.  
  4004.             filterReply(item);
  4005.           })
  4006.         );
  4007.       }
  4008.     };
  4009.  
  4010.     const hookFunction = (object, functionName, callback) => {
  4011.       ((originalFunction) => {
  4012.         object[functionName] = function () {
  4013.           const returnValue = originalFunction.apply(this, arguments);
  4014.  
  4015.           callback.apply(this, [returnValue, originalFunction, arguments]);
  4016.  
  4017.           return returnValue;
  4018.         };
  4019.       })(object[functionName]);
  4020.     };
  4021.  
  4022.     const initialized = {
  4023.       topicArg: false,
  4024.       postArg: false,
  4025.     };
  4026.  
  4027.     hookFunction(commonui, "eval", () => {
  4028.       if (Object.values(initialized).findIndex((item) => item === false) < 0) {
  4029.         return;
  4030.       }
  4031.  
  4032.       if (commonui.topicArg && initialized.topicArg === false) {
  4033.         hookFunction(commonui.topicArg, "add", runFilter);
  4034.  
  4035.         initialized.topicArg = true;
  4036.  
  4037.         topicModule = commonui.topicArg;
  4038.       }
  4039.  
  4040.       if (commonui.postArg && initialized.postArg === false) {
  4041.         hookFunction(commonui.postArg, "proc", runFilter);
  4042.  
  4043.         initialized.postArg = true;
  4044.  
  4045.         replyModule = commonui.postArg;
  4046.       }
  4047.     });
  4048.  
  4049.     runFilter();
  4050.   };
  4051.  
  4052.   // 主函数
  4053.   (() => {
  4054.     // 前置过滤
  4055.     if (preFilter) {
  4056.       handlePreFilter();
  4057.       return;
  4058.     }
  4059.  
  4060.     // 等待页面加载完毕后过滤
  4061.     unsafeWindow.addEventListener("load", () => {
  4062.       if (unsafeWindow.commonui === undefined) {
  4063.         return;
  4064.       }
  4065.  
  4066.       commonui = unsafeWindow.commonui;
  4067.  
  4068.       menuModule = commonui.mainMenu;
  4069.       topicModule = commonui.topicArg;
  4070.       replyModule = commonui.postArg;
  4071.  
  4072.       loadUI();
  4073.       handleFilter();
  4074.     });
  4075.   })();
  4076. })();