☰

Wenku Doc Downloader

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

当前为 2022-02-22 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         Wenku Doc Downloader
  3. // @namespace    http://tampermonkey.net/
  4. // @version      1.4.11
  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. // @require      https://cdn.bootcdn.net/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js
  16. // @require      https://cdn.bootcdn.net/ajax/libs/jszip/3.7.1/jszip.min.js
  17. // @require      https://cdn.bootcdn.net/ajax/libs/jspdf/2.3.1/jspdf.umd.min.js
  18. // @require      https://cdn.bootcdn.net/ajax/libs/html2canvas/1.4.1/html2canvas.min.js
  19. // @icon         https://s2.loli.net/2022/01/12/wc9je8RX7HELbYQ.png
  20. // @icon64       https://s2.loli.net/2022/01/12/tmFeSKDf8UkNMjC.png
  21. // @grant        none
  22. // @license      GPL-3.0-only
  23. // @create       2021-11-22
  24. // @note         修复了小于50页的百度文档打印PDF时文字重叠的bug
  25. // ==/UserScript==
  26.  
  27.  
  28. (function () {
  29.     'use strict';
  30.  
  31.     let utils = {
  32.         /**
  33.          * 创建并下载文件
  34.          * @param {string} fileName 
  35.          * @param {string} content 
  36.          */
  37.         createAndDownloadFile: function(fileName, content) {
  38.             let aTag = document.createElement('a');
  39.             let blob = new Blob([content]);
  40.             aTag.download = fileName;
  41.             aTag.href = URL.createObjectURL(blob);
  42.             aTag.click();
  43.             URL.revokeObjectURL(blob);
  44.         },
  45.  
  46.         /**
  47.          * 临时禁用脚本，执行func后移除btns_section。
  48.          * @param {Function} func
  49.          */
  50.         banSelf: function(func = () => { }) {
  51.             func();
  52.             document.querySelector(".btns_section").remove();
  53.         },
  54.  
  55.         /**
  56.          * 睡眠 delay 毫秒
  57.          * @param {Number} delay 
  58.          */
  59.         sleep: function(delay) {
  60.             let start = (new Date()).getTime();
  61.             while ((new Date()).getTime() - start < delay) {
  62.                 continue;
  63.             }
  64.         },
  65.  
  66.         /**
  67.          * 允许打印页面
  68.          */
  69.         allowPrint: function() {
  70.             let style = document.createElement("style");
  71.             style.innerHTML = `
  72.             @media print {
  73.                 body{
  74.                     display:block;
  75.                 }
  76.             }
  77.         `;
  78.             document.head.appendChild(style);
  79.         },
  80.  
  81.         /**
  82.          * 求main_set去除cut_set后的set
  83.          * @param {Set} main_set 
  84.          * @param {Set} cut_set 
  85.          * @returns 差集
  86.          */
  87.         difference: function(main_set, cut_set) {
  88.             let _diff = new Set(main_set);
  89.             for (let elem of cut_set) {
  90.                 _diff.delete(elem);
  91.             }
  92.             return _diff;
  93.         },
  94.  
  95.         /**
  96.          * 抛出set中的第一个元素
  97.          * @param {Set} set 
  98.          * @returns 一个元素
  99.          */
  100.         setPop: function(set) {
  101.             for (let item of set) {
  102.                 set.delete(item);
  103.                 return item;
  104.             }
  105.         },
  106.  
  107.         /**
  108.          * 绑定事件到指定按钮，返回按钮引用
  109.          * @param {Function} event click事件
  110.          * @param {Array} args 事件的参数列表 
  111.          * @param {String} aim_btn 按钮的变量名
  112.          * @param {String} new_text 按钮的新文本，为null则不替换
  113.          * @returns 按钮元素的引用
  114.          */
  115.         setBtnEvent: function(event, args = [], aim_btn = "btn_3", new_text = null) {
  116.             let btn = document.querySelector(`.${aim_btn.replace("_", "-")}`);
  117.             // 如果需要，替换按钮内文本
  118.             if (new_text) {
  119.                 btn.textContent = new_text;
  120.             }
  121.             // 绑定事件，添加到页面上
  122.             btn.onclick = () => {
  123.                 this.enhanceBtnClickReaction(aim_btn);
  124.                 if (args.length) {
  125.                     event(...args);
  126.                 } else {
  127.                     event();
  128.                 }
  129.             };
  130.             return btn;
  131.         },
  132.  
  133.         /**
  134.          * 强制隐藏元素
  135.          * @param {String} selector 
  136.          */
  137.         forceHide: function(selector) {
  138.             document.querySelectorAll(selector).forEach((elem) => {
  139.                 elem.className += " force_hide";
  140.             });
  141.             let style = document.createElement("style");
  142.             style.innerHTML = `.force_hide {
  143.             visibility: hidden !important;
  144.         }`;
  145.             document.head.appendChild(style);
  146.         },
  147.  
  148.         /**
  149.          * 隐藏按钮，打印页面，显示按钮
  150.          */
  151.         hideBtnThenPrint: function() {
  152.             // 隐藏按钮，然后打印页面
  153.             let section = document.getElementsByClassName("btns_section")[0];
  154.             section.style.display = "none";
  155.             window.print();
  156.             // 打印结束，显示按钮
  157.             section.style.removeProperty("display");
  158.         },
  159.  
  160.         /**
  161.          * 返回times个倍数连接的str
  162.          * @param {String} str 
  163.          * @param {Number} times 
  164.          * @returns multiplied_str
  165.          */
  166.         multiplyStr: function(str, times) {
  167.             let str_list = [];
  168.             for (let i = 0; i < times; i++) {
  169.                 str_list.push(str);
  170.             }
  171.             return str_list.join("");
  172.         },
  173.  
  174.         /**
  175.          * 增强按钮（默认为蓝色按钮：展开文档）的点击效果
  176.          * @param {String} custom_btn 按钮变量名
  177.          */
  178.         enhanceBtnClickReaction: function(custom_btn = null) {
  179.             let aim_btn;
  180.             // 如果不使用自定义按钮元素，则默认为使用蓝色展开文档按钮
  181.             if (!custom_btn || custom_btn === "btn_1") {
  182.                 aim_btn = document.querySelector(".btn-1");
  183.             } else {
  184.                 aim_btn = document.querySelector(`.${custom_btn.replace("_", "-")}`);
  185.             }
  186.  
  187.             let old_color = aim_btn.style.color; // 保存旧的颜色
  188.             let old_text = aim_btn.textContent; // 保存旧的文字内容
  189.             // 变黑缩小
  190.             aim_btn.style.color = "black";
  191.             aim_btn.style.fontWeight = "normal";
  192.             aim_btn.textContent = `->${old_text}<-`;
  193.             // 复原加粗
  194.             let changeColorBack = function() {
  195.                 aim_btn.style.color = old_color;
  196.                 aim_btn.style.fontWeight = "bold";
  197.                 aim_btn.textContent = old_text;
  198.             };
  199.             setTimeout(changeColorBack, 1250);
  200.         },
  201.  
  202.         /**
  203.          * 切换按钮显示/隐藏状态
  204.          * @param {String} aim_btn 按钮变量名
  205.          * @returns 按钮元素的引用
  206.          */
  207.         toggleBtnStatus: function(aim_btn) {
  208.             let btn = document.querySelector(`.${aim_btn.replace("_", "-")}`);
  209.             let display = getComputedStyle(btn).display;
  210.             // return;
  211.             if (display === "none") {
  212.                 btn.style.display = "block";
  213.             } else {
  214.                 btn.style.display = "none";
  215.             }
  216.             return btn;
  217.         },
  218.  
  219.         /**
  220.          * 根据canvas元素数量返回quality值
  221.          * @param {Number} canvas_amount
  222.          * @returns quality: Number
  223.          */
  224.         getQualityByCanvasAmount: function(canvas_amount) {
  225.             let quality;
  226.             if (canvas_amount <= 25) {
  227.                 quality = 1.0;
  228.             } else if (25 < canvas_amount <= 50) {
  229.                 quality = 0.85;
  230.             } else {
  231.                 quality = 0.7;
  232.             }
  233.             return quality;
  234.         },
  235.  
  236.         /**
  237.          * 用input框跳转到对应页码
  238.          * @param {Element} cur_page 当前页码
  239.          * @param {string} aim_page 目标页码
  240.          * @param {string} event_type 键盘事件类型："keyup" | "keypress" | "keydown"
  241.          */
  242.         jump2pageNo: function(cur_page, aim_page, event_type) {
  243.             // 设置跳转页码为目标页码
  244.             cur_page.value = aim_page;
  245.             // 模拟回车事件来跳转
  246.             let keyboard_event_enter = new KeyboardEvent(event_type, {
  247.                 bubbles: true,
  248.                 cancelable: true,
  249.                 keyCode: 13
  250.             });
  251.             cur_page.dispatchEvent(keyboard_event_enter);
  252.         },
  253.  
  254.         /**
  255.          * 滚动到页面底部
  256.          */
  257.         scrollToBottom: function() {
  258.             window.scrollTo({
  259.                 top: document.body.scrollHeight,
  260.                 behavior: "smooth"
  261.             });
  262.         },
  263.  
  264.         /**
  265.          * 用try移除元素
  266.          * @param {Element} element 要移除的元素
  267.          */
  268.         tryToRemoveElement: function(element) {
  269.             try {
  270.                 element.remove();
  271.             } catch (e) {
  272.             }
  273.         },
  274.  
  275.         /**
  276.          * 用try移除 [元素列表1, 元素列表2, ...] 中的元素
  277.          * @param {Array} elem_list_box 要移除的元素列表构成的列表
  278.          */
  279.         tryToRemoveSameElem: function(elem_list_box) {
  280.             for (let elem_list of elem_list_box) {
  281.                 if (!elem_list) {
  282.                     continue;
  283.                 }
  284.                 for (let elem of elem_list) {
  285.                     try {
  286.                         elem.remove();
  287.                     } catch (e) {
  288.                         console.log();
  289.                     }
  290.                 }
  291.             }
  292.         },
  293.  
  294.         /**
  295.          * 使文档在页面上居中
  296.          * @param {String} selector 文档容器的css选择器
  297.          * @param {String} default_offset 文档部分向右偏移的百分比（0-59）
  298.          * @returns 偏移值是否合法
  299.          */
  300.         centerDoc: function(selector, default_offset) {
  301.             let doc_main = document.querySelector(selector);
  302.             let offset = window.prompt("请输入偏移百分位:", default_offset);
  303.             // 如果输入的数字不在 0-59 内，提醒用户重新设置
  304.             if (offset.length === 1 && offset.search(/[0-9]/) !== -1) {
  305.                 doc_main.style.marginLeft = offset + "%";
  306.                 return true;
  307.             } else if (offset.length === 2 && offset.search(/[1-5][0-9]/) !== -1) {
  308.                 doc_main.style.marginLeft = offset + "%";
  309.                 return true
  310.             } else {
  311.                 alert("请输入一个正整数，范围在0至59之间，用来使文档居中\n（不同文档偏移量不同，所以需要手动调整）");
  312.                 return false;
  313.             }
  314.         },
  315.  
  316.         /**
  317.          * 调整按钮内文本
  318.          * @param {String} aim_btn 按钮变量名
  319.          * @param {String} new_text 新的文本，null则保留旧文本
  320.          * @param {Boolean} recommend_btn 是否增加"（推荐）"到按钮文本
  321.          * @param {Boolean} use_hint 是否提示"文档已经完全展开，可以导出"
  322.          */
  323.         modifyBtnText: function(aim_btn = "btn_2", new_text = null, recommend_btn = false, use_hint = true) {
  324.             // 提示文档已经展开
  325.             if (use_hint) {
  326.                 let hint = "文档已经完全展开，可以导出";
  327.                 alert(hint);
  328.             }
  329.             let btn = document.querySelector(`.${aim_btn.replace("_", "-")}`);
  330.             // 要替换的文本
  331.             if (new_text) {
  332.                 btn.textContent = new_text;
  333.             }
  334.             // 推荐按钮
  335.             if (recommend_btn) {
  336.                 btn.textContent += "(推荐)";
  337.             }
  338.         },
  339.  
  340.         /**
  341.          * 将html元素转为canvas再合并到pdf中，最后下载pdf
  342.          * @param {Array} elem_list html元素列表
  343.          * @param {String} title 文档标题
  344.          */
  345.         html2PDF: async function(elem_list, title = "文档") {
  346.             // 如果是空元素列表，返回null并终止函数
  347.             if (elem_list.length === 0) {
  348.                 console.log("html2PDF was called, but no canvas element avaiable.");
  349.                 return null;
  350.             }
  351.             let tasks = []; //  存放异步任务
  352.             let contents = []; //  存放canvas元素
  353.             for (let elem of elem_list) {
  354.                 let task = html2canvas(elem).then((canvas) => {
  355.                     contents.push(canvas);
  356.                 });
  357.                 tasks.push(task);
  358.             }
  359.             // 等待全部page转化完成
  360.             await Promise.all(tasks);
  361.             // 控制台检查结果
  362.             console.log("生成的canvas元素如下：");
  363.             console.log(contents);
  364.  
  365.             // 拿到canvas宽、高：如果第二页存在，就用第二页的宽高，如果不存在就用第一页的
  366.             let model_page = document.querySelector("#pageNo-2") ? document.querySelector("#pageNo-2") : document.querySelector("#pageNo-1");
  367.             let width, height;
  368.             width = model_page.offsetWidth;
  369.             height = model_page.offsetHeight;
  370.             // 打包为pdf
  371.             this.saveCanvasesToPDF(contents, title, width, height);
  372.         },
  373.  
  374.         /**
  375.          * 下载全部图片链接，适用性：爱问共享资料、得力文库
  376.          * @param {string} selector 图形元素的父级元素
  377.          */
  378.         savePicUrls: function(selector) {
  379.             let pages = document.querySelectorAll(selector);
  380.             let pic_urls = [];
  381.  
  382.             for (let elem of pages) {
  383.                 let pic_obj = elem.children[0];
  384.                 let url = pic_obj.src;
  385.                 pic_urls.push(url);
  386.             }
  387.             let content = pic_urls.join("\n");
  388.             // 启动下载
  389.             this.createAndDownloadFile("urls.csv", content);
  390.         },
  391.  
  392.         /**
  393.          * 存储所有canvas图形为png到一个压缩包
  394.          * @param {Array} node_list canvas元素列表
  395.          * @param {String} title 文档标题
  396.          */
  397.         saveCanvasesToZip: function(node_list, title) {
  398.             // canvas元素转为png图像
  399.             // 所有png合并为一个zip压缩包
  400.             let zip = new JSZip();
  401.             let n = node_list.length;
  402.  
  403.             for (let i = 0; i < n; i++) {
  404.                 let canvas = node_list[i];
  405.                 let data_base64 = canvas.toDataURL();
  406.                 let blob = atob(data_base64.split(",")[1]);
  407.                 zip.file(`page-${i+1}.png`, blob, { binary: true });
  408.             }
  409.  
  410.             // 导出zip
  411.             // promise.then(onCompleted, onRejected);
  412.             zip.generateAsync({ type: "blob" }).then(function(content) {
  413.                 // see filesaver.js
  414.                 console.log(content);
  415.                 saveAs(content, `${title}.zip`);
  416.             });
  417.         },
  418.  
  419.         /**
  420.          * 将canvas转为jpeg，然后导出PDF
  421.          * @param {Array} node_list canvas元素列表
  422.          * @param {String} title 文档标题
  423.          */
  424.         saveCanvasesToPDF: function(node_list, title, width = 0, height = 0) {
  425.             // 如果没有手动指定canvas的长宽，则自动检测
  426.             if (!width && !height) {
  427.                 // 先获取第一个canvas用于判断竖向还是横向，以及得到页面长宽
  428.                 let first_canvas = node_list[0];
  429.                 // 如果style的长宽不存在，则直接用canvas的元素长宽
  430.                 let width_str, height_str;
  431.                 if (first_canvas.width && parseInt(first_canvas.width) && parseInt(first_canvas.height)) {
  432.                     [width_str, height_str] = [first_canvas.width, first_canvas.height];
  433.                 } else {
  434.                     [width_str, height_str] = [first_canvas.style.width.replace(/(px)|(rem)|(em)/, ""), first_canvas.style.height.replace(/(px)|(rem)|(em)/, "")];
  435.                 }
  436.                 // jsPDF的第三个参数为format，当自定义时，参数为数字数组。
  437.                 [width, height] = [parseFloat(width_str), parseFloat(height_str)];
  438.             }
  439.             console.log(`canvas数据：宽: ${width}px，高: ${height}px`);
  440.             // 如果文档第一页的宽比长更大，则landscape，否则portrait
  441.             let orientation = width > height ? 'l' : 'p';
  442.             let pdf = new jspdf.jsPDF(orientation, 'px', [height, width]);
  443.  
  444.             // 根据canvas数量确定quality
  445.             let quality = this.getQualityByCanvasAmount(node_list.length);
  446.  
  447.             // 保存每一页文档到每一页pdf
  448.             node_list.forEach(function(canvas, index) {
  449.                 pdf.addImage(canvas.toDataURL("image/jpeg", quality), 'JPEG', 0, 0, width, height);
  450.                 // 如果当前不是文档最后一页，则需要添加下一个空白页
  451.                 if (index !== node_list.length - 1) {
  452.                     pdf.addPage();
  453.                 }
  454.             });
  455.  
  456.             // 导出文件
  457.             pdf.save(`${title}.pdf`);
  458.         },
  459.  
  460.         /**
  461.          * 取得elem的class为class_name的父级元素
  462.          * @param {String} class_name 
  463.          * @param {Element} elem 
  464.          * @param {object} JSobj 默认为window.baiduJS
  465.          */
  466.         getParentByClassName: function(class_name, elem, JSobj) {
  467.             let parent = elem.parentElement;
  468.             let now_name;
  469.             try {
  470.                 now_name = parent.className;
  471.             } catch (e) {
  472.                 // 没有父级元素了，返回null
  473.                 return "no parent node";
  474.             }
  475.             let iterator_count = JSobj.iterator_count;
  476.             if (iterator_count > 9) {
  477.                 // 超过最大迭代次数，认为不存在，返回null
  478.                 JSobj.iterator_count = 0;
  479.                 return "over max iterator counts limit";
  480.             } else {
  481.                 JSobj.iterator_count += 1;
  482.             }
  483.             // 如果类名匹配，返回该节点
  484.             if (now_name.split(" ").includes(class_name)) {
  485.                 iterator_count = 0;
  486.                 return parent;
  487.             }
  488.             return this.getParentByClassName(class_name, parent, JSobj);
  489.         },
  490.  
  491.         /**
  492.          * 将func绑定到window.onscroll，并设置触发频率
  493.          * @param {Function} func scroll的监听函数
  494.          * @param {Object} JSobj 全局对象，至少要有srcoll_count
  495.          * @param {Number} useful_range 有效的触发范围，默认是10。即0-10次时触发函数。
  496.          * @param {Number} wait_range 等待的范围，默认是110。即useful_range-110次不触发函数。
  497.          * @param {String} hint 触发函数后的日志内容，默认为空字符串。
  498.          * @param {Window} inner_window 特定的window对象，主要用于 iframe 情况。JSobj中必须有scrollFunc，在调用后会重新写入scrollFunc。
  499.          */
  500.         scrollFunc: function(func, JSobj, useful_range = 10, wait_range = 110, hint = "", inner_window = null) {
  501.             let new_func = (func, JSobj, useful_range, wait_range, hint) => {
  502.                 JSobj.scroll_count += 1;
  503.  
  504.                 if (JSobj.scroll_count < useful_range) {
  505.                     func();
  506.                     console.log(hint);
  507.                 } else if (JSobj.scroll_count > wait_range) {
  508.                     JSobj.scroll_count = 0;
  509.                 }
  510.             };
  511.             // 如果没有指定的window对象，则使用默认的window
  512.             if (!inner_window) {
  513.                 window.onscroll = () => {
  514.                     new_func(func, JSobj, useful_range, wait_range, hint);
  515.                 };
  516.                 return;
  517.             }
  518.             // 特定的window对象，一般用于iframe，追加scroll监听器
  519.             let scrollFunc = () => {
  520.                 new_func(func, JSobj, useful_range, wait_range, hint);
  521.             };
  522.             JSobj.scrollFunc = scrollFunc;
  523.             inner_window.addEventListener("scroll", scrollFunc, false);
  524.         },
  525.  
  526.         /**
  527.          * 创建5个按钮：展开文档、导出图片、导出PDF、未设定4、未设定5；默认均为隐藏
  528.          */
  529.         createBtns: function() {
  530.             // 创建按钮组
  531.             let section = document.createElement("section");
  532.             section.className = "btns_section";
  533.             section.innerHTML = `
  534.             <p class="logo_tit">Wenku Doc Downloader</p>
  535.             <button class="btn-1" title="请先滑到底部，使内容加载完，防止出现空白页">展开文档 😈</button>
  536.             <button class="btn-2">导出图片 🖼️</button>
  537.             <button class="btn-3">导出PDF 🌼</button>
  538.             <button class="btn-4">未设定4</button>
  539.             <button class="btn-5">未设定5</button>`;
  540.             document.body.appendChild(section);
  541.  
  542.             // 设定样式
  543.             let style = document.createElement("style");
  544.             style.innerHTML = `
  545.             .btns_section{
  546.                 position: fixed;
  547.                 width: 154px;                
  548.                 left: 10px;
  549.                 top: 32%;
  550.                 background: #E7F1FF;
  551.                 border: 2px solid #1676FF;                
  552.                 padding: 0px 0px 10px 0px;
  553.                 font-weight: 600;
  554.                 border-radius: 2px;
  555.                 font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', 'Hiragino Sans GB',
  556.                 'Microsoft YaHei', 'Helvetica Neue', Helvetica, Arial, sans-serif, 'Apple Color Emoji',
  557.                 'Segoe UI Emoji', 'Segoe UI Symbol';
  558.                 z-index: 5000;
  559.             }
  560.             .logo_tit{
  561.                 width: 100%;
  562.                 background: #1676FF;
  563.                 text-align: center;
  564.                 font-size:12px ;
  565.                 color: #E7F1FF;
  566.                 line-height: 40px;
  567.                 height: 40px;
  568.                 margin: 0 0 16px 0;
  569.             }
  570.  
  571.             .btn-1{
  572.                 display: block;
  573.                 width: 128px;
  574.                 height: 28px;
  575.                 background: linear-gradient(180deg, #00E7F7 0%, #FEB800 0.01%, #FF8700 100%);
  576.                 border-radius: 4px;
  577.                 color: #fff;
  578.                 font-size: 12px;
  579.                 border: none;
  580.                 outline: none;
  581.                 margin: 8px auto;
  582.                 font-weight: bold;
  583.                 cursor: pointer;
  584.                 opacity: .9;
  585.             }
  586.             .btn-2{
  587.                 display: none;
  588.                 width: 128px;
  589.                 height: 28px;
  590.                 background: #07C160;
  591.                 border-radius: 4px;
  592.                 color: #fff;
  593.                 font-size: 12px;
  594.                 border: none;
  595.                 outline: none;
  596.                 margin: 8px auto;
  597.                 font-weight: bold;
  598.                 cursor: pointer;
  599.                 opacity: .9;
  600.             }
  601.             .btn-3{
  602.                 display: none;
  603.                 width: 128px;
  604.                 height: 28px;
  605.                 background:#FA5151;
  606.                 border-radius: 4px;
  607.                 color: #fff;
  608.                 font-size: 12px;
  609.                 border: none;
  610.                 outline: none;
  611.                 margin: 8px auto;
  612.                 font-weight: bold;
  613.                 cursor: pointer;
  614.                 opacity: .9;
  615.             }
  616.             .btn-4{
  617.                 display: none;
  618.                 width: 128px;
  619.                 height: 28px;
  620.                 background: #1676FF;
  621.                 border-radius: 4px;
  622.                 color: #fff;
  623.                 font-size: 12px;
  624.                 border: none;
  625.                 outline: none;
  626.                 margin: 8px auto;
  627.                 font-weight: bold;
  628.                 cursor: pointer;
  629.                 opacity: .9;
  630.             }
  631.             .btn-5{
  632.                 display: none;
  633.                 width: 128px;
  634.                 height: 28px;
  635.                 background: #ff6600;
  636.                 border-radius: 4px;
  637.                 color: #fff;
  638.                 font-size: 12px;
  639.                 border: none;
  640.                 outline: none;
  641.                 margin: 8px auto;
  642.                 font-weight: bold;
  643.                 cursor: pointer;
  644.                 opacity: .9;
  645.             }
  646.             .btn-1:hover,.btn-2:hover,.btn-3:hover,.btn-4,.btn-5:hover{ opacity: .8;}
  647.             .btn-1:active,.btn-2:active,.btn-3:active,.btn-4,.btn-5:active{ opacity: 1;}`;
  648.             document.head.appendChild(style);
  649.         }
  650.     };
  651.  
  652.     /**
  653.      * 清理百度文库页面的无关元素
  654.      */
  655.     function clearPage_Baidu() {
  656.         let selectors = [
  657.             "#hd, .aside, .reader-tools-bar-wrap, .sb-con, .bg-opacity",
  658.             ".doc-tag-wrap, .doc-bottom-wrap, .ft, #ft, .crubms-wrap, .banner-ad",
  659.             "#activity-tg, .top-ads-banner-wrap, .reader_ab_test, .tag-tips, .doc-value",
  660.             ".owner-desc-wrap, a[title='全屏显示']"
  661.         ];
  662.         let elem_list = document.querySelectorAll(selectors.join(", "));
  663.         for (let elem of elem_list) {
  664.             utils.tryToRemoveElement(elem);
  665.         }
  666.         let nut_selector = ".fix-searchbar-wrap, #hd";
  667.         utils.forceHide(nut_selector);
  668.         // 去除页面顶部空白
  669.         document.querySelector("#doc").style.paddingTop = "0";
  670.     }
  671.  
  672.  
  673.     /**
  674.      * 判断是否收集完元素，如果没有，则给出提醒
  675.      * @param {Array} msg_list 附加提示信息列表
  676.      * @returns bool 是否完成元素收集/冻结
  677.      */
  678.     function isFinished(msg_list = []) {
  679.         if (!window.baiduJS.finished) {
  680.             let hint = [
  681.                 "仍有内容未加载完，无法使用该功能",
  682.                 "建议从头到尾慢速地再浏览一遍",
  683.                 ...msg_list
  684.             ];
  685.             alert(hint.join("\n"));
  686.             return false;
  687.         }
  688.         return true;
  689.     }
  690.  
  691.  
  692.     /**
  693.      * 提取文字，导出txt。适用于百度文库
  694.      */
  695.     function saveText_Baidu() {
  696.         // 判断是否存在文字元素
  697.         let elems = document.querySelectorAll(".reader-txt-layer");
  698.         if (!elems.length) {
  699.             alert("当前页面没有文字元素\n如果你看到了文字说明它的原文档就是图片，所以提取不到文字");
  700.             return;
  701.         }
  702.         // 判断页面是否加载完成
  703.         if (!isFinished()) {
  704.             return;
  705.         }
  706.         let title = document.title.split("-")[0].trim(); // 取得文档标题
  707.         let page_texts = [];
  708.         for (let elem of window.baiduJS.elems_map.values()) {
  709.             // 取得该页文档下的全部文字
  710.             let text = elem.textContent;
  711.             page_texts.push(text);
  712.         }
  713.         utils.createAndDownloadFile(`${title}.txt`, page_texts.join("\n"));
  714.     }
  715.  
  716.  
  717.     /**
  718.      * 动态存储".ppt-image-wrap img"图形，并导出urls
  719.      * @returns
  720.      */
  721.     function savePicUrls_Baidu() {
  722.         let urls = [];
  723.         let elems = document.querySelectorAll(".ppt-image-wrap img");
  724.         if (!elems.length) {
  725.             alert("当前页面没有PPT图形");
  726.             return;
  727.         }
  728.         elems.forEach((elem) => {
  729.             if (elem.hasAttribute("src")) {
  730.                 urls.push(elem.src);
  731.             } else {
  732.                 urls.push(elem.getAttribute("data-src"));
  733.             }
  734.         });
  735.         utils.createAndDownloadFile("urls.csv", urls.join("\n"));
  736.     }
  737.  
  738.  
  739.     /**
  740.      * 动态存储".reader-pic-item"图形，并导出urls
  741.      * @returns 
  742.      */
  743.     function savePicUrls_BaiduNonPPT() {
  744.         // 判断是否存在非PPT图形元素
  745.         let elems = document.querySelectorAll(".reader-pic-item");
  746.         if (!elems.length) {
  747.             alert("当前页面没有非PPT图形");
  748.             return;
  749.         }
  750.         // 判断是否页面都加载完成
  751.         if (!isFinished()) {
  752.             return;
  753.         }
  754.         // 找到img元素，导出urls
  755.         let img_urls = [];
  756.         for (let elem of window.baiduJS.elems_map.values()) {
  757.             // 取得img元素
  758.             elem.querySelectorAll(".reader-pic-item").forEach((img) => {
  759.                 // 取得img链接
  760.                 let url = img.style.backgroundImage.split('"')[1];
  761.                 img_urls.push(url);
  762.             });
  763.         }
  764.         utils.createAndDownloadFile("urls.csv", img_urls.join("\n"));
  765.     }
  766.  
  767.  
  768.     /**
  769.      * 找出没有收录的id，需求的id列表形如：["pageNo-4", "pageNo-5", ...]
  770.      * @returns 未收录的id_list: [1, 2, 3, ...]
  771.      */
  772.     function getUnfrozen() {
  773.         // 获取已经冻结的文档元素
  774.         let _frozen_ids = new Set(window.baiduJS.elems);
  775.         let frozen_ids = new Set();
  776.         _frozen_ids.forEach((full_id) => {
  777.             // full_id: pageNo-1
  778.             let id = parseInt(full_id.split("-")[1]);
  779.             frozen_ids.add(id);
  780.         });
  781.  
  782.         if (!frozen_ids.size) {
  783.             return ["all pages"];
  784.         }
  785.  
  786.         // 取得基础页码
  787.         let a_id = utils.setPop(frozen_ids);
  788.         let basis = parseInt(a_id / 50) * 50;
  789.         // 获取全部文档元素
  790.         let all_ids = new Set();
  791.         let all_elems = document.querySelectorAll(".mod.reader-page.complex[class*=reader-page]");
  792.         all_elems.forEach((elem) => {
  793.             // ['mod', 'reader-page', 'complex', 'hidden-doc-banner', 'reader-page-1'] -> "1" -> 1
  794.             let id = parseInt(elem.className.split(" ").at(-1).split("-")[2]);
  795.             all_ids.add(basis + id);
  796.         });
  797.  
  798.         // 求差集，取得未冻结的
  799.         let unfrozen_set = utils.difference(all_ids, frozen_ids);
  800.         let unfrozen_list = Array.from(unfrozen_set);
  801.         unfrozen_list.sort((prev, next) => { return prev - next; });
  802.         // 打印日志
  803.         console.log([
  804.             `all_ids: ${Array.from(all_ids)}`,
  805.             `frozen_ids: ${Array.from(frozen_ids)}`,
  806.             `unfrozen_list: ${unfrozen_list}`
  807.         ].join("\n"));
  808.         return unfrozen_list;
  809.     }
  810.  
  811.  
  812.     /**
  813.      * 适用于【带有api=1】get参数的页面。可以打印页面。
  814.      * @returns 
  815.      */
  816.     function printPage_Baidu() {
  817.         // 判断是否页面都加载完成
  818.         let msg_list = [
  819.             "未加载的页面如下：",
  820.             getUnfrozen().join(", ")
  821.         ];
  822.         if (!isFinished(msg_list)) {
  823.             return;
  824.         }
  825.         let next50pages = document.querySelector(".pageList-btn.next-pageList");
  826.         utils.tryToRemoveElement(next50pages);
  827.         utils.hideBtnThenPrint();
  828.     }
  829.  
  830.  
  831.     /**
  832.      * 适用于【*不*带有api=1】get参数的页面。可以打印页面。
  833.      * @returns 
  834.      */
  835.     function printPage_BaiduNoArgs() {
  836.         // 判断是否页面都加载完成
  837.         let msg_list = [
  838.             "未加载的页面如下：",
  839.             getUnfrozen().join(", ")
  840.         ];
  841.         if (!isFinished(msg_list)) {
  842.             return;
  843.         }
  844.         // 清理页面
  845.         clearPage_Baidu();
  846.         // 隐藏上下页按钮
  847.         document.querySelectorAll("a[data-next-page], a[data-prev-page]").forEach((elem) => {
  848.             elem.setAttribute("style", "display: none !important;");
  849.         });
  850.         // 打印
  851.         utils.hideBtnThenPrint();
  852.         // 显示上下页按钮
  853.         document.querySelectorAll("a[data-next-page], a[data-prev-page]").forEach((elem) => {
  854.             elem.style.display = "block";
  855.         });
  856.     }
  857.  
  858.  
  859.     /**
  860.      * 调整页间距为 width px
  861.      * @param {Number} width 页间距
  862.      */
  863.     function adjustSpace(width) {
  864.         // 调整页间距
  865.         let space_selector = ".reader-container .reader-page, .reader-container .pay-page-mod";
  866.         document.querySelectorAll(space_selector).forEach((space) => {
  867.             space.style.margin = `0 0 ${width}px`;
  868.         });
  869.         console.log(`页间距已经调整为：${width}px`);
  870.     }
  871.  
  872.  
  873.     function userAdjustSpace() {
  874.         let space_selector = ".reader-container .reader-page, .reader-container .pay-page-mod";
  875.         let space = document.querySelector(space_selector);
  876.         let old_width = getComputedStyle(space).marginBottom;
  877.         let width_str = prompt(`当前页间距为：${old_width}\n请输入调整后的页间距(0-500的整数)：`);
  878.         let width = parseInt(width_str);
  879.         width = Number.isInteger(width) && (0 <= width <= 500) ? width : parseInt(old_width);
  880.         adjustSpace(width);
  881.         console.log(`调整后的页间距为：${width}px`);
  882.     }
  883.  
  884.  
  885.     /**
  886.      * 根据键中的id数字对map排序
  887.      * @param {Map} elems_map 
  888.      * @returns sorted_map
  889.      */
  890.     function sortMapByID$2(elems_map) {
  891.         // id形式：pageNo-10
  892.         let elems_arr = Array.from(elems_map);
  893.         elems_arr.sort((item1, item2) => {
  894.             // 从key中取出id
  895.             let id1 = parseInt(item1[0].split("-")[1]);
  896.             let id2 = parseInt(item2[0].split("-")[1]);
  897.             // 升序排序
  898.             return id1 - id2;
  899.         });
  900.         // 返回排序好的map
  901.         return new Map(elems_arr);
  902.     }
  903.  
  904.  
  905.     /**
  906.      * 存储html元素。适用于百度文库的文字型文档
  907.      */
  908.     function storeHtmlElemts_Baidu(selector = "[class*=reader-main]") {
  909.         let elems_map = window.baiduJS.elems_map;
  910.         document.querySelectorAll(selector).forEach(
  911.             (elem) => {
  912.                 let origin_page_elem = utils.getParentByClassName("bd", elem, window.baiduJS);
  913.                 if (typeof(origin_page_elem) === "string") {
  914.                     return;
  915.                 }
  916.                 // 复制元素防止丢失
  917.                 let page_elem = origin_page_elem.cloneNode(true);
  918.                 // 移除data标签，切断vue对数据的渲染控制
  919.                 page_elem.removeAttribute("data-page-no");
  920.                 let id = page_elem.id; // id的形式：pageNo-10
  921.                 if (!elems_map.has(id)) {
  922.                     elems_map.set(id, page_elem);
  923.                 }
  924.             });
  925.         if (elems_map.size === window.baiduJS.max_page) {
  926.             // 根据id排序，保证导出的图片链接不是乱序的
  927.             window.baiduJS.elems_map = sortMapByID$2(window.baiduJS.elems_map);
  928.             // 已经保存完全部文档页元素，移除滚动事件的绑定函数
  929.             window.baiduJS.finished = true;
  930.             window.onscroll = () => { };
  931.         }
  932.     }
  933.  
  934.  
  935.     /**
  936.      * 移除html元素上的data标签，切断vue的数据渲染控制。适用于百度文库的文字型文档
  937.      * @param {String} selector 要移除 data-page-no属性 的元素选择器
  938.      */
  939.     function freezeHtmlElemts_Baidu(selector = "[class*=reader-main]") {
  940.         let elems = window.baiduJS.elems;
  941.         document.querySelectorAll(selector).forEach(
  942.             (elem) => {
  943.                 let page_elem = utils.getParentByClassName("bd", elem, window.baiduJS);
  944.                 if (typeof(page_elem) === "string") {
  945.                     return;
  946.                 }
  947.                 // 移除data标签，切断vue对数据的渲染控制
  948.                 page_elem.removeAttribute("data-page-no");
  949.                 // 存储已经冻结的元素id
  950.                 let id = page_elem.id; // id的形式：pageNo-10
  951.                 if (!elems.includes(id)) {
  952.                     elems.push(id);
  953.                 }
  954.             });
  955.         if (elems.length === window.baiduJS.max_page) {
  956.             // 已经冻结完全部文档页元素，移除滚动事件的绑定函数
  957.             window.baiduJS.finished = true;
  958.             window.onscroll = () => { };
  959.         }
  960.     }
  961.  
  962.  
  963.     /**
  964.      * 递归的展开百度文档，适用于旧版页面。
  965.      * @param {Function} extra_task 在文档展开完成后执行的追加函数
  966.      * @returns 
  967.      */
  968.     function readMoreRecursively(extra_task = () => { }) {
  969.         let go_more = document.querySelector("#html-reader-go-more");
  970.         if (!go_more || go_more.style.display === "none") {
  971.             // 如果不存在继续阅读按钮，或隐藏显示，则认为完成了展开
  972.             console.log("wk: 文档展开完成");
  973.             extra_task();
  974.             return;
  975.         }
  976.         let read_more = go_more.querySelector(".moreBtn.goBtn");
  977.         read_more.click();
  978.         console.log("wk: 展开文档");
  979.         setTimeout(readMoreRecursively, 500);
  980.     }
  981.  
  982.  
  983.     /**
  984.      * 统计文档页的数量
  985.      * @param {String} selector 文档页元素选择器
  986.      * @returns 文档页的数量
  987.      */
  988.     function countPages$1(selector = ".mod.reader-page.complex[class*=reader-page]") {
  989.         let all_elems = document.querySelectorAll(selector);
  990.         return all_elems.length;
  991.     }
  992.  
  993.  
  994.     function baiduWenku_OldVer() {
  995.         // 为导出内容提供全局变量，便于动态收集文档页元素的存取
  996.         let real_max_page;
  997.         try {
  998.             real_max_page = parseInt(document.querySelector(".page-count").textContent.replace("/", ""));
  999.         } catch (e) {
  1000.             real_max_page = countPages$1();
  1001.         }
  1002.  
  1003.         window.baiduJS = {
  1004.             max_page: countPages$1(), // 当前文档页面数量
  1005.             real_max_page: real_max_page, // 当前文档的总页数
  1006.             iterator_count: 0, // getParentByClassName的最大迭代次数为9
  1007.             finished: false, // 是否收集完了全部文档页元素
  1008.             scroll_count: 0, // 用于统计累计触发scroll的次数
  1009.             elems: [], // 存储已经冻结的元素id
  1010.             elems_map: new Map() // id: element
  1011.         };
  1012.  
  1013.         if (location.href.includes("?share_api=1&width=800")) {
  1014.             // 带分享参数的页面，适用于word和excel
  1015.  
  1016.             // 跟随浏览，动态冻结页面元素
  1017.             utils.scrollFunc(freezeHtmlElemts_Baidu, window.baiduJS, 10, 50, "baidu元素: 冻结");
  1018.  
  1019.             // 隐藏按钮
  1020.             utils.toggleBtnStatus("btn_1");
  1021.             // 显示按钮
  1022.             utils.toggleBtnStatus("btn_2");
  1023.             utils.toggleBtnStatus("btn_3");
  1024.             // 绑定事件到按钮
  1025.             // 按钮2：调整页间距
  1026.             utils.setBtnEvent(userAdjustSpace, [], "btn_2", "调整页间距");
  1027.             // 按钮3：打印页面到PDF
  1028.             utils.setBtnEvent(printPage_Baidu, [], "btn_3", "打印页面到PDF");
  1029.  
  1030.         } else if (location.href.includes("\u002f\u0073\u0068\u0061\u0072\u0065\u002f")) {
  1031.             // old version for fetch doc elements
  1032.             // 跟随浏览，动态收集页面元素
  1033.             utils.scrollFunc(storeHtmlElemts_Baidu, window.baiduJS, 10, 50, "baidu元素: 收集");
  1034.  
  1035.             // 隐藏按钮
  1036.             utils.toggleBtnStatus("btn_1");
  1037.             // 显示按钮
  1038.             utils.toggleBtnStatus("btn_2");
  1039.             utils.toggleBtnStatus("btn_3");
  1040.             utils.toggleBtnStatus("btn_4");
  1041.             utils.toggleBtnStatus("btn_5");
  1042.             // 绑定事件到按钮
  1043.             utils.setBtnEvent(saveText_Baidu, [], "btn_3", "导出纯文本");
  1044.             utils.setBtnEvent(savePicUrls_Baidu, [], "btn_4", "导出图片链接(仅PPT)");
  1045.             utils.setBtnEvent(savePicUrls_BaiduNonPPT, [], "btn_5", "导出图片链接(除PPT)");
  1046.             // btn_2
  1047.             utils.setBtnEvent(() => {
  1048.                 if (confirm("仅对excel和word文档有效，是否继续？")) {
  1049.                     // 在无参数的旧版页面处理超过50页的文档
  1050.                     // 跟随浏览，动态冻结页面元素
  1051.                     window.baiduJS.finished = false;
  1052.                     utils.scrollFunc(freezeHtmlElemts_Baidu, window.baiduJS, 10, 50, "baidu元素: 冻结");
  1053.                     // 重新绑定按钮监听器
  1054.                     utils.setBtnEvent(userAdjustSpace, [], "btn_4", "调整页间距");
  1055.                     utils.setBtnEvent(printPage_BaiduNoArgs, [], "btn_3", "打印页面到PDF◈");
  1056.                     alert("正在截获文档内容，请上下浏览页面后再次点击该按钮");
  1057.  
  1058.                     // 隐藏按钮
  1059.                     utils.toggleBtnStatus("btn_2");
  1060.                     utils.toggleBtnStatus("btn_5");
  1061.                 }
  1062.             }, [], "btn_2", "打印页面到PDF");
  1063.         } else {
  1064.             console.log(`无法识别的页面：${location.href}`);
  1065.         }
  1066.     }
  1067.  
  1068.  
  1069.     /**
  1070.      * 百度文档下载策略
  1071.      */
  1072.     function baiduWenku() {
  1073.         // 允许打印页面
  1074.         utils.allowPrint();
  1075.         // 原文档解析到预览文档
  1076.         if (location.href.includes("\u002f\u0076\u0069\u0065\u0077\u002f")) {
  1077.             utils.createBtns();
  1078.             let jump2sharePage_Baidu = function() {
  1079.                 location.href = `https://${location.host}${location.pathname.replace("\u0076\u0069\u0065\u0077", "\u0073\u0068\u0061\u0072\u0065")}`;
  1080.             };
  1081.             utils.setBtnEvent(jump2sharePage_Baidu, [], "btn_1");
  1082.         } else {
  1083.             // 在完全展开文档后启用旧版页面处理函数
  1084.             // 创建按钮组
  1085.             console.log("\n\nwk: 进入旧版页面\n\n\n");
  1086.             utils.createBtns();
  1087.             utils.setBtnEvent(readMoreRecursively, [baiduWenku_OldVer], "btn_1");
  1088.         }
  1089.     }
  1090.  
  1091.     /**
  1092.      * 展开道客巴巴的文档
  1093.      */
  1094.     function readAllDoc88() {
  1095.         // 获取“继续阅读”按钮
  1096.         let continue_btn = document.querySelector("#continueButton");
  1097.         // 如果存在“继续阅读”按钮
  1098.         if (continue_btn) {
  1099.             // 跳转到文末（等同于展开全文）
  1100.             let cur_page = document.querySelector("#pageNumInput");
  1101.             // 取得最大页码
  1102.             let page_max = cur_page.parentElement.textContent.replace(" / ", "");
  1103.             // 跳转到尾页
  1104.             utils.jump2pageNo(cur_page, page_max, "keypress");
  1105.             // 返回顶部
  1106.             setTimeout(utils.jump2pageNo(cur_page, "1", "keypress"), 1000);
  1107.         }
  1108.         // 文档展开后，显示按钮2、3
  1109.         else {
  1110.             // 隐藏按钮
  1111.             utils.toggleBtnStatus("btn_1");
  1112.             // 显示按钮
  1113.             utils.toggleBtnStatus("btn_2");
  1114.             utils.toggleBtnStatus("btn_3");
  1115.         }
  1116.     }
  1117.  
  1118.     /**
  1119.      * 道客巴巴文档下载策略
  1120.      */
  1121.     function doc88() {
  1122.         // 创建脚本启动按钮1、2
  1123.         utils.createBtns();
  1124.  
  1125.         // 绑定主函数
  1126.         let prepare = function() {
  1127.             // 获取canvas元素列表
  1128.             let node_list = document.querySelectorAll(".inner_page");
  1129.             // 获取文档标题
  1130.             let title;
  1131.             if (document.querySelector(".doctopic h1")) {
  1132.                 title = document.querySelector(".doctopic h1").title;
  1133.             } else {
  1134.                 title = "文档";
  1135.             }
  1136.             return [node_list, title];
  1137.         };
  1138.  
  1139.         // btn_1: 展开文档
  1140.         utils.setBtnEvent(() => {
  1141.             readAllDoc88();
  1142.         }, [], "btn_1");
  1143.         // btn_2: 导出zip
  1144.         utils.setBtnEvent(() => {
  1145.             if (confirm("确定每页内容都加载完成了吗？")) {
  1146.                 utils.saveCanvasesToZip(...prepare());
  1147.             }
  1148.         }, [], "btn_2", "导出图片到zip");
  1149.         // btn_3: 导出PDF
  1150.         utils.setBtnEvent(() => {
  1151.             if (confirm("确定每页内容都加载完成了吗？")) {
  1152.                 utils.saveCanvasesToPDF(...prepare());
  1153.             }
  1154.         }, [], "btn_3", "导出图片到PDF");
  1155.     }
  1156.  
  1157.     // 绑定主函数
  1158.     function getCanvasList() {
  1159.         // 获取全部canvas元素，用于传递canvas元素列表给 btn_2 和 btn_3
  1160.         let parent_node_list = document.querySelectorAll(".hkswf-content");
  1161.         let node_list = [];
  1162.         for (let node of parent_node_list) {
  1163.             node_list.push(node.children[0]);
  1164.         }
  1165.         return node_list;
  1166.     }
  1167.  
  1168.  
  1169.     function prepare() {
  1170.         // 获取canvas元素列表
  1171.         let node_list = getCanvasList();
  1172.         // 获取文档标题
  1173.         let title;
  1174.         if (document.querySelector("h1 [title=doc]")) {
  1175.             title = document.querySelector("h1 [title=doc]").nextElementSibling.textContent;
  1176.         } else if (document.querySelector(".doc_title")) {
  1177.             title = document.querySelector(".doc_title").textContent;
  1178.         } else {
  1179.             title = "文档";
  1180.         }
  1181.         return [node_list, title];
  1182.     }
  1183.  
  1184.  
  1185.     // 判断是否有canvas元素
  1186.     function detectCanvas() {
  1187.         let haveCanvas = getCanvasList().length === 0 ? false : true;
  1188.  
  1189.         // 隐藏按钮
  1190.         utils.toggleBtnStatus("btn_1");
  1191.         // 显示按钮
  1192.         utils.toggleBtnStatus("btn_2");
  1193.  
  1194.         // 如果没有canvas元素，则认为文档页面由外链图片构成
  1195.         if (!haveCanvas) {
  1196.             // btn_2: 导出图片链接
  1197.             utils.setBtnEvent(() => {
  1198.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1199.                     utils.savePicUrls("[id*=img_]");
  1200.                 }
  1201.             }, [], "btn_2", "导出全部图片链接");
  1202.         } else {
  1203.             // 显示按钮3
  1204.             utils.toggleBtnStatus("btn_3");
  1205.             // btn_2: 导出zip
  1206.             utils.setBtnEvent(() => {
  1207.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1208.                     utils.saveCanvasesToZip(...prepare());
  1209.                 }
  1210.             }, [], "btn_2", "导出图片到zip");
  1211.             // btn_3: 导出PDF
  1212.             utils.setBtnEvent(() => {
  1213.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1214.                     utils.saveCanvasesToPDF(...prepare());
  1215.                 }
  1216.             }, [], "btn_3", "导出图片到PDF");
  1217.         }
  1218.     }
  1219.  
  1220.  
  1221.     /**
  1222.      * 豆丁文档下载策略
  1223.      */
  1224.     function docin() {
  1225.         // 创建脚本启动按钮
  1226.         utils.createBtns();
  1227.  
  1228.         // 隐藏底部工具栏
  1229.         document.querySelector("#j_select").click(); // 选择指针
  1230.         let tool_bar = document.querySelector(".reader_tools_bar_wrap.tools_bar_small.clear");
  1231.         tool_bar.style.display = "none";
  1232.  
  1233.         // btn_1: 判断文档类型
  1234.         utils.setBtnEvent(() => {
  1235.             utils.forceHide(".jz_watermark");
  1236.             detectCanvas();
  1237.         }, [], "btn_1", "判断文档类型");
  1238.     }
  1239.  
  1240.     /**
  1241.      * 点击“展开继续阅读”，适用性：爱尚共享资料
  1242.      */
  1243.     function readAlliShare() {
  1244.         // 获取“继续阅读”元素
  1245.         let red_btn = document.getElementsByClassName("red-color")[0];
  1246.         let red_text = red_btn.textContent;
  1247.         // 如果可以展开，则展开
  1248.         if (red_text.search("点击可继续阅读") !== -1) {
  1249.             red_btn.click();
  1250.             setTimeout(readAlliShare, 1000);
  1251.         }
  1252.         // 否则启动按钮2，准备清理页面然后打印为PDF
  1253.         else {
  1254.             // 隐藏按钮
  1255.             utils.toggleBtnStatus("btn_1");
  1256.             // 显示按钮
  1257.             utils.toggleBtnStatus("btn_2");
  1258.             utils.toggleBtnStatus("btn_3");
  1259.  
  1260.             // 显示svg图片的链接
  1261.             let page1 = document.querySelector('[data-num="1"] .data-detail embed');
  1262.             if (!page1) {
  1263.                 // 如果不存在svg图形，终止后续代码
  1264.                 console.log("当前页面不存在svg图形");
  1265.                 return;
  1266.             }
  1267.             let page2 = document.querySelector('[data-num="2"] .data-detail embed');
  1268.             let [svg1_src_div, svg2_src_div] = [document.createElement("div"), document.createElement("div")];
  1269.             svg1_src_div.innerHTML = `<div id="src-1"
  1270.                                     style="font-weight: bold;font-size: 20px; height: 100px; width: 100%">
  1271.                                         访问以下链接以复制文字:<br>${page1.src}
  1272.                                     </div>`;
  1273.             svg2_src_div.innerHTML = `<div id="src-1"
  1274.                                     style="font-weight: bold;font-size: 20px; height: 100px; width: 100%">
  1275.                                     访问以下链接以复制文字:<br>${page2.src}
  1276.                                     </div>`;
  1277.             // 添加到页面上
  1278.             page1.parentElement.parentElement.parentElement.append(svg1_src_div);
  1279.             page2.parentElement.parentElement.parentElement.append(svg2_src_div);
  1280.         }
  1281.     }
  1282.  
  1283.  
  1284.     /**
  1285.      * 清理并打印爱问共享资料的文档页
  1286.      * @returns 如果输入偏移量非法，返回空值以终止函数
  1287.      */
  1288.     function printPageiShare() {
  1289.         // # 清理并打印爱问共享资料的文档页
  1290.         // ## 移除页面上无关的元素
  1291.         // ### 移除单个元素
  1292.         let topbanner = document.getElementsByClassName("detail-topbanner")[0];
  1293.         let header = document.getElementsByClassName("new-detail-header")[0];
  1294.         let fixright = document.getElementById("fix-right");
  1295.         let redpacket = document.getElementsByClassName("loginRedPacket-dialog")[0];
  1296.         let fixedrightfull = document.getElementsByClassName("fixed-right-full")[0];
  1297.         let footer = document.getElementsByClassName("website-footer")[0];
  1298.         let guess = document.getElementsByClassName("guess-you-like-warpper")[0];
  1299.         let detailtopbox = document.getElementsByClassName("detail-top-box")[0];
  1300.         let fullscreen = document.getElementsByClassName("reader-fullScreen")[0];
  1301.         let endhint = document.getElementsByClassName("endof-trial-reading")[0];
  1302.         let crumb_arrow;
  1303.         try { crumb_arrow = document.getElementsByClassName("crumb-arrow")[0].parentElement; } catch (e) { console.log(); }
  1304.         let copyright = document.getElementsByClassName("copyright-container")[0];
  1305.         let state_btn = document.getElementsByClassName("state-bottom")[0];
  1306.         let comments = document.getElementsByClassName("user-comments-wrapper")[0];
  1307.         // ### 执行移除
  1308.         let elem_list = [
  1309.             topbanner,
  1310.             header,
  1311.             fixright,
  1312.             redpacket,
  1313.             fixedrightfull,
  1314.             footer,
  1315.             guess,
  1316.             detailtopbox,
  1317.             fullscreen,
  1318.             endhint,
  1319.             crumb_arrow,
  1320.             copyright,
  1321.             state_btn,
  1322.             comments
  1323.         ];
  1324.         for (let elem of elem_list) {
  1325.             utils.tryToRemoveElement(elem);
  1326.         }
  1327.         // ### 移除全部同类元素
  1328.         let elem_list_2 = document.querySelectorAll(".tui-detail, .adv-container");
  1329.         for (let elem_2 of elem_list_2) {
  1330.             utils.tryToRemoveElement(elem_2);
  1331.         }
  1332.         // 使文档居中
  1333.         alert("建议使用:\n偏移量: 18\n缩放: 默认\n如果预览中有广告，就取消打印\n再点一次按钮，预览中应该就没有广告了");
  1334.         if (!utils.centerDoc("doc-main", "18")) {
  1335.             return; // 如果输入非法，终止函数调用
  1336.         }
  1337.         // 隐藏按钮，然后打印页面
  1338.         utils.hideBtnThenPrint();
  1339.     }
  1340.  
  1341.  
  1342.     /**
  1343.      * 爱问共享资料文档下载策略
  1344.      */
  1345.     function ishare() {
  1346.         // 创建脚本启动按钮1、2
  1347.         utils.createBtns();
  1348.  
  1349.         // btn_1: 展开文档
  1350.         utils.setBtnEvent(readAlliShare, [], "btn_1");
  1351.         // btn_2: 导出图片链接
  1352.         utils.setBtnEvent(() => {
  1353.             utils.savePicUrls(".data-detail");
  1354.         }, [], "btn_2", "导出图片链接（推荐）");
  1355.         // btn_3: 打印页面到PDF
  1356.         utils.setBtnEvent(printPageiShare, [], "btn_3", "打印页面到PDF");
  1357.  
  1358.         // 移除底部下载条
  1359.         let detailfixed = document.getElementsByClassName("detail-fixed")[0];
  1360.         utils.tryToRemoveElement(detailfixed);
  1361.     }
  1362.  
  1363.     /**
  1364.      * 清理并打印得力文库的文档页
  1365.      */
  1366.     function printPageDeliwenku() {
  1367.         // 移除页面上的无关元素
  1368.         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";
  1369.         let elem_list = document.querySelectorAll(selector);
  1370.         for (let elem of elem_list) {
  1371.             utils.tryToRemoveElement(elem);
  1372.         }
  1373.         // 修改页间距
  1374.         let outer_pages = document.getElementsByClassName("outer_page");
  1375.         for (let page of outer_pages) {
  1376.             page.style.marginBottom = "20px";
  1377.         }
  1378.         // 使文档居中
  1379.         alert("建议使用:\n偏移量: 3\n缩放: 112\n请上下滚动页面，确保每页内容都加载完成以避免空白页\n如果预览时有空白页或文末有绿色按钮，请取消打印重试");
  1380.         if (!utils.centerDoc("#boxleft", "3")) {
  1381.             return; // 如果输入非法，终止函数调用
  1382.         }
  1383.         // 打印文档
  1384.         utils.hideBtnThenPrint();
  1385.     }
  1386.  
  1387.  
  1388.     /**
  1389.      * 点击“继续阅读”，适用性：得力文库
  1390.      */
  1391.     function readAllDeliwenku() {
  1392.         // 点击“同意并开始预览全文”
  1393.         let start_btn = document.getElementsByClassName("pre_button")[0];
  1394.         let display = start_btn.parentElement.parentElement.style.display;
  1395.         // 如果该按钮显示着，则点击，然后滚动至页面底部，最后终止函数
  1396.         if (!display) {
  1397.             start_btn.children[0].click();
  1398.             setTimeout("scroll(0, document.body.scrollHeight)", 200);
  1399.             return;
  1400.         }
  1401.         // 增强按钮点击效果
  1402.         utils.enhanceBtnClickReaction();
  1403.  
  1404.         let read_all_btn = document.getElementsByClassName("fc2e")[0];
  1405.         let display2 = read_all_btn.parentElement.parentElement.style.display;
  1406.             // 继续阅读
  1407.         if (display2 !== "none") {
  1408.             // 获取input元素
  1409.             let cur_page = document.querySelector("#pageNumInput");
  1410.             let page_old = cur_page.value;
  1411.             let page_max = cur_page.parentElement.nextElementSibling.textContent.replace(" / ", "");
  1412.             // 跳转到尾页
  1413.             utils.jump2pageNo(cur_page, page_max, "keydown");
  1414.             // 跳转回来
  1415.             utils.jump2pageNo(cur_page, page_old, "keydown");
  1416.  
  1417.             // 切换按钮准备导出
  1418.         } else {
  1419.             // 推荐导出图片链接
  1420.             utils.modifyBtnText("btn_2", null, true);
  1421.             // 隐藏按钮
  1422.             utils.toggleBtnStatus("btn_1");
  1423.             // 显示按钮
  1424.             utils.toggleBtnStatus("btn_2");
  1425.             utils.toggleBtnStatus("btn_3");
  1426.             // btn_3 橙色按钮
  1427.             utils.setBtnEvent(printPageDeliwenku, [], "btn_3", "打印页面到PDF");
  1428.         }
  1429.     }
  1430.  
  1431.  
  1432.     /**
  1433.      * 得力文库文档下载策略
  1434.      */
  1435.     function deliwenku() {
  1436.         // 创建脚本启动按钮1、2
  1437.         utils.createBtns();
  1438.  
  1439.         // btn_1: 展开文档
  1440.         utils.setBtnEvent(readAllDeliwenku, [], "btn_1");
  1441.         // btn_2: 导出图片链接
  1442.         utils.setBtnEvent(() => {
  1443.             if (confirm("确定每页内容都加载完成了吗？")) {
  1444.                 utils.savePicUrls('.inner_page div');
  1445.             }
  1446.         }, [], "btn_2", "导出图片链接");
  1447.  
  1448.         // 尝试关闭页面弹窗
  1449.         try { document.querySelector("div[title=点击关闭]").click(); } catch (e) { console.log(0); }
  1450.         // 解除打印限制
  1451.         utils.allowPrint();
  1452.     }
  1453.  
  1454.     function readAll360Doc() {
  1455.         // 展开文档
  1456.         document.querySelector(".articleMaxH").setAttribute("class", "");
  1457.         // 隐藏按钮
  1458.         utils.toggleBtnStatus("btn_1");
  1459.         // 显示按钮
  1460.         utils.toggleBtnStatus("btn_2");
  1461.         utils.toggleBtnStatus("btn_3");
  1462.     }
  1463.  
  1464.  
  1465.     function saveText_360Doc() {
  1466.         // 捕获图片链接
  1467.         let images = document.querySelectorAll("#artContent img");
  1468.         let content = [];
  1469.  
  1470.         for (let i = 0; i < images.length; i++) {
  1471.             let src = images[i].src;
  1472.             content.push(`图${i+1}，链接：${src}`);
  1473.         }
  1474.         // 捕获文本
  1475.         let text = document.querySelector("#artContent").textContent;
  1476.         content.push(text);
  1477.  
  1478.         // 保存纯文本文档
  1479.         let title = document.querySelector("#titiletext").textContent;
  1480.         utils.createAndDownloadFile(`${title}.txt`, content.join("\n"));
  1481.     }
  1482.  
  1483.  
  1484.     function printPage360Doc() {
  1485.         // # 清理并打印360doc的文档页
  1486.         // ## 移除页面上无关的元素
  1487.         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";
  1488.         let elem_list = document.querySelectorAll(selector);
  1489.         let under_doc_1, under_doc_2;
  1490.         try {
  1491.             under_doc_1 = document.querySelector("#bgchange p.clearboth").nextElementSibling;
  1492.             under_doc_2 = document.querySelector("#bgchange").nextElementSibling.nextElementSibling;
  1493.         } catch (e) { console.log(); }
  1494.         // 执行移除
  1495.         for (let elem of elem_list) {
  1496.             utils.tryToRemoveElement(elem);
  1497.         }
  1498.         utils.tryToRemoveElement(under_doc_1);
  1499.         utils.tryToRemoveElement(under_doc_2);
  1500.         // 执行隐藏
  1501.         document.querySelector("a[title]").style.display = "none";
  1502.  
  1503.         // 使文档居中
  1504.         alert("建议使用:\n偏移量: 20\n缩放: 默认\n");
  1505.         if (!utils.centerDoc(".a_left", "20")) {
  1506.             return; // 如果输入非法，终止函数调用
  1507.         }
  1508.         // 隐藏按钮，然后打印页面
  1509.         utils.hideBtnThenPrint();
  1510.     }
  1511.  
  1512.  
  1513.     /**
  1514.      * 360doc个人图书馆下载策略
  1515.      */
  1516.     function doc360() {
  1517.         // 创建按钮区
  1518.         utils.createBtns();
  1519.         // btn_1: 展开文档
  1520.         utils.setBtnEvent(readAll360Doc, [], "btn_1");
  1521.         // btn_2: 导出纯文本
  1522.         utils.setBtnEvent(saveText_360Doc, [], "btn_2", "导出纯文本");
  1523.         // btn_3: 打印页面到PDF
  1524.         utils.setBtnEvent(() => {
  1525.             if (confirm("确定每页内容都加载完成了吗？")) {
  1526.                 printPage360Doc();
  1527.             }
  1528.         }, [], "btn_3", "打印页面到PDF");
  1529.     }
  1530.  
  1531.     /**
  1532.      * 查找出所有未被捕获的页码，并返回列表
  1533.      * @returns 未捕获页码列表
  1534.      */
  1535.     function getMissedPages() {
  1536.         let all = []; // 全部页码
  1537.         for (let i = 0; i < window.mbaJS.max_page; i++) {
  1538.             all[i] = i + 1;
  1539.         }
  1540.         let missed = []; // 未捕获页码
  1541.         let possessed = Array.from(window.mbaJS.canvases_map.keys()); // 已捕获页面
  1542.  
  1543.         // 排除并录入未捕获页码
  1544.         for (let num of all) {
  1545.             if (!possessed.includes(`page${num}`)) {
  1546.                 missed.push(num);
  1547.             }
  1548.         }
  1549.         return missed;
  1550.     }
  1551.  
  1552.  
  1553.     /**
  1554.      * 根据键中的id数字对map排序
  1555.      * @param {Map} elems_map 
  1556.      * @returns sorted_map
  1557.      */
  1558.     function sortMapByID$1(elems_map) {
  1559.         // id形式：page2
  1560.         let elems_arr = Array.from(elems_map);
  1561.         elems_arr.sort((item1, item2) => {
  1562.             // 从key中取出id
  1563.             let id1 = parseInt(item1[0].replace("page", ""));
  1564.             let id2 = parseInt(item2[0].replace("page", ""));
  1565.             // 升序排序
  1566.             return id1 - id2;
  1567.         });
  1568.         // 返回排序好的map
  1569.         return new Map(elems_arr);
  1570.     }
  1571.  
  1572.  
  1573.     /**
  1574.      * 存储动态加载的canvas元素、textContent
  1575.      */
  1576.     function storeElements_MBA() {
  1577.         let canvases_map = window.mbaJS.canvases_map;
  1578.         let texts_map = window.mbaJS.texts_map;
  1579.         let quality = window.mbaJS.quality;
  1580.  
  1581.         document.querySelectorAll(".page[data-loaded=true]").forEach(
  1582.             (elem) => {
  1583.                 let capture = (elem) => {
  1584.                     // (1) 存储页面为canvas图形
  1585.                     let canvas, data_base64;
  1586.                     // 导出canvas数据防止丢失
  1587.                     try {
  1588.                         // 存储canvas
  1589.                         canvas = elem.querySelector("canvas[id*=page]");
  1590.                         if (window.mbaJS.only_text) {
  1591.                             data_base64 = null;
  1592.                         } else {
  1593.                             data_base64 = canvas.toDataURL("image/jpeg", quality);
  1594.                         }
  1595.                     } catch (e) {
  1596.                         // utils.sleep(500);
  1597.                         return;
  1598.                     }
  1599.                     // 增量录入map
  1600.                     let id = canvas.id; // id的形式：page2
  1601.                     if (!canvases_map.has(id)) {
  1602.                         canvases_map.set(id, data_base64);
  1603.                     }
  1604.                     // 确定canvas长宽
  1605.                     if (!window.mbaJS.only_text && !window.mbaJS.width) {
  1606.                         window.mbaJS.width = parseInt(canvas.width);
  1607.                         window.mbaJS.height = parseInt(canvas.height);
  1608.                     }
  1609.  
  1610.                     // (2) 存储text
  1611.                     let text = elem.textContent;
  1612.                     if (!texts_map.has(id)) {
  1613.                         texts_map.set(id, text);
  1614.                     }
  1615.                 };
  1616.                 setTimeout(capture, 500, elem);
  1617.             });
  1618.         if (canvases_map.size === window.mbaJS.max_page) {
  1619.             // 根据id排序
  1620.             window.mbaJS.canvases_map = sortMapByID$1(window.mbaJS.canvases_map);
  1621.             window.mbaJS.texts_map = sortMapByID$1(window.mbaJS.texts_map);
  1622.             window.mbaJS.finished = true;
  1623.             window.onscroll = null;
  1624.         }
  1625.     }
  1626.  
  1627.  
  1628.     /**
  1629.      * 将canvas转为jpeg，然后导出PDF
  1630.      * @param {Array} base64_list canvas元素列表
  1631.      * @param {String} title 文档标题
  1632.      */
  1633.     function saveCanvasesToPDF_MBA(base64_list, title) {
  1634.         let width = window.mbaJS.width;
  1635.         let height = window.mbaJS.height;
  1636.  
  1637.         console.log(`canvas数据：宽: ${width}px，高: ${height}px`);
  1638.         // 如果文档第一页的宽比长更大，则landscape，否则portrait
  1639.         let orientation = width > height ? 'l' : 'p';
  1640.         let pdf = new jspdf.jsPDF(orientation, 'px', [height, width]);
  1641.  
  1642.         // 保存每一页文档到每一页pdf
  1643.         let i = 0;
  1644.         for (let base64 of base64_list) {
  1645.             i += 1;
  1646.             pdf.addImage(base64, 'JPEG', 0, 0, width, height);
  1647.             // 如果当前不是文档最后一页，则需要添加下一个空白页
  1648.             if (i < window.mbaJS.max_page) {
  1649.                 pdf.addPage();
  1650.             }
  1651.         }
  1652.         // 导出文件
  1653.         pdf.save(`${title}.pdf`);
  1654.     }
  1655.  
  1656.     /**
  1657.      * 判断文档页是否收集完毕，当不行时给出提示
  1658.      * @returns boolean
  1659.      */
  1660.     function ready2use() {
  1661.         removeAds(); // 顺便清理广告
  1662.         // 如果是首次点击按钮，给出提示
  1663.         if (window.mbaJS.first_hint) {
  1664.             let hint = [
  1665.                 "如果浏览速度过快，比如：",
  1666.                 "当前页面还没完全加载好就滚动页面去看下一页",
  1667.                 "那就极有可能导致导出的PDF有空白页或文本有缺漏",
  1668.                 "由防范技术的干扰，该功能目前很不好用，见谅"
  1669.             ].join("\n");
  1670.             alert(hint);
  1671.             window.mbaJS.first_hint = false;
  1672.         }
  1673.         // 如果文档页没有收集完，给出提示
  1674.         if (!window.mbaJS.finished) {
  1675.             let hint = [
  1676.                 "仍有内容未加载完，无法使用该功能",
  1677.                 "建议从头到尾慢速地再浏览一遍",
  1678.                 "以下是没有加载完成页面的页码：",
  1679.                 getMissedPages().join(",")
  1680.             ];
  1681.             alert(hint.join("\n"));
  1682.             return false;
  1683.         }
  1684.         return true;
  1685.     }
  1686.  
  1687.  
  1688.     /**
  1689.      * 用捕获好的canvas转jpg，生成PDF
  1690.      * @returns 
  1691.      */
  1692.     function canvas2PDF_mba() {
  1693.         if (!ready2use()) {
  1694.             return;
  1695.         }
  1696.         let canvases = window.mbaJS.canvases_map.values();
  1697.         // 导出PDF
  1698.         let title = document.title.split("-")[0].trim();
  1699.         saveCanvasesToPDF_MBA(canvases, title);
  1700.     }
  1701.  
  1702.  
  1703.     /**
  1704.      * 拼合捕获好的文本，保存到txt文件
  1705.      * @returns 
  1706.      */
  1707.     function saveText_mba() {
  1708.         if (!ready2use()) {
  1709.             return;
  1710.         }
  1711.         let content = Array.from(window.mbaJS.texts_map.values());
  1712.         let title = document.title.split("-")[0].trim();
  1713.         utils.createAndDownloadFile(`${title}.txt`, content.join("\n"));
  1714.     }
  1715.  
  1716.  
  1717.     /**
  1718.      * 移除广告
  1719.      */
  1720.     function removeAds() {
  1721.         document.querySelectorAll(".doc-ad").forEach((ad_elem) => {
  1722.             utils.tryToRemoveElement(ad_elem);
  1723.         });
  1724.     }
  1725.  
  1726.  
  1727.     function mbalib_() {
  1728.         // 移除广告和左侧工具栏
  1729.         removeAds();
  1730.         let tool_bar = document.querySelector(".tool-bar");
  1731.         utils.tryToRemoveElement(tool_bar);
  1732.  
  1733.         // 创建按钮
  1734.         utils.createBtns();
  1735.         // 隐藏按钮
  1736.         utils.toggleBtnStatus("btn_1");
  1737.         // 显示按钮
  1738.         utils.toggleBtnStatus("btn_2");
  1739.         utils.toggleBtnStatus("btn_3");
  1740.         utils.toggleBtnStatus("btn_4");
  1741.  
  1742.         // 取得页数
  1743.         let max_page = parseInt(document.querySelector("#numPages").textContent.replace("/ ", ""));
  1744.         let quality = utils.getQualityByCanvasAmount(max_page);
  1745.  
  1746.         // 为导出内容提供全局变量，便于动态收集文档页元素的存取
  1747.         window.mbaJS = {
  1748.             max_page: max_page,
  1749.             texts_map: new Map(), // id: text
  1750.             canvases_map: new Map(), // id: canvas_data_base64
  1751.             quality: quality, // canvas转jpg的质量
  1752.             width: null, // canvas宽度（px）
  1753.             height: null,
  1754.             finished: false, // 是否收集完了全部文档页元素
  1755.             first_hint: true,
  1756.             scroll_count: 0, // 用于统计累计触发scroll的次数,
  1757.             only_text: false // 是否仅捕获文本
  1758.         };
  1759.         // 跟随浏览，动态收集页面元素
  1760.         window.onscroll = () => {
  1761.             storeElements_MBA();
  1762.         };
  1763.         // 跟随浏览，动态收集页面元素
  1764.         utils.scrollFunc(storeElements_MBA, window.mbaJS, 20, 50, "mba元素: 收集");
  1765.         // 绑定事件
  1766.         utils.setBtnEvent(saveText_mba, [], "btn_2", "导出纯文本(不稳定)");
  1767.         utils.setBtnEvent(canvas2PDF_mba, [], "btn_3", "导出PDF(不稳定)");
  1768.  
  1769.         // 根据页数决定按钮功能：<40页，导出文本+导出pdf，>40页：导出文本
  1770.         let btn_text, aim_btn, hint;
  1771.         if (max_page > 40) {
  1772.             btn_text = "失效说明";
  1773.             aim_btn = "btn_3";
  1774.             hint = [
  1775.                 "页数超过40，脚本无效",
  1776.                 "只能使用导出文本功能",
  1777.                 "而此脚本会使页面内容加载明显变慢，建议禁用"
  1778.             ];
  1779.             utils.setBtnEvent(utils.banSelf, [
  1780.                 () => { window.onscroll = null; }
  1781.             ], "btn_4", "临时禁用脚本");
  1782.         } else {
  1783.             btn_text = "空白页说明";
  1784.             aim_btn = "btn_4";
  1785.             hint = [
  1786.                 "导致空白页的原因如下",
  1787.                 "加载该页的时间超过2秒 / 明显等待",
  1788.                 "而此脚本会使页面内容加载明显变慢，如果影响严重请禁用"
  1789.             ];
  1790.         }
  1791.  
  1792.         utils.setBtnEvent(() => {
  1793.             alert(hint.join("\n"));
  1794.         }, [], aim_btn, btn_text);
  1795.     }
  1796.  
  1797.  
  1798.     function mbalib() {
  1799.         setTimeout(mbalib_, 2000);
  1800.     }
  1801.  
  1802.     // 拼接swf: https://pan.baidu.com/s/1PTM6watxNlqs-jvvX6XKzg?pwd=abe9 中的 JoinSWFFiles_setup.exe
  1803.     // swf转pdf: https://youfiles.herokuapp.com/swftopdf/
  1804.  
  1805.  
  1806.     /**
  1807.      * 统计文档页的数量
  1808.      * @param {String} inner_selector 【信息摘要】元素选择器
  1809.      * @returns 文档页的数量
  1810.      */
  1811.     function countPages(inner_selector = ".container div[style=' margin:20px; ']") {
  1812.         let abstract = inner_window.document.querySelector(inner_selector).textContent;
  1813.         let page_amount_pattern = /文档页数：共 ([1-9]|[1-9][0-9]|[1-9][0-9][0-9]) 页/;
  1814.         // 捕获到: ["文档页数：共 xx 页", "xx"]
  1815.         let max_page = parseInt(abstract.match(page_amount_pattern)[1]);
  1816.         return max_page;
  1817.     }
  1818.  
  1819.  
  1820.     /**
  1821.      * 判断当前帮帮文档是否为高清版页面
  1822.      * @returns 是否为高清
  1823.      */
  1824.     function isHD() {
  1825.         // 取得页面左侧【高清版】切换功能区
  1826.         let hd_bar = inner_window.document.querySelector("#gaoging");
  1827.         // 取得功能区内提示文字
  1828.         let hint = hd_bar.querySelector("#gqts").textContent;
  1829.         // 如果存在如下文字，认为当前页面是模糊版，否则是高清版
  1830.         if (hint.includes("点此阅读高清版")) {
  1831.             return false;
  1832.         }
  1833.         return true;
  1834.     }
  1835.  
  1836.  
  1837.     /**
  1838.      * 开启收集swf链接任务，隐藏按钮1，显示按钮2、3
  1839.      */
  1840.     function main$1() {
  1841.         // 已经是高清版
  1842.         // 跟随浏览，动态冻结页面元素
  1843.         utils.scrollFunc(storeSWFLinks_Woc88, window.woc88JS, 10, 30, "woc88元素: 收集", inner_window);
  1844.  
  1845.         // 绑定按钮的触发函数
  1846.         utils.setBtnEvent(btn2SaveSwfUrls, [], "btn_2", "导出swf链接");
  1847.         utils.setBtnEvent(() => {
  1848.             let hints = [
  1849.                 "本脚本无需【flash】。",
  1850.                 "你的电脑上无需安装任何flash player也可以使用。",
  1851.                 "导出 media-urls.csv 后，",
  1852.                 "需要使用【资源下载器】来取得swf文档资源。",
  1853.                 "详细用法请访问脚本主页: ",
  1854.                 "https://greasyfork.org/zh-CN/scripts/435884-wenku-doc-downloader"
  1855.             ];
  1856.             alert(hints.join("\n"));
  1857.         }, [], "btn_3", "友情提示");
  1858.  
  1859.         // 隐藏按钮
  1860.         utils.toggleBtnStatus("btn_1");
  1861.         // 显示按钮
  1862.         utils.toggleBtnStatus("btn_2");
  1863.         utils.toggleBtnStatus("btn_3");
  1864.     }
  1865.  
  1866.  
  1867.     function switch2HD() {
  1868.         // 取得页面左侧【高清版】切换功能区
  1869.         let hd_bar = inner_window.document.querySelector("#gaoging");
  1870.         // 取得功能区内【切换高清版】按钮
  1871.         let hd_button = hd_bar.querySelector("#gqts span[onclick]");
  1872.         hd_button.click();
  1873.         // 开启主任务
  1874.         setTimeout(main$1, 1000);
  1875.     }
  1876.  
  1877.  
  1878.     /**
  1879.      * 根据键中的id数字对map排序
  1880.      * @param {Map} elems_map 
  1881.      * @returns sorted_map
  1882.      */
  1883.     function sortMapByID(elems_map) {
  1884.         // id形式：5, 类型: int
  1885.         let elems_arr = Array.from(elems_map);
  1886.         elems_arr.sort((id1, id2) => {
  1887.             // 升序排序
  1888.             return id1 - id2;
  1889.         });
  1890.         // 返回排序好的map
  1891.         return new Map(elems_arr);
  1892.     }
  1893.  
  1894.  
  1895.     /**
  1896.      * 存储swf链接。适用于帮帮文库。
  1897.      * @param {String} inner_selector iframe#test 框架下的【swf链接所在元素】选择器
  1898.      */
  1899.     function storeSWFLinks_Woc88(inner_selector = "div[id*=imgcount] > div > object") {
  1900.         let elems_map = window.woc88JS.elems_map;
  1901.         inner_window.document.querySelectorAll(inner_selector).forEach(
  1902.             (elem) => {
  1903.                 // 复制链接防止丢失
  1904.                 // 拿到id
  1905.                 let id_elem = elem.parentElement.parentElement.id;
  1906.                 let id = parseInt(id_elem.replace("imgcount", ""));
  1907.                 // 拿到link
  1908.                 let link = elem.data;
  1909.                 // 储存id: link
  1910.                 elems_map.set(id, link);
  1911.             });
  1912.         if (elems_map.size === window.woc88JS.max_page) {
  1913.             // 根据id排序，保证导出的图片链接不是乱序的
  1914.             window.woc88JS.elems_map = sortMapByID(window.woc88JS.elems_map);
  1915.             // 已经保存完全部文档页元素，移除滚动事件的绑定函数
  1916.             window.woc88JS.finished = true;
  1917.             inner_window.removeEventListener("scroll", window.woc88JS.scrollFunc, false);
  1918.         }
  1919.     }
  1920.  
  1921.  
  1922.     /**
  1923.      * 导出swf链接到csv文件。需要配合【资源下载器】使用。
  1924.      */
  1925.     function saveSwfUrls_Woc88() {
  1926.         let urls = [];
  1927.         window.woc88JS.elems_map.forEach((url) => {
  1928.             // 遍历map就是遍历value
  1929.             urls.push(url);
  1930.         });
  1931.         utils.createAndDownloadFile("media-urls.csv", urls.join("\n"));
  1932.     }
  1933.  
  1934.  
  1935.     /**
  1936.      * 返回一个列表，包含所有未捕获的页码
  1937.      * @returns 未捕获页码列表
  1938.      */
  1939.     function getNotStored() {
  1940.         // 取得全部页码
  1941.         let max_page = window.woc88JS.max_page;
  1942.         // 取得未捕获页码
  1943.         let stored = new Set(window.woc88JS.elems_map.keys());
  1944.         let not_stored = [];
  1945.         for (let i = 1; i <= max_page; i++) {
  1946.             // 如果当前页码未被捕获，则录入not_stored
  1947.             if (!stored.has(i)) {
  1948.                 not_stored.push(i);
  1949.             }
  1950.         }
  1951.         return not_stored;
  1952.     }
  1953.  
  1954.  
  1955.     function btn2SaveSwfUrls() {
  1956.         if (!window.woc88JS.finished) {
  1957.             let hints = [
  1958.                 "仍有内容未加载完，无法使用该功能",
  1959.                 "请再次浏览未加载出的页面，未加载的页码如下",
  1960.                 getNotStored().join(",")
  1961.             ];
  1962.             alert(hints.join("\n"));
  1963.             return;
  1964.         }
  1965.         saveSwfUrls_Woc88();
  1966.     }
  1967.  
  1968.  
  1969.     /**
  1970.      * 帮帮文库下载策略
  1971.      */
  1972.     function woc88() {
  1973.         // 1 初始环境配置
  1974.         // 取得iframe的window
  1975.         window.inner_window = document.querySelector("#test").contentWindow;
  1976.         // 设置全局变量
  1977.         window.woc88JS = {
  1978.             max_page: countPages(), // 当前文档页面数量
  1979.             finished: false, // 是否收集完了全部文档页元素
  1980.             scroll_count: 0, // 用于统计累计触发scroll的次数
  1981.             elems_map: new Map(), // 存储已经捕获的元素: {id: element}
  1982.             scrollFunc: null
  1983.         };
  1984.  
  1985.         // 2 主任务
  1986.         // 创建按钮组
  1987.         utils.createBtns();
  1988.         // 如果不是高清版，先切换至高清版
  1989.         if (!isHD()) {
  1990.             utils.setBtnEvent(switch2HD, [], "btn_1", "高清版");
  1991.             return;
  1992.         }
  1993.         main$1();
  1994.     }
  1995.  
  1996.     /**
  1997.      * 主函数：识别网站，执行对应文档下载策略
  1998.      */
  1999.     function main() {
  2000.         let host = window.location.host;
  2001.         console.log(`当前host: ${host}`);
  2002.         window.user_utils = utils;
  2003.         console.log("wk: user_utils已经挂载到全局");
  2004.  
  2005.         if (host.includes("docin.com")) {
  2006.             docin();
  2007.         } else if (host === "ishare.iask.sina.com.cn") {
  2008.             ishare();
  2009.         } else if (host === "www.deliwenku.com") {
  2010.             deliwenku();
  2011.         } else if (host === "www.doc88.com") {
  2012.             doc88();
  2013.         } else if (host === "www.360doc.com") {
  2014.             doc360();
  2015.         } else if (host === "wenku.baidu.com") {
  2016.             baiduWenku();
  2017.         } else if (host === "doc.mbalib.com") {
  2018.             mbalib();
  2019.         } else if (host === "www.woc88.com") {
  2020.             woc88();
  2021.         } else {
  2022.             console.log("匹配到了无效网页");
  2023.         }
  2024.     }
  2025.  
  2026.     let options = {
  2027.         fast_mode: false,
  2028.         activation_test: false
  2029.     };
  2030.     
  2031.     if (options.cli_mode) {
  2032.         (() => {
  2033.             loadExternalScripts();
  2034.             setTimeout(main, 2000);
  2035.             return;
  2036.         })();
  2037.     }
  2038.     
  2039.     if (options.activation_test) {
  2040.         alert(`Wenku Doc Downloader 已经生效！\n当前网址：\n${window.location.host}`);
  2041.     }
  2042.     
  2043.     if (options.fast_mode) {
  2044.         main();
  2045.     } else {
  2046.         window.onload = main;
  2047.     }
  2048.  
  2049. })();