☰

Wenku Doc Downloader

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

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

  1. // ==UserScript==
  2. // @name         Wenku Doc Downloader
  3. // @namespace    http://tampermonkey.net/
  4. // @version      1.4.13
  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         紧急修复百度文档不能展开的bug(bug出现于1.4.12版本)
  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='全屏显示'], #next_doc_box"
  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.     /**
  995.      * 取得当前行高
  996.      * @returns 行高，例如 192px
  997.      */
  998.     function getLineHeight() {
  999.         let line = document.querySelector("p.reader-word-layer");
  1000.         if (!line) {
  1001.             return null;
  1002.         }
  1003.         let height = getComputedStyle(line).lineHeight;
  1004.         console.log(`get line-height: ${height}`);
  1005.         return height;
  1006.     }
  1007.  
  1008.  
  1009.     /**
  1010.      * 增大行间距到1500px，用于解决文字重叠
  1011.      */
  1012.     function changeLineHeight() {
  1013.         let lines = document.querySelectorAll("p.reader-word-layer");
  1014.         let aim_height, aim_hint;
  1015.  
  1016.         if (getComputedStyle(lines[0]).lineHeight !== window.baiduJS.origin_line_height) {
  1017.             // 切换回旧的行高
  1018.             aim_height = window.baiduJS.origin_line_height;
  1019.             aim_hint = "解决文字重叠";
  1020.             console.log(`changed to original line height`);
  1021.         } else {
  1022.             // 切换到增大的行高
  1023.             aim_height = "1500px";
  1024.             aim_hint = "切回旧行高";
  1025.             console.log(`changed to new line height: 1500px`);
  1026.         }
  1027.         // 应用新的行高
  1028.         for (let line of lines) {
  1029.             line.style.lineHeight = aim_height;
  1030.         }
  1031.         // 应用新的按钮文本
  1032.         setTimeout(() => {
  1033.             utils.modifyBtnText("btn_5", aim_hint, false, false);
  1034.         }, 2000);
  1035.     }
  1036.  
  1037.  
  1038.     function baiduWenku_OldVer() {
  1039.         // 为导出内容提供全局变量，便于动态收集文档页元素的存取
  1040.         let real_max_page;
  1041.         try {
  1042.             real_max_page = parseInt(document.querySelector(".page-count").textContent.replace("/", ""));
  1043.         } catch (e) {
  1044.             real_max_page = countPages$1();
  1045.         }
  1046.  
  1047.         window.baiduJS = {
  1048.             max_page: countPages$1(), // 当前文档页面数量
  1049.             real_max_page: real_max_page, // 当前文档的总页数
  1050.             iterator_count: 0, // getParentByClassName的最大迭代次数为9
  1051.             finished: false, // 是否收集完了全部文档页元素
  1052.             scroll_count: 0, // 用于统计累计触发scroll的次数
  1053.             elems: [], // 存储已经冻结的元素id
  1054.             elems_map: new Map(), // id: element
  1055.             origin_line_height: getLineHeight() // 原始行高
  1056.         };
  1057.  
  1058.         if (location.href.includes("?share_api=1&width=800")) {
  1059.             // 带分享参数的页面，适用于word和excel
  1060.  
  1061.             // 跟随浏览，动态冻结页面元素
  1062.             utils.scrollFunc(freezeHtmlElemts_Baidu, window.baiduJS, 10, 50, "baidu元素: 冻结");
  1063.  
  1064.             // 隐藏按钮
  1065.             utils.toggleBtnStatus("btn_1");
  1066.             // 显示按钮
  1067.             utils.toggleBtnStatus("btn_2");
  1068.             utils.toggleBtnStatus("btn_3");
  1069.             // 绑定事件到按钮
  1070.             // 按钮2：调整页间距
  1071.             utils.setBtnEvent(userAdjustSpace, [], "btn_2", "调整页间距");
  1072.             // 按钮3：打印页面到PDF
  1073.             utils.setBtnEvent(printPage_Baidu, [], "btn_3", "打印页面到PDF");
  1074.  
  1075.         } else if (location.href.includes("\u002f\u0073\u0068\u0061\u0072\u0065\u002f")) {
  1076.             // old version for fetch doc elements
  1077.             // 跟随浏览，动态收集页面元素
  1078.             utils.scrollFunc(storeHtmlElemts_Baidu, window.baiduJS, 10, 50, "baidu元素: 收集");
  1079.  
  1080.             // 隐藏按钮
  1081.             utils.toggleBtnStatus("btn_1");
  1082.             // 显示按钮
  1083.             utils.toggleBtnStatus("btn_2");
  1084.             utils.toggleBtnStatus("btn_3");
  1085.             utils.toggleBtnStatus("btn_4");
  1086.             utils.toggleBtnStatus("btn_5");
  1087.             // 绑定事件到按钮
  1088.             utils.setBtnEvent(saveText_Baidu, [], "btn_3", "导出纯文本");
  1089.             utils.setBtnEvent(savePicUrls_Baidu, [], "btn_4", "导出图片链接(仅PPT)");
  1090.             utils.setBtnEvent(savePicUrls_BaiduNonPPT, [], "btn_5", "导出图片链接(除PPT)");
  1091.             // btn_2
  1092.             utils.setBtnEvent(() => {
  1093.                 if (confirm("仅对excel和word文档有效，是否继续？")) {
  1094.                     // 在无参数的旧版页面处理超过50页的文档
  1095.                     // 跟随浏览，动态冻结页面元素
  1096.                     window.baiduJS.finished = false;
  1097.                     utils.scrollFunc(freezeHtmlElemts_Baidu, window.baiduJS, 10, 50, "baidu元素: 冻结");
  1098.                     // 重新绑定按钮监听器
  1099.                     utils.setBtnEvent(userAdjustSpace, [], "btn_4", "调整页间距");
  1100.                     utils.setBtnEvent(printPage_BaiduNoArgs, [], "btn_3", "打印页面到PDF◈");
  1101.                     alert("正在截获文档内容，请上下浏览页面后再次点击该按钮");
  1102.                     utils.setBtnEvent(changeLineHeight, [], "btn_5", "解决文字重叠");
  1103.  
  1104.                     // 隐藏按钮
  1105.                     utils.toggleBtnStatus("btn_2");
  1106.                 }
  1107.             }, [], "btn_2", "打印页面到PDF");
  1108.         } else {
  1109.             console.log(`无法识别的页面：${location.href}`);
  1110.         }
  1111.     }
  1112.  
  1113.  
  1114.     /**
  1115.      * 百度文档下载策略
  1116.      */
  1117.     function baiduWenku() {
  1118.         // 允许打印页面
  1119.         utils.allowPrint();
  1120.         // 原文档解析到预览文档
  1121.         if (location.href.includes("\u002f\u0076\u0069\u0065\u0077\u002f")) {
  1122.             utils.createBtns();
  1123.             let jump2sharePage_Baidu = function() {
  1124.                 location.href = `https://${location.host}${location.pathname.replace("\u0076\u0069\u0065\u0077", "\u0073\u0068\u0061\u0072\u0065")}`;
  1125.             };
  1126.             utils.setBtnEvent(jump2sharePage_Baidu, [], "btn_1");
  1127.         } else {
  1128.             // 在完全展开文档后启用旧版页面处理函数
  1129.             // 创建按钮组
  1130.             console.log("\n\nwk: 进入旧版页面\n\n\n");
  1131.             utils.createBtns();
  1132.             utils.setBtnEvent(readMoreRecursively, [baiduWenku_OldVer], "btn_1");
  1133.         }
  1134.     }
  1135.  
  1136.     /**
  1137.      * 展开道客巴巴的文档
  1138.      */
  1139.     function readAllDoc88() {
  1140.         // 获取“继续阅读”按钮
  1141.         let continue_btn = document.querySelector("#continueButton");
  1142.         // 如果存在“继续阅读”按钮
  1143.         if (continue_btn) {
  1144.             // 跳转到文末（等同于展开全文）
  1145.             let cur_page = document.querySelector("#pageNumInput");
  1146.             // 取得最大页码
  1147.             let page_max = cur_page.parentElement.textContent.replace(" / ", "");
  1148.             // 跳转到尾页
  1149.             utils.jump2pageNo(cur_page, page_max, "keypress");
  1150.             // 返回顶部
  1151.             setTimeout(utils.jump2pageNo(cur_page, "1", "keypress"), 1000);
  1152.         }
  1153.         // 文档展开后，显示按钮2、3
  1154.         else {
  1155.             // 隐藏按钮
  1156.             utils.toggleBtnStatus("btn_1");
  1157.             // 显示按钮
  1158.             utils.toggleBtnStatus("btn_2");
  1159.             utils.toggleBtnStatus("btn_3");
  1160.         }
  1161.     }
  1162.  
  1163.     /**
  1164.      * 道客巴巴文档下载策略
  1165.      */
  1166.     function doc88() {
  1167.         // 创建脚本启动按钮1、2
  1168.         utils.createBtns();
  1169.  
  1170.         // 绑定主函数
  1171.         let prepare = function() {
  1172.             // 获取canvas元素列表
  1173.             let node_list = document.querySelectorAll(".inner_page");
  1174.             // 获取文档标题
  1175.             let title;
  1176.             if (document.querySelector(".doctopic h1")) {
  1177.                 title = document.querySelector(".doctopic h1").title;
  1178.             } else {
  1179.                 title = "文档";
  1180.             }
  1181.             return [node_list, title];
  1182.         };
  1183.  
  1184.         // btn_1: 展开文档
  1185.         utils.setBtnEvent(() => {
  1186.             readAllDoc88();
  1187.         }, [], "btn_1");
  1188.         // btn_2: 导出zip
  1189.         utils.setBtnEvent(() => {
  1190.             if (confirm("确定每页内容都加载完成了吗？")) {
  1191.                 utils.saveCanvasesToZip(...prepare());
  1192.             }
  1193.         }, [], "btn_2", "导出图片到zip");
  1194.         // btn_3: 导出PDF
  1195.         utils.setBtnEvent(() => {
  1196.             if (confirm("确定每页内容都加载完成了吗？")) {
  1197.                 utils.saveCanvasesToPDF(...prepare());
  1198.             }
  1199.         }, [], "btn_3", "导出图片到PDF");
  1200.     }
  1201.  
  1202.     // 绑定主函数
  1203.     function getCanvasList() {
  1204.         // 获取全部canvas元素，用于传递canvas元素列表给 btn_2 和 btn_3
  1205.         let parent_node_list = document.querySelectorAll(".hkswf-content");
  1206.         let node_list = [];
  1207.         for (let node of parent_node_list) {
  1208.             node_list.push(node.children[0]);
  1209.         }
  1210.         return node_list;
  1211.     }
  1212.  
  1213.  
  1214.     function prepare() {
  1215.         // 获取canvas元素列表
  1216.         let node_list = getCanvasList();
  1217.         // 获取文档标题
  1218.         let title;
  1219.         if (document.querySelector("h1 [title=doc]")) {
  1220.             title = document.querySelector("h1 [title=doc]").nextElementSibling.textContent;
  1221.         } else if (document.querySelector(".doc_title")) {
  1222.             title = document.querySelector(".doc_title").textContent;
  1223.         } else {
  1224.             title = "文档";
  1225.         }
  1226.         return [node_list, title];
  1227.     }
  1228.  
  1229.  
  1230.     // 判断是否有canvas元素
  1231.     function detectCanvas() {
  1232.         let haveCanvas = getCanvasList().length === 0 ? false : true;
  1233.  
  1234.         // 隐藏按钮
  1235.         utils.toggleBtnStatus("btn_1");
  1236.         // 显示按钮
  1237.         utils.toggleBtnStatus("btn_2");
  1238.  
  1239.         // 如果没有canvas元素，则认为文档页面由外链图片构成
  1240.         if (!haveCanvas) {
  1241.             // btn_2: 导出图片链接
  1242.             utils.setBtnEvent(() => {
  1243.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1244.                     utils.savePicUrls("[id*=img_]");
  1245.                 }
  1246.             }, [], "btn_2", "导出全部图片链接");
  1247.         } else {
  1248.             // 显示按钮3
  1249.             utils.toggleBtnStatus("btn_3");
  1250.             // btn_2: 导出zip
  1251.             utils.setBtnEvent(() => {
  1252.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1253.                     utils.saveCanvasesToZip(...prepare());
  1254.                 }
  1255.             }, [], "btn_2", "导出图片到zip");
  1256.             // btn_3: 导出PDF
  1257.             utils.setBtnEvent(() => {
  1258.                 if (confirm("确定每页内容都加载完成了吗？")) {
  1259.                     utils.saveCanvasesToPDF(...prepare());
  1260.                 }
  1261.             }, [], "btn_3", "导出图片到PDF");
  1262.         }
  1263.     }
  1264.  
  1265.  
  1266.     /**
  1267.      * 豆丁文档下载策略
  1268.      */
  1269.     function docin() {
  1270.         // 创建脚本启动按钮
  1271.         utils.createBtns();
  1272.  
  1273.         // 隐藏底部工具栏
  1274.         document.querySelector("#j_select").click(); // 选择指针
  1275.         let tool_bar = document.querySelector(".reader_tools_bar_wrap.tools_bar_small.clear");
  1276.         tool_bar.style.display = "none";
  1277.  
  1278.         // btn_1: 判断文档类型
  1279.         utils.setBtnEvent(() => {
  1280.             utils.forceHide(".jz_watermark");
  1281.             detectCanvas();
  1282.         }, [], "btn_1", "判断文档类型");
  1283.     }
  1284.  
  1285.     /**
  1286.      * 点击“展开继续阅读”，适用性：爱尚共享资料
  1287.      */
  1288.     function readAlliShare() {
  1289.         // 获取“继续阅读”元素
  1290.         let red_btn = document.getElementsByClassName("red-color")[0];
  1291.         let red_text = red_btn.textContent;
  1292.         // 如果可以展开，则展开
  1293.         if (red_text.search("点击可继续阅读") !== -1) {
  1294.             red_btn.click();
  1295.             setTimeout(readAlliShare, 1000);
  1296.         }
  1297.         // 否则启动按钮2，准备清理页面然后打印为PDF
  1298.         else {
  1299.             // 隐藏按钮
  1300.             utils.toggleBtnStatus("btn_1");
  1301.             // 显示按钮
  1302.             utils.toggleBtnStatus("btn_2");
  1303.             utils.toggleBtnStatus("btn_3");
  1304.  
  1305.             // 显示svg图片的链接
  1306.             let page1 = document.querySelector('[data-num="1"] .data-detail embed');
  1307.             if (!page1) {
  1308.                 // 如果不存在svg图形，终止后续代码
  1309.                 console.log("当前页面不存在svg图形");
  1310.                 return;
  1311.             }
  1312.             let page2 = document.querySelector('[data-num="2"] .data-detail embed');
  1313.             let [svg1_src_div, svg2_src_div] = [document.createElement("div"), document.createElement("div")];
  1314.             svg1_src_div.innerHTML = `<div id="src-1"
  1315.                                     style="font-weight: bold;font-size: 20px; height: 100px; width: 100%">
  1316.                                         访问以下链接以复制文字:<br>${page1.src}
  1317.                                     </div>`;
  1318.             svg2_src_div.innerHTML = `<div id="src-1"
  1319.                                     style="font-weight: bold;font-size: 20px; height: 100px; width: 100%">
  1320.                                     访问以下链接以复制文字:<br>${page2.src}
  1321.                                     </div>`;
  1322.             // 添加到页面上
  1323.             page1.parentElement.parentElement.parentElement.append(svg1_src_div);
  1324.             page2.parentElement.parentElement.parentElement.append(svg2_src_div);
  1325.         }
  1326.     }
  1327.  
  1328.  
  1329.     /**
  1330.      * 清理并打印爱问共享资料的文档页
  1331.      * @returns 如果输入偏移量非法，返回空值以终止函数
  1332.      */
  1333.     function printPageiShare() {
  1334.         // # 清理并打印爱问共享资料的文档页
  1335.         // ## 移除页面上无关的元素
  1336.         // ### 移除单个元素
  1337.         let topbanner = document.getElementsByClassName("detail-topbanner")[0];
  1338.         let header = document.getElementsByClassName("new-detail-header")[0];
  1339.         let fixright = document.getElementById("fix-right");
  1340.         let redpacket = document.getElementsByClassName("loginRedPacket-dialog")[0];
  1341.         let fixedrightfull = document.getElementsByClassName("fixed-right-full")[0];
  1342.         let footer = document.getElementsByClassName("website-footer")[0];
  1343.         let guess = document.getElementsByClassName("guess-you-like-warpper")[0];
  1344.         let detailtopbox = document.getElementsByClassName("detail-top-box")[0];
  1345.         let fullscreen = document.getElementsByClassName("reader-fullScreen")[0];
  1346.         let endhint = document.getElementsByClassName("endof-trial-reading")[0];
  1347.         let crumb_arrow;
  1348.         try { crumb_arrow = document.getElementsByClassName("crumb-arrow")[0].parentElement; } catch (e) { console.log(); }
  1349.         let copyright = document.getElementsByClassName("copyright-container")[0];
  1350.         let state_btn = document.getElementsByClassName("state-bottom")[0];
  1351.         let comments = document.getElementsByClassName("user-comments-wrapper")[0];
  1352.         // ### 执行移除
  1353.         let elem_list = [
  1354.             topbanner,
  1355.             header,
  1356.             fixright,
  1357.             redpacket,
  1358.             fixedrightfull,
  1359.             footer,
  1360.             guess,
  1361.             detailtopbox,
  1362.             fullscreen,
  1363.             endhint,
  1364.             crumb_arrow,
  1365.             copyright,
  1366.             state_btn,
  1367.             comments
  1368.         ];
  1369.         for (let elem of elem_list) {
  1370.             utils.tryToRemoveElement(elem);
  1371.         }
  1372.         // ### 移除全部同类元素
  1373.         let elem_list_2 = document.querySelectorAll(".tui-detail, .adv-container");
  1374.         for (let elem_2 of elem_list_2) {
  1375.             utils.tryToRemoveElement(elem_2);
  1376.         }
  1377.         // 使文档居中
  1378.         alert("建议使用:\n偏移量: 18\n缩放: 默认\n如果预览中有广告，就取消打印\n再点一次按钮，预览中应该就没有广告了");
  1379.         if (!utils.centerDoc("doc-main", "18")) {
  1380.             return; // 如果输入非法，终止函数调用
  1381.         }
  1382.         // 隐藏按钮，然后打印页面
  1383.         utils.hideBtnThenPrint();
  1384.     }
  1385.  
  1386.  
  1387.     /**
  1388.      * 爱问共享资料文档下载策略
  1389.      */
  1390.     function ishare() {
  1391.         // 创建脚本启动按钮1、2
  1392.         utils.createBtns();
  1393.  
  1394.         // btn_1: 展开文档
  1395.         utils.setBtnEvent(readAlliShare, [], "btn_1");
  1396.         // btn_2: 导出图片链接
  1397.         utils.setBtnEvent(() => {
  1398.             utils.savePicUrls(".data-detail");
  1399.         }, [], "btn_2", "导出图片链接（推荐）");
  1400.         // btn_3: 打印页面到PDF
  1401.         utils.setBtnEvent(printPageiShare, [], "btn_3", "打印页面到PDF");
  1402.  
  1403.         // 移除底部下载条
  1404.         let detailfixed = document.getElementsByClassName("detail-fixed")[0];
  1405.         utils.tryToRemoveElement(detailfixed);
  1406.     }
  1407.  
  1408.     /**
  1409.      * 清理并打印得力文库的文档页
  1410.      */
  1411.     function printPageDeliwenku() {
  1412.         // 移除页面上的无关元素
  1413.         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";
  1414.         let elem_list = document.querySelectorAll(selector);
  1415.         for (let elem of elem_list) {
  1416.             utils.tryToRemoveElement(elem);
  1417.         }
  1418.         // 修改页间距
  1419.         let outer_pages = document.getElementsByClassName("outer_page");
  1420.         for (let page of outer_pages) {
  1421.             page.style.marginBottom = "20px";
  1422.         }
  1423.         // 使文档居中
  1424.         alert("建议使用:\n偏移量: 3\n缩放: 112\n请上下滚动页面，确保每页内容都加载完成以避免空白页\n如果预览时有空白页或文末有绿色按钮，请取消打印重试");
  1425.         if (!utils.centerDoc("#boxleft", "3")) {
  1426.             return; // 如果输入非法，终止函数调用
  1427.         }
  1428.         // 打印文档
  1429.         utils.hideBtnThenPrint();
  1430.     }
  1431.  
  1432.  
  1433.     /**
  1434.      * 点击“继续阅读”，适用性：得力文库
  1435.      */
  1436.     function readAllDeliwenku() {
  1437.         // 点击“同意并开始预览全文”
  1438.         let start_btn = document.getElementsByClassName("pre_button")[0];
  1439.         let display = start_btn.parentElement.parentElement.style.display;
  1440.         // 如果该按钮显示着，则点击，然后滚动至页面底部，最后终止函数
  1441.         if (!display) {
  1442.             start_btn.children[0].click();
  1443.             setTimeout("scroll(0, document.body.scrollHeight)", 200);
  1444.             return;
  1445.         }
  1446.         // 增强按钮点击效果
  1447.         utils.enhanceBtnClickReaction();
  1448.  
  1449.         let read_all_btn = document.getElementsByClassName("fc2e")[0];
  1450.         let display2 = read_all_btn.parentElement.parentElement.style.display;
  1451.             // 继续阅读
  1452.         if (display2 !== "none") {
  1453.             // 获取input元素
  1454.             let cur_page = document.querySelector("#pageNumInput");
  1455.             let page_old = cur_page.value;
  1456.             let page_max = cur_page.parentElement.nextElementSibling.textContent.replace(" / ", "");
  1457.             // 跳转到尾页
  1458.             utils.jump2pageNo(cur_page, page_max, "keydown");
  1459.             // 跳转回来
  1460.             utils.jump2pageNo(cur_page, page_old, "keydown");
  1461.  
  1462.             // 切换按钮准备导出
  1463.         } else {
  1464.             // 推荐导出图片链接
  1465.             utils.modifyBtnText("btn_2", null, true);
  1466.             // 隐藏按钮
  1467.             utils.toggleBtnStatus("btn_1");
  1468.             // 显示按钮
  1469.             utils.toggleBtnStatus("btn_2");
  1470.             utils.toggleBtnStatus("btn_3");
  1471.             // btn_3 橙色按钮
  1472.             utils.setBtnEvent(printPageDeliwenku, [], "btn_3", "打印页面到PDF");
  1473.         }
  1474.     }
  1475.  
  1476.  
  1477.     /**
  1478.      * 得力文库文档下载策略
  1479.      */
  1480.     function deliwenku() {
  1481.         // 创建脚本启动按钮1、2
  1482.         utils.createBtns();
  1483.  
  1484.         // btn_1: 展开文档
  1485.         utils.setBtnEvent(readAllDeliwenku, [], "btn_1");
  1486.         // btn_2: 导出图片链接
  1487.         utils.setBtnEvent(() => {
  1488.             if (confirm("确定每页内容都加载完成了吗？")) {
  1489.                 utils.savePicUrls('.inner_page div');
  1490.             }
  1491.         }, [], "btn_2", "导出图片链接");
  1492.  
  1493.         // 尝试关闭页面弹窗
  1494.         try { document.querySelector("div[title=点击关闭]").click(); } catch (e) { console.log(0); }
  1495.         // 解除打印限制
  1496.         utils.allowPrint();
  1497.     }
  1498.  
  1499.     function readAll360Doc() {
  1500.         // 展开文档
  1501.         document.querySelector(".articleMaxH").setAttribute("class", "");
  1502.         // 隐藏按钮
  1503.         utils.toggleBtnStatus("btn_1");
  1504.         // 显示按钮
  1505.         utils.toggleBtnStatus("btn_2");
  1506.         utils.toggleBtnStatus("btn_3");
  1507.     }
  1508.  
  1509.  
  1510.     function saveText_360Doc() {
  1511.         // 捕获图片链接
  1512.         let images = document.querySelectorAll("#artContent img");
  1513.         let content = [];
  1514.  
  1515.         for (let i = 0; i < images.length; i++) {
  1516.             let src = images[i].src;
  1517.             content.push(`图${i+1}，链接：${src}`);
  1518.         }
  1519.         // 捕获文本
  1520.         let text = document.querySelector("#artContent").textContent;
  1521.         content.push(text);
  1522.  
  1523.         // 保存纯文本文档
  1524.         let title = document.querySelector("#titiletext").textContent;
  1525.         utils.createAndDownloadFile(`${title}.txt`, content.join("\n"));
  1526.     }
  1527.  
  1528.  
  1529.     function printPage360Doc() {
  1530.         // # 清理并打印360doc的文档页
  1531.         // ## 移除页面上无关的元素
  1532.         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";
  1533.         let elem_list = document.querySelectorAll(selector);
  1534.         let under_doc_1, under_doc_2;
  1535.         try {
  1536.             under_doc_1 = document.querySelector("#bgchange p.clearboth").nextElementSibling;
  1537.             under_doc_2 = document.querySelector("#bgchange").nextElementSibling.nextElementSibling;
  1538.         } catch (e) { console.log(); }
  1539.         // 执行移除
  1540.         for (let elem of elem_list) {
  1541.             utils.tryToRemoveElement(elem);
  1542.         }
  1543.         utils.tryToRemoveElement(under_doc_1);
  1544.         utils.tryToRemoveElement(under_doc_2);
  1545.         // 执行隐藏
  1546.         document.querySelector("a[title]").style.display = "none";
  1547.  
  1548.         // 使文档居中
  1549.         alert("建议使用:\n偏移量: 20\n缩放: 默认\n");
  1550.         if (!utils.centerDoc(".a_left", "20")) {
  1551.             return; // 如果输入非法，终止函数调用
  1552.         }
  1553.         // 隐藏按钮，然后打印页面
  1554.         utils.hideBtnThenPrint();
  1555.     }
  1556.  
  1557.  
  1558.     /**
  1559.      * 360doc个人图书馆下载策略
  1560.      */
  1561.     function doc360() {
  1562.         // 创建按钮区
  1563.         utils.createBtns();
  1564.         // btn_1: 展开文档
  1565.         utils.setBtnEvent(readAll360Doc, [], "btn_1");
  1566.         // btn_2: 导出纯文本
  1567.         utils.setBtnEvent(saveText_360Doc, [], "btn_2", "导出纯文本");
  1568.         // btn_3: 打印页面到PDF
  1569.         utils.setBtnEvent(() => {
  1570.             if (confirm("确定每页内容都加载完成了吗？")) {
  1571.                 printPage360Doc();
  1572.             }
  1573.         }, [], "btn_3", "打印页面到PDF");
  1574.     }
  1575.  
  1576.     /**
  1577.      * 查找出所有未被捕获的页码，并返回列表
  1578.      * @returns 未捕获页码列表
  1579.      */
  1580.     function getMissedPages() {
  1581.         let all = []; // 全部页码
  1582.         for (let i = 0; i < window.mbaJS.max_page; i++) {
  1583.             all[i] = i + 1;
  1584.         }
  1585.         let missed = []; // 未捕获页码
  1586.         let possessed = Array.from(window.mbaJS.canvases_map.keys()); // 已捕获页面
  1587.  
  1588.         // 排除并录入未捕获页码
  1589.         for (let num of all) {
  1590.             if (!possessed.includes(`page${num}`)) {
  1591.                 missed.push(num);
  1592.             }
  1593.         }
  1594.         return missed;
  1595.     }
  1596.  
  1597.  
  1598.     /**
  1599.      * 根据键中的id数字对map排序
  1600.      * @param {Map} elems_map 
  1601.      * @returns sorted_map
  1602.      */
  1603.     function sortMapByID$1(elems_map) {
  1604.         // id形式：page2
  1605.         let elems_arr = Array.from(elems_map);
  1606.         elems_arr.sort((item1, item2) => {
  1607.             // 从key中取出id
  1608.             let id1 = parseInt(item1[0].replace("page", ""));
  1609.             let id2 = parseInt(item2[0].replace("page", ""));
  1610.             // 升序排序
  1611.             return id1 - id2;
  1612.         });
  1613.         // 返回排序好的map
  1614.         return new Map(elems_arr);
  1615.     }
  1616.  
  1617.  
  1618.     /**
  1619.      * 存储动态加载的canvas元素、textContent
  1620.      */
  1621.     function storeElements_MBA() {
  1622.         let canvases_map = window.mbaJS.canvases_map;
  1623.         let texts_map = window.mbaJS.texts_map;
  1624.         let quality = window.mbaJS.quality;
  1625.  
  1626.         document.querySelectorAll(".page[data-loaded=true]").forEach(
  1627.             (elem) => {
  1628.                 let capture = (elem) => {
  1629.                     // (1) 存储页面为canvas图形
  1630.                     let canvas, data_base64;
  1631.                     // 导出canvas数据防止丢失
  1632.                     try {
  1633.                         // 存储canvas
  1634.                         canvas = elem.querySelector("canvas[id*=page]");
  1635.                         if (window.mbaJS.only_text) {
  1636.                             data_base64 = null;
  1637.                         } else {
  1638.                             data_base64 = canvas.toDataURL("image/jpeg", quality);
  1639.                         }
  1640.                     } catch (e) {
  1641.                         // utils.sleep(500);
  1642.                         return;
  1643.                     }
  1644.                     // 增量录入map
  1645.                     let id = canvas.id; // id的形式：page2
  1646.                     if (!canvases_map.has(id)) {
  1647.                         canvases_map.set(id, data_base64);
  1648.                     }
  1649.                     // 确定canvas长宽
  1650.                     if (!window.mbaJS.only_text && !window.mbaJS.width) {
  1651.                         window.mbaJS.width = parseInt(canvas.width);
  1652.                         window.mbaJS.height = parseInt(canvas.height);
  1653.                     }
  1654.  
  1655.                     // (2) 存储text
  1656.                     let text = elem.textContent;
  1657.                     if (!texts_map.has(id)) {
  1658.                         texts_map.set(id, text);
  1659.                     }
  1660.                 };
  1661.                 setTimeout(capture, 500, elem);
  1662.             });
  1663.         if (canvases_map.size === window.mbaJS.max_page) {
  1664.             // 根据id排序
  1665.             window.mbaJS.canvases_map = sortMapByID$1(window.mbaJS.canvases_map);
  1666.             window.mbaJS.texts_map = sortMapByID$1(window.mbaJS.texts_map);
  1667.             window.mbaJS.finished = true;
  1668.             window.onscroll = null;
  1669.         }
  1670.     }
  1671.  
  1672.  
  1673.     /**
  1674.      * 将canvas转为jpeg，然后导出PDF
  1675.      * @param {Array} base64_list canvas元素列表
  1676.      * @param {String} title 文档标题
  1677.      */
  1678.     function saveCanvasesToPDF_MBA(base64_list, title) {
  1679.         let width = window.mbaJS.width;
  1680.         let height = window.mbaJS.height;
  1681.  
  1682.         console.log(`canvas数据：宽: ${width}px，高: ${height}px`);
  1683.         // 如果文档第一页的宽比长更大，则landscape，否则portrait
  1684.         let orientation = width > height ? 'l' : 'p';
  1685.         let pdf = new jspdf.jsPDF(orientation, 'px', [height, width]);
  1686.  
  1687.         // 保存每一页文档到每一页pdf
  1688.         let i = 0;
  1689.         for (let base64 of base64_list) {
  1690.             i += 1;
  1691.             pdf.addImage(base64, 'JPEG', 0, 0, width, height);
  1692.             // 如果当前不是文档最后一页，则需要添加下一个空白页
  1693.             if (i < window.mbaJS.max_page) {
  1694.                 pdf.addPage();
  1695.             }
  1696.         }
  1697.         // 导出文件
  1698.         pdf.save(`${title}.pdf`);
  1699.     }
  1700.  
  1701.     /**
  1702.      * 判断文档页是否收集完毕，当不行时给出提示
  1703.      * @returns boolean
  1704.      */
  1705.     function ready2use() {
  1706.         removeAds(); // 顺便清理广告
  1707.         // 如果是首次点击按钮，给出提示
  1708.         if (window.mbaJS.first_hint) {
  1709.             let hint = [
  1710.                 "如果浏览速度过快，比如：",
  1711.                 "当前页面还没完全加载好就滚动页面去看下一页",
  1712.                 "那就极有可能导致导出的PDF有空白页或文本有缺漏",
  1713.                 "由防范技术的干扰，该功能目前很不好用，见谅"
  1714.             ].join("\n");
  1715.             alert(hint);
  1716.             window.mbaJS.first_hint = false;
  1717.         }
  1718.         // 如果文档页没有收集完，给出提示
  1719.         if (!window.mbaJS.finished) {
  1720.             let hint = [
  1721.                 "仍有内容未加载完，无法使用该功能",
  1722.                 "建议从头到尾慢速地再浏览一遍",
  1723.                 "以下是没有加载完成页面的页码：",
  1724.                 getMissedPages().join(",")
  1725.             ];
  1726.             alert(hint.join("\n"));
  1727.             return false;
  1728.         }
  1729.         return true;
  1730.     }
  1731.  
  1732.  
  1733.     /**
  1734.      * 用捕获好的canvas转jpg，生成PDF
  1735.      * @returns 
  1736.      */
  1737.     function canvas2PDF_mba() {
  1738.         if (!ready2use()) {
  1739.             return;
  1740.         }
  1741.         let canvases = window.mbaJS.canvases_map.values();
  1742.         // 导出PDF
  1743.         let title = document.title.split("-")[0].trim();
  1744.         saveCanvasesToPDF_MBA(canvases, title);
  1745.     }
  1746.  
  1747.  
  1748.     /**
  1749.      * 拼合捕获好的文本，保存到txt文件
  1750.      * @returns 
  1751.      */
  1752.     function saveText_mba() {
  1753.         if (!ready2use()) {
  1754.             return;
  1755.         }
  1756.         let content = Array.from(window.mbaJS.texts_map.values());
  1757.         let title = document.title.split("-")[0].trim();
  1758.         utils.createAndDownloadFile(`${title}.txt`, content.join("\n"));
  1759.     }
  1760.  
  1761.  
  1762.     /**
  1763.      * 移除广告
  1764.      */
  1765.     function removeAds() {
  1766.         document.querySelectorAll(".doc-ad").forEach((ad_elem) => {
  1767.             utils.tryToRemoveElement(ad_elem);
  1768.         });
  1769.     }
  1770.  
  1771.  
  1772.     function mbalib_() {
  1773.         // 移除广告和左侧工具栏
  1774.         removeAds();
  1775.         let tool_bar = document.querySelector(".tool-bar");
  1776.         utils.tryToRemoveElement(tool_bar);
  1777.  
  1778.         // 创建按钮
  1779.         utils.createBtns();
  1780.         // 隐藏按钮
  1781.         utils.toggleBtnStatus("btn_1");
  1782.         // 显示按钮
  1783.         utils.toggleBtnStatus("btn_2");
  1784.         utils.toggleBtnStatus("btn_3");
  1785.         utils.toggleBtnStatus("btn_4");
  1786.  
  1787.         // 取得页数
  1788.         let max_page = parseInt(document.querySelector("#numPages").textContent.replace("/ ", ""));
  1789.         let quality = utils.getQualityByCanvasAmount(max_page);
  1790.  
  1791.         // 为导出内容提供全局变量，便于动态收集文档页元素的存取
  1792.         window.mbaJS = {
  1793.             max_page: max_page,
  1794.             texts_map: new Map(), // id: text
  1795.             canvases_map: new Map(), // id: canvas_data_base64
  1796.             quality: quality, // canvas转jpg的质量
  1797.             width: null, // canvas宽度（px）
  1798.             height: null,
  1799.             finished: false, // 是否收集完了全部文档页元素
  1800.             first_hint: true,
  1801.             scroll_count: 0, // 用于统计累计触发scroll的次数,
  1802.             only_text: false // 是否仅捕获文本
  1803.         };
  1804.         // 跟随浏览，动态收集页面元素
  1805.         window.onscroll = () => {
  1806.             storeElements_MBA();
  1807.         };
  1808.         // 跟随浏览，动态收集页面元素
  1809.         utils.scrollFunc(storeElements_MBA, window.mbaJS, 20, 50, "mba元素: 收集");
  1810.         // 绑定事件
  1811.         utils.setBtnEvent(saveText_mba, [], "btn_2", "导出纯文本(不稳定)");
  1812.         utils.setBtnEvent(canvas2PDF_mba, [], "btn_3", "导出PDF(不稳定)");
  1813.  
  1814.         // 根据页数决定按钮功能：<40页，导出文本+导出pdf，>40页：导出文本
  1815.         let btn_text, aim_btn, hint;
  1816.         if (max_page > 40) {
  1817.             btn_text = "失效说明";
  1818.             aim_btn = "btn_3";
  1819.             hint = [
  1820.                 "页数超过40，脚本无效",
  1821.                 "只能使用导出文本功能",
  1822.                 "而此脚本会使页面内容加载明显变慢，建议禁用"
  1823.             ];
  1824.             utils.setBtnEvent(utils.banSelf, [
  1825.                 () => { window.onscroll = null; }
  1826.             ], "btn_4", "临时禁用脚本");
  1827.         } else {
  1828.             btn_text = "空白页说明";
  1829.             aim_btn = "btn_4";
  1830.             hint = [
  1831.                 "导致空白页的原因如下",
  1832.                 "加载该页的时间超过2秒 / 明显等待",
  1833.                 "而此脚本会使页面内容加载明显变慢，如果影响严重请禁用"
  1834.             ];
  1835.         }
  1836.  
  1837.         utils.setBtnEvent(() => {
  1838.             alert(hint.join("\n"));
  1839.         }, [], aim_btn, btn_text);
  1840.     }
  1841.  
  1842.  
  1843.     function mbalib() {
  1844.         setTimeout(mbalib_, 2000);
  1845.     }
  1846.  
  1847.     // 拼接swf: https://pan.baidu.com/s/1PTM6watxNlqs-jvvX6XKzg?pwd=abe9 中的 JoinSWFFiles_setup.exe
  1848.     // swf转pdf: https://youfiles.herokuapp.com/swftopdf/
  1849.  
  1850.  
  1851.     /**
  1852.      * 统计文档页的数量
  1853.      * @param {String} inner_selector 【信息摘要】元素选择器
  1854.      * @returns 文档页的数量
  1855.      */
  1856.     function countPages(inner_selector = ".container div[style=' margin:20px; ']") {
  1857.         let abstract = inner_window.document.querySelector(inner_selector).textContent;
  1858.         let page_amount_pattern = /文档页数：共 ([1-9]|[1-9][0-9]|[1-9][0-9][0-9]) 页/;
  1859.         // 捕获到: ["文档页数：共 xx 页", "xx"]
  1860.         let max_page = parseInt(abstract.match(page_amount_pattern)[1]);
  1861.         return max_page;
  1862.     }
  1863.  
  1864.  
  1865.     /**
  1866.      * 判断当前帮帮文档是否为高清版页面
  1867.      * @returns 是否为高清
  1868.      */
  1869.     function isHD() {
  1870.         // 取得页面左侧【高清版】切换功能区
  1871.         let hd_bar = inner_window.document.querySelector("#gaoging");
  1872.         // 取得功能区内提示文字
  1873.         let hint = hd_bar.querySelector("#gqts").textContent;
  1874.         // 如果存在如下文字，认为当前页面是模糊版，否则是高清版
  1875.         if (hint.includes("点此阅读高清版")) {
  1876.             return false;
  1877.         }
  1878.         return true;
  1879.     }
  1880.  
  1881.  
  1882.     /**
  1883.      * 开启收集swf链接任务，隐藏按钮1，显示按钮2、3
  1884.      */
  1885.     function main$1() {
  1886.         // 已经是高清版
  1887.         // 跟随浏览，动态冻结页面元素
  1888.         utils.scrollFunc(storeSWFLinks_Woc88, window.woc88JS, 10, 30, "woc88元素: 收集", inner_window);
  1889.  
  1890.         // 绑定按钮的触发函数
  1891.         utils.setBtnEvent(btn2SaveSwfUrls, [], "btn_2", "导出swf链接");
  1892.         utils.setBtnEvent(() => {
  1893.             let hints = [
  1894.                 "本脚本无需【flash】。",
  1895.                 "你的电脑上无需安装任何flash player也可以使用。",
  1896.                 "导出 media-urls.csv 后，",
  1897.                 "需要使用【资源下载器】来取得swf文档资源。",
  1898.                 "详细用法请访问脚本主页: ",
  1899.                 "https://greasyfork.org/zh-CN/scripts/435884-wenku-doc-downloader"
  1900.             ];
  1901.             alert(hints.join("\n"));
  1902.         }, [], "btn_3", "友情提示");
  1903.  
  1904.         // 隐藏按钮
  1905.         utils.toggleBtnStatus("btn_1");
  1906.         // 显示按钮
  1907.         utils.toggleBtnStatus("btn_2");
  1908.         utils.toggleBtnStatus("btn_3");
  1909.     }
  1910.  
  1911.  
  1912.     function switch2HD() {
  1913.         // 取得页面左侧【高清版】切换功能区
  1914.         let hd_bar = inner_window.document.querySelector("#gaoging");
  1915.         // 取得功能区内【切换高清版】按钮
  1916.         let hd_button = hd_bar.querySelector("#gqts span[onclick]");
  1917.         hd_button.click();
  1918.         // 开启主任务
  1919.         setTimeout(main$1, 1000);
  1920.     }
  1921.  
  1922.  
  1923.     /**
  1924.      * 根据键中的id数字对map排序
  1925.      * @param {Map} elems_map 
  1926.      * @returns sorted_map
  1927.      */
  1928.     function sortMapByID(elems_map) {
  1929.         // id形式：5, 类型: int
  1930.         let elems_arr = Array.from(elems_map);
  1931.         elems_arr.sort((id1, id2) => {
  1932.             // 升序排序
  1933.             return id1 - id2;
  1934.         });
  1935.         // 返回排序好的map
  1936.         return new Map(elems_arr);
  1937.     }
  1938.  
  1939.  
  1940.     /**
  1941.      * 存储swf链接。适用于帮帮文库。
  1942.      * @param {String} inner_selector iframe#test 框架下的【swf链接所在元素】选择器
  1943.      */
  1944.     function storeSWFLinks_Woc88(inner_selector = "div[id*=imgcount] > div > object") {
  1945.         let elems_map = window.woc88JS.elems_map;
  1946.         inner_window.document.querySelectorAll(inner_selector).forEach(
  1947.             (elem) => {
  1948.                 // 复制链接防止丢失
  1949.                 // 拿到id
  1950.                 let id_elem = elem.parentElement.parentElement.id;
  1951.                 let id = parseInt(id_elem.replace("imgcount", ""));
  1952.                 // 拿到link
  1953.                 let link = elem.data;
  1954.                 // 储存id: link
  1955.                 elems_map.set(id, link);
  1956.             });
  1957.         if (elems_map.size === window.woc88JS.max_page) {
  1958.             // 根据id排序，保证导出的图片链接不是乱序的
  1959.             window.woc88JS.elems_map = sortMapByID(window.woc88JS.elems_map);
  1960.             // 已经保存完全部文档页元素，移除滚动事件的绑定函数
  1961.             window.woc88JS.finished = true;
  1962.             inner_window.removeEventListener("scroll", window.woc88JS.scrollFunc, false);
  1963.         }
  1964.     }
  1965.  
  1966.  
  1967.     /**
  1968.      * 导出swf链接到csv文件。需要配合【资源下载器】使用。
  1969.      */
  1970.     function saveSwfUrls_Woc88() {
  1971.         let urls = [];
  1972.         window.woc88JS.elems_map.forEach((url) => {
  1973.             // 遍历map就是遍历value
  1974.             urls.push(url);
  1975.         });
  1976.         utils.createAndDownloadFile("media-urls.csv", urls.join("\n"));
  1977.     }
  1978.  
  1979.  
  1980.     /**
  1981.      * 返回一个列表，包含所有未捕获的页码
  1982.      * @returns 未捕获页码列表
  1983.      */
  1984.     function getNotStored() {
  1985.         // 取得全部页码
  1986.         let max_page = window.woc88JS.max_page;
  1987.         // 取得未捕获页码
  1988.         let stored = new Set(window.woc88JS.elems_map.keys());
  1989.         let not_stored = [];
  1990.         for (let i = 1; i <= max_page; i++) {
  1991.             // 如果当前页码未被捕获，则录入not_stored
  1992.             if (!stored.has(i)) {
  1993.                 not_stored.push(i);
  1994.             }
  1995.         }
  1996.         return not_stored;
  1997.     }
  1998.  
  1999.  
  2000.     function btn2SaveSwfUrls() {
  2001.         if (!window.woc88JS.finished) {
  2002.             let hints = [
  2003.                 "仍有内容未加载完，无法使用该功能",
  2004.                 "请再次浏览未加载出的页面，未加载的页码如下",
  2005.                 getNotStored().join(",")
  2006.             ];
  2007.             alert(hints.join("\n"));
  2008.             return;
  2009.         }
  2010.         saveSwfUrls_Woc88();
  2011.     }
  2012.  
  2013.  
  2014.     /**
  2015.      * 帮帮文库下载策略
  2016.      */
  2017.     function woc88() {
  2018.         // 1 初始环境配置
  2019.         // 取得iframe的window
  2020.         window.inner_window = document.querySelector("#test").contentWindow;
  2021.         // 设置全局变量
  2022.         window.woc88JS = {
  2023.             max_page: countPages(), // 当前文档页面数量
  2024.             finished: false, // 是否收集完了全部文档页元素
  2025.             scroll_count: 0, // 用于统计累计触发scroll的次数
  2026.             elems_map: new Map(), // 存储已经捕获的元素: {id: element}
  2027.             scrollFunc: null
  2028.         };
  2029.  
  2030.         // 2 主任务
  2031.         // 创建按钮组
  2032.         utils.createBtns();
  2033.         // 如果不是高清版，先切换至高清版
  2034.         if (!isHD()) {
  2035.             utils.setBtnEvent(switch2HD, [], "btn_1", "高清版");
  2036.             return;
  2037.         }
  2038.         main$1();
  2039.     }
  2040.  
  2041.     /**
  2042.      * 主函数：识别网站，执行对应文档下载策略
  2043.      */
  2044.     function main() {
  2045.         let host = window.location.host;
  2046.         console.log(`当前host: ${host}`);
  2047.         window.user_utils = utils;
  2048.         console.log("wk: user_utils已经挂载到全局");
  2049.  
  2050.         if (host.includes("docin.com")) {
  2051.             docin();
  2052.         } else if (host === "ishare.iask.sina.com.cn") {
  2053.             ishare();
  2054.         } else if (host === "www.deliwenku.com") {
  2055.             deliwenku();
  2056.         } else if (host === "www.doc88.com") {
  2057.             doc88();
  2058.         } else if (host === "www.360doc.com") {
  2059.             doc360();
  2060.         } else if (host === "wenku.baidu.com") {
  2061.             baiduWenku();
  2062.         } else if (host === "doc.mbalib.com") {
  2063.             mbalib();
  2064.         } else if (host === "www.woc88.com") {
  2065.             woc88();
  2066.         } else {
  2067.             console.log("匹配到了无效网页");
  2068.         }
  2069.     }
  2070.  
  2071.     let options = {
  2072.         fast_mode: false,
  2073.         activation_test: false
  2074.     };
  2075.     
  2076.     if (options.cli_mode) {
  2077.         (() => {
  2078.             loadExternalScripts();
  2079.             setTimeout(main, 2000);
  2080.             return;
  2081.         })();
  2082.     }
  2083.     
  2084.     if (options.activation_test) {
  2085.         alert(`Wenku Doc Downloader 已经生效！\n当前网址：\n${window.location.host}`);
  2086.     }
  2087.     
  2088.     if (options.fast_mode) {
  2089.         main();
  2090.     } else {
  2091.         window.onload = main;
  2092.     }
  2093.  
  2094. })();