☰

笔趣阁优化

专注阅读

  1. // ==UserScript==
  2. // @name         笔趣阁优化
  3. // @namespace    https://gitee.com/linhq1999/OhMyScript
  4. // @version      5.2
  5. // @description  专注阅读
  6. // @author       LinHQ
  7. // @match        http*://www.shuquge.com/*.html
  8. // @exclude      http*://www.shuquge.com/*index.html
  9. // @match        http*://www.sywx8.com/*.html
  10. // @match        http*://www.biqugetv.com/*.html
  11. // @match        http*://www.bqxs520.com/*.html
  12. // @match        https://www.dshfood.net/*.html
  13. // @grant        GM_addStyle
  14. // @grant        GM_openInTab
  15. // @grant        GM_xmlhttpRequest
  16. // @require      https://gf.qytechs.cn/scripts/427726-gbk-url-js/code/GBK_URLjs.js?version=953098
  17. // @inject-into  auto
  18. // @license MIT
  19. // ==/UserScript==
  20. 'use strict';
  21. /** 配置示例
  22. * 建议在定制 search 函数时， rq 函数始终把参数写全
  23. * "sites": [
  24. *   {
  25. *       "desc": "shuquge", 网站链接关键字
  26. *       "url": "https://....", 网站首页链接
  27. *       "main": "div.reader", 主要部分选择器
  28. *       "title": ".reader h1", 标题选择器
  29. *       "txt": "#content", 文字部分选择器
  30. *       "toc": "dd a", 目录链接选择器
  31. *       "tocJump": 12, 跳过前面多少章
  32. *       "filter": ["div.header", "div.nav", "div.link"], 带有此选择器的元素将被删除
  33. *       "txtfilter": ["shuqu"] 带有此关键字的行将被删除
  34. *       "funcFilter"?: () => void, 自定义过滤器
  35. *       "nodash"?: boolean, 判断是否应该在书籍详情页链接后加额外的斜杠
  36. *       "search"?: (keywords: string, baseurl:string) => Promise<Link[]> 搜索行为
  37. *   }
  38. * ]
  39. */
  40. (() => {
  41.     // 缺省值，一般不用修改
  42.     const lineHeight = 1.3;
  43.     // const defaultFont = "楷体";
  44.     const defaultFont = "Source Han Sans SC VF";
  45.     let C = {
  46.         "sites": [
  47.             {
  48.                 "desc": "shuquge",
  49.                 "url": "https://www.shuquge.com/",
  50.                 "main": "div.reader",
  51.                 "title": ".reader h1",
  52.                 "txt": "#content",
  53.                 "toc": "dd a",
  54.                 "tocJump": 12,
  55.                 "filter": [
  56.                     "div.header", "div.nav", "div.link", "img",
  57.                     "#coupletleft", "#coupletright", "#HMRichBox"
  58.                 ],
  59.                 "txtfilter": ["shuqu"],
  60.                 "funcFilter": () => { var _a, _b; return (_b = (_a = fd(document, "#content")) === null || _a === void 0 ? void 0 : _a.previousSibling) === null || _b === void 0 ? void 0 : _b.remove(); }
  61.             },
  62.             {
  63.                 "desc": "sywx",
  64.                 "url": "https://www.sywx8.com/",
  65.                 "main": "div#container",
  66.                 "title": "div>h1",
  67.                 "toc": "li a",
  68.                 "tocJump": 0,
  69.                 "txt": "div#BookText",
  70.                 "filter": ["div.top", ".link.xb", "#footer"],
  71.                 "txtfilter": ["最快更新", "松语", "本章完", "本章未完"],
  72.                 // javascript 不支持 gbk 的 uri 编码，所以无法实现
  73.                 // 但是用 gbk.js 就不一样了
  74.                 "search": async (keywords, baseurl) => {
  75.                     let links = [];
  76.                     let doc = await rq({
  77.                         "url": `https://www.sywx8.com/modules/article/search.php?searchkey=${$URL.encode(keywords)}`
  78.                     }, 8000, "GBK");
  79.                     for (let a of doc.querySelectorAll(".c_row .c_subject a")) {
  80.                         // 这个网站比较特殊，链接默认是完整的
  81.                         links.push({ "title": `(sywx) ${a.textContent}`, "href": attr(a, "href") });
  82.                     }
  83.                     return links;
  84.                 }
  85.             },
  86.             {
  87.                 "desc": "bqxs",
  88.                 "url": "http://www.bqxs520.com/",
  89.                 "main": ".box_con",
  90.                 "title": "div.content_read h1",
  91.                 "toc": "#list dd a",
  92.                 "tocJump": 9,
  93.                 "txt": "#content",
  94.                 "filter": [".ywtop", ".header", ".nav", ".bottem1", ".lm", "#page_set", ".bookname~.box_con"],
  95.                 "txtfilter": ["请记住本书", "http"],
  96.                 "search": async (keywords, baseurl) => {
  97.                     let links = [];
  98.                     let doc = await rq({
  99.                         "method": "POST",
  100.                         "headers": { "Content-Type": "application/x-www-form-urlencoded" },
  101.                         "url": encodeURI(`http://www.bqxs520.com/case.php?m=search`),
  102.                         "data": `&key=${encodeURI(keywords)}`
  103.                     }, 7000, "UTF-8");
  104.                     for (let a of doc.querySelectorAll(".l .s2 a")) {
  105.                         links.push({ "title": `(bqxs) ${a.textContent}`, "href": concatURL(baseurl, attr(a, "href")) });
  106.                     }
  107.                     return links;
  108.                 }
  109.             },
  110.             {
  111.                 "desc": "biqugetv",
  112.                 "url": "https://www.biqugetv.com/",
  113.                 "main": ".box_con",
  114.                 "title": "div.content_read h1",
  115.                 "toc": "#list dd a",
  116.                 "tocJump": 0,
  117.                 "txt": "#content",
  118.                 "filter": [".ywtop", ".header", ".nav", ".bottem1", ".lm", "#page_set"],
  119.                 "txtfilter": [],
  120.                 "search": async (keywords, baseurl) => {
  121.                     let links = [];
  122.                     let doc = await rq({
  123.                         "url": encodeURI(`https://www.biqugetv.com/search.php?keyword=${keywords}`)
  124.                     }, 6000, "UTF-8");
  125.                     for (let a of doc.querySelectorAll("h3 a")) {
  126.                         links.push({ "title": `(biqugetv) ${a.textContent}`, "href": concatURL(baseurl, attr(a, "href")) });
  127.                     }
  128.                     return links;
  129.                 }
  130.             },
  131.             {
  132.                 "desc": "dshfood",
  133.                 "url": "https://www.dshfood.net/",
  134.                 "main": ".box_con",
  135.                 "title": "div.content_read h1",
  136.                 "toc": "#list dd a",
  137.                 "tocJump": 9,
  138.                 "txt": "#content",
  139.                 "filter": [".ywtop", ".header", ".nav", ".bottem1", "#page_set", "#content>div"],
  140.                 "txtfilter": ["笔趣阁"],
  141.                 "nodash": true,
  142.                 "funcFilter": () => document.querySelectorAll("img")
  143.                     .forEach(e => { var _a; return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.remove(); }),
  144.                 "search": async (keywords, baseurl) => {
  145.                     let links = [];
  146.                     let doc = await rq({
  147.                         "method": "POST",
  148.                         "headers": {
  149.                             "Content-Type": "application/x-www-form-urlencoded",
  150.                             "referer": "https://www.dshfood.net/so/"
  151.                         },
  152.                         "url": "https://www.dshfood.net/so/",
  153.                         // 鉴于使用了 GBK 进行编码，不能再使用 URLSearchParams
  154.                         "data": `?searchtype=articlename&searchkey=${$URL.encode(keywords)}&submit=`
  155.                     }, 6000, "GBK");
  156.                     for (let a of doc.querySelectorAll(".line a.blue")) {
  157.                         links.push({ "title": `(dshfood) ${a.textContent}`, "href": concatURL(baseurl, attr(a, "href")) });
  158.                     }
  159.                     return links;
  160.                 }
  161.             }
  162.         ],
  163.         "states": {
  164.             "fontSize": 16,
  165.             "lineHeight": 16 * lineHeight,
  166.             "toc": false,
  167.             "flow": false
  168.         },
  169.         "style": `
  170.             body {
  171.                 background-color: #EAEAEF !important;
  172.             }
  173.  
  174.             .bqg.inject.win {
  175.                 width: 55vw !important;
  176.                 min-width: 600px;
  177.                 border: 2px double gray !important;
  178.                 border-radius: 8px;
  179.             }
  180.  
  181.             .bqg.inject.txt {
  182.                 font-family: Calibri,'${defaultFont}',serif!important;
  183.                 background-color: #EAEAEF !important;
  184.                 padding: 0.5em 1em !important;
  185.                 margin: 0.5em auto !important;
  186.                 width: auto !important;
  187.                 white-space: pre-wrap;
  188.             }
  189.  
  190.             .bqg.inject.title {
  191.                 color: black;
  192.                 background-color: #EAEAEF;
  193.                 font-family: Calibri,'${defaultFont}',serif!important;
  194.                 cursor: pointer !important;
  195.             }
  196.  
  197.             .bqg.inject.title:hover {
  198.                 color: #0258d8 !important;
  199.             }
  200.             
  201.             .hq.inject.toc {
  202.                 font-family: Calibri,sans-serif;
  203.                 width: 275px;
  204.                 position: fixed;
  205.                 top: 30px;
  206.                 left: 8px;
  207.                 /*目录默认是关闭的*/
  208.                 transform: translateX(-300px);
  209.                 opacity: 0;
  210.                 padding: 5px;
  211.                 display: flex;
  212.                 flex-flow: column;
  213.                 box-shadow: #7b7b7b 5px 4px 5px;
  214.                 transition-property: transform, box-shadow, opacity;
  215.                 transition-duration: .5s;
  216.                 transition-timing-function:cubic-bezier(0.35, 1.06, 0.83, 0.99);
  217.                 background: rgb(246 246 246 / 60%);
  218.                 backdrop-filter: blur(2px);
  219.                 border-radius: 8px;
  220.             }
  221.  
  222.             .hq.inject ul {
  223.                 height: 280px;
  224.                 width: 100%;
  225.                 /*offsetTop 计算需要*/
  226.                 position:relative;
  227.                 overflow: auto;
  228.             }
  229.  
  230.             .hq.inject ul li {
  231.                 cursor: pointer;
  232.                 margin: 2px;
  233.                 width: 95%;
  234.                 padding: 1px 4px;
  235.                 font-size: 12px;
  236.                 border-radius: 4px;
  237.             }
  238.  
  239.             .hq.inject ul li:hover {
  240.                 background: #0258d8;
  241.                 color: #f6f6f6;
  242.             }
  243.  
  244.             .hq.inject.toc>h3 {
  245.                 font-size: 1.1rem;
  246.                 font-weight: bold;
  247.                 border-radius: 2px;
  248.                 align-self: center;
  249.                 cursor: pointer;
  250.                 margin: 4px 0 8px 0;
  251.             }
  252.  
  253.             .hq.inject.toc>h3:hover {
  254.                 color: #ffa631 !important;
  255.             }
  256.  
  257.             .hq.inject.search {
  258.                 font-family: Calibri,sans-serif;
  259.                 width: 275px;
  260.                 position: fixed;
  261.                 top: 30px;
  262.                 padding: 5px;
  263.                 display: flex;
  264.                 flex-flow: column;
  265.                 transition: right 0.5s cubic-bezier(0.35, 1.06, 0.83, 0.99);
  266.                 background: rgb(246 246 246 / 60%);
  267.                 border-radius: 8px;
  268.             }
  269.  
  270.             .hq.inject.search input {
  271.                 margin: 8px auto;
  272.                 width: 95%;
  273.             }
  274.             `
  275.     };
  276.     // 查询已经保存的字体信息
  277.     let savedStates = localStorage.getItem("bqg_cfg");
  278.     // 检查是否存在已有设置且和当前版本相符
  279.     let states;
  280.     if (savedStates === null) {
  281.         states = C.states;
  282.         console.warn("当前状态已保存");
  283.     }
  284.     else {
  285.         let cfg = JSON.parse(savedStates);
  286.         let defaultStates = Object.keys(C.states);
  287.         let cfg_ = Object.keys(cfg);
  288.         let useSaved = true;
  289.         // 检查键是否匹配
  290.         if (defaultStates.length == cfg_.length) {
  291.             for (let key of Object.keys(cfg)) {
  292.                 if (!defaultStates.includes(key)) {
  293.                     useSaved = false;
  294.                     break;
  295.                 }
  296.             }
  297.         }
  298.         else {
  299.             useSaved = false;
  300.         }
  301.         if (useSaved) {
  302.             states = cfg;
  303.         }
  304.         else {
  305.             states = C.states;
  306.             console.warn("检测到版本变化，状态已重置");
  307.         }
  308.     }
  309.     // 检测当前的网址，应用对应的设置
  310.     let tmp = C.sites.filter(site => document.URL.includes(site.desc));
  311.     if (tmp.length == 0) {
  312.         console.warn("没有匹配的设置，脚本已终止！");
  313.         return;
  314.     }
  315.     let currentSite = tmp[0];
  316.     // 完成样式注入
  317.     GM_addStyle(C.style);
  318.     /**
  319.      * 保存交互式状态
  320.      */
  321.     function saveStates() {
  322.         localStorage.setItem("bqg_cfg", JSON.stringify(states));
  323.     }
  324.     /**
  325.      * 上一章，同时移除所有 flow 拼接结果
  326.      */
  327.     function prevChapter() {
  328.         var _a;
  329.         (_a = fd(document, "a", "上一")) === null || _a === void 0 ? void 0 : _a.click();
  330.     }
  331.     /**
  332.      * 下一章，同时移除所有 flow 拼接结果
  333.      */
  334.     function nextChapter() {
  335.         var _a;
  336.         (_a = fd(document, "a", "下一")) === null || _a === void 0 ? void 0 : _a.click();
  337.     }
  338.     /**
  339.      * 异步，向下拼页
  340.      * 绑定到事件上时务必注意重复触发的情况
  341.      */
  342.     async function concatNextCh() {
  343.         var _a;
  344.         let next = fd(document, "a", "下一");
  345.         let prev = fd(document, "a", "上一");
  346.         let currentText = fd(document, currentSite.txt);
  347.         try {
  348.             let doc = await rq({ url: next === null || next === void 0 ? void 0 : next.href });
  349.             let text = fd(doc, currentSite.txt);
  350.             // console.log(text.textContent)
  351.             // 更好的性能
  352.             currentText.insertAdjacentHTML("beforeend", "<br><hr style='border: unset;border-top: 1px solid gray; margin: ${states.lineHeight}px 0'>");
  353.             currentText.insertAdjacentText("beforeend", txtFilter((_a = text.innerText) !== null && _a !== void 0 ? _a : "文本过滤错误", /(?![a-zA-Z0-9!.'"])\s+/));
  354.             // /id/xxx_1.html -> /id/xxx_1
  355.             let href = attr(next, "href").replace(/\.html$/, "");
  356.             // 重新渲染目录，currentBookToc 不可能为 null
  357.             renderTOC(JSON.parse(currentBookToc), ul, href);
  358.             // 重设上一页和下一页按钮的链接
  359.             prev.href = fd(doc, "a", "上一").href;
  360.             next.href = fd(doc, "a", "下一").href;
  361.         }
  362.         catch (error) {
  363.             currentText.innerText = currentText.innerText.concat("\n\n\t获取下一页错误，上下滚动以重新获取");
  364.         }
  365.     }
  366.     // 目录切换
  367.     function switchToc(open) {
  368.         let toc = fd(document, ".hq.inject.toc");
  369.         if (open) {
  370.             toc.style.transform = "translateX(0)";
  371.             toc.style.opacity = "1";
  372.             toc.style.boxShadow = "box-shadow: #7b7b7b 5px 3px 4px 0px;";
  373.             states.toc = true;
  374.         }
  375.         else {
  376.             toc.style.transform = "translateX(-300px)";
  377.             toc.style.opacity = "0";
  378.             toc.style.boxShadow = "box-shadow: #7b7b7b 5px 2px 0px 0px;";
  379.             states.toc = false;
  380.         }
  381.         saveStates();
  382.     }
  383.     // 目录开关
  384.     function toggleToc() {
  385.         if (states.toc) {
  386.             switchToc(false);
  387.         }
  388.         else {
  389.             switchToc(true);
  390.         }
  391.     }
  392.     /**
  393.      * 根据 site 中的条件进行过滤，同时将缩进统一
  394.      *
  395.      * @param itxt 需要过滤的，innerText 通用性最好
  396.      * @param delim 默认的切分点，从网页解析得到的内容和 ajax 获取到的内容切分点不一致
  397.      * @returns 过滤后字符串
  398.      */
  399.     function txtFilter(itxt, delim = /\n/g) {
  400.         var _a;
  401.         // innerText 相对于 textContent 保留了视觉上的换行（块的换行）
  402.         return (_a = itxt === null || itxt === void 0 ? void 0 : itxt.split(delim)) === null || _a === void 0 ? void 0 : _a.filter(line => {
  403.             if (/^\s*$/.test(line))
  404.                 return false;
  405.             // 去除白行和包含的关键字
  406.             for (const keyword of currentSite.txtfilter) {
  407.                 if (line.includes(keyword)) {
  408.                     return false;
  409.                 }
  410.             }
  411.             return true;
  412.         }).map(line => `${"　".repeat(2)}${line.trim()}`).join("\n\n");
  413.     }
  414.     if (states.flow) {
  415.         // 变相 throttle 一下不然顶不住
  416.         let loading = false;
  417.         document.onscroll = async (_) => {
  418.             if (!loading && chkBoundry(true, window.innerHeight * 0.75)) {
  419.                 loading = true;
  420.                 // 意思是上一次拼页完过1.5秒才允许继续拼页，避免在加载下一页时反复调用拼页函数
  421.                 // 效果比固定延迟要稳定
  422.                 await concatNextCh();
  423.                 setTimeout(() => { loading = false; }, 1500);
  424.             }
  425.         };
  426.     }
  427.     // 对可变部分产生影响
  428.     let doInject = function () {
  429.         var _a;
  430.         // 执行元素过滤
  431.         currentSite.filter.forEach(filter => { var _a; return (_a = document.querySelectorAll(filter)) === null || _a === void 0 ? void 0 : _a.forEach(ele => ele.remove()); });
  432.         // 执行自定义过滤
  433.         if (currentSite.funcFilter) {
  434.             currentSite.funcFilter();
  435.         }
  436.         // 应用已经保存的状态
  437.         let textWin = fd(document, currentSite.txt);
  438.         textWin.setAttribute("style", `font-size:${states.fontSize}px;line-height:${states.lineHeight}px`);
  439.         textWin.classList.add("bqg", "inject", "txt");
  440.         // 执行文字过滤
  441.         textWin.textContent = txtFilter((_a = textWin.innerText) !== null && _a !== void 0 ? _a : "文本过滤错误");
  442.         let mainWin = fd(document, currentSite.main);
  443.         mainWin.classList.add("bqg", "inject", "win");
  444.         let title = fd(document, currentSite.title);
  445.         title.title = "点击显示目录";
  446.         title.classList.add("bqg", "inject", "title");
  447.         title.onclick = (ev) => {
  448.             toggleToc();
  449.             // 避免跳到上一章
  450.             // 比下面的更为具体，所以有效。
  451.             ev.stopPropagation();
  452.         };
  453.         // 阻止双击事件被捕获（双击会回到顶部）
  454.         document.body.ondblclick = (ev) => ev.stopImmediatePropagation();
  455.         document.body.onclick = (ev) => {
  456.             let root = document.documentElement;
  457.             let winHeight = window.innerHeight;
  458.             // 下半屏单击下滚，反之上滚
  459.             if (ev.clientY > root.clientHeight / 2) {
  460.                 if (chkBoundry() && !states.flow)
  461.                     nextChapter();
  462.                 window.scrollBy({ top: (window.innerHeight - lineHeight) * 1 });
  463.             }
  464.             else {
  465.                 if (chkBoundry(false)) {
  466.                     prevChapter();
  467.                 }
  468.                 window.scrollBy({ top: (window.innerHeight - lineHeight) * -1 });
  469.             }
  470.         };
  471.         document.body.onkeydown = (ev) => {
  472.             switch (ev.key) {
  473.                 case "-":
  474.                     states.fontSize -= 2;
  475.                     textWin.style.fontSize = `${states.fontSize}px`;
  476.                     states.lineHeight = states.fontSize * lineHeight;
  477.                     textWin.style.lineHeight = `${states.lineHeight}px`;
  478.                     saveStates();
  479.                     break;
  480.                 case "=":
  481.                     states.fontSize += 2;
  482.                     textWin.style.fontSize = `${states.fontSize}px`;
  483.                     states.lineHeight = states.fontSize * lineHeight;
  484.                     textWin.style.lineHeight = `${states.lineHeight}px`;
  485.                     saveStates();
  486.                     break;
  487.                 case "j":
  488.                     if (chkBoundry() && !states.flow) {
  489.                         nextChapter();
  490.                     }
  491.                     else {
  492.                         window.scrollBy({ top: window.innerHeight - states.lineHeight });
  493.                     }
  494.                     break;
  495.                 case "k":
  496.                     // 考虑在 flow 模式下也允许上一章
  497.                     if (chkBoundry(false) && !states.flow) {
  498.                         prevChapter();
  499.                     }
  500.                     else {
  501.                         window.scrollBy({ top: -1 * (window.innerHeight - states.lineHeight) });
  502.                     }
  503.                     break;
  504.                 case "h":
  505.                     prevChapter();
  506.                     break;
  507.                 case "l":
  508.                     nextChapter();
  509.                     break;
  510.                 case "t":
  511.                     toggleToc();
  512.                     break;
  513.                 case "s":
  514.                     toggleSearch();
  515.                     break;
  516.                 case "f":
  517.                     states.flow = !states.flow;
  518.                     saveStates();
  519.                     break;
  520.                 default:
  521.                     break;
  522.             }
  523.         };
  524.     };
  525.     // 先调用一次，后面是有变化时才会触发，避免有时无法起作用
  526.     doInject();
  527.     // 强力覆盖
  528.     new MutationObserver((_, ob) => {
  529.         doInject();
  530.     }).observe(document.body, { childList: true });
  531.     // 添加目录
  532.     let toc = document.createElement("div");
  533.     toc.className = "hq inject toc";
  534.     toc.onclick = ev => ev.stopPropagation();
  535.     // 已保存状态读取
  536.     document.body.append(toc);
  537.     if (states.toc)
  538.         switchToc(true);
  539.     // 目录状态指示灯
  540.     let pointer = document.createElement("h3");
  541.     // 当然也可以靠不同类名实现
  542.     let pointerColors = { "loaded": "#afdd22", "loading": "#ffa631", "unload": "#ed5736" };
  543.     pointer.title = "点击以重新加载目录";
  544.     pointer.innerHTML = "目<span style='display: inline-block;width: 1em'></span>录";
  545.     pointer.style.cursor = "pointer";
  546.     pointer.style.color = pointerColors.unload;
  547.     toc.append(pointer);
  548.     // 目录列表
  549.     let ul = document.createElement("ul");
  550.     toc.append(ul);
  551.     /**
  552.      * 从源渲染目录到指定元素
  553.      *
  554.      * @param toc 目录源
  555.      * @param ul 容器
  556.      * @param href 定位链接，格式 http://host/id/chp.html 中最短为 /id/chp 部分
  557.      */
  558.     function renderTOC(toc, ul, href) {
  559.         var _a;
  560.         // 清空旧内容
  561.         ul.innerHTML = "";
  562.         let current = null;
  563.         // 进度计数器
  564.         let counter = 1;
  565.         for (let lnk of toc) {
  566.             let li = document.createElement("li");
  567.             li.textContent = lnk.title;
  568.             // 根据传入的 href 是否包含目录中的链接来判定，因为有的网站包含子页面 XXXX_1.html 形式
  569.             // 比对时标准目录链接 lnk: /id/chp.html 之中，仅取用 chp
  570.             let last = (_a = lnk.href.replace(".html", "")) !== null && _a !== void 0 ? _a : "";
  571.             if (current == null && href.includes(last)) {
  572.                 li.innerHTML = `${lnk.title}<span style="flex: 1;"></span>${(counter / toc.length * 100).toFixed(1)}%`;
  573.                 current = li;
  574.             }
  575.             li.onclick = (ev) => {
  576.                 document.location.href = lnk.href;
  577.                 ev.stopPropagation();
  578.             };
  579.             ul.append(li);
  580.             counter++;
  581.         }
  582.         // 渲染完修改指示灯状态
  583.         pointer.style.color = pointerColors.loaded;
  584.         // 滚动到当前位置，并高亮
  585.         if (current !== null) {
  586.             current.setAttribute("style", "display:flex;font-weight:bold;background: #0258d8;color: #f6f6f6;");
  587.             ul.scrollTo({ top: current.offsetTop - 130 });
  588.         }
  589.     }
  590.     /**
  591.      * 获取目录信息
  592.      *
  593.      * @param currentBookLink 当前书的链接，用作存储的键
  594.      * @param pointer 指示灯，在需要的时候修改状态
  595.      */
  596.     async function fetchTOC(currentBookLink, pointer) {
  597.         var _a;
  598.         // 修改指示灯状态
  599.         pointer.style.color = pointerColors.loading;
  600.         try {
  601.             let doc = await rq({ url: currentBookLink });
  602.             let tocs = doc.querySelectorAll(currentSite.toc);
  603.             let data = [];
  604.             // 序列化存储准备
  605.             for (let link of tocs) {
  606.                 // 使用字面意义上的链接 /chapter.html 而不是 http://**/id/chapter.html 以减小存储量
  607.                 data.push({ "title": (_a = link.textContent) !== null && _a !== void 0 ? _a : "", "href": attr(link, "href") });
  608.             }
  609.             if (currentSite.tocJump)
  610.                 data = data.slice(currentSite.tocJump);
  611.             // 缓存目录信息
  612.             let stdata = JSON.stringify(data);
  613.             sessionStorage.setItem(currentBookLink, stdata);
  614.             // 更新变量，避免章节拼接时以为找不到
  615.             currentBookToc = stdata;
  616.             renderTOC(data, ul, href);
  617.         }
  618.         catch (_) {
  619.             pointer.style.color = pointerColors.unload;
  620.         }
  621.     }
  622.     let source = document.URL.split("/");
  623.     source.pop();
  624.     // 用来定位的 url
  625.     let href = document.URL.replace(/\.html$/, "");
  626.     // 最后加斜杠保险
  627.     let currentBook = source.join("/");
  628.     if (!currentSite.nodash) {
  629.         currentBook += "/";
  630.     }
  631.     let currentBookToc = sessionStorage.getItem(currentBook);
  632.     if (currentBookToc === null) {
  633.         fetchTOC(currentBook, pointer);
  634.     }
  635.     else {
  636.         renderTOC(JSON.parse(currentBookToc), ul, href);
  637.     }
  638.     // 单击指示灯刷新目录缓存
  639.     pointer.onclick = _ => fetchTOC(currentBook, pointer);
  640.     // 添加聚合搜索
  641.     let searchBox = document.createElement("div");
  642.     searchBox.onclick = ev => ev.stopPropagation();
  643.     searchBox.onkeydown = ev => ev.stopPropagation();
  644.     searchBox.className = "hq inject search";
  645.     searchBox.style.right = "-300px";
  646.     searchBox.innerHTML = `
  647.     <input id="insearch" type="search" placeholder="至少输入两个字"/>
  648.     <span style="align-self:center;margin-bottem: 4px;color: ${pointerColors.loaded}">已就绪</span>
  649.     `;
  650.     document.body.append(searchBox);
  651.     let inputBox = fd(searchBox, "#insearch");
  652.     let search_ul = document.createElement("ul");
  653.     searchBox.append(search_ul);
  654.     let search_pointer = fd(searchBox, "#insearch~span");
  655.     // debounce 一下不然顶不住
  656.     let timer = null;
  657.     inputBox.oninput = _ => {
  658.         if (timer !== null)
  659.             clearTimeout(timer);
  660.         timer = setTimeout(async () => {
  661.             var _a, _b;
  662.             // 放外面也可
  663.             if (((_a = inputBox) === null || _a === void 0 ? void 0 : _a.value.length) < 2)
  664.                 return;
  665.             // 更新指示灯
  666.             search_pointer.textContent = `正在搜索：${inputBox.value}`;
  667.             search_pointer.style.color = pointerColors.loading;
  668.             let requests = [];
  669.             let others = [{ "title": "没有搜索结果，也可以看看:", "href": "#" }];
  670.             for (let s of C.sites) {
  671.                 if (s.search !== undefined) {
  672.                     // 搜索开始
  673.                     requests.push(s.search((_b = inputBox) === null || _b === void 0 ? void 0 : _b.value, s.url));
  674.                 }
  675.                 else {
  676.                     others.push({ "title": s.desc, "href": s.url });
  677.                 }
  678.             }
  679.             let result_count = 0, failed = 0;
  680.             let list = await Promise.allSettled(requests);
  681.             // 获取结果后清空旧内容
  682.             search_ul.innerHTML = "";
  683.             for (let site of list) {
  684.                 if (site.status === "fulfilled") {
  685.                     for (let lnk of site.value) {
  686.                         let li = document.createElement("li");
  687.                         li.textContent = lnk.title.trim();
  688.                         li.onclick = ev => GM_openInTab(lnk.href, { active: true });
  689.                         search_ul.append(li);
  690.                         result_count++;
  691.                     }
  692.                 }
  693.                 else {
  694.                     failed++;
  695.                 }
  696.             }
  697.             // 处理一下没有结果的情况，把没有实现 search 的网站摆上去
  698.             if (result_count === 0) {
  699.                 for (let o of others) {
  700.                     let li = document.createElement("li");
  701.                     li.textContent = o.title;
  702.                     li.onclick = ev => GM_openInTab(o.href, { active: true });
  703.                     search_ul.append(li);
  704.                 }
  705.             }
  706.             // 更新指示
  707.             search_pointer.textContent = `搜索完成：${result_count} 条结果 [${failed} 错误]`;
  708.             search_pointer.style.color = pointerColors.loaded;
  709.         }, 1000);
  710.     };
  711.     // 搜索框开关
  712.     function toggleSearch() {
  713.         if (parseInt(searchBox.style.right) < 0) {
  714.             searchBox.style.right = "8px";
  715.         }
  716.         else {
  717.             searchBox.style.right = "-300px";
  718.         }
  719.     }
  720.     /*
  721.       以下是工具函数
  722.      */
  723.     /**
  724.      * 发起请求
  725.      *
  726.      * @param details 油猴标准请求格式，onload,onerror,responseType 会被忽略
  727.      * @param timeout 超时时间 默认：5000
  728.      * @param encoding 请求数据的编码 默认：当前所在页面的编码
  729.      * @returns Promise<Document>
  730.      */
  731.     function rq(details, timeout = 5000, encoding) {
  732.         // 自动探测一手
  733.         if (!encoding)
  734.             encoding = document.characterSet;
  735.         return new Promise((res, rej) => {
  736.             details.onerror = rej;
  737.             details.ontimeout = rej;
  738.             details.timeout = timeout;
  739.             details.responseType = "arraybuffer";
  740.             details.onload = resp => {
  741.                 if (resp.status != 200)
  742.                     rej();
  743.                 let decoder = new TextDecoder(encoding);
  744.                 res(new DOMParser()
  745.                     .parseFromString(decoder.decode(resp.response), "text/html"));
  746.             };
  747.             GM_xmlhttpRequest(details);
  748.         });
  749.     }
  750.     /**
  751.      * 返回符合条件的第一个元素
  752.      *
  753.      * @param doc 被查找的文档
  754.      * @param selector 选择器
  755.      * @param text 可选 元素的文本（子字符串）
  756.      * @returns 符合条件的元素
  757.      */
  758.     function fd(doc, selector, text) {
  759.         var _a;
  760.         if (text) {
  761.             for (let e of doc.querySelectorAll(selector)) {
  762.                 if ((_a = e.textContent) === null || _a === void 0 ? void 0 : _a.includes(text)) {
  763.                     return e;
  764.                 }
  765.             }
  766.         }
  767.         else {
  768.             return doc.querySelector(selector);
  769.         }
  770.         return null;
  771.     }
  772.     /**
  773.      * 拼接 URL
  774.      *
  775.      * @param host 网站域名
  776.      * @param path 一般是链接之中的相对路径
  777.      * @returns 完整的 URL
  778.      */
  779.     function concatURL(host, path) {
  780.         let url = new URL(host);
  781.         url.pathname = path;
  782.         return url.toString();
  783.     }
  784.     /**
  785.      * 如果是 a 标签，且想要获取字面上的 href，必须使用此方法，不可以用 a.href
  786.      *
  787.      * @param ele 标签名
  788.      * @param attr 属性名
  789.      * @returns 属性值
  790.      */
  791.     function attr(ele, attr) {
  792.         var _a;
  793.         return (_a = ele.getAttribute(attr)) !== null && _a !== void 0 ? _a : "";
  794.     }
  795.     /**
  796.      * 检查当前位置是否处于边界
  797.      *
  798.      * @param bottom 是否检查到达底部，否则检查是否处于顶部
  799.      * @param range 距离底部多少，默认是 0（最底部）
  800.      * @returns boolean
  801.      */
  802.     function chkBoundry(bottom = true, range = 0) {
  803.         let root = document.documentElement;
  804.         let winHeight = window.innerHeight;
  805.         if (bottom) {
  806.             return (root.scrollTop + winHeight + range >= root.scrollHeight);
  807.         }
  808.         else {
  809.             return (root.scrollTop == 0);
  810.         }
  811.     }
  812. })();

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址