☰

Wenku Doc Downloader

下载文档，导出PDF。支持①百度文库②豆丁网③道客巴巴④360doc个人图书馆⑤得力文库⑥MBA智库⑦爱问共享资料（新浪文档）⑧原创力文档⑨读根网。在文档页面左侧中间有Wenku Doc Download按钮区，说明脚本生效了。【反馈请提供网址】。暂不支持手机端，手机端请切换为电脑UA访问。

目前为 2022-03-08 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         Wenku Doc Downloader
  3. // @namespace    http://tampermonkey.net/
  4. // @version      1.5.0
  5. // @description  下载文档，导出PDF。支持①百度文库②豆丁网③道客巴巴④360doc个人图书馆⑤得力文库⑥MBA智库⑦爱问共享资料（新浪文档）⑧原创力文档⑨读根网。在文档页面左侧中间有Wenku Doc Download按钮区，说明脚本生效了。【反馈请提供网址】。暂不支持手机端，手机端请切换为电脑UA访问。
  6. // @author       allenlv2690@gmail.com
  7. // @match        *://*.docin.com/p-*
  8. // @match        *://ishare.iask.sina.com.cn/f/*
  9. // @match        *://www.deliwenku.com/p-*
  10. // @match        *://www.doc88.com/p-*
  11. // @match        *://www.360doc.com/content/*
  12. // @match        *://wenku.baidu.com/*/*
  13. // @match        *://doc.mbalib.com/view/*
  14. // @match        *://www.woc88.com/so-*
  15. // @match        *://www.dugen.com/p-*
  16. // @match        *://max.book118.com/html/*
  17. // @match        *://view-cache.book118.com/pptView.html?*
  18. // @match        *://*.book118.com/?readpage=*
  19. // @require      https://cdn.bootcdn.net/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js
  20. // @require      https://cdn.bootcdn.net/ajax/libs/jszip/3.7.1/jszip.min.js
  21. // @require      https://cdn.bootcdn.net/ajax/libs/jspdf/2.3.1/jspdf.umd.min.js
  22. // @require      https://cdn.bootcdn.net/ajax/libs/html2canvas/1.4.1/html2canvas.min.js
  23. // @icon         https://s2.loli.net/2022/01/12/wc9je8RX7HELbYQ.png
  24. // @icon64       https://s2.loli.net/2022/01/12/tmFeSKDf8UkNMjC.png
  25. // @grant        none
  26. // @license      GPL-3.0-only
  27. // @create       2021-11-22
  28. // @note         1. 增加了对【原创力】文档的支持
  29. // @note         2. 增加了对【读根】文档的支持
  30. // @note         3. 更新了对百度文库ppt文档的识别
  31. // ==/UserScript==
  32.  
  33.  
  34. (function () {
  35.     'use strict';
  36.  
  37.     let utils = {
  38.         /**
  39.          * 创建并下载文件
  40.          * @param {String} file_name 文件名
  41.          * @param {String | Blob} content 文本或blob
  42.          */
  43.         createAndDownloadFile: function(file_name, content) {
  44.             let aTag = document.createElement('a');
  45.             let blob;
  46.             if (typeof(content) === "string") {
  47.                 blob = new Blob([content]);
  48.             }
  49.             aTag.download = file_name;
  50.             aTag.href = URL.createObjectURL(blob);
  51.             aTag.click();
  52.             URL.revokeObjectURL(blob);
  53.         },
  54.  
  55.         /**
  56.          * 创建并下载链接资源
  57.          * @param {String} file_name 
  58.          * @param {String} src 
  59.          */
  60.         downloadUrlFile: function(file_name, src) {
  61.             let aTag = document.createElement('a');
  62.             aTag.download = file_name;
  63.             aTag.href = src;
  64.             aTag.click();
  65.         },
  66.  
  67.         /**
  68.          * 添加外部js到当前页面
  69.          * @param {String} url 
  70.          */
  71.         addScripts2HTML: function(url) {
  72.             let script = document.createElement("script");
  73.             script.src = url;
  74.             document.head.appendChild(script);
  75.         },
  76.  
  77.         /**
  78.          * 临时禁用脚本，执行func后移除btns_section。
  79.          * @param {Function} func
  80.          */
  81.         banSelf: function(func = () => { }) {
  82.             func();
  83.             document.querySelector(".btns_section").remove();
  84.         },
  85.  
  86.         /**
  87.          * 睡眠 delay 毫秒
  88.          * @param {Number} delay 
  89.          */
  90.         sleep: function(delay) {
  91.             let start = (new Date()).getTime();
  92.             while ((new Date()).getTime() - start < delay) {
  93.                 continue;
  94.             }
  95.         },
  96.  
  97.         /**
  98.          * 允许打印页面
  99.          */
  100.         allowPrint: function() {
  101.             let style = document.createElement("style");
  102.             style.innerHTML = `
  103.             @media print {
  104.                 body{
  105.                     display:block;
  106.                 }
  107.             }
  108.         `;
  109.             document.head.appendChild(style);
  110.         },
  111.  
  112.         /**
  113.          * 求main_set去除cut_set后的set
  114.          * @param {Set} main_set 
  115.          * @param {Set} cut_set 
  116.          * @returns 差集
  117.          */
  118.         difference: function(main_set, cut_set) {
  119.             let _diff = new Set(main_set);
  120.             for (let elem of cut_set) {
  121.                 _diff.delete(elem);
  122.             }
  123.             return _diff;
  124.         },
  125.  
  126.         /**
  127.          * 抛出set中的第一个元素
  128.          * @param {Set} set 
  129.          * @returns 一个元素
  130.          */
  131.         setPop: function(set) {
  132.             for (let item of set) {
  133.                 set.delete(item);
  134.                 return item;
  135.             }
  136.         },
  137.  
  138.         /**
  139.          * 绑定事件到指定按钮，返回按钮引用
  140.          * @param {Function} event click事件
  141.          * @param {Array} args 事件的参数列表 
  142.          * @param {String} aim_btn 按钮的变量名
  143.          * @param {String} new_text 按钮的新文本，为null则不替换
  144.          * @returns 按钮元素的引用
  145.          */
  146.         setBtnEvent: function(event, args = [], aim_btn = "btn_3", new_text = null) {
  147.             let btn = document.querySelector(`.${aim_btn.replace("_", "-")}`);
  148.             // 如果需要，替换按钮内文本
  149.             if (new_text) {
  150.                 btn.textContent = new_text;
  151.             }
  152.             // 绑定事件，添加到页面上
  153.             btn.onclick = () => {
  154.                 this.enhanceBtnClickReaction(aim_btn);
  155.                 if (args.length) {
  156.                     event(...args);
  157.                 } else {
  158.                     event();
  159.                 }
  160.             };
  161.             return btn;
  162.         },
  163.  
  164.         /**
  165.          * 强制隐藏元素
  166.          * @param {String} selector 
  167.          */
  168.         forceHide: function(selector) {
  169.             let style_cls = "force-hide";
  170.             document.querySelectorAll(selector).forEach((elem) => {
  171.                 elem.className += ` ${style_cls}`;
  172.             });
  173.             // 判断css样式是否已经存在
  174.             let style;
  175.             style = document.querySelector(`style.${style_cls}`);
  176.             // 如果已经存在，则无须重复创建
  177.             if (style) {
  178.                 return;
  179.             }
  180.             // 否则创建
  181.             style = document.createElement("style");
  182.             style.innerHTML = `style.${style_cls} {
  183.             visibility: hidden !important;
  184.         }`;
  185.             document.head.appendChild(style);
  186.         },
  187.  
  188.         /**
  189.          * 隐藏按钮，打印页面，显示按钮
  190.          */
  191.         hideBtnThenPrint: function() {
  192.             // 隐藏按钮，然后打印页面
  193.             let section = document.getElementsByClassName("btns_section")[0];
  194.             section.style.display = "none";
  195.             window.print();
  196.             // 打印结束，显示按钮
  197.             section.style.removeProperty("display");
  198.         },
  199.  
  200.         /**
  201.          * 返回times个倍数连接的str
  202.          * @param {String} str 
  203.          * @param {Number} times 
  204.          * @returns multiplied_str
  205.          */
  206.         multiplyStr: function(str, times) {
  207.             let str_list = [];
  208.             for (let i = 0; i < times; i++) {
  209.                 str_list.push(str);
  210.             }
  211.             return str_list.join("");
  212.         },
  213.  
  214.         /**
  215.          * 增强按钮（默认为蓝色按钮：展开文档）的点击效果
  216.          * @param {String} custom_btn 按钮变量名
  217.          */
  218.         enhanceBtnClickReaction: function(custom_btn = null) {
  219.             let aim_btn;
  220.             // 如果不使用自定义按钮元素，则默认为使用蓝色展开文档按钮
  221.             if (!custom_btn || custom_btn === "btn_1") {
  222.                 aim_btn = document.querySelector(".btn-1");
  223.             } else {
  224.                 aim_btn = document.querySelector(`.${custom_btn.replace("_", "-")}`);
  225.             }
  226.  
  227.             let old_color = aim_btn.style.color; // 保存旧的颜色
  228.             let old_text = aim_btn.textContent; // 保存旧的文字内容
  229.             // 变黑缩小
  230.             aim_btn.style.color = "black";
  231.             aim_btn.style.fontWeight = "normal";
  232.             aim_btn.textContent = `->${old_text}<-`;
  233.             // 复原加粗
  234.             let changeColorBack = function() {
  235.                 aim_btn.style.color = old_color;
  236.                 aim_btn.style.fontWeight = "bold";
  237.                 aim_btn.textContent = old_text;
  238.             };
  239.             setTimeout(changeColorBack, 1250);
  240.         },
  241.  
  242.         /**
  243.          * 切换按钮显示/隐藏状态
  244.          * @param {String} aim_btn 按钮变量名
  245.          * @returns 按钮元素的引用
  246.          */
  247.         toggleBtnStatus: function(aim_btn) {
  248.             let btn = document.querySelector(`.${aim_btn.replace("_", "-")}`);
  249.             let display = getComputedStyle(btn).display;
  250.             // return;
  251.             if (display === "none") {
  252.                 btn.style.display = "block";
  253.             } else {
  254.                 btn.style.display = "none";
  255.             }
  256.             return btn;
  257.         },
  258.  
  259.         /**
  260.          * 根据canvas元素数量返回quality值
  261.          * @param {Number} canvas_amount
  262.          * @returns quality: Number
  263.          */
  264.         getQualityByCanvasAmount: function(canvas_amount) {
  265.             // 如果有全局参数，优先用全局的
  266.             if (window.img_quality !== undefined) {
  267.                 console.log(`image quality: ${window.img_quality*100}%`);
  268.                 return window.img_quality;
  269.             }
  270.             // 否则用默认的
  271.             let quality;
  272.             if (canvas_amount <= 25) {
  273.                 quality = 1.0;
  274.             } else if (25 < canvas_amount <= 50) {
  275.                 quality = 0.9;
  276.             } else {
  277.                 quality = 0.8;
  278.             }
  279.             console.log(`image quality: ${quality*100}%`);
  280.             return quality;
  281.         },
  282.  
  283.         /**
  284.          * 挂载func到全局
  285.          * @param {Function} func 
  286.          */
  287.         globalFunc: function(func) {
  288.             globalThis[func.name] = func;
  289.         },
  290.  
  291.         /**
  292.          * 用input框跳转到对应页码
  293.          * @param {Element} cur_page 当前页码
  294.          * @param {string} aim_page 目标页码
  295.          * @param {string} event_type 键盘事件类型："keyup" | "keypress" | "keydown"
  296.          */
  297.         jump2pageNo: function(cur_page, aim_page, event_type) {
  298.             // 设置跳转页码为目标页码
  299.             cur_page.value = aim_page;
  300.             // 模拟回车事件来跳转
  301.             let keyboard_event_enter = new KeyboardEvent(event_type, {
  302.                 bubbles: true,
  303.                 cancelable: true,
  304.                 keyCode: 13
  305.             });
  306.             cur_page.dispatchEvent(keyboard_event_enter);
  307.         },
  308.  
  309.         /**
  310.          * 在新标签页打开链接
  311.          * @param {String} href 
  312.          */
  313.         openInNewTab: function(href) {
  314.             let link = document.createElement("a");
  315.             link.href = href;
  316.             link.target = "_blank";
  317.             link.click();
  318.         },
  319.  
  320.         /**
  321.          * 滚动到页面底部
  322.          */
  323.         scrollToBottom: function() {
  324.             window.scrollTo({
  325.                 top: document.body.scrollHeight,
  326.                 behavior: "smooth"
  327.             });
  328.         },
  329.  
  330.         /**
  331.          * 用try移除元素
  332.          * @param {Element} element 要移除的元素
  333.          */
  334.         tryToRemoveElement: function(element) {
  335.             try {
  336.                 element.remove();
  337.             } catch (e) {
  338.             }
  339.         },
  340.  
  341.         /**
  342.          * 用try移除 [元素列表1, 元素列表2, ...] 中的元素
  343.          * @param {Array} elem_list_box 要移除的元素列表构成的列表
  344.          */
  345.         tryToRemoveSameElem: function(elem_list_box) {
  346.             for (let elem_list of elem_list_box) {
  347.                 if (!elem_list) {
  348.                     continue;
  349.                 }
  350.                 for (let elem of elem_list) {
  351.                     try {
  352.                         elem.remove();
  353.                     } catch (e) {
  354.                         console.log();
  355.                     }
  356.                 }
  357.             }
  358.         },
  359.  
  360.         /**
  361.          * 使文档在页面上居中
  362.          * @param {String} selector 文档容器的css选择器
  363.          * @param {String} default_offset 文档部分向右偏移的百分比（0-59）
  364.          * @returns 偏移值是否合法
  365.          */
  366.         centerDoc: function(selector, default_offset) {
  367.             let doc_main = document.querySelector(selector);
  368.             let offset = window.prompt("请输入偏移百分位:", default_offset);
  369.             // 如果输入的数字不在 0-59 内，提醒用户重新设置
  370.             if (offset.length === 1 && offset.search(/[0-9]/) !== -1) {
  371.                 doc_main.style.marginLeft = offset + "%";
  372.                 return true;
  373.             } else if (offset.length === 2 && offset.search(/[1-5][0-9]/) !== -1) {
  374.                 doc_main.style.marginLeft = offset + "%";
  375.                 return true
  376.             } else {
  377.                 alert("请输入一个正整数，范围在0至59之间，用来使文档居中\n（不同文档偏移量不同，所以需要手动调整）");
  378.                 return false;
  379.             }
  380.         },
  381.  
  382.         /**
  383.          * 调整按钮内文本
  384.          * @param {String} aim_btn 按钮变量名
  385.          * @param {String} new_text 新的文本，null则保留旧文本
  386.          * @param {Boolean} recommend_btn 是否增加"（推荐）"到按钮文本
  387.          * @param {Boolean} use_hint 是否提示"文档已经完全展开，可以导出"
  388.          */
  389.         modifyBtnText: function(aim_btn = "btn_2", new_text = null, recommend_btn = false, use_hint = true) {
  390.             // 提示文档已经展开
  391.             if (use_hint) {
  392.                 let hint = "文档已经完全展开，可以导出";
  393.                 alert(hint);
  394.             }
  395.             let btn = document.querySelector(`.${aim_btn.replace("_", "-")}`);
  396.             // 要替换的文本
  397.             if (new_text) {
  398.                 btn.textContent = new_text;
  399.             }
  400.             // 推荐按钮
  401.             if (recommend_btn) {
  402.                 btn.textContent += "(推荐)";
  403.             }
  404.         },
  405.  
  406.         html2Canvases: async function(elem_list) {
  407.             // 如果是空元素列表，返回null并终止函数
  408.             if (elem_list.length === 0) {
  409.                 console.log("html2canvases was called, but no element is avaiable.");
  410.                 return null;
  411.             }
  412.             let tasks = []; //  存放异步任务
  413.             let contents = []; //  存放canvas元素
  414.             for (let elem of elem_list) {
  415.                 let task = html2canvas(elem).then((canvas) => {
  416.                     contents.push(canvas);
  417.                 });
  418.                 tasks.push(task);
  419.             }
  420.             // 等待全部page转化完成
  421.             await Promise.all(tasks);
  422.             return contents;
  423.         },
  424.  
  425.         /**
  426.          * 将html元素转为canvas再合并到pdf中，最后下载pdf
  427.          * @param {Array} elem_list html元素列表
  428.          * @param {String} title 文档标题
  429.          */
  430.         html2PDF: async function(elem_list, title = "文档") {
  431.             // 如果是空元素列表，终止函数
  432.             let _contents = this.html2Canvases(elem_list);
  433.             if (_contents === null) {
  434.                 return;
  435.             }
  436.             _contents.then((contents) => {
  437.                 // 控制台检查结果
  438.                 console.log("生成的canvas元素如下：");
  439.                 console.log(contents);
  440.  
  441.                 // 拿到canvas宽、高
  442.                 let model = elem_list[0];
  443.                 let width, height;
  444.                 width = model.offsetWidth;
  445.                 height = model.offsetHeight;
  446.                 // 打包为pdf
  447.                 this.saveCanvasesToPDF(contents, title, width, height);
  448.             });
  449.         },
  450.  
  451.         /**
  452.          * 下载全部图片链接，适用性：爱问共享资料、得力文库
  453.          * @param {string} selector 图形元素的父级元素
  454.          */
  455.         savePicUrls: function(selector) {
  456.             let pages = document.querySelectorAll(selector);
  457.             let pic_urls = [];
  458.  
  459.             for (let elem of pages) {
  460.                 let pic_obj = elem.children[0];
  461.                 let url = pic_obj.src;
  462.                 pic_urls.push(url);
  463.             }
  464.             let content = pic_urls.join("\n");
  465.             // 启动下载
  466.             this.createAndDownloadFile("urls.csv", content);
  467.         },
  468.  
  469.         /**
  470.          * 存储所有canvas图形为png到一个压缩包
  471.          * @param {Array} node_list canvas元素列表
  472.          * @param {String} title 文档标题
  473.          */
  474.         saveCanvasesToZip: function(node_list, title) {
  475.             // canvas元素转为png图像
  476.             // 所有png合并为一个zip压缩包
  477.             let zip = new JSZip();
  478.             let n = node_list.length;
  479.  
  480.             for (let i = 0; i < n; i++) {
  481.                 let canvas = node_list[i];
  482.                 let data_base64 = canvas.toDataURL();
  483.                 let blob = atob(data_base64.split(",")[1]);
  484.                 zip.file(`page-${i+1}.png`, blob, { binary: true });
  485.             }
  486.  
  487.             // 导出zip
  488.             // promise.then(onCompleted, onRejected);
  489.             zip.generateAsync({ type: "blob" }).then(function(content) {
  490.                 // see filesaver.js
  491.                 console.log(content);
  492.                 saveAs(content, `${title}.zip`);
  493.             });
  494.         },
  495.  
  496.         /**
  497.          * 将canvas转为jpeg，然后导出PDF
  498.          * @param {Array} node_list canvas元素列表
  499.          * @param {String} title 文档标题
  500.          */
  501.         saveCanvasesToPDF: function(node_list, title, width = 0, height = 0) {
  502.             // 如果没有手动指定canvas的长宽，则自动检测
  503.             if (!width && !height) {
  504.                 // 先获取第一个canvas用于判断竖向还是横向，以及得到页面长宽
  505.                 let first_canvas = node_list[0];
  506.                 // 如果style的长宽不存在，则直接用canvas的元素长宽
  507.                 let width_str, height_str;
  508.                 if (first_canvas.width && parseInt(first_canvas.width) && parseInt(first_canvas.height)) {
  509.                     [width_str, height_str] = [first_canvas.width, first_canvas.height];
  510.                 } else {
  511.                     [width_str, height_str] = [first_canvas.style.width.replace(/(px)|(rem)|(em)/, ""), first_canvas.style.height.replace(/(px)|(rem)|(em)/, "")];
  512.                 }
  513.                 // jsPDF的第三个参数为format，当自定义时，参数为数字数组。
  514.                 [width, height] = [parseFloat(width_str), parseFloat(height_str)];
  515.             }
  516.             console.log(`canvas数据：宽: ${width}px，高: ${height}px`);
  517.             // 如果文档第一页的宽比长更大，则landscape，否则portrait
  518.             let orientation = width > height ? 'l' : 'p';
  519.             let pdf = new jspdf.jsPDF(orientation, 'px', [height, width]);
  520.  
  521.             // 根据canvas数量确定quality
  522.             let quality = this.getQualityByCanvasAmount(node_list.length);
  523.  
  524.             // 保存每一页文档到每一页pdf
  525.             node_list.forEach(function(canvas, index) {
  526.                 pdf.addImage(canvas.toDataURL("image/jpeg", quality), 'JPEG', 0, 0, width, height);
  527.                 // 如果当前不是文档最后一页，则需要添加下一个空白页
  528.                 if (index !== node_list.length - 1) {
  529.                     pdf.addPage();
  530.                 }
  531.             });
  532.  
  533.             // 导出文件
  534.             pdf.save(`${title}.pdf`);
  535.         },
  536.  
  537.         /**
  538.          * Image元素列表合并到一个PDF中
  539.          * @param {NodeList} imgs Image元素列表
  540.          * @param {String} title 文档名
  541.          */
  542.         imgs2pdf: function(imgs, title) {
  543.             // 取得宽高
  544.             let model = imgs[0];
  545.             let width = model.offsetWidth;
  546.             let height = model.offsetHeight;
  547.  
  548.             // 创建pdf
  549.             let orientation = width > height ? 'l' : 'p';
  550.             let pdf = new jspdf.jsPDF(orientation, 'px', [height, width]);
  551.  
  552.             // 添加图像到pdf
  553.             imgs.forEach((img, index) => {
  554.                 pdf.addImage(img, 'PNG', 0, 0, width, height);
  555.                 // 如果当前不是文档最后一页，则需要添加下一个空白页
  556.                 if (index !== imgs.length - 1) {
  557.                     pdf.addPage();
  558.                 }
  559.             });
  560.  
  561.             // 导出文件
  562.             pdf.save(`${title}.pdf`);
  563.         },
  564.  
  565.         /**
  566.          * 取得elem的class为class_name的父级元素
  567.          * @param {String} class_name 
  568.          * @param {Element} elem 起点元素
  569.          * @param {object} JSobj 全局对象，需要有<iterator_count>计数器。默认为window.baiduJS。
  570.          * @param {Boolean} ignore 是否忽略递归计数器。默认false。如果启用请确保不会无限递归。
  571.          * @returns {null | Element} parent_element
  572.          */
  573.         getParentByClassName: function(class_name, elem, JSobj, ignore = false) {
  574.             let parent = elem.parentElement;
  575.             let iterator_count = JSobj.iterator_count;
  576.             let now_name;
  577.  
  578.             try {
  579.                 now_name = parent.className;
  580.             } catch (e) {
  581.                 JSobj.iterator_count = 0;
  582.                 // 没有父级元素了
  583.                 return "no parent node";
  584.             }
  585.  
  586.             // 如果不忽略递归次数计数器
  587.             if (!ignore) {
  588.                 if (iterator_count > 9) {
  589.                     // 超过最大迭代次数，认为不存在，返回null
  590.                     JSobj.iterator_count = 0;
  591.                     return "over max iterator counts limit";
  592.                 } else {
  593.                     JSobj.iterator_count += 1;
  594.                 }
  595.             }
  596.             // 如果类名匹配，返回该节点
  597.             if (now_name.split(" ").includes(class_name)) {
  598.                 iterator_count = 0;
  599.                 return parent;
  600.             }
  601.             return this.getParentByClassName(class_name, parent, JSobj);
  602.         },
  603.  
  604.         /**
  605.          * 将func绑定到window.onscroll，并设置触发频率
  606.          * @param {Function} func scroll的监听函数
  607.          * @param {Object} JSobj 全局对象，至少要有srcoll_count
  608.          * @param {Number} useful_range 有效的触发范围，默认是10。即0-10次时触发函数。
  609.          * @param {Number} wait_range 等待的范围，默认是110。即useful_range-110次不触发函数。
  610.          * @param {String} hint 触发函数后的日志内容，默认为空字符串。
  611.          * @param {Window} inner_window 特定的window对象，主要用于 iframe 情况。JSobj中必须有scrollFunc，在调用后会重新写入scrollFunc。
  612.          */
  613.         scrollFunc: function(func, JSobj, useful_range = 10, wait_range = 110, hint = "", inner_window = null) {
  614.             let new_func = (func, JSobj, useful_range, wait_range, hint) => {
  615.                 JSobj.scroll_count += 1;
  616.  
  617.                 if (JSobj.scroll_count < useful_range) {
  618.                     func();
  619.                     console.log(hint);
  620.                 } else if (JSobj.scroll_count > wait_range) {
  621.                     JSobj.scroll_count = 0;
  622.                 }
  623.             };
  624.             // 如果没有指定的window对象，则使用默认的window
  625.             if (!inner_window) {
  626.                 window.onscroll = () => {
  627.                     new_func(func, JSobj, useful_range, wait_range, hint);
  628.                 };
  629.                 return;
  630.             }
  631.             // 特定的window对象，一般用于iframe，追加scroll监听器
  632.             let scrollFunc = () => {
  633.                 new_func(func, JSobj, useful_range, wait_range, hint);
  634.             };
  635.             JSobj.scrollFunc = scrollFunc;
  636.             inner_window.addEventListener("scroll", scrollFunc, false);
  637.         },
  638.  
  639.         /**
  640.          * 创建5个按钮：展开文档、导出图片、导出PDF、未设定4、未设定5；默认均为隐藏
  641.          */
  642.         createBtns: function() {
  643.             // 创建按钮组
  644.             let section = document.createElement("section");
  645.             section.className = "btns_section";
  646.             section.innerHTML = `
  647.             <p class="logo_tit">Wenku Doc Downloader</p>
  648.             <button class="btn-1" title="请先使内容加载完，防止出现空白页">展开文档 😈</button>
  649.             <button class="btn-2">未设定2</button>
  650.             <button class="btn-3">未设定3</button>
  651.             <button class="btn-4">未设定4</button>
  652.             <button class="btn-5">未设定5</button>`;
  653.             document.body.appendChild(section);
  654.  
  655.             // 设定样式
  656.             let style = document.createElement("style");
  657.             style.innerHTML = `
  658.             .btns_section{
  659.                 position: fixed;
  660.                 width: 154px;                
  661.                 left: 10px;
  662.                 top: 32%;
  663.                 background: #E7F1FF;
  664.                 border: 2px solid #1676FF;                
  665.                 padding: 0px 0px 10px 0px;
  666.                 font-weight: 600;
  667.                 border-radius: 2px;
  668.                 font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', 'Hiragino Sans GB',
  669.                 'Microsoft YaHei', 'Helvetica Neue', Helvetica, Arial, sans-serif, 'Apple Color Emoji',
  670.                 'Segoe UI Emoji', 'Segoe UI Symbol';
  671.                 z-index: 5000;
  672.             }
  673.             .logo_tit{
  674.                 width: 100%;
  675.                 background: #1676FF;
  676.                 text-align: center;
  677.                 font-size:12px ;
  678.                 color: #E7F1FF;
  679.                 line-height: 40px;
  680.                 height: 40px;
  681.                 margin: 0 0 16px 0;
  682.             }
  683.  
  684.             .btn-1{
  685.                 display: block;
  686.                 width: 128px;
  687.                 height: 28px;
  688.                 background: linear-gradient(180deg, #00E7F7 0%, #FEB800 0.01%, #FF8700 100%);
  689.                 border-radius: 4px;
  690.                 color: #fff;
  691.                 font-size: 12px;
  692.                 border: none;
  693.                 outline: none;
  694.                 margin: 8px auto;
  695.                 font-weight: bold;
  696.                 cursor: pointer;
  697.                 opacity: .9;
  698.             }
  699.             .btn-2{
  700.                 display: none;
  701.                 width: 128px;
  702.                 height: 28px;
  703.                 background: #07C160;
  704.                 border-radius: 4px;
  705.                 color: #fff;
  706.                 font-size: 12px;
  707.                 border: none;
  708.                 outline: none;
  709.                 margin: 8px auto;
  710.                 font-weight: bold;
  711.                 cursor: pointer;
  712.                 opacity: .9;
  713.             }
  714.             .btn-3{
  715.                 display: none;
  716.                 width: 128px;
  717.                 height: 28px;
  718.                 background:#FA5151;
  719.                 border-radius: 4px;
  720.                 color: #fff;
  721.                 font-size: 12px;
  722.                 border: none;
  723.                 outline: none;
  724.                 margin: 8px auto;
  725.                 font-weight: bold;
  726.                 cursor: pointer;
  727.                 opacity: .9;
  728.             }
  729.             .btn-4{
  730.                 display: none;
  731.                 width: 128px;
  732.                 height: 28px;
  733.                 background: #1676FF;
  734.                 border-radius: 4px;
  735.                 color: #fff;
  736.                 font-size: 12px;
  737.                 border: none;
  738.                 outline: none;
  739.                 margin: 8px auto;
  740.                 font-weight: bold;
  741.                 cursor: pointer;
  742.                 opacity: .9;
  743.             }
  744.             .btn-5{
  745.                 display: none;
  746.                 width: 128px;
  747.                 height: 28px;
  748.                 background: #ff6600;
  749.                 border-radius: 4px;
  750.                 color: #fff;
  751.                 font-size: 12px;
  752.                 border: none;
  753.                 outline: none;
  754.                 margin: 8px auto;
  755.                 font-weight: bold;
  756.                 cursor: pointer;
  757.                 opacity: .9;
  758.             }
  759.             .btn-1:hover,.btn-2:hover,.btn-3:hover,.btn-4,.btn-5:hover{ opacity: .8;}
  760.             .btn-1:active,.btn-2:active,.btn-3:active,.btn-4,.btn-5:active{ opacity: 1;}`;
  761.             document.head.appendChild(style);
  762.         }
  763.     };
  764.  
  765.     /**
  766.      * 清理百度文库页面的无关元素
  767.      */
  768.     function clearPage_Baidu() {
  769.         let selectors = [
  770.             "#hd, .aside, .reader-tools-bar-wrap, .sb-con, .bg-opacity",
  771.             ".doc-tag-wrap, .doc-bottom-wrap, .ft, #ft, .crubms-wrap, .banner-ad",
  772.             "#activity-tg, .top-ads-banner-wrap, .reader_ab_test, .tag-tips, .doc-value",
  773.             ".owner-desc-wrap, a[title='全屏显示'], #next_doc_box"
  774.         ];
  775.         let elem_list = document.querySelectorAll(selectors.join(", "));
  776.         for (let elem of elem_list) {
  777.             utils.tryToRemoveElement(elem);
  778.         }
  779.         let nut_selector = ".fix-searchbar-wrap, #hd";
  780.         utils.forceHide(nut_selector);
  781.         // 去除页面顶部空白
  782.         document.querySelector("#doc").style.paddingTop = "0";
  783.     }
  784.  
  785.  
  786.     /**
  787.      * 判断是否收集完元素，如果没有，则给出提醒
  788.      * @param {Array} msg_list 附加提示信息列表
  789.      * @returns bool 是否完成元素收集/冻结
  790.      */
  791.     function isFinished(msg_list = []) {
  792.         if (!window.baiduJS.finished) {
  793.             let hint = [
  794.                 "仍有内容未加载完，无法使用该功能",
  795.                 "建议从头到尾慢速地再浏览一遍",
  796.                 ...msg_list
  797.             ];
  798.             alert(hint.join("\n"));
  799.             return false;
  800.         }
  801.         return true;
  802.     }
  803.  
  804.  
  805.     /**
  806.      * 提取文字，导出txt。适用于百度文库
  807.      */
  808.     function saveText_Baidu() {
  809.         // 判断是否存在文字元素
  810.         let elems = document.querySelectorAll(".reader-txt-layer");
  811.         if (!elems.length) {
  812.             alert("当前页面没有文字元素\n如果你看到了文字说明它的原文档就是图片，所以提取不到文字");
  813.             return;
  814.         }
  815.         // 判断页面是否加载完成
  816.         if (!isFinished()) {
  817.             return;
  818.         }
  819.         let title = document.title.split("-")[0].trim(); // 取得文档标题
  820.         let page_texts = [];
  821.         for (let elem of window.baiduJS.elems_map.values()) {
  822.             // 取得该页文档下的全部文字
  823.             let text = elem.textContent;
  824.             page_texts.push(text);
  825.         }
  826.         utils.createAndDownloadFile(`${title}.txt`, page_texts.join("\n"));
  827.     }
  828.  
  829.  
  830.     /**
  831.      * 存储ppt格式的ppt图形
  832.      * @param {NodeList} elems ppt元素列表
  833.      */
  834.     function savePPTurls_1(elems) {
  835.         let urls = [];
  836.         elems.forEach((elem) => {
  837.             if (elem.hasAttribute("src")) {
  838.                 urls.push(elem.src);
  839.             } else {
  840.                 urls.push(elem.getAttribute("data-src"));
  841.             }
  842.         });
  843.         utils.createAndDownloadFile("urls.csv", urls.join("\n"));
  844.     }
  845.  
  846.  
  847.     /**
  848.      * 取得未捕获pdf格式ppt元素的页码的列表
  849.      * @returns {Array} not_loaded
  850.      */
  851.     function getNotLoaded_pdf_PPT() {
  852.         if (window.baiduJS.finished) {
  853.             return [];
  854.         }
  855.  
  856.         //取得loaded
  857.         let elems_map = window.baiduJS.elems_map;
  858.         elems_map = sortMapByID$2(elems_map); // id形式："pageNo-1"
  859.  
  860.         // 找出not loaded
  861.         let not_loaded = [];
  862.         for (let i = 1; i <= window.baiduJS.max_page; i++) {
  863.             if (!elems_map.has(`pageNo-${i}`)) {
  864.                 not_loaded.push(i);
  865.             }
  866.         }
  867.         return not_loaded;
  868.     }
  869.  
  870.  
  871.     /**
  872.      * 存储pdf格式的ppt元素
  873.      */
  874.     function storePPTurls() {
  875.         let imgs = document.querySelectorAll("img.reader-pptstyle");
  876.         for (let img of imgs) {
  877.             let page = utils.getParentByClassName("bd", img, window.baiduJS, true);
  878.             let src = img.src;
  879.             let id = page.id;
  880.  
  881.             if (id === undefined) {
  882.                 continue;
  883.             }
  884.  
  885.             // 如果不存在则录入
  886.             if (!window.baiduJS.elems_map.has(id)) {
  887.                 window.baiduJS.elems_map.set(id, src);
  888.             }
  889.         }
  890.         // 如果全部捕获，则解绑
  891.         if (window.baiduJS.elems_map.size === window.baiduJS.max_page) {
  892.             window.onscroll = () => { };
  893.             window.baiduJS.elems_map = sortMapByID$2(window.baiduJS.elems_map);
  894.             window.baiduJS.finished = true;
  895.         }
  896.     }
  897.  
  898.  
  899.     function savePPTurls_2() {
  900.         let not_loaded = getNotLoaded_pdf_PPT();
  901.         let hints = [
  902.             "以下页面需要浏览并再次加载：",
  903.             not_loaded.join(",")
  904.         ];
  905.         if (!isFinished(hints)) {
  906.             return;
  907.         }
  908.         // 页面都加载完毕
  909.         let elems_map = window.baiduJS.elems_map;
  910.         let urls = Array.from(elems_map.values());
  911.         utils.createAndDownloadFile("urls.csv", urls.join("\n"));
  912.     }
  913.  
  914.  
  915.     /**
  916.      * 动态存储".ppt-image-wrap img"图形，并导出urls
  917.      * @returns
  918.      */
  919.     function savePicUrls_Baidu() {
  920.         // 尝试取得ppt元素
  921.         let elems = document.querySelectorAll(".ppt-image-wrap img"); // 真正的ppt
  922.         let elems_2 = document.querySelectorAll("img.reader-pptstyle"); // pdf格式的ppt
  923.  
  924.         // 根据试探情况（ppt元素存在情况）做出相应决策
  925.         if (!elems.length && !elems_2.length) {
  926.             alert("当前页面没有PPT图形");
  927.             return;
  928.         } else if (elems.length && !elems_2.length) {
  929.             // 真正的ppt
  930.             savePPTurls_1(elems);
  931.         } else if (!elems.length && elems_2.length) {
  932.             // pdf格式的ppt
  933.             utils.scrollFunc(storePPTurls, window.baiduJS, 10, 50, "baidu元素(ppt Ⅱ型): 收集");
  934.             savePPTurls_2();
  935.         } else {
  936.             // 未知情况
  937.             utils.banSelf();
  938.             utils.createBtns();
  939.             utils.setBtnEvent(() => { }, [], "btn_1", "未知情况");
  940.         }
  941.  
  942.     }
  943.  
  944.  
  945.     /**
  946.      * 动态存储".reader-pic-item"图形，并导出urls
  947.      * @returns 
  948.      */
  949.     function savePicUrls_BaiduNonPPT() {
  950.         // 判断是否存在非PPT图形元素
  951.         let elems = document.querySelectorAll(".reader-pic-item");
  952.         if (!elems.length) {
  953.             alert("当前页面没有非PPT图形");
  954.             return;
  955.         }
  956.         // 判断是否页面都加载完成
  957.         if (!isFinished()) {
  958.             return;
  959.         }
  960.         // 找到img元素，导出urls
  961.         let img_urls = [];
  962.         for (let elem of window.baiduJS.elems_map.values()) {
  963.             // 取得img元素
  964.             elem.querySelectorAll(".reader-pic-item").forEach((img) => {
  965.                 // 取得img链接
  966.                 let url = img.style.backgroundImage.split('"')[1];
  967.                 img_urls.push(url);
  968.             });
  969.         }
  970.         utils.createAndDownloadFile("urls.csv", img_urls.join("\n"));
  971.     }
  972.  
  973.  
  974.     /**
  975.      * 找出没有收录的id，需求的id列表形如：["pageNo-4", "pageNo-5", ...]
  976.      * @returns 未收录的id_list: [1, 2, 3, ...]
  977.      */
  978.     function getUnfrozen() {
  979.         // 获取已经冻结的文档元素
  980.         let _frozen_ids = new Set(window.baiduJS.elems);
  981.         let frozen_ids = new Set();
  982.         _frozen_ids.forEach((full_id) => {
  983.             // full_id: pageNo-1
  984.             let id = parseInt(full_id.split("-")[1]);
  985.             frozen_ids.add(id);
  986.         });
  987.  
  988.         if (!frozen_ids.size) {
  989.             return ["all pages"];
  990.         }
  991.  
  992.         // 取得基础页码
  993.         let a_id = utils.setPop(frozen_ids);
  994.         let basis = parseInt(a_id / 50) * 50;
  995.         // 获取全部文档元素
  996.         let all_ids = new Set();
  997.         let all_elems = document.querySelectorAll(".mod.reader-page.complex[class*=reader-page]");
  998.         all_elems.forEach((elem) => {
  999.             // ['mod', 'reader-page', 'complex', 'hidden-doc-banner', 'reader-page-1'] -> "1" -> 1
  1000.             let id = parseInt(elem.className.split(" ").at(-1).split("-")[2]);
  1001.             all_ids.add(basis + id);
  1002.         });
  1003.  
  1004.         // 求差集，取得未冻结的
  1005.         let unfrozen_set = utils.difference(all_ids, frozen_ids);
  1006.         let unfrozen_list = Array.from(unfrozen_set);
  1007.         unfrozen_list.sort((prev, next) => { return prev - next; });
  1008.         // 打印日志
  1009.         console.log([
  1010.             `all_ids: ${Array.from(all_ids)}`,
  1011.             `frozen_ids: ${Array.from(frozen_ids)}`,
  1012.             `unfrozen_list: ${unfrozen_list}`
  1013.         ].join("\n"));
  1014.         return unfrozen_list;
  1015.     }
  1016.  
  1017.  
  1018.     /**
  1019.      * 适用于【*不*带有api=1】get参数的页面。可以打印页面。
  1020.      * @returns 
  1021.      */
  1022.     function printPage_BaiduNoArgs() {
  1023.         // 判断是否页面都加载完成
  1024.         let msg_list = [
  1025.             "未加载的页面如下：",
  1026.             getUnfrozen().join(", ")
  1027.         ];
  1028.         if (!isFinished(msg_list)) {
  1029.             return;
  1030.         }
  1031.         // 清理页面
  1032.         clearPage_Baidu();
  1033.         // 隐藏上下页按钮
  1034.         document.querySelectorAll("a[data-next-page], a[data-prev-page]").forEach((elem) => {
  1035.             elem.setAttribute("style", "display: none !important;");
  1036.         });
  1037.         // 打印
  1038.         utils.hideBtnThenPrint();
  1039.         // 显示上下页按钮
  1040.         document.querySelectorAll("a[data-next-page], a[data-prev-page]").forEach((elem) => {
  1041.             elem.style.display = "block";
  1042.         });
  1043.     }
  1044.  
  1045.  
  1046.     /**
  1047.      * 调整页间距为 width px
  1048.      * @param {Number} width 页间距
  1049.      */
  1050.     function adjustSpace(width) {
  1051.         // 调整页间距
  1052.         let space_selector = ".reader-container .reader-page, .reader-container .pay-page-mod";
  1053.         document.querySelectorAll(space_selector).forEach((space) => {
  1054.             space.style.margin = `0 0 ${width}px`;
  1055.         });
  1056.         console.log(`页间距已经调整为：${width}px`);
  1057.     }
  1058.  
  1059.  
  1060.     function userAdjustSpace() {
  1061.         let space_selector = ".reader-container .reader-page, .reader-container .pay-page-mod";
  1062.         let space = document.querySelector(space_selector);
  1063.         let old_width = getComputedStyle(space).marginBottom;
  1064.         let width_str = prompt(`当前页间距为：${old_width}\n请输入调整后的页间距(0-500的整数)：`);
  1065.         let width = parseInt(width_str);
  1066.         width = Number.isInteger(width) && (0 <= width <= 500) ? width : parseInt(old_width);
  1067.         adjustSpace(width);
  1068.         console.log(`调整后的页间距为：${width}px`);
  1069.     }
  1070.  
  1071.  
  1072.     /**
  1073.      * 根据键中的id数字对map排序
  1074.      * @param {Map} elems_map 
  1075.      * @returns sorted_map
  1076.      */
  1077.     function sortMapByID$2(elems_map) {
  1078.         // id形式：pageNo-10
  1079.         let elems_arr = Array.from(elems_map);
  1080.         elems_arr.sort((item1, item2) => {
  1081.             // 从key中取出id
  1082.             let id1 = parseInt(item1[0].split("-")[1]);
  1083.             let id2 = parseInt(item2[0].split("-")[1]);
  1084.             // 升序排序
  1085.             return id1 - id2;
  1086.         });
  1087.         // 返回排序好的map
  1088.         return new Map(elems_arr);
  1089.     }
  1090.  
  1091.  
  1092.     /**
  1093.      * 存储html元素。适用于百度文库的文字型文档
  1094.      */
  1095.     function storeHtmlElemts_Baidu(selector = "[class*=reader-main]") {
  1096.         let elems_map = window.baiduJS.elems_map;
  1097.         document.querySelectorAll(selector).forEach(
  1098.             (elem) => {
  1099.                 let origin_page_elem = utils.getParentByClassName("bd", elem, window.baiduJS);
  1100.                 if (typeof(origin_page_elem) === "string") {
  1101.                     return;
  1102.                 }
  1103.                 // 复制元素防止丢失
  1104.                 let page_elem = origin_page_elem.cloneNode(true);
  1105.                 // 移除data标签，切断vue对数据的渲染控制
  1106.                 page_elem.removeAttribute("data-page-no");
  1107.                 let id = page_elem.id; // id的形式：pageNo-10
  1108.                 if (!elems_map.has(id)) {
  1109.                     elems_map.set(id, page_elem);
  1110.                 }
  1111.             });
  1112.         if (elems_map.size === window.baiduJS.max_page) {
  1113.             // 根据id排序，保证导出的图片链接不是乱序的
  1114.             window.baiduJS.elems_map = sortMapByID$2(window.baiduJS.elems_map);
  1115.             // 已经保存完全部文档页元素，移除滚动事件的绑定函数
  1116.             window.baiduJS.finished = true;
  1117.             window.onscroll = () => { };
  1118.         }
  1119.     }
  1120.  
  1121.  
  1122.     /**
  1123.      * 移除html元素上的data标签，切断vue的数据渲染控制。适用于百度文库的文字型文档
  1124.      * @param {String} selector 要移除 data-page-no属性 的元素选择器
  1125.      */
  1126.     function freezeHtmlElemts_Baidu(selector = "[class*=reader-main]") {
  1127.         let elems = window.baiduJS.elems;
  1128.         document.querySelectorAll(selector).forEach(
  1129.             (elem) => {
  1130.                 let page_elem = utils.getParentByClassName("bd", elem, window.baiduJS);
  1131.                 if (typeof(page_elem) === "string") {
  1132.                     return;
  1133.                 }
  1134.                 // 移除data标签，切断vue对数据的渲染控制
  1135.                 page_elem.removeAttribute("data-page-no");
  1136.                 // 存储已经冻结的元素id
  1137.                 let id = page_elem.id; // id的形式：pageNo-10
  1138.                 if (!elems.includes(id)) {
  1139.                     elems.push(id);
  1140.                 }
  1141.             });
  1142.         if (elems.length === window.baiduJS.max_page) {
  1143.             // 已经冻结完全部文档页元素，移除滚动事件的绑定函数
  1144.             window.baiduJS.finished = true;
  1145.             window.onscroll = () => { };
  1146.         }
  1147.     }
  1148.  
  1149.  
  1150.     /**
  1151.      * 递归的展开百度文档，适用于旧版页面。
  1152.      * @param {Function} extra_task 在文档展开完成后执行的追加函数
  1153.      * @returns 
  1154.      */
  1155.     function readMoreRecursively(extra_task = () => { }) {
  1156.         let go_more = document.querySelector("#html-reader-go-more");
  1157.         if (!go_more || go_more.style.display === "none") {
  1158.             // 如果不存在继续阅读按钮，或隐藏显示，则认为完成了展开
  1159.             console.log("wk: 文档展开完成");
  1160.             extra_task();
  1161.             return;
  1162.         }
  1163.         let read_more = go_more.querySelector(".moreBtn.goBtn");
  1164.         read_more.click();
  1165.         console.log("wk: 展开文档");
  1166.         setTimeout(readMoreRecursively, 500);
  1167.     }
  1168.  
  1169.  
  1170.     /**
  1171.      * 统计文档页的数量
  1172.      * @param {String} selector 文档页元素选择器
  1173.      * @returns 文档页的数量
  1174.      */
  1175.     function countPages$1(selector = ".mod.reader-page.complex[class*=reader-page]") {
  1176.         let all_elems = document.querySelectorAll(selector);
  1177.         return all_elems.length;
  1178.     }
  1179.  
  1180.  
  1181.     /**
  1182.      * 取得当前行高
  1183.      * @returns 行高，例如 192px
  1184.      */
  1185.     function getLineHeight() {
  1186.         let line = document.querySelector("p.reader-word-layer");
  1187.         if (!line) {
  1188.             // 对于没有文字的文档，返回null即可
  1189.             return null;
  1190.         }
  1191.         let height = getComputedStyle(line).lineHeight;
  1192.         console.log(`get line-height: ${height}`);
  1193.         return height;
  1194.     }
  1195.  
  1196.  
  1197.     /**
  1198.      * 增大行间距到1500px，用于解决文字重叠
  1199.      */
  1200.     function changeLineHeight() {
  1201.         let lines = document.querySelectorAll("p.reader-word-layer");
  1202.         let aim_height, aim_hint;
  1203.  
  1204.         if (getComputedStyle(lines[0]).lineHeight !== window.baiduJS.origin_line_height) {
  1205.             // 切换回旧的行高
  1206.             aim_height = window.baiduJS.origin_line_height;
  1207.             aim_hint = "解决文字重叠";
  1208.             console.log(`changed to original line height`);
  1209.         } else {
  1210.             // 切换到增大的行高
  1211.             aim_height = "1500px";
  1212.             aim_hint = "切回旧行高";
  1213.             console.log(`changed to new line height: 1500px`);
  1214.         }
  1215.         // 应用新的行高
  1216.         for (let line of lines) {
  1217.             line.style.lineHeight = aim_height;
  1218.         }
  1219.         // 应用新的按钮文本
  1220.         setTimeout(() => {
  1221.             utils.modifyBtnText("btn_5", aim_hint, false, false);
  1222.         }, 2000);
  1223.     }
  1224.  
  1225.  
  1226.     function baiduWenku_OldVer() {
  1227.         // 为导出内容提供全局变量，便于动态收集文档页元素的存取
  1228.         let real_max_page;
  1229.         try {
  1230.             real_max_page = parseInt(document.querySelector(".page-count").textContent.replace("/", ""));
  1231.         } catch (e) {
  1232.             real_max_page = countPages$1();
  1233.         }
  1234.  
  1235.         window.baiduJS = {
  1236.             max_page: countPages$1(), // 当前文档页面数量
  1237.             real_max_page: real_max_page, // 当前文档的总页数
  1238.             iterator_count: 0, // getParentByClassName的最大迭代次数为9
  1239.             finished: false, // 是否收集完了全部文档页元素
  1240.             scroll_count: 0, // 用于统计累计触发scroll的次数
  1241.             elems: [], // 存储已经冻结的元素id
  1242.             elems_map: new Map(), // id: element
  1243.             origin_line_height: getLineHeight() // 原始行高
  1244.         };
  1245.  
  1246.         if (location.href.includes("\u002f\u0073\u0068\u0061\u0072\u0065\u002f")) {
  1247.             // old version for fetch doc elements
  1248.             // 跟随浏览，动态收集页面元素
  1249.             utils.scrollFunc(storeHtmlElemts_Baidu, window.baiduJS, 10, 50, "baidu元素: 收集");
  1250.  
  1251.             // 隐藏按钮
  1252.             utils.toggleBtnStatus("btn_1");
  1253.             // 显示按钮
  1254.             utils.toggleBtnStatus("btn_2");
  1255.             utils.toggleBtnStatus("btn_3");
  1256.             utils.toggleBtnStatus("btn_4");
  1257.             utils.toggleBtnStatus("btn_5");
  1258.             // 绑定事件到按钮
  1259.             utils.setBtnEvent(saveText_Baidu, [], "btn_3", "导出纯文本");
  1260.             utils.setBtnEvent(savePicUrls_Baidu, [], "btn_4", "导出图片链接(仅PPT)");
  1261.             utils.setBtnEvent(savePicUrls_BaiduNonPPT, [], "btn_5", "导出图片链接(除PPT)");
  1262.             // btn_2
  1263.             utils.setBtnEvent(() => {
  1264.                 let hints = [
  1265.                     "最好是excel和word文档，是否继续？",
  1266.                     "其他类型如ppt、pdf也可，但是不推荐。",
  1267.                     "其他类型建议【导出图片链接】。"
  1268.                 ];
  1269.                 if (confirm(hints.join("\n"))) {
  1270.                     // 在无参数的旧版页面处理超过50页的文档
  1271.                     // 跟随浏览，动态冻结页面元素
  1272.                     window.baiduJS.finished = false;
  1273.                     utils.scrollFunc(freezeHtmlElemts_Baidu, window.baiduJS, 10, 50, "baidu元素: 冻结");
  1274.                     // 重新绑定按钮监听器
  1275.                     utils.setBtnEvent(userAdjustSpace, [], "btn_4", "调整页间距");
  1276.                     utils.setBtnEvent(printPage_BaiduNoArgs, [], "btn_3", "打印页面到PDF◈");
  1277.                     alert("正在截获文档内容，请上下浏览页面后再次点击该按钮");
  1278.                     utils.setBtnEvent(changeLineHeight, [], "btn_5", "解决文字重叠");
  1279.  
  1280.                     // 隐藏按钮
  1281.                     utils.toggleBtnStatus("btn_2");
  1282.                 }
  1283.             }, [], "btn_2", "打印页面到PDF");
  1284.         } else {
  1285.             console.log(`无法识别的页面：${location.href}`);
  1286.         }
  1287.     }
  1288.  
  1289.  
  1290.     /**
  1291.      * 百度文档下载策略
  1292.      */
  1293.     function baiduWenku() {
  1294.         // 允许打印页面
  1295.         utils.allowPrint();
  1296.         // 原文档解析到预览文档
  1297.         if (location.href.includes("\u002f\u0076\u0069\u0065\u0077\u002f")) {
  1298.             utils.createBtns();
  1299.             let jump2sharePage_Baidu = function() {
  1300.                 location.href = `https://${location.host}${location.pathname.replace("\u0076\u0069\u0065\u0077", "\u0073\u0068\u0061\u0072\u0065")}`;
  1301.             };
  1302.             utils.setBtnEvent(jump2sharePage_Baidu, [], "btn_1");
  1303.         } else {
  1304.             // 在完全展开文档后启用旧版页面处理函数
  1305.             // 创建按钮组
  1306.             console.log("\n\nwk: 进入旧版页面\n\n\n");
  1307.             utils.createBtns();
  1308.             utils.setBtnEvent(readMoreRecursively, [baiduWenku_OldVer], "btn_1");
  1309.         }
  1310.     }
  1311.  
  1312.     /**
  1313.      * 展开道客巴巴的文档
  1314.      */
  1315.     function readAllDoc88() {
  1316.         // 获取“继续阅读”按钮
  1317.         let continue_btn = document.querySelector("#continueButton");
  1318.         // 如果存在“继续阅读”按钮
  1319.         if (continue_btn) {
  1320.             // 跳转到文末（等同于展开全文）
  1321.             let cur_page = document.querySelector("#pageNumInput");
  1322.             // 取得最大页码
  1323.             let page_max = cur_page.parentElement.textContent.replace(" / ", "");
  1324.             // 跳转到尾页
  1325.             utils.jump2pageNo(cur_page, page_max, "keypress");
  1326.             // 返回顶部
  1327.             setTimeout(utils.jump2pageNo(cur_page, "1", "keypress"), 1000);
  1328.         }
  1329.         // 文档展开后，显示按钮2、3
  1330.         else {
  1331.             // 隐藏按钮
  1332.             utils.toggleBtnStatus("btn_1");
  1333.             // 显示按钮
  1334.             utils.toggleBtnStatus("btn_2");
  1335.             utils.toggleBtnStatus("btn_3");
  1336.         }
  1337.     }
  1338.  
  1339.     /**
  1340.      * 道客巴巴文档下载策略
  1341.      */
  1342.     function doc88() {
  1343.         // 创建脚本启动按钮1、2
  1344.         utils.createBtns();
  1345.  
  1346.         // 绑定主函数
  1347.         let prepare = function() {
  1348.             // 获取canvas元素列表
  1349.             let node_list = document.querySelectorAll(".inner_page");
  1350.             // 获取文档标题
  1351.             let title;
  1352.             if (document.querySelector(".doctopic h1")) {
  1353.                 title = document.querySelector(".doctopic h1").title;
  1354.             } else {
  1355.                 title = "文档";
  1356.             }
  1357.             return [node_list, title];
  1358.         };
  1359.  
  1360.         // btn_1: 展开文档
  1361.         utils.setBtnEvent(() => {
  1362.             readAllDoc88();
  1363.         }, [], "btn_1");
  1364.         // btn_2: 导出zip
  1365.         utils.setBtnEvent(() => {
  1366.             if (confirm("确定每页内容都加载完成了吗？")) {
  1367.                 utils.saveCanvasesToZip(...prepare());
  1368.             }
  1369.         }, [], "btn_2", "导出图片到zip");
  1370.         // btn_3: 导出PDF
  1371.         utils.setBtnEvent(() => {
  1372.             if (confirm("确定每页内容都加载完成了吗？")) {
  1373.                 utils.saveCanvasesToPDF(...prepare());
  1374.             }
  1375.         }, [], "btn_3", "导出图片到PDF");
  1376.     }
  1377.  
  1378.     // 绑定主函数
  1379.     function getCanvasList() {
  1380.         // 获取全部canvas元素，用于传递canvas元素列表给 btn_2 和 btn_3
  1381.         let parent_node_list = document.querySelectorAll(".hkswf-content");
  1382.         let node_list = [];
  1383.         for (let node of parent_node_list) {
  1384.             node_list.push(node.children[0]);
  1385.         }
  1386.         return node_list;
  1387.     }
  1388.  
  1389.  
  1390.     function prepare() {
  1391.         // 获取canvas元素列表
  1392.         let node_list = getCanvasList();
  1393.         // 获取文档标题
  1394.         let title;
  1395.         if (document.querySelector("h1 [title=doc]")) {
  1396.             title = document.querySelector("h1 [title=doc]").nextElementSibling.textContent;
  1397.         } else if (document.querySelector(".doc_title")) {
  1398.             title = document.querySelector(".doc_title").textContent;
  1399.         } else {
  1400.             title = "文档";
  1401.         }
  1402.         return [node_list, title];
  1403.     }
  1404.  
  1405.  
  1406.     // 判断是否有canvas元素
  1407.     function detectCanvas() {
  1408.         let haveCanvas = getCanvasList().length === 0 ? false : true;
  1409.  
  1410.         // 隐藏按钮
  1411.         utils.toggleBtnStatus("btn_1");
  1412.         // 显示按钮
  1413.         utils.toggleBtnStatus("btn_2");
  1414.  
  1415.         // 如果没有canvas元素，则认为文档页面由外链图片构成
  1416.         if (!haveCanvas) {
  1417.             // btn_2: 导出图片链接
  1418.             utils.setBtnEvent(() => {
  1419.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1420.                     utils.savePicUrls("[id*=img_]");
  1421.                 }
  1422.             }, [], "btn_2", "导出全部图片链接");
  1423.         } else {
  1424.             // 显示按钮3
  1425.             utils.toggleBtnStatus("btn_3");
  1426.             // btn_2: 导出zip
  1427.             utils.setBtnEvent(() => {
  1428.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1429.                     utils.saveCanvasesToZip(...prepare());
  1430.                 }
  1431.             }, [], "btn_2", "导出图片到zip");
  1432.             // btn_3: 导出PDF
  1433.             utils.setBtnEvent(() => {
  1434.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1435.                     utils.saveCanvasesToPDF(...prepare());
  1436.                 }
  1437.             }, [], "btn_3", "导出图片到PDF");
  1438.         }
  1439.     }
  1440.  
  1441.  
  1442.     /**
  1443.      * 豆丁文档下载策略
  1444.      */
  1445.     function docin() {
  1446.         // 创建脚本启动按钮
  1447.         utils.createBtns();
  1448.  
  1449.         // 隐藏底部工具栏
  1450.         document.querySelector("#j_select").click(); // 选择指针
  1451.         let tool_bar = document.querySelector(".reader_tools_bar_wrap.tools_bar_small.clear");
  1452.         tool_bar.style.display = "none";
  1453.  
  1454.         // btn_1: 判断文档类型
  1455.         utils.setBtnEvent(() => {
  1456.             utils.forceHide(".jz_watermark");
  1457.             detectCanvas();
  1458.         }, [], "btn_1", "判断文档类型");
  1459.     }
  1460.  
  1461.     /**
  1462.      * 点击“展开继续阅读”，适用性：爱尚共享资料
  1463.      */
  1464.     function readAlliShare() {
  1465.         // 获取“继续阅读”元素
  1466.         let red_btn = document.getElementsByClassName("red-color")[0];
  1467.         let red_text = red_btn.textContent;
  1468.         // 如果可以展开，则展开
  1469.         if (red_text.search("点击可继续阅读") !== -1) {
  1470.             red_btn.click();
  1471.             setTimeout(readAlliShare, 1000);
  1472.         }
  1473.         // 否则启动按钮2，准备清理页面然后打印为PDF
  1474.         else {
  1475.             // 隐藏按钮
  1476.             utils.toggleBtnStatus("btn_1");
  1477.             // 显示按钮
  1478.             utils.toggleBtnStatus("btn_2");
  1479.             utils.toggleBtnStatus("btn_3");
  1480.  
  1481.             // 显示svg图片的链接
  1482.             let page1 = document.querySelector('[data-num="1"] .data-detail embed');
  1483.             if (!page1) {
  1484.                 // 如果不存在svg图形，终止后续代码
  1485.                 console.log("当前页面不存在svg图形");
  1486.                 return;
  1487.             }
  1488.             let page2 = document.querySelector('[data-num="2"] .data-detail embed');
  1489.             let [svg1_src_div, svg2_src_div] = [document.createElement("div"), document.createElement("div")];
  1490.             svg1_src_div.innerHTML = `<div id="src-1"
  1491.                                     style="font-weight: bold;font-size: 20px; height: 100px; width: 100%">
  1492.                                         访问以下链接以复制文字:<br>${page1.src}
  1493.                                     </div>`;
  1494.             svg2_src_div.innerHTML = `<div id="src-1"
  1495.                                     style="font-weight: bold;font-size: 20px; height: 100px; width: 100%">
  1496.                                     访问以下链接以复制文字:<br>${page2.src}
  1497.                                     </div>`;
  1498.             // 添加到页面上
  1499.             page1.parentElement.parentElement.parentElement.append(svg1_src_div);
  1500.             page2.parentElement.parentElement.parentElement.append(svg2_src_div);
  1501.         }
  1502.     }
  1503.  
  1504.  
  1505.     /**
  1506.      * 清理并打印爱问共享资料的文档页
  1507.      * @returns 如果输入偏移量非法，返回空值以终止函数
  1508.      */
  1509.     function printPageiShare() {
  1510.         // # 清理并打印爱问共享资料的文档页
  1511.         // ## 移除页面上无关的元素
  1512.         // ### 移除单个元素
  1513.         let topbanner = document.getElementsByClassName("detail-topbanner")[0];
  1514.         let header = document.getElementsByClassName("new-detail-header")[0];
  1515.         let fixright = document.getElementById("fix-right");
  1516.         let redpacket = document.getElementsByClassName("loginRedPacket-dialog")[0];
  1517.         let fixedrightfull = document.getElementsByClassName("fixed-right-full")[0];
  1518.         let footer = document.getElementsByClassName("website-footer")[0];
  1519.         let guess = document.getElementsByClassName("guess-you-like-warpper")[0];
  1520.         let detailtopbox = document.getElementsByClassName("detail-top-box")[0];
  1521.         let fullscreen = document.getElementsByClassName("reader-fullScreen")[0];
  1522.         let endhint = document.getElementsByClassName("endof-trial-reading")[0];
  1523.         let crumb_arrow;
  1524.         try { crumb_arrow = document.getElementsByClassName("crumb-arrow")[0].parentElement; } catch (e) { console.log(); }
  1525.         let copyright = document.getElementsByClassName("copyright-container")[0];
  1526.         let state_btn = document.getElementsByClassName("state-bottom")[0];
  1527.         let comments = document.getElementsByClassName("user-comments-wrapper")[0];
  1528.         // ### 执行移除
  1529.         let elem_list = [
  1530.             topbanner,
  1531.             header,
  1532.             fixright,
  1533.             redpacket,
  1534.             fixedrightfull,
  1535.             footer,
  1536.             guess,
  1537.             detailtopbox,
  1538.             fullscreen,
  1539.             endhint,
  1540.             crumb_arrow,
  1541.             copyright,
  1542.             state_btn,
  1543.             comments
  1544.         ];
  1545.         for (let elem of elem_list) {
  1546.             utils.tryToRemoveElement(elem);
  1547.         }
  1548.         // ### 移除全部同类元素
  1549.         let elem_list_2 = document.querySelectorAll(".tui-detail, .adv-container");
  1550.         for (let elem_2 of elem_list_2) {
  1551.             utils.tryToRemoveElement(elem_2);
  1552.         }
  1553.         // 使文档居中
  1554.         alert("建议使用:\n偏移量: 18\n缩放: 默认\n如果预览中有广告，就取消打印\n再点一次按钮，预览中应该就没有广告了");
  1555.         if (!utils.centerDoc("doc-main", "18")) {
  1556.             return; // 如果输入非法，终止函数调用
  1557.         }
  1558.         // 隐藏按钮，然后打印页面
  1559.         utils.hideBtnThenPrint();
  1560.     }
  1561.  
  1562.  
  1563.     /**
  1564.      * 爱问共享资料文档下载策略
  1565.      */
  1566.     function ishare() {
  1567.         // 创建脚本启动按钮1、2
  1568.         utils.createBtns();
  1569.  
  1570.         // btn_1: 展开文档
  1571.         utils.setBtnEvent(readAlliShare, [], "btn_1");
  1572.         // btn_2: 导出图片链接
  1573.         utils.setBtnEvent(() => {
  1574.             utils.savePicUrls(".data-detail");
  1575.         }, [], "btn_2", "导出图片链接（推荐）");
  1576.         // btn_3: 打印页面到PDF
  1577.         utils.setBtnEvent(printPageiShare, [], "btn_3", "打印页面到PDF");
  1578.  
  1579.         // 移除底部下载条
  1580.         let detailfixed = document.getElementsByClassName("detail-fixed")[0];
  1581.         utils.tryToRemoveElement(detailfixed);
  1582.     }
  1583.  
  1584.     /**
  1585.      * 清理并打印得力文库的文档页
  1586.      */
  1587.     function printPageDeliwenku() {
  1588.         // 移除页面上的无关元素
  1589.         let selector = ".hr-wrap, #readshop, .nav_uis, .bookdesc, #boxright, .QQ_S1, .QQ_S, #outer_page_more, .works-manage-box.shenshu, .works-intro, .mt10.related-pic-box, .mt10.works-comment, .foot_nav, .siteInner";
  1590.         let elem_list = document.querySelectorAll(selector);
  1591.         for (let elem of elem_list) {
  1592.             utils.tryToRemoveElement(elem);
  1593.         }
  1594.         // 修改页间距
  1595.         let outer_pages = document.getElementsByClassName("outer_page");
  1596.         for (let page of outer_pages) {
  1597.             page.style.marginBottom = "20px";
  1598.         }
  1599.         // 使文档居中
  1600.         alert("建议使用:\n偏移量: 3\n缩放: 112\n请上下滚动页面，确保每页内容都加载完成以避免空白页\n如果预览时有空白页或文末有绿色按钮，请取消打印重试");
  1601.         if (!utils.centerDoc("#boxleft", "3")) {
  1602.             return; // 如果输入非法，终止函数调用
  1603.         }
  1604.         // 打印文档
  1605.         utils.hideBtnThenPrint();
  1606.     }
  1607.  
  1608.  
  1609.     /**
  1610.      * 点击“继续阅读”，适用性：得力文库
  1611.      */
  1612.     function readAllDeliwenku() {
  1613.         // 点击“同意并开始预览全文”
  1614.         let start_btn = document.getElementsByClassName("pre_button")[0];
  1615.         let display = start_btn.parentElement.parentElement.style.display;
  1616.         // 如果该按钮显示着，则点击，然后滚动至页面底部，最后终止函数
  1617.         if (!display) {
  1618.             start_btn.children[0].click();
  1619.             setTimeout("scroll(0, document.body.scrollHeight)", 200);
  1620.             return;
  1621.         }
  1622.         // 增强按钮点击效果
  1623.         utils.enhanceBtnClickReaction();
  1624.  
  1625.         let read_all_btn = document.getElementsByClassName("fc2e")[0];
  1626.         let display2 = read_all_btn.parentElement.parentElement.style.display;
  1627.             // 继续阅读
  1628.         if (display2 !== "none") {
  1629.             // 获取input元素
  1630.             let cur_page = document.querySelector("#pageNumInput");
  1631.             let page_old = cur_page.value;
  1632.             let page_max = cur_page.parentElement.nextElementSibling.textContent.replace(" / ", "");
  1633.             // 跳转到尾页
  1634.             utils.jump2pageNo(cur_page, page_max, "keydown");
  1635.             // 跳转回来
  1636.             utils.jump2pageNo(cur_page, page_old, "keydown");
  1637.  
  1638.             // 切换按钮准备导出
  1639.         } else {
  1640.             // 推荐导出图片链接
  1641.             utils.modifyBtnText("btn_2", null, true);
  1642.             // 隐藏按钮
  1643.             utils.toggleBtnStatus("btn_1");
  1644.             // 显示按钮
  1645.             utils.toggleBtnStatus("btn_2");
  1646.             utils.toggleBtnStatus("btn_3");
  1647.             // btn_3 橙色按钮
  1648.             utils.setBtnEvent(printPageDeliwenku, [], "btn_3", "打印页面到PDF");
  1649.         }
  1650.     }
  1651.  
  1652.  
  1653.     /**
  1654.      * 得力文库文档下载策略
  1655.      */
  1656.     function deliwenku() {
  1657.         // 创建脚本启动按钮1、2
  1658.         utils.createBtns();
  1659.  
  1660.         // btn_1: 展开文档
  1661.         utils.setBtnEvent(readAllDeliwenku, [], "btn_1");
  1662.         // btn_2: 导出图片链接
  1663.         utils.setBtnEvent(() => {
  1664.             if (confirm("确定每页内容都加载完成了吗？")) {
  1665.                 utils.savePicUrls('.inner_page div');
  1666.             }
  1667.         }, [], "btn_2", "导出图片链接");
  1668.  
  1669.         // 尝试关闭页面弹窗
  1670.         try { document.querySelector("div[title=点击关闭]").click(); } catch (e) { console.log(0); }
  1671.         // 解除打印限制
  1672.         utils.allowPrint();
  1673.     }
  1674.  
  1675.     function readAll360Doc() {
  1676.         // 展开文档
  1677.         document.querySelector(".articleMaxH").setAttribute("class", "");
  1678.         // 隐藏按钮
  1679.         utils.toggleBtnStatus("btn_1");
  1680.         // 显示按钮
  1681.         utils.toggleBtnStatus("btn_2");
  1682.         utils.toggleBtnStatus("btn_3");
  1683.     }
  1684.  
  1685.  
  1686.     function saveText_360Doc() {
  1687.         // 捕获图片链接
  1688.         let images = document.querySelectorAll("#artContent img");
  1689.         let content = [];
  1690.  
  1691.         for (let i = 0; i < images.length; i++) {
  1692.             let src = images[i].src;
  1693.             content.push(`图${i+1}，链接：${src}`);
  1694.         }
  1695.         // 捕获文本
  1696.         let text = document.querySelector("#artContent").textContent;
  1697.         content.push(text);
  1698.  
  1699.         // 保存纯文本文档
  1700.         let title = document.querySelector("#titiletext").textContent;
  1701.         utils.createAndDownloadFile(`${title}.txt`, content.join("\n"));
  1702.     }
  1703.  
  1704.  
  1705.     function printPage360Doc() {
  1706.         // # 清理并打印360doc的文档页
  1707.         // ## 移除页面上无关的元素
  1708.         let selector = ".fontsize_bgcolor_controler, .atfixednav, .header, .a_right, .article_data, .prev_next, .str_border, .youlike, .new_plbox, .str_border, .ul-similar, #goTop2, #divtort, #divresaveunder, .bottom_controler, .floatqrcode";
  1709.         let elem_list = document.querySelectorAll(selector);
  1710.         let under_doc_1, under_doc_2;
  1711.         try {
  1712.             under_doc_1 = document.querySelector("#bgchange p.clearboth").nextElementSibling;
  1713.             under_doc_2 = document.querySelector("#bgchange").nextElementSibling.nextElementSibling;
  1714.         } catch (e) { console.log(); }
  1715.         // 执行移除
  1716.         for (let elem of elem_list) {
  1717.             utils.tryToRemoveElement(elem);
  1718.         }
  1719.         utils.tryToRemoveElement(under_doc_1);
  1720.         utils.tryToRemoveElement(under_doc_2);
  1721.         // 执行隐藏
  1722.         document.querySelector("a[title]").style.display = "none";
  1723.  
  1724.         // 使文档居中
  1725.         alert("建议使用:\n偏移量: 20\n缩放: 默认\n");
  1726.         if (!utils.centerDoc(".a_left", "20")) {
  1727.             return; // 如果输入非法，终止函数调用
  1728.         }
  1729.         // 隐藏按钮，然后打印页面
  1730.         utils.hideBtnThenPrint();
  1731.     }
  1732.  
  1733.  
  1734.     /**
  1735.      * 360doc个人图书馆下载策略
  1736.      */
  1737.     function doc360() {
  1738.         // 创建按钮区
  1739.         utils.createBtns();
  1740.         // btn_1: 展开文档
  1741.         utils.setBtnEvent(readAll360Doc, [], "btn_1");
  1742.         // btn_2: 导出纯文本
  1743.         utils.setBtnEvent(saveText_360Doc, [], "btn_2", "导出纯文本");
  1744.         // btn_3: 打印页面到PDF
  1745.         utils.setBtnEvent(() => {
  1746.             if (confirm("确定每页内容都加载完成了吗？")) {
  1747.                 printPage360Doc();
  1748.             }
  1749.         }, [], "btn_3", "打印页面到PDF");
  1750.     }
  1751.  
  1752.     /**
  1753.      * 查找出所有未被捕获的页码，并返回列表
  1754.      * @returns 未捕获页码列表
  1755.      */
  1756.     function getMissedPages() {
  1757.         let all = []; // 全部页码
  1758.         for (let i = 0; i < window.mbaJS.max_page; i++) {
  1759.             all[i] = i + 1;
  1760.         }
  1761.         let missed = []; // 未捕获页码
  1762.         let possessed = Array.from(window.mbaJS.canvases_map.keys()); // 已捕获页面
  1763.  
  1764.         // 排除并录入未捕获页码
  1765.         for (let num of all) {
  1766.             if (!possessed.includes(`page${num}`)) {
  1767.                 missed.push(num);
  1768.             }
  1769.         }
  1770.         return missed;
  1771.     }
  1772.  
  1773.  
  1774.     /**
  1775.      * 根据键中的id数字对map排序
  1776.      * @param {Map} elems_map 
  1777.      * @returns sorted_map
  1778.      */
  1779.     function sortMapByID$1(elems_map) {
  1780.         // id形式：page2
  1781.         let elems_arr = Array.from(elems_map);
  1782.         elems_arr.sort((item1, item2) => {
  1783.             // 从key中取出id
  1784.             let id1 = parseInt(item1[0].replace("page", ""));
  1785.             let id2 = parseInt(item2[0].replace("page", ""));
  1786.             // 升序排序
  1787.             return id1 - id2;
  1788.         });
  1789.         // 返回排序好的map
  1790.         return new Map(elems_arr);
  1791.     }
  1792.  
  1793.  
  1794.     /**
  1795.      * 存储动态加载的canvas元素、textContent
  1796.      */
  1797.     function storeElements_MBA() {
  1798.         let canvases_map = window.mbaJS.canvases_map;
  1799.         let texts_map = window.mbaJS.texts_map;
  1800.         let quality = window.mbaJS.quality;
  1801.  
  1802.         document.querySelectorAll(".page[data-loaded=true]").forEach(
  1803.             (elem) => {
  1804.                 let capture = (elem) => {
  1805.                     // (1) 存储页面为canvas图形
  1806.                     let canvas, data_base64;
  1807.                     // 导出canvas数据防止丢失
  1808.                     try {
  1809.                         // 存储canvas
  1810.                         canvas = elem.querySelector("canvas[id*=page]");
  1811.                         if (window.mbaJS.only_text) {
  1812.                             data_base64 = null;
  1813.                         } else {
  1814.                             data_base64 = canvas.toDataURL("image/jpeg", quality);
  1815.                         }
  1816.                     } catch (e) {
  1817.                         // utils.sleep(500);
  1818.                         return;
  1819.                     }
  1820.                     // 增量录入map
  1821.                     let id = canvas.id; // id的形式：page2
  1822.                     if (!canvases_map.has(id)) {
  1823.                         canvases_map.set(id, data_base64);
  1824.                     }
  1825.                     // 确定canvas长宽
  1826.                     if (!window.mbaJS.only_text && !window.mbaJS.width) {
  1827.                         window.mbaJS.width = parseInt(canvas.width);
  1828.                         window.mbaJS.height = parseInt(canvas.height);
  1829.                     }
  1830.  
  1831.                     // (2) 存储text
  1832.                     let text = elem.textContent;
  1833.                     if (!texts_map.has(id)) {
  1834.                         texts_map.set(id, text);
  1835.                     }
  1836.                 };
  1837.                 setTimeout(capture, 500, elem);
  1838.             });
  1839.         if (canvases_map.size === window.mbaJS.max_page) {
  1840.             // 根据id排序
  1841.             window.mbaJS.canvases_map = sortMapByID$1(window.mbaJS.canvases_map);
  1842.             window.mbaJS.texts_map = sortMapByID$1(window.mbaJS.texts_map);
  1843.             window.mbaJS.finished = true;
  1844.             window.onscroll = null;
  1845.         }
  1846.     }
  1847.  
  1848.  
  1849.     /**
  1850.      * 将canvas转为jpeg，然后导出PDF
  1851.      * @param {Array} base64_list canvas元素列表
  1852.      * @param {String} title 文档标题
  1853.      */
  1854.     function saveCanvasesToPDF_MBA(base64_list, title) {
  1855.         let width = window.mbaJS.width;
  1856.         let height = window.mbaJS.height;
  1857.  
  1858.         console.log(`canvas数据：宽: ${width}px，高: ${height}px`);
  1859.         // 如果文档第一页的宽比长更大，则landscape，否则portrait
  1860.         let orientation = width > height ? 'l' : 'p';
  1861.         let pdf = new jspdf.jsPDF(orientation, 'px', [height, width]);
  1862.  
  1863.         // 保存每一页文档到每一页pdf
  1864.         let i = 0;
  1865.         for (let base64 of base64_list) {
  1866.             i += 1;
  1867.             pdf.addImage(base64, 'JPEG', 0, 0, width, height);
  1868.             // 如果当前不是文档最后一页，则需要添加下一个空白页
  1869.             if (i < window.mbaJS.max_page) {
  1870.                 pdf.addPage();
  1871.             }
  1872.         }
  1873.         // 导出文件
  1874.         pdf.save(`${title}.pdf`);
  1875.     }
  1876.  
  1877.     /**
  1878.      * 判断文档页是否收集完毕，当不行时给出提示
  1879.      * @returns boolean
  1880.      */
  1881.     function ready2use() {
  1882.         removeAds(); // 顺便清理广告
  1883.         // 如果是首次点击按钮，给出提示
  1884.         if (window.mbaJS.first_hint) {
  1885.             let hint = [
  1886.                 "如果浏览速度过快，比如：",
  1887.                 "当前页面还没完全加载好就滚动页面去看下一页",
  1888.                 "那就极有可能导致导出的PDF有空白页或文本有缺漏",
  1889.                 "由防范技术的干扰，该功能目前很不好用，见谅"
  1890.             ].join("\n");
  1891.             alert(hint);
  1892.             window.mbaJS.first_hint = false;
  1893.         }
  1894.         // 如果文档页没有收集完，给出提示
  1895.         if (!window.mbaJS.finished) {
  1896.             let hint = [
  1897.                 "仍有内容未加载完，无法使用该功能",
  1898.                 "建议从头到尾慢速地再浏览一遍",
  1899.                 "以下是没有加载完成页面的页码：",
  1900.                 getMissedPages().join(",")
  1901.             ];
  1902.             alert(hint.join("\n"));
  1903.             return false;
  1904.         }
  1905.         return true;
  1906.     }
  1907.  
  1908.  
  1909.     /**
  1910.      * 用捕获好的canvas转jpg，生成PDF
  1911.      * @returns 
  1912.      */
  1913.     function canvas2PDF_mba() {
  1914.         if (!ready2use()) {
  1915.             return;
  1916.         }
  1917.         let canvases = window.mbaJS.canvases_map.values();
  1918.         // 导出PDF
  1919.         let title = document.title.split("-")[0].trim();
  1920.         saveCanvasesToPDF_MBA(canvases, title);
  1921.     }
  1922.  
  1923.  
  1924.     /**
  1925.      * 拼合捕获好的文本，保存到txt文件
  1926.      * @returns 
  1927.      */
  1928.     function saveText_mba() {
  1929.         if (!ready2use()) {
  1930.             return;
  1931.         }
  1932.         let content = Array.from(window.mbaJS.texts_map.values());
  1933.         let title = document.title.split("-")[0].trim();
  1934.         utils.createAndDownloadFile(`${title}.txt`, content.join("\n"));
  1935.     }
  1936.  
  1937.  
  1938.     /**
  1939.      * 移除广告
  1940.      */
  1941.     function removeAds() {
  1942.         document.querySelectorAll(".doc-ad").forEach((ad_elem) => {
  1943.             utils.tryToRemoveElement(ad_elem);
  1944.         });
  1945.     }
  1946.  
  1947.  
  1948.     function mbalib_() {
  1949.         // 移除广告和左侧工具栏
  1950.         removeAds();
  1951.         let tool_bar = document.querySelector(".tool-bar");
  1952.         utils.tryToRemoveElement(tool_bar);
  1953.  
  1954.         // 创建按钮
  1955.         utils.createBtns();
  1956.         // 隐藏按钮
  1957.         utils.toggleBtnStatus("btn_1");
  1958.         // 显示按钮
  1959.         utils.toggleBtnStatus("btn_2");
  1960.         utils.toggleBtnStatus("btn_3");
  1961.         utils.toggleBtnStatus("btn_4");
  1962.  
  1963.         // 取得页数
  1964.         let max_page = parseInt(document.querySelector("#numPages").textContent.replace("/ ", ""));
  1965.         let quality = utils.getQualityByCanvasAmount(max_page);
  1966.  
  1967.         // 为导出内容提供全局变量，便于动态收集文档页元素的存取
  1968.         window.mbaJS = {
  1969.             max_page: max_page,
  1970.             texts_map: new Map(), // id: text
  1971.             canvases_map: new Map(), // id: canvas_data_base64
  1972.             quality: quality, // canvas转jpg的质量
  1973.             width: null, // canvas宽度（px）
  1974.             height: null,
  1975.             finished: false, // 是否收集完了全部文档页元素
  1976.             first_hint: true,
  1977.             scroll_count: 0, // 用于统计累计触发scroll的次数,
  1978.             only_text: false // 是否仅捕获文本
  1979.         };
  1980.         // 跟随浏览，动态收集页面元素
  1981.         window.onscroll = () => {
  1982.             storeElements_MBA();
  1983.         };
  1984.         // 跟随浏览，动态收集页面元素
  1985.         utils.scrollFunc(storeElements_MBA, window.mbaJS, 20, 50, "mba元素: 收集");
  1986.         // 绑定事件
  1987.         utils.setBtnEvent(saveText_mba, [], "btn_2", "导出纯文本(不稳定)");
  1988.         utils.setBtnEvent(canvas2PDF_mba, [], "btn_3", "导出PDF(不稳定)");
  1989.  
  1990.         // 根据页数决定按钮功能：<40页，导出文本+导出pdf，>40页：导出文本
  1991.         let btn_text, aim_btn, hint;
  1992.         if (max_page > 40) {
  1993.             btn_text = "失效说明";
  1994.             aim_btn = "btn_3";
  1995.             hint = [
  1996.                 "页数超过40，脚本无效",
  1997.                 "只能使用导出文本功能",
  1998.                 "而此脚本会使页面内容加载明显变慢，建议禁用"
  1999.             ];
  2000.             utils.setBtnEvent(utils.banSelf, [
  2001.                 () => { window.onscroll = null; }
  2002.             ], "btn_4", "临时禁用脚本");
  2003.         } else {
  2004.             btn_text = "空白页说明";
  2005.             aim_btn = "btn_4";
  2006.             hint = [
  2007.                 "导致空白页的原因如下",
  2008.                 "加载该页的时间超过2秒 / 明显等待",
  2009.                 "而此脚本会使页面内容加载明显变慢，如果影响严重请禁用"
  2010.             ];
  2011.         }
  2012.  
  2013.         utils.setBtnEvent(() => {
  2014.             alert(hint.join("\n"));
  2015.         }, [], aim_btn, btn_text);
  2016.     }
  2017.  
  2018.  
  2019.     function mbalib() {
  2020.         setTimeout(mbalib_, 2000);
  2021.     }
  2022.  
  2023.     // 拼接swf: https://pan.baidu.com/s/1PTM6watxNlqs-jvvX6XKzg?pwd=abe9 中的 JoinSWFFiles_setup.exe
  2024.     // swf转pdf: https://youfiles.herokuapp.com/swftopdf/
  2025.  
  2026.  
  2027.     /**
  2028.      * 统计文档页的数量
  2029.      * @param {String} inner_selector 【信息摘要】元素选择器
  2030.      * @returns 文档页的数量
  2031.      */
  2032.     function countPages(inner_selector = ".container div[style=' margin:20px; ']") {
  2033.         let abstract = inner_window.document.querySelector(inner_selector).textContent;
  2034.         let page_amount_pattern = /文档页数：共 ([1-9]|[1-9][0-9]|[1-9][0-9][0-9]) 页/;
  2035.         // 捕获到: ["文档页数：共 xx 页", "xx"]
  2036.         let max_page = parseInt(abstract.match(page_amount_pattern)[1]);
  2037.         return max_page;
  2038.     }
  2039.  
  2040.  
  2041.     /**
  2042.      * 判断当前帮帮文档是否为高清版页面
  2043.      * @returns 是否为高清
  2044.      */
  2045.     function isHD() {
  2046.         // 取得页面左侧【高清版】切换功能区
  2047.         let hd_bar = inner_window.document.querySelector("#gaoging");
  2048.         // 取得功能区内提示文字
  2049.         let hint = hd_bar.querySelector("#gqts").textContent;
  2050.         // 如果存在如下文字，认为当前页面是模糊版，否则是高清版
  2051.         if (hint.includes("点此阅读高清版")) {
  2052.             return false;
  2053.         }
  2054.         return true;
  2055.     }
  2056.  
  2057.  
  2058.     /**
  2059.      * 开启收集swf链接任务，隐藏按钮1，显示按钮2、3
  2060.      */
  2061.     function main$1() {
  2062.         // 已经是高清版
  2063.         // 跟随浏览，动态冻结页面元素
  2064.         utils.scrollFunc(storeSWFLinks_Woc88, window.woc88JS, 10, 30, "woc88元素: 收集", inner_window);
  2065.  
  2066.         // 绑定按钮的触发函数
  2067.         utils.setBtnEvent(btn2SaveSwfUrls, [], "btn_2", "导出swf链接");
  2068.         utils.setBtnEvent(() => {
  2069.             let hints = [
  2070.                 "本脚本无需【flash】。",
  2071.                 "你的电脑上无需安装任何flash player也可以使用。",
  2072.                 "导出 media-urls.csv 后，",
  2073.                 "需要使用【资源下载器】来取得swf文档资源。",
  2074.                 "详细用法请访问脚本主页: ",
  2075.                 "https://greasyfork.org/zh-CN/scripts/435884-wenku-doc-downloader"
  2076.             ];
  2077.             alert(hints.join("\n"));
  2078.         }, [], "btn_3", "友情提示");
  2079.  
  2080.         // 隐藏按钮
  2081.         utils.toggleBtnStatus("btn_1");
  2082.         // 显示按钮
  2083.         utils.toggleBtnStatus("btn_2");
  2084.         utils.toggleBtnStatus("btn_3");
  2085.     }
  2086.  
  2087.  
  2088.     function switch2HD() {
  2089.         // 取得页面左侧【高清版】切换功能区
  2090.         let hd_bar = inner_window.document.querySelector("#gaoging");
  2091.         // 取得功能区内【切换高清版】按钮
  2092.         let hd_button = hd_bar.querySelector("#gqts span[onclick]");
  2093.         hd_button.click();
  2094.         // 开启主任务
  2095.         setTimeout(main$1, 1000);
  2096.     }
  2097.  
  2098.  
  2099.     /**
  2100.      * 根据键中的id数字对map排序
  2101.      * @param {Map} elems_map 
  2102.      * @returns sorted_map
  2103.      */
  2104.     function sortMapByID(elems_map) {
  2105.         // id形式：5, 类型: int
  2106.         let elems_arr = Array.from(elems_map);
  2107.         elems_arr.sort((id1, id2) => {
  2108.             // 升序排序
  2109.             return id1 - id2;
  2110.         });
  2111.         // 返回排序好的map
  2112.         return new Map(elems_arr);
  2113.     }
  2114.  
  2115.  
  2116.     /**
  2117.      * 存储swf链接。适用于帮帮文库。
  2118.      * @param {String} inner_selector iframe#test 框架下的【swf链接所在元素】选择器
  2119.      */
  2120.     function storeSWFLinks_Woc88(inner_selector = "div[id*=imgcount] > div > object") {
  2121.         let elems_map = window.woc88JS.elems_map;
  2122.         inner_window.document.querySelectorAll(inner_selector).forEach(
  2123.             (elem) => {
  2124.                 // 复制链接防止丢失
  2125.                 // 拿到id
  2126.                 let id_elem = elem.parentElement.parentElement.id;
  2127.                 let id = parseInt(id_elem.replace("imgcount", ""));
  2128.                 // 拿到link
  2129.                 let link = elem.data;
  2130.                 // 储存id: link
  2131.                 elems_map.set(id, link);
  2132.             });
  2133.         if (elems_map.size === window.woc88JS.max_page) {
  2134.             // 根据id排序，保证导出的图片链接不是乱序的
  2135.             window.woc88JS.elems_map = sortMapByID(window.woc88JS.elems_map);
  2136.             // 已经保存完全部文档页元素，移除滚动事件的绑定函数
  2137.             window.woc88JS.finished = true;
  2138.             inner_window.removeEventListener("scroll", window.woc88JS.scrollFunc, false);
  2139.         }
  2140.     }
  2141.  
  2142.  
  2143.     /**
  2144.      * 导出swf链接到csv文件。需要配合【资源下载器】使用。
  2145.      */
  2146.     function saveSwfUrls_Woc88() {
  2147.         let urls = [];
  2148.         window.woc88JS.elems_map.forEach((url) => {
  2149.             // 遍历map就是遍历value
  2150.             urls.push(url);
  2151.         });
  2152.         utils.createAndDownloadFile("media-urls.csv", urls.join("\n"));
  2153.     }
  2154.  
  2155.  
  2156.     /**
  2157.      * 返回一个列表，包含所有未捕获的页码
  2158.      * @returns 未捕获页码列表
  2159.      */
  2160.     function getNotStored() {
  2161.         // 取得全部页码
  2162.         let max_page = window.woc88JS.max_page;
  2163.         // 取得未捕获页码
  2164.         let stored = new Set(window.woc88JS.elems_map.keys());
  2165.         let not_stored = [];
  2166.         for (let i = 1; i <= max_page; i++) {
  2167.             // 如果当前页码未被捕获，则录入not_stored
  2168.             if (!stored.has(i)) {
  2169.                 not_stored.push(i);
  2170.             }
  2171.         }
  2172.         return not_stored;
  2173.     }
  2174.  
  2175.  
  2176.     function btn2SaveSwfUrls() {
  2177.         if (!window.woc88JS.finished) {
  2178.             let hints = [
  2179.                 "仍有内容未加载完，无法使用该功能",
  2180.                 "请再次浏览未加载出的页面，未加载的页码如下",
  2181.                 getNotStored().join(",")
  2182.             ];
  2183.             alert(hints.join("\n"));
  2184.             return;
  2185.         }
  2186.         saveSwfUrls_Woc88();
  2187.     }
  2188.  
  2189.  
  2190.     /**
  2191.      * 帮帮文库下载策略
  2192.      */
  2193.     function woc88() {
  2194.         // 1 初始环境配置
  2195.         // 取得iframe的window
  2196.         window.inner_window = document.querySelector("#test").contentWindow;
  2197.         // 设置全局变量
  2198.         window.woc88JS = {
  2199.             max_page: countPages(), // 当前文档页面数量
  2200.             finished: false, // 是否收集完了全部文档页元素
  2201.             scroll_count: 0, // 用于统计累计触发scroll的次数
  2202.             elems_map: new Map(), // 存储已经捕获的元素: {id: element}
  2203.             scrollFunc: null
  2204.         };
  2205.  
  2206.         // 2 主任务
  2207.         // 创建按钮组
  2208.         utils.createBtns();
  2209.         // 如果不是高清版，先切换至高清版
  2210.         if (!isHD()) {
  2211.             utils.setBtnEvent(switch2HD, [], "btn_1", "高清版");
  2212.             return;
  2213.         }
  2214.         main$1();
  2215.     }
  2216.  
  2217.     /**
  2218.      * 判断是否进入预览模式
  2219.      * @returns Boolean
  2220.      */
  2221.     function isInPreview() {
  2222.         let p_elem = document.querySelector("#preview_tips");
  2223.         if (p_elem.style.display === "none") {
  2224.             return true;
  2225.         }
  2226.         return false;
  2227.     }
  2228.  
  2229.  
  2230.     /**
  2231.      * 判断是否展开了全文
  2232.      * @returns Boolean
  2233.      */
  2234.     function isNoMorePage() {
  2235.         let read_more = document.querySelector("#ntip2");
  2236.         if (read_more.style.display === "none") {
  2237.             return true;
  2238.         }
  2239.         return false;
  2240.     }
  2241.  
  2242.  
  2243.     /**
  2244.      * 确保进入预览模式
  2245.      */
  2246.     function ensureInPreview() {
  2247.         if (!isInPreview()) {
  2248.             // 如果没有进入预览，则先进入
  2249.             document.querySelector(".pre_button a").click();
  2250.             utils.sleep(500);
  2251.         }
  2252.     }
  2253.  
  2254.  
  2255.     /**
  2256.      * 展开全文预览，当展开完成后再次调用时，返回true
  2257.      * @returns 
  2258.      */
  2259.     function unfoldAll() {
  2260.         ensureInPreview();
  2261.         if (isNoMorePage()) {
  2262.             // 如果全文展开了，则切换按钮，然后退出
  2263.             utils.toggleBtnStatus("btn_1");
  2264.             utils.toggleBtnStatus("btn_2");
  2265.             return true;
  2266.         }
  2267.         // 跳转到最后一页，以展开全文
  2268.         let cur_page = document.querySelector("#pageNumInput");
  2269.         utils.jump2pageNo(cur_page, "999", "keydown");
  2270.     }
  2271.  
  2272.  
  2273.     /**
  2274.      * 取得最大页码（最大20）
  2275.      * @returns {Number} 页码int
  2276.      */
  2277.     function getPageCounts$1() {
  2278.         let counts_str = document.querySelector(".counts").textContent;
  2279.         let counts = counts_str.match(/[0-9]{1,3}/)[0];
  2280.         if (counts > 20) {
  2281.             counts = 20; // 最多免费预览20页，所以设置最大页码20
  2282.         }
  2283.         return parseInt(counts);
  2284.     }
  2285.  
  2286.  
  2287.     /**
  2288.      * 取得全部文档页面的链接，返回urls；如果有页面未加载，则返回null
  2289.      * @returns Array | null
  2290.      */
  2291.     function getImgUrls() {
  2292.         let pages = document.querySelectorAll("[id*=pageflash_]");
  2293.         // 尚未浏览完全部页面，返回null
  2294.         if (pages.length < window.dugenJS.page_counts) {
  2295.             return null;
  2296.         }
  2297.         // 浏览完全部页面，返回urls
  2298.         let urls = [];
  2299.         pages.forEach((page) => {
  2300.             let url = page.querySelector("img").src;
  2301.             urls.push(url);
  2302.         });
  2303.         return urls;
  2304.     }
  2305.  
  2306.  
  2307.     /**
  2308.      * 返回当前未加载页面的页码
  2309.      * @returns not_loaded
  2310.      */
  2311.     function getNotloadedPages() {
  2312.         // 已经取得的页码
  2313.         let pages = document.querySelectorAll("[id*=pageflash_]");
  2314.         let loaded = new Set();
  2315.         pages.forEach((page) => {
  2316.             let id = page.id.split("_")[1];
  2317.             id = parseInt(id);
  2318.             loaded.add(id);
  2319.         });
  2320.         // 未取得的页码
  2321.         let not_loaded = [];
  2322.         for (let i = 1; i <= window.dugenJS.page_counts; i++) {
  2323.             if (!loaded.has(i)) {
  2324.                 not_loaded.push(i);
  2325.             }
  2326.         }
  2327.         return not_loaded;
  2328.     }
  2329.  
  2330.  
  2331.     function WantImgUrls() {
  2332.         let res = getImgUrls();
  2333.         // 页面尚未加载完
  2334.         if (res === null) {
  2335.             let hints = [
  2336.                 "尚未加载完全部页面",
  2337.                 "以下页面需要浏览并加载：",
  2338.                 getNotloadedPages().join(",")
  2339.             ];
  2340.             alert(hints.join("\n"));
  2341.             return;
  2342.         }
  2343.         // 页面全部加载完
  2344.         utils.createAndDownloadFile("urls.csv", res.join("\n"));
  2345.     }
  2346.  
  2347.  
  2348.     /**
  2349.      * dugen文档下载策略
  2350.      */
  2351.     function dugen() {
  2352.         ensureInPreview();
  2353.         // 全局对象
  2354.         window.dugenJS = {
  2355.             page_counts: getPageCounts$1() // 最大页码(int)
  2356.         };
  2357.  
  2358.         // 创建按钮区
  2359.         utils.createBtns();
  2360.  
  2361.         // 绑定监听器
  2362.         // 按钮1：展开文档
  2363.         utils.setBtnEvent(unfoldAll, [], "btn_1");
  2364.         // 按钮2：导出图片链接
  2365.         utils.setBtnEvent(WantImgUrls, [], "btn_2", "导出图片链接");
  2366.     }
  2367.  
  2368.     /**
  2369.      * 取得文档类型
  2370.      * @returns {String} 文档类型str
  2371.      */
  2372.     function getDocType() {
  2373.         let type_elem = document.querySelector(".title .icon.icon-format");
  2374.         // ["icon", "icon-format", "icon-format-doc"]
  2375.         let cls_str = type_elem.classList[2];
  2376.         // "icon-format-doc"
  2377.         let type = cls_str.split("-")[2];
  2378.         return type;
  2379.     }
  2380.  
  2381.  
  2382.     /**
  2383.      * 判断文档类型是否为type_list其中之一
  2384.      * @returns 是否为type
  2385.      */
  2386.     function isTypeof(type_list) {
  2387.         let type = getDocType();
  2388.         if (type_list.includes(type)) {
  2389.             return true;
  2390.         }
  2391.         return false;
  2392.     }
  2393.  
  2394.  
  2395.     /**
  2396.      * 判断文档类型是否为PPT
  2397.      * @returns 是否为PPT
  2398.      */
  2399.     function isPPT() {
  2400.         return isTypeof(["ppt", "pptx"]);
  2401.     }
  2402.  
  2403.  
  2404.     /**
  2405.      * 判断文档类型是否为Excel
  2406.      * @returns 是否为Excel
  2407.      */
  2408.     function isEXCEL() {
  2409.         return isTypeof(["xls", "xlsm", "xlsx"]);
  2410.     }
  2411.  
  2412.  
  2413.     /**
  2414.      * 取得最大页码
  2415.      * @returns 最大页码int
  2416.      */
  2417.     function getPageCounts() {
  2418.         let page_counts_str = document.querySelector(".intro-list").children[3].textContent;
  2419.         let page_counts = parseInt(page_counts_str.match(/[0-9]{1,3}(?=页)/)[0]);
  2420.         return page_counts;
  2421.     }
  2422.  
  2423.  
  2424.     /**
  2425.      * 取得未加载页面的页码
  2426.      * @param {Set} loaded 已加载的页码集合
  2427.      * @returns {Array} not_loaded 未加载页码列表
  2428.      */
  2429.     function getNotLoaded(loaded) {
  2430.         let not_loaded = [];
  2431.         let page_counts = window.book118JS.page_counts;
  2432.         for (let i = 1; i <= page_counts; i++) {
  2433.             if (!loaded.has(i)) {
  2434.                 not_loaded.push(i);
  2435.             }
  2436.         }
  2437.         return not_loaded;
  2438.     }
  2439.  
  2440.  
  2441.     /**
  2442.      * 取得全部文档页的url
  2443.      * @returns [<是否全部加载>, <未加载页码列表>|<urls列表>]
  2444.      */
  2445.     function getUrls() {
  2446.         let loaded = new Set(); // 存储已加载页面的页码
  2447.         let urls = []; // 存储已加载页面的图形src
  2448.         // 收集已加载页面的url
  2449.         document.querySelectorAll("div[data-id]").forEach((div) => {
  2450.             let src = div.querySelector("img").src;
  2451.             if (src) {
  2452.                 // "1": "https://view-cache.book118.com/..."
  2453.                 loaded.add(parseInt(div.getAttribute("data-id")));
  2454.                 urls.push(src);
  2455.             }
  2456.         });
  2457.         // 如果所有页面加载完毕
  2458.         if (loaded.size === window.book118JS.page_counts) {
  2459.             return [true, urls];
  2460.         }
  2461.         // 否则收集未加载页面的url
  2462.         return [false, getNotLoaded(loaded)];
  2463.     }
  2464.  
  2465.  
  2466.     /**
  2467.      * 展开全文
  2468.      */
  2469.     function readAll() {
  2470.         window.preview.jump(999);
  2471.     }
  2472.  
  2473.  
  2474.     /**
  2475.      * btn_2: 导出图片链接
  2476.      */
  2477.     function wantUrls() {
  2478.         let [flag, res] = getUrls();
  2479.         // 页面都加载完毕，下载urls
  2480.         if (flag) {
  2481.             utils.createAndDownloadFile("urls.csv", res.join("\n"));
  2482.             return;
  2483.         }
  2484.         // 没有加载完，提示出未加载好的页码
  2485.         let hints = [
  2486.             "仍有页面没有加载",
  2487.             "请浏览并加载如下页面：",
  2488.             res.join(",")
  2489.         ];
  2490.         alert(hints.join("\n"));
  2491.     }
  2492.  
  2493.  
  2494.     /**
  2495.      * 打开PPT预览页面
  2496.      */
  2497.     function openPPTpage() {
  2498.         window.preview.getSrc();
  2499.         let openPPT = () => {
  2500.             let ppt_src = document.querySelector("iframe.preview-iframe").src;
  2501.             utils.openInNewTab(ppt_src);
  2502.             window.preview.close();
  2503.         };
  2504.         setTimeout(openPPT, 1000);
  2505.     }
  2506.  
  2507.  
  2508.     /**
  2509.      * 原创力文档(非PPT或Excel)下载策略
  2510.      */
  2511.     function book118_CommonDoc() {
  2512.         // 创建全局对象
  2513.         window.book118JS = {
  2514.             doc_type: getDocType(),
  2515.             page_counts: getPageCounts()
  2516.         };
  2517.  
  2518.         // 处理非PPT文档
  2519.         // 创建按钮组
  2520.         utils.createBtns();
  2521.         // 绑定监听器到按钮
  2522.         // 按钮1：展开文档
  2523.         utils.setBtnEvent(() => {
  2524.             readAll();
  2525.             utils.toggleBtnStatus("btn_1");
  2526.             utils.toggleBtnStatus("btn_2");
  2527.         }, [], "btn_1");
  2528.         // 按钮2：导出图片链接
  2529.         utils.setBtnEvent(wantUrls, [], "btn_2", "导出图片链接");
  2530.     }
  2531.  
  2532.  
  2533.     /**
  2534.      * 取得PPT文档最大页码
  2535.      * @returns PPT文档最大页码int
  2536.      */
  2537.     function getPageCountsPPT() {
  2538.         let counts_str = document.querySelector("#PageCount").textContent;
  2539.         let counts = parseInt(counts_str);
  2540.         console.log(`get page counts: ${counts}`);
  2541.         return counts;
  2542.     }
  2543.  
  2544.  
  2545.     /**
  2546.      * 转换当前视图为canvas，添加到book118JS.canvases中。在递归终止时显示btn_2。
  2547.      * @param {Number} max 转换执行次数，或者说，页面数量
  2548.      */
  2549.     function docView2Canvas(max, i = 0) {
  2550.         // 取得页码
  2551.         let cur_page = document.querySelector("#PageIndex").textContent;
  2552.         cur_page = parseInt(cur_page);
  2553.         // 取得视图元素，计数从0开始
  2554.         let doc_view = document.querySelector(`#view${cur_page-1}`);
  2555.         // 转化为canvas
  2556.         let canvas_promise = html2canvas(doc_view);
  2557.         console.log(canvas_promise); // 打印信息以检查状况
  2558.         canvas_promise.then((canvas) => {
  2559.             // 保存canvas到全局对象
  2560.             window.book118JS.canvases.push(canvas);
  2561.             // 打印日志
  2562.             i += 1;
  2563.             console.log(`wk: ${cur_page} complete`);
  2564.  
  2565.             // 下一页
  2566.             document.querySelector(".btmRight").click();
  2567.             utils.sleep(500); // 等待页面加载
  2568.             // 如果递归未达到最大次数
  2569.             if (i < max) {
  2570.                 // 则下一次递归
  2571.                 docView2Canvas(max, i);
  2572.             } else {
  2573.                 // 否则终止递归，并且显示导出PDF按钮
  2574.                 utils.toggleBtnStatus("btn_2");
  2575.             }
  2576.         });
  2577.     }
  2578.  
  2579.  
  2580.     /**
  2581.      * 将捕获的canvases合并并导出为pdf
  2582.      * @returns 
  2583.      */
  2584.     function canvases2pdf() {
  2585.         // 已经捕获的页面数量
  2586.         let stored_amount = window.book118JS.canvases.length;
  2587.         // 总页面数量
  2588.         let page_counts = window.book118JS.page_counts;
  2589.         // 校验数量
  2590.         let diff = page_counts - stored_amount;
  2591.         if (diff > 0) {
  2592.             alert(`缺失了 ${diff} 页，可以过一会再点击该按钮试试。`);
  2593.             if (!confirm("是否仍要导出PDF？")) {
  2594.                 // 不坚持导出PDF的情况
  2595.                 return;
  2596.             }
  2597.         }
  2598.         // 导出PDF
  2599.         let canvases = window.book118JS.canvases;
  2600.         // 取得宽高
  2601.         let model = canvases[0];
  2602.         let width = model.width;
  2603.         let height = model.height;
  2604.         // 取得标题然后导出pdf
  2605.         utils.saveCanvasesToPDF(canvases, "原创力PPT文档", width, height);
  2606.     }
  2607.  
  2608.  
  2609.     /**
  2610.      * 原创力文档(PPT)下载策略
  2611.      */
  2612.     function book118_PPT() {
  2613.         // 创建全局对象
  2614.         window.book118JS = {
  2615.             page_counts: getPageCountsPPT(),
  2616.             canvases: [] // 存储每页文档转化的canvas
  2617.         };
  2618.  
  2619.         // 创建按钮区
  2620.         utils.createBtns();
  2621.         // 绑定监听器到按钮1
  2622.         utils.setBtnEvent(() => {
  2623.             let hints = [
  2624.                 "正在为文档“截图”，请耐心等待过程完成，不要操作",
  2625.                 "“截图”会有额外一层黑边，原因未知，暂无法处理，烦请谅解"
  2626.             ];
  2627.             alert(hints.join("\n"));
  2628.             // 隐藏按钮1
  2629.             utils.toggleBtnStatus("btn_1");
  2630.             // 开始捕获页面
  2631.             docView2Canvas(window.book118JS.page_counts);
  2632.         }, [], "btn_1", "捕获页面");
  2633.         // 为按钮2绑定监听器
  2634.         utils.setBtnEvent(canvases2pdf, [], "btn_2", "导出PDF");
  2635.     }
  2636.  
  2637.  
  2638.     /**
  2639.      * 取得当前页面的excel，返回csv string
  2640.      * @returns {String} csv
  2641.      */
  2642.     function excel2CSV() {
  2643.         let table = [];
  2644.         let rows = document.querySelectorAll("tr[id]");
  2645.  
  2646.         // 遍历行
  2647.         for (let row of rows) {
  2648.             let csv_row = [];
  2649.             // 遍历列（单元格）
  2650.             for (let cell of row.querySelectorAll("td[class*=fi], td.tdrl")) {
  2651.                 // 判断单元格是否存储图片
  2652.                 let img = cell.querySelector("img");
  2653.                 if (img) {
  2654.                     // 如果是图片，保存图片链接
  2655.                     csv_row.push(img.src);
  2656.                 } else {
  2657.                     // 否则保存单元格文本
  2658.                     csv_row.push(cell.textContent);
  2659.                 }
  2660.             }
  2661.             table.push(csv_row.join(","));
  2662.         }
  2663.  
  2664.         let csv = table.join("\n");
  2665.         csv = csv.replace(/\n{2,}/g, "\n");
  2666.         return csv;
  2667.     }
  2668.  
  2669.  
  2670.     /**
  2671.      * 下载当前表格内容，保存为csv（utf-8编码）
  2672.      */
  2673.     function wantEXCEL() {
  2674.         let file_name = "原创力表格_UTF-8.csv";
  2675.         utils.createAndDownloadFile(file_name, excel2CSV());
  2676.     }
  2677.  
  2678.  
  2679.     /**
  2680.      * 在Excel预览页面给出操作提示
  2681.      */
  2682.     function help() {
  2683.         let hints = [
  2684.             "【导出表格到CSV】只能导出当前sheet，",
  2685.             "如果有多张sheet请在每个sheet上用按钮分别导出CSV。",
  2686.             "CSV是一种简单的表格格式，可以被Excel打开，",
  2687.             "并转为 xls 或 xlsx 格式存储，",
  2688.             "但CSV本身不能存储图片，所以用图片链接代替，请自行下载图片",
  2689.             "",
  2690.             "本功能导出的CSV文件无法直接用Excel打开，因为中文会乱码。",
  2691.             "有两个办法：",
  2692.             "1. 打开Excel，选择【数据】，选择【从文本/CSV】，",
  2693.             "  选择文件，【文件原始格式】选择【65001: Unicode(UTF-8)】，选择【加载】。",
  2694.             "2. 用【记事本】打开CSV文件，【文件】->【另存为】->",
  2695.             "  【编码】选择【ANSI】->【保存】。现在可以用Excel直接打开它了。"
  2696.         ];
  2697.         alert(hints.join("\n"));
  2698.     }
  2699.  
  2700.  
  2701.     /**
  2702.      * 原创力文档(EXCEL)下载策略
  2703.      */
  2704.     function book118_EXCEL() {
  2705.         // 创建按钮区
  2706.         utils.createBtns();
  2707.         // 绑定监听器到按钮
  2708.         utils.setBtnEvent(wantEXCEL, [], "btn_1", "导出表格到CSV");
  2709.         utils.setBtnEvent(help, [], "btn_2", "使用说明");
  2710.         // 显示按钮
  2711.         utils.toggleBtnStatus("btn_2");
  2712.     }
  2713.  
  2714.  
  2715.     /**
  2716.      * 打开Excel预览页面
  2717.      */
  2718.     function openEXCELpage() {
  2719.         openPPTpage();
  2720.     }
  2721.  
  2722.  
  2723.     /**
  2724.      * 原创力文档下载策略
  2725.      */
  2726.     function book118() {
  2727.         let host = window.location.hostname;
  2728.         if (host === 'max.book118.com') {
  2729.             if (isEXCEL()) {
  2730.                 utils.createBtns();
  2731.                 utils.setBtnEvent(openEXCELpage, [], "btn_1", "导出EXCEL");
  2732.             } else if (isPPT()) {
  2733.                 utils.createBtns();
  2734.                 utils.setBtnEvent(openPPTpage, [], "btn_1", "导出PPT");
  2735.             } else {
  2736.                 book118_CommonDoc();
  2737.             }
  2738.         } else if (host === "view-cache.book118.com") {
  2739.             book118_PPT();
  2740.         } else if (host.match(/view[0-9]{1,3}.book118.com/)) {
  2741.             book118_EXCEL();
  2742.         } else {
  2743.             console.log(`wk: Unknown host: ${host}`);
  2744.         }
  2745.     }
  2746.  
  2747.     /**
  2748.      * 设置图像质量为100
  2749.      */
  2750.     function HD() {
  2751.         window.img_quality = 1;
  2752.         console.log("图像质量已经设置为100%");
  2753.         console.log("如果刷新页面或跳转页面则需要再次使用该命令");
  2754.     }
  2755.  
  2756.     /**
  2757.      * 主函数：识别网站，执行对应文档下载策略
  2758.      */
  2759.     function main() {
  2760.         // 显示当前位置
  2761.         let host = window.location.host;
  2762.         console.log(`当前host: ${host}`);
  2763.         // 挂载工具包到全局
  2764.         window.user_utils = utils;
  2765.         console.log("wk: user_utils已经挂载到全局");
  2766.  
  2767.         // 附加任务
  2768.         utils.globalFunc(HD); // 全局设置高清图片的函数
  2769.  
  2770.         // 主任务
  2771.         if (host.includes("docin.com")) {
  2772.             docin();
  2773.         } else if (host === "ishare.iask.sina.com.cn") {
  2774.             ishare();
  2775.         } else if (host === "www.deliwenku.com") {
  2776.             deliwenku();
  2777.         } else if (host === "www.doc88.com") {
  2778.             doc88();
  2779.         } else if (host === "www.360doc.com") {
  2780.             doc360();
  2781.         } else if (host === "wenku.baidu.com") {
  2782.             baiduWenku();
  2783.         } else if (host === "doc.mbalib.com") {
  2784.             mbalib();
  2785.         } else if (host === "www.woc88.com") {
  2786.             woc88();
  2787.         } else if (host === "www.dugen.com") {
  2788.             dugen();
  2789.         } else if (host.includes("book118.com")) {
  2790.             book118();
  2791.         } else {
  2792.             console.log("匹配到了无效网页");
  2793.         }
  2794.     }
  2795.  
  2796.     let options = {
  2797.         fast_mode: false,
  2798.         activation_test: false
  2799.     };
  2800.     
  2801.     if (options.cli_mode) {
  2802.         (() => {
  2803.             loadExternalScripts();
  2804.             setTimeout(main, 2000);
  2805.             return;
  2806.         })();
  2807.     }
  2808.     
  2809.     if (options.activation_test) {
  2810.         alert(`Wenku Doc Downloader 已经生效！\n当前网址：\n${window.location.host}`);
  2811.     }
  2812.     
  2813.     if (options.fast_mode) {
  2814.         main();
  2815.     } else {
  2816.         window.onload = main;
  2817.     }
  2818.  
  2819. })();