Wenku Doc Downloader

下载文档,导出纯图片PDF。有限地支持 (1)豆丁网 (2)道客巴巴 (3)360doc个人图书馆 (4)得力文库 (5)MBA智库 (6)<暂时移除> (7)原创力文档 (8)读根网 (9)国标网 (10)食典通 (11)安全文库网。在文档页面左侧中间有按钮区和小猴子图标,说明脚本生效了。【反馈请提供网址】。不支持手机端。你能预览多少页,就可以导出多少页的PDF。

当前为 2022-11-24 提交的版本,查看 最新版本

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

QingJ © 2025

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