Wenku Doc Downloader

对文档截图,合并为纯图片PDF。有限地支持(1)豆丁网 (2)道客巴巴 (3)360个人图书馆(4)得力文库 (5)MBA智库(6)爱问文库(7)原创力文档(8)读根网(9)国标网(10)安全文库网(11)人人文库(12)云展网(13)360文库(14)技工教育网(15)文库吧(16)中国社会科学文库。在网页左侧中间有按钮区和小猴子图标,说明脚本生效了。预览多少页,导出多少页。额外支持(1)食典通(2)JJG 计量技术规范,详见下方说明。

当前为 2023-04-26 提交的版本,查看 最新版本

  1. // ==UserScript==
  2. // @name Wenku Doc Downloader
  3. // @namespace http://tampermonkey.net/
  4. // @version 1.8.6
  5. // @description 对文档截图,合并为纯图片PDF。有限地支持(1)豆丁网 (2)道客巴巴 (3)360个人图书馆(4)得力文库 (5)MBA智库(6)爱问文库(7)原创力文档(8)读根网(9)国标网(10)安全文库网(11)人人文库(12)云展网(13)360文库(14)技工教育网(15)文库吧(16)中国社会科学文库。在网页左侧中间有按钮区和小猴子图标,说明脚本生效了。预览多少页,导出多少页。额外支持(1)食典通(2)JJG 计量技术规范,详见下方说明。
  6. // @author 2690874578@qq.com
  7. // @match *://*.docin.com/p-*
  8. // @match *://docimg1.docin.com/?wk=true
  9. // @match *://ishare.iask.sina.com.cn/f/*
  10. // @match *://ishare.iask.com/f/*
  11. // @match *://swf.ishare.down.sina.com.cn/?path=*
  12. // @match *://swf.ishare.down.sina.com.cn/?wk=true
  13. // @match *://www.deliwenku.com/p-*
  14. // @match *://file.deliwenku.com/?num=*
  15. // @match *://file3.deliwenku.com/?num=*
  16. // @match *://www.doc88.com/p-*
  17. // @match *://www.360doc.com/content/*
  18. // @match *://doc.mbalib.com/view/*
  19. // @match *://www.dugen.com/p-*
  20. // @match *://max.book118.com/html/*
  21. // @match *://openapi.book118.com/?*
  22. // @match *://view-cache.book118.com/pptView.html?*
  23. // @match *://*.book118.com/?readpage=*
  24. // @match *://c.gb688.cn/bzgk/gb/showGb?*
  25. // @match *://www.safewk.com/p-*
  26. // @match *://www.renrendoc.com/paper/*
  27. // @match *://www.renrendoc.com/p-*
  28. // @match *://www.yunzhan365.com/basic/*
  29. // @match *://book.yunzhan365.com/*index.html*
  30. // @match *://www.bing.com/search?q=Bing+AI&showconv=1*
  31. // @match *://wenku.so.com/d/*
  32. // @match *://jg.class.com.cn/cms/resourcedetail.htm?contentUid=*
  33. // @match *://preview.imm.aliyuncs.com/index.html?url=*/jgjyw/*
  34. // @match *://www.wenkub.com/p-*.html*
  35. // @match *://www.sklib.cn/manuscripts/?*
  36. // @match *://www.jinchutou.com/shtml/view-*
  37. // @match *://www.jinchutou.com/p-*
  38. // @require https://cdn.staticfile.org/jspdf/2.5.1/jspdf.umd.min.js
  39. // @require https://cdn.staticfile.org/html2canvas/1.4.1/html2canvas.min.js
  40. // @icon https://s2.loli.net/2022/01/12/wc9je8RX7HELbYQ.png
  41. // @icon64 https://s2.loli.net/2022/01/12/tmFeSKDf8UkNMjC.png
  42. // @grant none
  43. // @run-at document-idle
  44. // @license GPL-3.0-only
  45. // @create 2021-11-22
  46. // @note 1. 重写原创力PPT导出PDF功能
  47. // ==/UserScript==
  48.  
  49.  
  50. (function () {
  51. 'use strict';
  52.  
  53. const
  54. ping = Symbol("ping"),
  55. pong = Symbol("pong"),
  56. onPing = Symbol("onPing"),
  57. onPong = Symbol("onPong");
  58.  
  59.  
  60. /**
  61. * 基于 window.postMessage 通信的套接字对象
  62. */
  63. class Socket {
  64. /**
  65. * 创建套接字对象
  66. * @param {Window} target 目标窗口
  67. */
  68. constructor(target) {
  69. if (!(target.window && (target === target.window))) {
  70. console.log(target);
  71. throw new Error(`target is not a [Window Object]`);
  72. }
  73. this.target = target;
  74. this.connected = false;
  75. this.listeners = new Set();
  76. }
  77.  
  78. get [Symbol.toStringTag]() { return "Socket"; }
  79.  
  80. /**
  81. * 向目标窗口发消息
  82. * @param {*} message
  83. */
  84. talk(message) {
  85. if (!this.target) {
  86. throw new TypeError(
  87. `socket.target is not a window: ${this.target}`
  88. );
  89. }
  90. this.target.postMessage(message, "*");
  91. }
  92.  
  93. /**
  94. * 添加捕获型监听器,返回实际添加的监听器
  95. * @param {Function} listener (e: MessageEvent) => {...}
  96. * @param {boolean} once 是否在执行后自动销毁,默认 false;如为 true 则使用自动包装过的监听器
  97. * @returns {Function} listener
  98. */
  99. listen(listener, once=false) {
  100. if (this.listeners.has(listener)) {
  101. return;
  102. }
  103.  
  104. let real_listener = listener;
  105. // 包装监听器
  106. if (once) {
  107. const self = this;
  108. function wrapped(e) {
  109. listener(e);
  110. self.notListen(wrapped);
  111. }
  112. real_listener = wrapped;
  113. }
  114. // 添加监听器
  115. this.listeners.add(real_listener);
  116. window.addEventListener(
  117. "message", real_listener, true
  118. );
  119. return real_listener;
  120. }
  121.  
  122. /**
  123. * 移除socket上的捕获型监听器
  124. * @param {Function} listener (e: MessageEvent) => {...}
  125. */
  126. notListen(listener) {
  127. console.log(listener);
  128. console.log(
  129. "listener delete operation:",
  130. this.listeners.delete(listener)
  131. );
  132. window.removeEventListener("message", listener, true);
  133. }
  134.  
  135. /**
  136. * 检查对方来信是否为pong消息
  137. * @param {MessageEvent} e
  138. * @param {Function} resolve
  139. */
  140. [onPong](e, resolve) {
  141. // 收到pong消息
  142. if (e.data.pong) {
  143. this.connected = true;
  144. this.listeners.forEach(
  145. listener => listener.ping ? this.notListen(listener) : 0
  146. );
  147. console.log("Client: Connected!\n" + new Date());
  148. resolve(this);
  149. }
  150. }
  151.  
  152. /**
  153. * 向对方发送ping消息
  154. * @returns {Promise<Socket>}
  155. */
  156. [ping]() {
  157. return new Promise((resolve, reject) => {
  158. // 绑定pong检查监听器
  159. const listener = this.listen(
  160. e => this[onPong](e, resolve)
  161. );
  162. listener.ping = true;
  163.  
  164. // 5分钟后超时
  165. setTimeout(
  166. () => reject(new Error(`Timeout Error during receiving pong (>5min)`)),
  167. 5 * 60 * 1000
  168. );
  169. // 发送ping消息
  170. this.talk({ ping: true });
  171. });
  172. }
  173.  
  174. /**
  175. * 检查对方来信是否为ping消息
  176. * @param {MessageEvent} e
  177. * @param {Function} resolve
  178. */
  179. [onPing](e, resolve) {
  180. // 收到ping消息
  181. if (e.data.ping) {
  182. this.target = e.source;
  183. this.connected = true;
  184. this.listeners.forEach(
  185. listener => listener.pong ? this.notListen(listener) : 0
  186. );
  187. console.log("Server: Connected!\n" + new Date());
  188. // resolve 后期约状态无法回退
  189. // 但后续代码仍可执行
  190. resolve(this);
  191. // 回应pong消息
  192. this.talk({ pong: true });
  193. }
  194. }
  195.  
  196. /**
  197. * 当对方来信是为ping消息时回应pong消息
  198. * @returns {Promise<Socket>}
  199. */
  200. [pong]() {
  201. return new Promise(resolve => {
  202. // 绑定ping检查监听器
  203. const listener = this.listen(
  204. e => this[onPing](e, resolve)
  205. );
  206. listener.pong = true;
  207. });
  208. }
  209.  
  210. /**
  211. * 连接至目标窗口
  212. * @param {boolean} talk_first 是否先发送ping消息
  213. * @param {Window} target 目标窗口
  214. * @returns {Promise<Socket>}
  215. */
  216. connect(talk_first) {
  217. // 先发起握手
  218. if (talk_first) {
  219. return this[ping]();
  220. }
  221. // 后发起握手
  222. return this[pong]();
  223. }
  224. }
  225.  
  226.  
  227. const base = {
  228. Socket,
  229.  
  230. // 用于取得一次列表中所有迭代器的值
  231. getAllValus: function(iterators) {
  232. if (iterators.length === 0) {
  233. return [true, []];
  234. }
  235. let values = [];
  236. for (let iterator of iterators) {
  237. let {value, done} = iterator.next();
  238. if (done) {
  239. return [true, []];
  240. }
  241. values.push(value);
  242. }
  243. return [false, values];
  244. },
  245.  
  246. /**
  247. * 使用过时的execCommand复制文字
  248. * @param {string} text
  249. */
  250. oldCopy: function(text) {
  251. const input = document.createElement("input");
  252. input.value = text;
  253. document.body.appendChild(input);
  254. input.select();
  255. document.execCommand("copy");
  256. input.remove();
  257. },
  258.  
  259. b64ToUint6: function(nChr) {
  260. return nChr > 64 && nChr < 91 ?
  261. nChr - 65
  262. : nChr > 96 && nChr < 123 ?
  263. nChr - 71
  264. : nChr > 47 && nChr < 58 ?
  265. nChr + 4
  266. : nChr === 43 ?
  267. 62
  268. : nChr === 47 ?
  269. 63
  270. :
  271. 0;
  272. },
  273.  
  274. /**
  275. * 元素选择器
  276. * @param {string} selector 选择器
  277. * @returns {Array<HTMLElement>} 元素列表
  278. */
  279. $: function(selector) {
  280. const self = this?.querySelectorAll ? this : document;
  281. return [...self.querySelectorAll(selector)];
  282. },
  283.  
  284. /**
  285. * 安全元素选择器,直到元素存在时才返回元素列表,最多等待5秒
  286. * @param {string} selector 选择器
  287. * @returns {Promise<Array<HTMLElement>>} 元素列表
  288. */
  289. $$: async function(selector) {
  290. const self = this?.querySelectorAll ? this : document;
  291.  
  292. for (let i = 0; i < 10; i++) {
  293. let elems = [...self.querySelectorAll(selector)];
  294. if (elems.length > 0) {
  295. return elems;
  296. }
  297. await new Promise(r => setTimeout(r, 500));
  298. }
  299. throw Error(`"${selector}" not found in 5s`);
  300. },
  301.  
  302. /**
  303. * 将2个及以上的空白字符(除了换行符)替换成一个空格
  304. * @param {string} text
  305. * @returns {string}
  306. */
  307. stripBlanks: function(text) {
  308. return text
  309. .replace(/([^\r\n])(\s{2,})(?=[^\r\n])/g, "$1 ")
  310. .replace(/\n{2,}/, "\n");
  311. },
  312.  
  313. /**
  314. * 复制属性(含访问器)到 target
  315. * @param {Object} target
  316. * @param {...Object} sources
  317. * @returns
  318. */
  319. superAssign: function(target, ...sources) {
  320. sources.forEach(source =>
  321. Object.defineProperties(
  322. target, Object.getOwnPropertyDescriptors(source)
  323. )
  324. );
  325. return target;
  326. },
  327.  
  328. makeCRC32: function() {
  329. function makeCRCTable() {
  330. let c;
  331. let crcTable = [];
  332. for(var n =0; n < 256; n++){
  333. c = n;
  334. for(var k =0; k < 8; k++){
  335. c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
  336. }
  337. crcTable[n] = c;
  338. }
  339. return crcTable;
  340. }
  341.  
  342. const crcTable = makeCRCTable();
  343.  
  344. /**
  345. * @param {string} str
  346. * @returns {number}
  347. */
  348. return function(str) {
  349. let crc = 0 ^ (-1);
  350. for (var i = 0; i < str.length; i++ ) {
  351. crc = (crc >>> 8) ^ crcTable[(crc ^ str.charCodeAt(i)) & 0xFF];
  352. }
  353. return (crc ^ (-1)) >>> 0;
  354. };
  355. }
  356. };
  357.  
  358. globalThis.wk$ = base.$;
  359. globalThis.wk$$ = base.$$;
  360.  
  361. const utils = {
  362. Socket: base.Socket,
  363.  
  364. /**
  365. * raise an error for status which is not in [200, 299]
  366. * @param {Response} response
  367. */
  368. raise_for_status(response) {
  369. if (!response.ok) {
  370. throw new Error(
  371. `Fetch Error with status code: ${response.status}`
  372. );
  373. }
  374. },
  375.  
  376. /**
  377. * 计算 str 的 CRC32 摘要(number)
  378. * @param {string} str
  379. * @returns {number}
  380. */
  381. crc32: base.makeCRC32(),
  382.  
  383. /**
  384. * 返回函数参数定义
  385. * @param {Function} fn
  386. * @param {boolean} print 是否打印到控制台,默认 true
  387. * @returns {string | undefined}
  388. */
  389. help: function(fn, print=true) {
  390. if (!(fn instanceof Function))
  391. throw new Error(`fn must be a function`);
  392.  
  393. const
  394. ARROW_ARG = /^([^(]+?)=>/,
  395. FN_ARGS = /^[^(]*\(\s*([^)]*)\)/m,
  396. STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg,
  397. fn_text = Function.prototype.toString.call(fn).replace(STRIP_COMMENTS, ''),
  398. args = fn_text.match(ARROW_ARG) || fn_text.match(FN_ARGS),
  399. // 如果自带 doc,优先使用,否则使用源码
  400. doc = fn.__doc__ ? fn.__doc__ : args[0];
  401. if (!print) return base.stripBlanks(doc);
  402.  
  403. const color = (window.matchMedia &&
  404. window.matchMedia('(prefers-color-scheme: dark)').matches
  405. ) ;
  406. console.log("%c" + doc, `color: ${color}; font: small italic`);
  407. },
  408.  
  409. /**
  410. * 字节数组转十六进制字符串
  411. * @param {Uint8Array} arr
  412. * @returns {string}
  413. */
  414. uint8ArrToHexStr: function(arr) {
  415. return Array.from(arr)
  416. .map(byte => byte.toString(16).padStart(2, "0"))
  417. .join("");
  418. },
  419.  
  420. /**
  421. * 取得对象类型
  422. * @param {*} obj
  423. * @returns {string} class
  424. */
  425. classof: function(obj) {
  426. return Object
  427. .prototype
  428. .toString
  429. .call(obj)
  430. .slice(8, -1);
  431. },
  432.  
  433. /**
  434. * 随机改变字体颜色、大小、粗细
  435. * @param {HTMLElement} elem
  436. */
  437. emphasizeText: function(elem) {
  438. const rand = Math.random;
  439. elem.style.cssText = `
  440. font-weight: ${200 + parseInt(700 * rand())};
  441. font-size: ${(1 + rand()).toFixed(1)}em;
  442. color: hsl(${parseInt(360 * rand())}, ${parseInt(40 + 60 * rand())}%, ${parseInt(60 * rand())}%);
  443. background-color: yellow;`;
  444. },
  445.  
  446. /**
  447. * 等待直到 DOM 节点停止变化
  448. * @param {HTMLElement} elem 监听节点
  449. * @param {number} timeout 超时毫秒数
  450. * @returns {Promise<MutationObserver>} observer
  451. */
  452. untilDOMStill: async function(elem, timeout=2000) {
  453. // 创建用于共享的监听器
  454. let observer;
  455. // 创建超时 Promise
  456. const timeout_promise = new Promise((_, reject) => {
  457. setTimeout(() => {
  458. // 停止监听、释放资源
  459. observer.disconnect();
  460. const error = new Error(
  461. `Timeout Error occured on listening DOM mutation (max ${timeout}ms)`,
  462. { cause: elem }
  463. );
  464. reject(error);
  465. }, timeout);
  466. });
  467. // 开始元素节点变动监听
  468. return Promise.race([
  469. new Promise(resolve => {
  470. // 创建监听器
  471. observer = new MutationObserver(
  472. (_, observer) => {
  473. // DOM 变动结束后终止监听、释放资源
  474. observer.disconnect();
  475. // 返回监听器
  476. resolve(observer);
  477. }
  478. );
  479. // 开始监听目标节点
  480. observer.observe(elem, {
  481. subtree: true,
  482. childList: true,
  483. attributes: true
  484. });
  485. }),
  486. timeout_promise,
  487. ])
  488. .catch(error => {
  489. if (`${error}`.includes("Timeout Error")) {
  490. return observer;
  491. }
  492. console.error(error);
  493. throw error;
  494. });
  495. },
  496.  
  497.  
  498. /**
  499. * 返回子数组位置,找不到返回-1
  500. * @param {Array} arr 父数组
  501. * @param {Array} sub_arr 子数组
  502. * @param {number} from 开始位置
  503. * @returns {number} index
  504. */
  505. indexOfSubArray: function(arr, sub_arr, from) {
  506. // 如果子数组为空,则返回-1
  507. if (sub_arr.length === 0) return -1;
  508. // 初始化当前位置为from
  509. let position = from;
  510. // 算出最大循环次数
  511. const length = arr.length - sub_arr.length + 1;
  512.  
  513. // 循环查找子数组直到没有更多
  514. while (position < length) {
  515. // 如果当前位置的元素与子数组的第一个元素相等,则开始比较后续元素
  516. if (arr[position] === sub_arr[0]) {
  517. // 初始化匹配标志为真
  518. let match = true;
  519. // 循环比较后续元素,如果有不相等的,则将匹配标志设为假,并跳出循环
  520. for (let i = 1; i < sub_arr.length; i++) {
  521. if (arr[position + i] !== sub_arr[i]) {
  522. match = false;
  523. break;
  524. }
  525. }
  526. // 如果匹配标志为真,则说明找到了子数组,返回当前位置
  527. if (match) return position;
  528. }
  529. // 更新当前位置为下一个位置
  530. position++;
  531. }
  532. // 如果循环结束还没有找到子数组,则返回-1
  533. return -1;
  534. },
  535.  
  536. /**
  537. * 用文件头切断文件集合体
  538. * @param {Uint8Array} data
  539. * @param {Uint8Array} head 默认 null,即使用 data 前 8 字节
  540. * @returns {Array<Uint8Array>} files
  541. */
  542. splitFiles: function(data, head=null) {
  543. // 创建一个空数组用于存放结果
  544. const files = [];
  545. // 初始化当前位置为0
  546. let pos = 0;
  547. let next_pos = 0;
  548. // 确定 head
  549. head = head ? head : data.slice(0, 8);
  550. // 循环查找PNG标识直到没有更多
  551. while (next_pos < data.length) {
  552. // 查找下一个PNG标识的位置
  553. next_pos = this.indexOfSubArray(
  554. data, head, pos + 1
  555. );
  556. let image;
  557. if (next_pos === -1) {
  558. // 如果没有找到,则说明已经到达最后一张图片,将其复制并添加到结果中
  559. image = data.slice(pos);
  560. files.push(image);
  561. break;
  562. }
  563. image = data.slice(pos, next_pos);
  564. files.push(image);
  565. // 更新当前位置为下一个PNG标识的位置
  566. pos = next_pos;
  567. }
  568. // 返回结果数组
  569. return files;
  570. },
  571.  
  572. /**
  573. * 函数装饰器:仅执行一次 func
  574. * @param {Function} func 无参无返回值函数
  575. * @returns {Function}
  576. */
  577. once: function(func) {
  578. return async function() {
  579. let used = false;
  580. if (!used) {
  581. used = true;
  582. return func();
  583. }
  584. }
  585. },
  586.  
  587. /**
  588. * 将类似于dict的简单object转为get请求的queryString
  589. * @param {Object} dict
  590. * @returns {string}
  591. */
  592. dictToQueryStr: function(dict) {
  593. const params = [];
  594. for (let prop in dict) {
  595. params.push(`${prop}=${dict[prop]}`);
  596. }
  597. return params.join("&");
  598. },
  599.  
  600. /**
  601. * 返回一个包含计数器的迭代器, 其每次迭代值为 [index, value]
  602. * @param {Iterable} iterable
  603. * @returns
  604. */
  605. enumerate: function* (iterable) {
  606. let i = 0;
  607. for (let value of iterable) {
  608. yield [i, value];
  609. i++;
  610. }
  611. },
  612.  
  613. /**
  614. * 同步的迭代若干可迭代对象
  615. * @param {...Iterable} iterables
  616. * @returns
  617. */
  618. zip: function* (...iterables) {
  619. // 强制转为迭代器
  620. let iterators = iterables.map(
  621. iterable => iterable[Symbol.iterator]()
  622. );
  623.  
  624. // 逐次迭代
  625. while (true) {
  626. let [done, values] = base.getAllValus(iterators);
  627. if (done) {
  628. return;
  629. }
  630. if (values.length === 1) {
  631. yield values[0];
  632. } else {
  633. yield values;
  634. }
  635. }
  636. },
  637.  
  638. /**
  639. * 返回指定范围整数生成器
  640. * @param {number} end 如果只提供 end, 则返回 [0, end)
  641. * @param {number} end2 如果同时提供 end2, 则返回 [end, end2)
  642. * @param {number} step 步长, 可以为负数,不能为 0
  643. * @returns
  644. */
  645. range: function*(end, end2=null, step=1) {
  646. // 参数合法性校验
  647. if (step === 0) {
  648. throw new RangeError("step can't be zero");
  649. }
  650. const len = end2 - end;
  651. if (end2 && len && step && (len * step < 0)) {
  652. throw new RangeError(`[${end}, ${end2}) with step ${step} is invalid`);
  653. }
  654.  
  655. // 生成范围
  656. end2 = end2 === null ? 0 : end2;
  657. let [small, big] = [end, end2].sort((a, b) => a - b);
  658. // 开始迭代
  659. if (step > 0) {
  660. for (let i = small; i < big; i += step) {
  661. yield i;
  662. }
  663. } else {
  664. for (let i = big; i > small; i += step) {
  665. yield i;
  666. }
  667. } },
  668.  
  669. /**
  670. * 获取整个文档的全部css样式
  671. * @returns {string} css text
  672. */
  673. getAllStyles: function() {
  674. let styles = [];
  675. for (let sheet of document.styleSheets) {
  676. let rules;
  677. try {
  678. rules = sheet.cssRules;
  679. } catch(e) {
  680. if (!(e instanceof DOMException)) {
  681. console.error(e);
  682. }
  683. continue;
  684. }
  685.  
  686. for (let rule of rules) {
  687. styles.push(rule.cssText);
  688. }
  689. }
  690. return styles.join("\n\n");
  691. },
  692.  
  693. /**
  694. * 复制text到剪贴板
  695. * @param {string} text
  696. * @returns
  697. */
  698. copyText: function(text) {
  699. // 输出到控制台和剪贴板
  700. console.log(text);
  701. if (!navigator.clipboard) {
  702. base.oldCopy(text);
  703. return;
  704. }
  705. navigator.clipboard.writeText(text)
  706. .catch(_ => base.oldCopy(text));
  707. },
  708.  
  709. /**
  710. * 复制媒体到剪贴板
  711. * @param {Blob} blob
  712. */
  713. copyData: async function(blob) {
  714. const data = [new ClipboardItem({ [blob.type]: blob })];
  715. try {
  716. await navigator.clipboard.write(data);
  717. console.log(`${blob.type} 成功复制到剪贴板`);
  718. } catch (err) {
  719. console.error(err.name, err.message);
  720. }
  721. },
  722.  
  723. /**
  724. * 创建并下载文件
  725. * @param {string} file_name 文件名
  726. * @param {ArrayBuffer | ArrayBufferView | Blob | string} content 内容
  727. * @param {string} type 媒体类型,需要符合 MIME 标准
  728. */
  729. save: function(file_name, content, type="") {
  730. const blob = new Blob(
  731. [content], { type }
  732. );
  733. const size = (blob.size / 1024).toFixed(1);
  734. console.log(`blob saved, size: ${size} kb, type: ${blob.type}`);
  735.  
  736. const url = URL.createObjectURL(blob);
  737. const a = document.createElement("a");
  738. a.download = file_name;
  739. a.href = url;
  740. a.click();
  741. URL.revokeObjectURL(url);
  742. },
  743.  
  744. /**
  745. * 显示/隐藏按钮区
  746. */
  747. toggle_box: function() {
  748. let sec = wk$(".wk-box")[0];
  749. if (sec.style.display === "none") {
  750. sec.style.display = "block";
  751. return;
  752. }
  753. sec.style.display = "none";
  754. },
  755.  
  756. /**
  757. * 异步地睡眠 delay 毫秒, 可选 max_delay 控制波动范围
  758. * @param {number} delay 等待毫秒
  759. * @param {number} max_delay 最大等待毫秒, 默认为null
  760. * @returns
  761. */
  762. sleep: async function(delay, max_delay=null) {
  763. max_delay = max_delay === null ? delay : max_delay;
  764. delay = delay + (max_delay - delay) * Math.random();
  765. return new Promise(resolve => setTimeout(resolve, delay));
  766. },
  767.  
  768. /**
  769. * 允许打印页面
  770. */
  771. allowPrint: function() {
  772. const style = document.createElement("style");
  773. style.innerHTML = `
  774. @media print {
  775. body { display: block; }
  776. }`;
  777. document.head.append(style);
  778. },
  779.  
  780. /**
  781. * 取得get参数key对应的value
  782. * @param {string} key
  783. * @returns {string} value
  784. */
  785. getParam: function(key) {
  786. return new URL(location.href).searchParams.get(key);
  787. },
  788.  
  789. /**
  790. * 求main_set去除cut_set后的set
  791. * @param {Iterable} main_set
  792. * @param {Iterable} cut_set
  793. * @returns 差集
  794. */
  795. diff: function(main_set, cut_set) {
  796. const _diff = new Set(main_set);
  797. for (let elem of cut_set) {
  798. _diff.delete(elem);
  799. }
  800. return _diff;
  801. },
  802.  
  803. /**
  804. * 增强按钮(默认为蓝色按钮:展开文档)的点击效果
  805. * @param {string} i 按钮序号
  806. */
  807. enhanceBtnClick: async function(i) {
  808. let btn = this.btn(i);
  809. const style = btn.getAttribute("style") || "";
  810. // 变黑缩小
  811. btn.setAttribute(
  812. "style",
  813. style + "color: black; font-weight: normal;"
  814. );
  815. await utils.sleep(500);
  816. btn = this.btn(i);
  817. // 复原加粗
  818. btn.setAttribute("style", style);
  819. },
  820.  
  821. /**
  822. * 绑定事件处理函数到指定按钮,返回实际添加的事件处理函数
  823. * @param {(btn: HTMLButtonElement) => Promise<void>} listener click监听器,第一个参数是按钮的引用
  824. * @param {number} i 按钮序号
  825. * @param {string} new_text 按钮的新文本,为null则不替换
  826. * @returns {Function} 事件处理函数
  827. */
  828. onclick: function(listener, i, new_text=null) {
  829. const btn = this.btn(i);
  830.  
  831. // 如果需要,替换按钮内文本
  832. if (new_text) {
  833. btn.textContent = new_text;
  834. }
  835. const _listener = async () => {
  836. const btn = this.btn(i);
  837. await listener(btn);
  838. await this.enhanceBtnClick(i);
  839. btn.textContent = new_text;
  840. };
  841.  
  842. // 绑定事件,添加到页面上
  843. btn.addEventListener("click", _listener, true);
  844. return _listener;
  845. },
  846.  
  847. /**
  848. * 返回第 index 个按钮引用
  849. * @param {number} i
  850. * @returns {HTMLButtonElement}
  851. */
  852. btn: function(i) {
  853. return wk$(`.wk-box [class="btn-${i}"]`)[0];
  854. },
  855.  
  856. /**
  857. * 强制隐藏元素
  858. * @param {string} selector
  859. */
  860. forceHide: function(selector) {
  861. const cls = "force-hide";
  862. wk$(selector).forEach(elem => {
  863. elem.classList.add(cls);
  864. });
  865. // 判断css样式是否已经存在
  866. let style = wk$(`style.${cls}`)[0];
  867. // 如果已经存在,则无须重复创建
  868. if (style) {
  869. return;
  870. }
  871. // 否则创建
  872. style = document.createElement("style");
  873. style.innerHTML = `style.${cls} {
  874. visibility: hidden !important;
  875. display: none !important;
  876. }`;
  877. document.head.append(style);
  878. },
  879.  
  880. /**
  881. * 等待直到元素可见。最多等待5秒。
  882. * @param {HTMLElement} elem 一个元素
  883. * @returns {Promise<HTMLElement>} elem
  884. */
  885. untilVisible: async function(elem) {
  886. let [max, i] = [25, 0];
  887. let style = getComputedStyle(elem);
  888. // 如果不可见就等待0.2秒/轮
  889. while (i <= max &&
  890. (style.display === "none" ||
  891. style.visibility !== "hidden")
  892. ) {
  893. i++;
  894. style = getComputedStyle(elem);
  895. await this.sleep(200);
  896. }
  897. return elem;
  898. },
  899.  
  900. /**
  901. * 等待直到函数返回true
  902. * @param {Function | Promise<Function>} isReady 判断条件达成与否的函数
  903. * @param {number} timeout 最大等待秒数, 默认5000毫秒
  904. */
  905. wait_until: async function(isReady, timeout=5000) {
  906. const gap = 200;
  907. let chances = parseInt(timeout / gap);
  908. chances = chances < 1 ? 1 : chances;
  909. while (! await isReady()) {
  910. await this.sleep(200);
  911. chances -= 1;
  912. if (!chances) {
  913. break;
  914. }
  915. }
  916. },
  917.  
  918. /**
  919. * 隐藏按钮,打印页面,显示按钮
  920. */
  921. hideBtnThenPrint: async function() {
  922. // 隐藏按钮,然后打印页面
  923. this.toggle_box();
  924. await this.sleep(1000);
  925. print();
  926. this.toggle_box();
  927. },
  928.  
  929. /**
  930. * 切换按钮显示/隐藏状态
  931. * @param {number} i 按钮序号
  932. * @returns 按钮元素的引用
  933. */
  934. toggle_btn: function(i) {
  935. const btn = this.btn(i);
  936. const display = getComputedStyle(btn).display;
  937. if (display === "none") {
  938. btn.style.display = "block";
  939. } else {
  940. btn.style.display = "none";
  941. }
  942. return btn;
  943. },
  944.  
  945. /**
  946. * 用input框跳转到对应页码
  947. * @param {Element} cur_page 当前页码
  948. * @param {string | Number} aim_page 目标页码
  949. * @param {string} event_type 键盘事件类型:"keyup" | "keypress" | "keydown"
  950. */
  951. toPageNo: function(cur_page, aim_page, event_type) {
  952. // 设置跳转页码为目标页码
  953. cur_page.value = `${aim_page}`;
  954. // 模拟回车事件来跳转
  955. let keyboard_event_enter = new KeyboardEvent(event_type, {
  956. bubbles: true,
  957. cancelable: true,
  958. keyCode: 13
  959. });
  960. cur_page.dispatchEvent(keyboard_event_enter);
  961. },
  962.  
  963. /**
  964. * 判断给定的url是否与当前页面同源
  965. * @param {string} url
  966. * @returns {boolean}
  967. */
  968. isSameOrigin: function(url) {
  969. url = new URL(url);
  970. if (url.protocol === "data:") {
  971. return true;
  972. }
  973. if (location.protocol === url.protocol
  974. && location.host === url.host
  975. && location.port === url.port
  976. ) {
  977. return true;
  978. }
  979. return false;
  980. },
  981.  
  982. /**
  983. * 在新标签页打开链接,如果提供文件名则下载
  984. * @param {string} url
  985. * @param {string} fname 下载文件的名称,默认为空,代表不下载
  986. */
  987. openURL: function(url, fname="") {
  988. const a = document.createElement("a");
  989. a.href = url;
  990. a.target = "_blank";
  991. if (fname && this.isSameOrigin(url)) {
  992. a.download = fname;
  993. }
  994. a.click();
  995. },
  996.  
  997. /**
  998. * 用try移除元素
  999. * @param {Element} element 要移除的元素
  1000. */
  1001. remove: function(element) {
  1002. try {
  1003. element.remove();
  1004. } catch (e) {}
  1005. },
  1006.  
  1007. /**
  1008. * 用try移除若干元素
  1009. * @param {Iterable<Element>} elements 要移除的元素列表
  1010. */
  1011. removeMulti: function(elements) {
  1012. Array.from(elements).forEach(elem =>
  1013. this.remove(elem)
  1014. );
  1015. },
  1016.  
  1017. /**
  1018. * 使文档在页面上居中
  1019. * @param {string} selector 文档容器的css选择器
  1020. * @param {string} default_offset 文档部分向右偏移的百分比(0-59)
  1021. * @returns 偏移值是否合法
  1022. */
  1023. centerDoc: function(selector, default_offset) {
  1024. const doc_main = wk$(selector)[0];
  1025. const offset = prompt("请输入偏移百分位:", default_offset);
  1026. // 如果输入的数字不在 0-59 内,提醒用户重新设置
  1027. if (offset.length === 1 && offset.search(/[0-9]/) !== -1) {
  1028. doc_main.style.marginLeft = offset + "%";
  1029. return true;
  1030. } else if (offset.length === 2 && offset.search(/[1-5][0-9]/) !== -1) {
  1031. doc_main.style.marginLeft = offset + "%";
  1032. return true
  1033. } else {
  1034. alert("请输入一个正整数,范围在0至59之间,用来使文档居中\n(不同文档偏移量不同,所以需要手动调整)");
  1035. return false;
  1036. }
  1037. },
  1038.  
  1039. /**
  1040. * 等待全部任务落定后返回值的列表
  1041. * @param {Iterable<Promise>} tasks
  1042. * @returns {Promise<Array>} values
  1043. */
  1044. gather: async function(tasks) {
  1045. const results = await Promise.allSettled(tasks);
  1046. return results
  1047. .filter(result => result.value)
  1048. .map(result => result.value);
  1049. },
  1050.  
  1051. /**
  1052. * html元素列表转为canvas列表
  1053. * @param {ArrayLike<HTMLElement>} elements
  1054. * @returns {Promise<Array<HTMLCanvasElement>>}
  1055. */
  1056. elementsToCanvases: async function(elements) {
  1057. if (!globalThis.html2canvas) {
  1058. await this.loadWebScript(
  1059. "https://cdn.staticfile.org/html2canvas/1.4.1/html2canvas.min.js"
  1060. );
  1061. }
  1062.  
  1063. // 如果是空列表, 则抛出异常
  1064. if (elements.length === 0) {
  1065. throw new Error("htmlToCanvases 未得到任何html元素");
  1066. }
  1067.  
  1068. return this.gather(
  1069. Array.from(elements).map(html2canvas)
  1070. );
  1071. },
  1072.  
  1073. /**
  1074. * 将html元素转为canvas再合并到pdf中,最后下载pdf
  1075. * @param {ArrayLike<HTMLElement>} elements html元素列表
  1076. * @param {string} title 文档标题
  1077. */
  1078. elementsToPDF: async function(elements, title = "文档") {
  1079. // 如果是空元素列表,终止函数
  1080. const canvases = await this.elementsToCanvases(elements);
  1081. // 控制台检查结果
  1082. console.log("生成的canvas元素如下:");
  1083. console.log(canvases);
  1084. // 合并为PDF
  1085. this.imgsToPDF(canvases, title);
  1086. },
  1087.  
  1088. /**
  1089. * 使用xhr异步GET请求目标url,返回响应体blob
  1090. * @param {string} url
  1091. * @returns {Promise<Blob>} blob
  1092. */
  1093. xhrGetBlob: async function(url) {
  1094. const xhr = new XMLHttpRequest();
  1095. xhr.open("GET", url);
  1096. xhr.responseType = "blob";
  1097. return new Promise((resolve, reject) => {
  1098. xhr.onload = () => {
  1099. const code = xhr.status;
  1100. if (code >= 200 && code <= 299) {
  1101. resolve(xhr.response);
  1102. }
  1103. else {
  1104. reject(new Error(`Network Error: ${code}`));
  1105. }
  1106. };
  1107. xhr.send();
  1108. });
  1109. },
  1110.  
  1111. /**
  1112. * 加载CDN脚本
  1113. * @param {string} url
  1114. */
  1115. loadWebScript: async function(url) {
  1116. try {
  1117. // xhr+eval方式
  1118. Function(
  1119. await (await this.xhrGetBlob(url)).text()
  1120. )();
  1121. } catch(e) {
  1122. console.error(e);
  1123. // 嵌入<script>方式
  1124. const script = document.createElement("script");
  1125. script.src = url;
  1126. document.body.append(script);
  1127. }
  1128. },
  1129.  
  1130. /**
  1131. * b64编码字符串转Uint8Array
  1132. * @param {string} sBase64 b64编码的字符串
  1133. * @param {number} nBlockSize 字节数
  1134. * @returns {Uint8Array} arr
  1135. */
  1136. base64DecToArr: function(sBase64, nBlockSize=1) {
  1137. const
  1138. sB64Enc = sBase64.replace(/[^A-Za-z0-9\+\/]/g, ""), nInLen = sB64Enc.length,
  1139. nOutLen = nBlockSize ? Math.ceil((nInLen * 3 + 1 >>> 2) / nBlockSize) * nBlockSize : nInLen * 3 + 1 >>> 2, aBytes = new Uint8Array(nOutLen);
  1140.  
  1141. for (var nMod3, nMod4, nUint24 = 0, nOutIdx = 0, nInIdx = 0; nInIdx < nInLen; nInIdx++) {
  1142. nMod4 = nInIdx & 3;
  1143. nUint24 |= base.b64ToUint6(sB64Enc.charCodeAt(nInIdx)) << 18 - 6 * nMod4;
  1144. if (nMod4 === 3 || nInLen - nInIdx === 1) {
  1145. for (nMod3 = 0; nMod3 < 3 && nOutIdx < nOutLen; nMod3++, nOutIdx++) {
  1146. aBytes[nOutIdx] = nUint24 >>> (16 >>> nMod3 & 24) & 255;
  1147. }
  1148. nUint24 = 0;
  1149. }
  1150. }
  1151. return aBytes;
  1152. },
  1153.  
  1154. /**
  1155. * canvas转blob
  1156. * @param {HTMLCanvasElement} canvas
  1157. * @param {string} type
  1158. * @returns {Promise<Blob>}
  1159. */
  1160. canvas_to_blob: function(canvas, type="image/png") {
  1161. return new Promise(
  1162. resolve => canvas.toBlob(resolve, type, 1)
  1163. );
  1164. },
  1165.  
  1166. /**
  1167. * 合并blobs到压缩包,然后下载
  1168. * @param {Iterable<Blob>} blobs
  1169. * @param {string} base_name 文件名通用部分,如 image-1.jpg 中的 image
  1170. * @param {string} ext 扩展名,如 jpg
  1171. * @param {string} zip_name 压缩包名称
  1172. */
  1173. blobsToZip: async function(blobs, base_name, ext, zip_name) {
  1174. const zip = new JSZip();
  1175. // 归档
  1176. for (let [i, blob] of this.enumerate(blobs)) {
  1177. zip.file(
  1178. `${base_name}-${i+1}.${ext}`, blob, { binary: true }
  1179. );
  1180. }
  1181. // 导出
  1182. const zip_blob = await zip.generateAsync({ type: "blob" });
  1183. console.log(zip_blob);
  1184. this.save(`${zip_name}.zip`, zip_blob);
  1185. },
  1186.  
  1187. /**
  1188. * 存储所有canvas图形为png到一个压缩包
  1189. * @param {Iterable<HTMLCanvasElement>} canvases canvas元素列表
  1190. * @param {string} title 文档标题
  1191. */
  1192. canvasesToZip: async function(canvases, title) {
  1193. // canvas元素转为png图像
  1194. // 所有png合并为一个zip压缩包
  1195. const tasks = [];
  1196. for (let canvas of canvases) {
  1197. tasks.push(this.canvas_to_blob(canvas));
  1198. }
  1199. const blobs = await this.gather(tasks);
  1200. this.blobsToZip(blobs, "page", "png", title);
  1201. },
  1202.  
  1203.  
  1204.  
  1205. /**
  1206. * 合并图像并导出PDF
  1207. * @param {Iterable<HTMLCanvasElement | Uint8Array | HTMLImageElement>} imgs 图像元素列表
  1208. * @param {string} title 文档标题
  1209. * @param {number} width (可选)页面宽度 默认 0
  1210. * @param {number} height (可选)页面高度 默认 0
  1211. * @param {boolean} blob (可选)是否返回 blob 默认 false
  1212. */
  1213. imgsToPDF: async function(imgs, title, width = 0, height = 0, blob=false) {
  1214. imgs = Array.from(imgs);
  1215. // 先获取第一个canvas用于判断竖向还是横向,以及得到页面长宽
  1216. const first = imgs[0];
  1217.  
  1218. // 如果没有手动指定canvas的长宽,则自动检测
  1219. if (!width && !height) {
  1220. // 如果是字节数组
  1221. if (first instanceof Uint8Array) {
  1222. const cover = await createImageBitmap(
  1223. new Blob([first])
  1224. );
  1225. [width, height] = [cover.width, cover.height];
  1226.  
  1227. // 如果是画布或图像元素
  1228. } else if (
  1229. first instanceof HTMLCanvasElement ||
  1230. first instanceof HTMLImageElement
  1231. ) {
  1232. if (first.width && parseInt(first.width) && parseInt(first.height)) {
  1233. [width, height] = [first.width, first.height];
  1234. } else {
  1235. const
  1236. width_str = first.style.width.replace(/(px)|(rem)|(em)/, ""),
  1237. height_str = first.style.height.replace(/(px)|(rem)|(em)/, "");
  1238. width = parseInt(width_str);
  1239. height = parseInt(height_str);
  1240. }
  1241. } else {
  1242. // 其他未知类型
  1243. throw TypeError("不能处理的画布元素类型:" + this.classof(first));
  1244. }
  1245. }
  1246. console.log(`canvas数据:宽: ${width}px,高: ${height}px`);
  1247. // 如果文档第一页的宽比长更大,则landscape,否则portrait
  1248. const orientation = width > height ? 'l' : 'p';
  1249. // jsPDF的第三个参数为format,当自定义时,参数为数字数组。
  1250. const pdf = new jspdf.jsPDF(orientation, 'px', [height, width]);
  1251.  
  1252. const last = imgs.pop();
  1253. // 保存每一页文档到每一页pdf
  1254. imgs.forEach((canvas, i) => {
  1255. pdf.addImage(canvas, 'png', 0, 0, width, height);
  1256. pdf.addPage();
  1257. this.popupText(`PDF 已经绘制 ${i + 1} 页`);
  1258. });
  1259. // 添加尾页
  1260. pdf.addImage(last, 'png', 0, 0, width, height);
  1261. // 导出文件
  1262. if (blob) {
  1263. return pdf.output("blob");
  1264. }
  1265. pdf.save(`${title}.pdf`);
  1266. },
  1267.  
  1268. /**
  1269. * imageBitMap转canvas
  1270. * @param {ImageBitmap} bmp
  1271. * @returns {HTMLCanvasElement} canvas
  1272. */
  1273. bmpToCanvas: function(bmp) {
  1274. const canvas = document.createElement("canvas");
  1275. canvas.height = bmp.height;
  1276. canvas.width = bmp.width;
  1277. const ctx = canvas.getContext("bitmaprenderer");
  1278. ctx.transferFromImageBitmap(bmp);
  1279. return canvas;
  1280. },
  1281.  
  1282. /**
  1283. * 导出图片链接
  1284. * @param {Iterable<string>} urls
  1285. */
  1286. saveImgURLs: function(urls) {
  1287. urls = Array
  1288. .from(urls)
  1289. .map(url => {
  1290. if (!url) return;
  1291. if (url.startsWith("//"))
  1292. return "https:" + url;
  1293. return url;
  1294. })
  1295. .filter(url => url);
  1296.  
  1297. this.save(
  1298. "urls.csv", urls.join("\n"), "text/csv"
  1299. );
  1300. },
  1301.  
  1302. /**
  1303. * 图片blobs合并并导出为单个PDF
  1304. * @param {Array<Blob>} blobs
  1305. * @param {string} title (可选)文档名称, 不含后缀, 默认为"文档"
  1306. * @param {boolean} filter (可选)是否过滤 type 不以 "image/" 开头的 blob; 默认为 true
  1307. * @param {boolean} blob (可选)是否返回 blob
  1308. */
  1309. imgBlobsToPDF: async function(blobs, title="文档", filter=true, blob=false) {
  1310. // 格式转换:img blob -> bmp
  1311. let tasks = blobs;
  1312. if (filter) {
  1313. tasks = blobs.filter(
  1314. blob => blob.type.startsWith("image/")
  1315. );
  1316. }
  1317. tasks = await this.gather(
  1318. tasks.map(blob => blob.arrayBuffer())
  1319. );
  1320. tasks = tasks.map(buffer => new Uint8Array(buffer));
  1321. // 导出PDF
  1322. return this.imgsToPDF(tasks, title, 0, 0, blob);
  1323. },
  1324.  
  1325. /**
  1326. * 下载可以简单直接请求的图片,合并到 PDF 并导出
  1327. * @param {Iterable<string>} urls 图片链接列表
  1328. * @param {string} title 文档名称
  1329. * @param {number} min_num 如果成功获取的图片数量 < min_num, 则等待 2 秒后重试; 默认 0 不重试
  1330. * @param {boolean} clear 是否在请求完成后清理控制台输出,默认false
  1331. */
  1332. imgURLsToPDF: async function(urls, title, min_num=0, clear=false) {
  1333. // 强制转换为迭代器类型
  1334. urls = urls[Symbol.iterator]();
  1335. const first = urls.next().value;
  1336. // 如果不符合同源策略,在打开新标签页
  1337. if (!this.isSameOrigin(first)) {
  1338. console.info("URL 不符合同源策略;转为新标签页打开目标网站");
  1339. this.openURL((new URL(first)).origin);
  1340. return;
  1341. }
  1342.  
  1343. let tasks, img_blobs, i = 3;
  1344. // 根据请求成功数量判断是否循环
  1345. do {
  1346. i -= 1;
  1347. // 发起请求
  1348. tasks = [this.xhrGetBlob(first)]; // 初始化时加入第一个
  1349. // 然后加入剩余的
  1350. for (const [j, url] of this.enumerate(urls)) {
  1351. tasks.push(this.xhrGetBlob(url));
  1352. this.popupText(`已经请求 ${j} 张图片`);
  1353. }
  1354. // 接收响应
  1355. img_blobs = (await this.gather(tasks)).filter(
  1356. blob => blob.type.startsWith("image/")
  1357. );
  1358.  
  1359. if (clear) {
  1360. console.clear();
  1361. }
  1362.  
  1363. if (
  1364. min_num
  1365. && img_blobs.length < min_num
  1366. && i
  1367. ) {
  1368. // 下轮行动前冷却
  1369. console.log(`打盹 2 秒`);
  1370. await utils.sleep(2000);
  1371. } else {
  1372. // 结束循环
  1373. break;
  1374. }
  1375. } while (true)
  1376. await this.imgBlobsToPDF(img_blobs, title, false);
  1377. },
  1378.  
  1379. /**
  1380. * 返回子串个数
  1381. * @param {string} str
  1382. * @param {string} sub
  1383. */
  1384. countSubStr: function(str, sub) {
  1385. return [...str.matchAll(sub)].length;
  1386. },
  1387.  
  1388. btnsSec: function() {
  1389. const sec = wk$(".wk-box .btns_section")[0];
  1390. if (!sec) throw new Error("wk 按钮区找不到");
  1391. return sec;
  1392. },
  1393.  
  1394. /**
  1395. * 折叠按钮区,返回是否转换了状态
  1396. */
  1397. foldBtns: function() {
  1398. const sec = this.btnsSec();
  1399. const hide_btn = wk$(".wk-box .hide_btn_wk")[0];
  1400. const display = getComputedStyle(sec).display;
  1401. if (display !== "block") return false;
  1402. // 显示 -> 隐藏
  1403. sec.style.display = "none";
  1404. hide_btn.style.left = "20px";
  1405. hide_btn.textContent = "🙈";
  1406. return true;
  1407. },
  1408.  
  1409. /**
  1410. * 展开按钮区,返回是否转换了状态
  1411. */
  1412. unfoldBtns: function() {
  1413. const sec = this.btnsSec();
  1414. const hide_btn = wk$(".wk-box .hide_btn_wk")[0];
  1415. const display = getComputedStyle(sec).display;
  1416. if (display === "block") return false;
  1417. // 隐藏 -> 显示
  1418. sec.style.display = "block";
  1419. hide_btn.style.left = "155px";
  1420. hide_btn.textContent = "🐵";
  1421. return true;
  1422. },
  1423.  
  1424. /**
  1425. * 运行基于按钮的、显示进度条的函数
  1426. * @param {number} i 按钮序号
  1427. * @param {Function} task 需要等待的耗时函数
  1428. */
  1429. runWithProgPopup: async function(i, task) {
  1430. const btn = utils.btn(i);
  1431. let new_btn;
  1432.  
  1433. if (!$("#wk-popup")[0]) {
  1434. this.addPopup();
  1435. }
  1436.  
  1437. this.foldBtns();
  1438. this.toID("wk-popup");
  1439.  
  1440. new_btn = btn.cloneNode(true);
  1441. btn.replaceWith(new_btn);
  1442. this.onclick(
  1443. () => utils.toID("wk-popup"), i, "显示进度"
  1444. );
  1445.  
  1446. try {
  1447. await task();
  1448. } catch(e) {
  1449. console.error(e);
  1450. }
  1451.  
  1452. this.toID("");
  1453. this.unfoldBtns();
  1454. this.removePopup();
  1455. new_btn.replaceWith(btn);
  1456. },
  1457.  
  1458. /**
  1459. * 创建5个按钮:展开文档、导出图片、导出PDF、未设定4、未设定5;除第1个外默认均为隐藏
  1460. */
  1461. createBtns: function() {
  1462. // 创建大容器
  1463. const box = document.createElement("div");
  1464. box.className = "wk-box";
  1465. document.body.append(box);
  1466.  
  1467. // 创建按钮组
  1468. const section = document.createElement("section");
  1469. section.className = "btns_section";
  1470. section.innerHTML = `
  1471. <p class="logo_tit">Wenku Doc Downloader</p>
  1472. <button class="btn-1">展开文档 😈</button>
  1473. <button class="btn-2">未设定2</button>
  1474. <button class="btn-3">未设定3</button>
  1475. <button class="btn-4">未设定4</button>
  1476. <button class="btn-5">未设定5</button>`;
  1477. box.append(section);
  1478.  
  1479. // 添加隐藏/展示按钮
  1480. // 隐藏【🙈】,展开【🐵】
  1481. const hide_btn = document.createElement("p");
  1482. hide_btn.className = "hide_btn_wk";
  1483. hide_btn.textContent = "🐵";
  1484. hide_btn.onclick = () => this.foldBtns() || this.unfoldBtns();
  1485. box.append(hide_btn);
  1486.  
  1487. // 设定样式
  1488. const style = document.createElement("style");
  1489. style.innerHTML = `
  1490. .hide_btn_wk {
  1491. position: fixed;
  1492. left: 155px;
  1493. top: 36%;
  1494. user-select: none;
  1495. font-size: large;
  1496. z-index: 2000;
  1497. }
  1498. .btns_section{
  1499. position: fixed;
  1500. width: 154px;
  1501. left: 10px;
  1502. top: 32%;
  1503. background: #E7F1FF;
  1504. border: 2px solid #1676FF;
  1505. padding: 0px 0px 10px 0px;
  1506. font-weight: 600;
  1507. border-radius: 2px;
  1508. font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', 'Hiragino Sans GB',
  1509. 'Microsoft YaHei', 'Helvetica Neue', Helvetica, Arial, sans-serif, 'Apple Color Emoji',
  1510. 'Segoe UI Emoji', 'Segoe UI Symbol';
  1511. z-index: 1000;
  1512. }
  1513. .logo_tit{
  1514. width: 100%;
  1515. background: #1676FF;
  1516. text-align: center;
  1517. font-size:12px ;
  1518. color: #E7F1FF;
  1519. line-height: 40px;
  1520. height: 40px;
  1521. margin: 0 0 16px 0;
  1522. }
  1523. .btn-1{
  1524. display: block;
  1525. width: 128px;
  1526. height: 28px;
  1527. background: linear-gradient(180deg, #00E7F7 0%, #FEB800 0.01%, #FF8700 100%);
  1528. border-radius: 4px;
  1529. color: #fff;
  1530. font-size: 12px;
  1531. border: none;
  1532. outline: none;
  1533. margin: 8px auto;
  1534. font-weight: bold;
  1535. cursor: pointer;
  1536. opacity: .9;
  1537. }
  1538. .btn-2{
  1539. display: none;
  1540. width: 128px;
  1541. height: 28px;
  1542. background: #07C160;
  1543. border-radius: 4px;
  1544. color: #fff;
  1545. font-size: 12px;
  1546. border: none;
  1547. outline: none;
  1548. margin: 8px auto;
  1549. font-weight: bold;
  1550. cursor: pointer;
  1551. opacity: .9;
  1552. }
  1553. .btn-3{
  1554. display: none;
  1555. width: 128px;
  1556. height: 28px;
  1557. background:#FA5151;
  1558. border-radius: 4px;
  1559. color: #fff;
  1560. font-size: 12px;
  1561. border: none;
  1562. outline: none;
  1563. margin: 8px auto;
  1564. font-weight: bold;
  1565. cursor: pointer;
  1566. opacity: .9;
  1567. }
  1568. .btn-4{
  1569. display: none;
  1570. width: 128px;
  1571. height: 28px;
  1572. background: #1676FF;
  1573. border-radius: 4px;
  1574. color: #fff;
  1575. font-size: 12px;
  1576. border: none;
  1577. outline: none;
  1578. margin: 8px auto;
  1579. font-weight: bold;
  1580. cursor: pointer;
  1581. opacity: .9;
  1582. }
  1583. .btn-5{
  1584. display: none;
  1585. width: 128px;
  1586. height: 28px;
  1587. background: #ff6600;
  1588. border-radius: 4px;
  1589. color: #fff;
  1590. font-size: 12px;
  1591. border: none;
  1592. outline: none;
  1593. margin: 8px auto;
  1594. font-weight: bold;
  1595. cursor: pointer;
  1596. opacity: .9;
  1597. }
  1598. .btn-1:hover,.btn-2:hover,.btn-3:hover,.btn-4,.btn-5:hover{ opacity: .8;}
  1599. .btn-1:active,.btn-2:active,.btn-3:active,.btn-4,.btn-5:active{ opacity: 1;}`;
  1600. document.head.append(style);
  1601. },
  1602.  
  1603. /**
  1604. * 添加弹窗到 body, 通过 utils.toID("wk-popup") 激发
  1605. */
  1606. addPopup: function() {
  1607. const container = document.createElement("div");
  1608. container.className = "wk-popup-container";
  1609. container.innerHTML = `
  1610. <div class='modal-wrapper' id='wk-popup'>
  1611. <div class='modal-body wk-card'>
  1612. <div class='modal-header'>
  1613. <h2 class='wk-popup-head'>下载进度条</h2>
  1614. <a href='#!' role='wk-button' class='close' aria-label='close this modal'>
  1615. <svg viewBox='0 0 24 24'>
  1616. <path d='M24 20.188l-8.315-8.209 8.2-8.282-3.697-3.697-8.212 8.318-8.31-8.203-3.666 3.666 8.321 8.24-8.206 8.313 3.666 3.666 8.237-8.318 8.285 8.203z'></path>
  1617. </svg>
  1618. </a>
  1619. </div>
  1620. <p class='wk-popup-body'>正在初始化内容...</p>
  1621. </div>
  1622. <a href='#!' class='outside-trigger'></a>
  1623. </div>
  1624. <style>.wk-popup-container{height:100vh;width:100vw;position:fixed;top:0;z-index:999;background:0 0}.wk-popup-head{font-size:1.5em;margin-bottom:12px}.wk-card{background:#fff;background-image:linear-gradient(48deg,#fff 0,#e5efe9 100%);border-top-right-radius:16px;border-bottom-left-radius:16px;box-shadow:-20px 20px 35px 1px rgba(10,49,86,.18);display:flex;flex-direction:column;padding:32px;margin:40px;max-width:400px;width:100%}.content-wrapper{font-size:1.1em;margin-bottom:44px}.content-wrapper:last-child{margin-bottom:0}.wk-button{align-items:center;background:#e5efe9;border:1px solid #5a72b5;border-radius:4px;color:#121943;cursor:pointer;display:flex;font-size:1em;font-weight:700;height:40px;justify-content:center;width:150px}.wk-button:focus{border:2px solid transparent;box-shadow:0 0 0 2px #121943;outline:solid 4px transparent}.link{color:#121943}.link:focus{box-shadow:0 0 0 2px #121943}.input-wrapper{display:flex;flex-direction:column}.input-wrapper .label{align-items:baseline;display:flex;font-weight:700;justify-content:space-between;margin-bottom:8px}.input-wrapper .optional{color:#5a72b5;font-size:.9em}.input-wrapper .input{border:1px solid #5a72b5;border-radius:4px;height:40px;padding:8px}.modal-header{align-items:baseline;display:flex;justify-content:space-between}.close{background:0 0;border:none;cursor:pointer;display:flex;height:16px;text-decoration:none;width:16px}.close svg{width:16px}.modal-wrapper{align-items:center;background:rgba(0,0,0,.7);bottom:0;display:flex;justify-content:center;left:0;position:fixed;right:0;top:0}#wk-popup{opacity:0;transition:opacity .25s ease-in-out;visibility:hidden}#wk-popup:target{opacity:1;visibility:visible}#wk-popup:target .modal-body{opacity:1;transform:translateY(1)}#wk-popup .modal-body{max-width:500px;opacity:0;transform:translateY(-100px);transition:opacity .25s ease-in-out;width:100%;z-index:1}.outside-trigger{bottom:0;cursor:default;left:0;position:fixed;right:0;top:0}</style>;`;
  1625. document.body.append(container);
  1626. },
  1627.  
  1628. /**
  1629. * 设置弹窗标题
  1630. * @param {string} text
  1631. */
  1632. setPopupHead: function(text) {
  1633. const head = wk$(".wk-popup-head")[0];
  1634. if (!head) return;
  1635. head.textContent = text;
  1636. },
  1637.  
  1638. /**
  1639. * 设置弹窗正文
  1640. * @param {string} text
  1641. */
  1642. popupText: function(text) {
  1643. const body = wk$(".wk-popup-body")[0];
  1644. if (!body) return;
  1645. body.textContent = text;
  1646. },
  1647.  
  1648. /**
  1649. * 移除弹窗
  1650. */
  1651. removePopup: function() {
  1652. this.remove(wk$(".wk-popup-container")[0]);
  1653. },
  1654.  
  1655. /**
  1656. * 滚动页面到id位置的元素处
  1657. * @param {string} id
  1658. */
  1659. toID: function(id) {
  1660. location.hash = `#${id}`;
  1661. }
  1662. };
  1663.  
  1664.  
  1665. /**
  1666. * ---------------------------------------------------------------------
  1667. * 绑定使用 this 的函数到 utils,使其均成为绑定方法
  1668. * ---------------------------------------------------------------------
  1669. */
  1670.  
  1671. /**
  1672. * 确保特定外部脚本加载的装饰器
  1673. * @param {string} global_obj_name
  1674. * @param {string} cdn_url
  1675. * @param {Function} func
  1676. * @returns
  1677. */
  1678. function ensureWebScript(global_obj_name, cdn_url, func) {
  1679. async function inner(...args) {
  1680. if (!window[global_obj_name]) {
  1681. // 根据需要加载依赖
  1682. await utils.loadWebScript(cdn_url);
  1683. }
  1684. return func(...args);
  1685. }
  1686. // 存储参数定义
  1687. base.superAssign(inner, func);
  1688. return inner;
  1689. }
  1690.  
  1691.  
  1692. /**
  1693. * 确保引用外部依赖的函数都在调用前加载了依赖
  1694. */
  1695. for (let prop of Object.keys(utils)) {
  1696. // 跳过非函数
  1697. if (
  1698. !(typeof utils[prop] === "function")
  1699. && !`${utils[prop]}`.startsWith("class")
  1700. ) {
  1701. continue;
  1702. }
  1703.  
  1704. // 绑定this到utils
  1705. if (/ this[.[][a-z_]/.test(`${utils[prop]}`)) {
  1706. // 存储参数定义
  1707. const doc = utils.help(utils[prop], false);
  1708. // 绑死this
  1709. utils[prop] = utils[prop].bind(utils);
  1710. // 重设参数定义
  1711. utils[prop].__doc__ = doc;
  1712. }
  1713.  
  1714. // 设定 __doc__ 为访问器属性
  1715. const doc_box = [
  1716. utils.help(utils[prop], false)
  1717. ];
  1718. Object.defineProperty(utils[prop], "__doc__", {
  1719. configurable: true,
  1720. enumerable: true,
  1721. get() { return doc_box.join("\n"); },
  1722. set(new_doc) { doc_box.push(new_doc); },
  1723. });
  1724.  
  1725. // 为有外部依赖的函数做包装
  1726. let obj, url;
  1727. let name = prop.toLowerCase();
  1728. if (name.includes("tozip")) {
  1729. obj = "JSZip";
  1730. url = "https://cdn.staticfile.org/jszip/3.7.1/jszip.min.js";
  1731. } else if (name.includes("topdf")) {
  1732. obj = "jspdf";
  1733. url = "https://cdn.staticfile.org/jspdf/2.5.1/jspdf.umd.min.js";
  1734. } else {
  1735. continue;
  1736. }
  1737. utils[prop] = ensureWebScript(obj, url, utils[prop]);
  1738. }
  1739.  
  1740.  
  1741. /**
  1742. * ---------------------------------------------------------------------
  1743. * 为 utils 部分函数绑定更详细的说明
  1744. * ---------------------------------------------------------------------
  1745. */
  1746.  
  1747. utils.base64DecToArr.__doc__ = `
  1748. /**
  1749. * b64编码字符串转Uint8Array
  1750. * @param {string} sBase64 b64编码的字符串
  1751. * @param {number} nBlockSize 字节数
  1752. * @returns {Uint8Array} arr
  1753. */
  1754. `;
  1755.  
  1756. utils.blobsToZip.__doc__ = `
  1757. /**
  1758. * 合并blobs到压缩包,然后下载
  1759. * @param {Iterable<Blob>} blobs
  1760. * @param {string} base_name 文件名通用部分,如 image-1.jpg 中的 image
  1761. * @param {string} ext 扩展名,如 jpg
  1762. * @param {string} zip_name 压缩包名称
  1763. */
  1764. `;
  1765.  
  1766. utils.imgsToPDF.__doc__ = `
  1767. /**
  1768. * 合并图像并导出PDF
  1769. * @param {Iterable<HTMLCanvasElement | Uint8Array | HTMLImageElement>} imgs 图像元素列表
  1770. * @param {string} title 文档标题
  1771. * @param {number} width (可选)页面宽度 默认 0
  1772. * @param {number} height (可选)页面高度 默认 0
  1773. * @param {boolean} blob (可选)是否返回 blob 默认 false
  1774. */
  1775. `;
  1776.  
  1777. utils.imgURLsToPDF.__doc__ = `
  1778. /**
  1779. * 下载可以简单直接请求的图片,合并到 PDF 并导出
  1780. * @param {Iterable<string>} urls 图片链接列表
  1781. * @param {string} title 文档名称
  1782. * @param {number} min_num 如果成功获取的图片数量 < min_num, 则等待 2 秒后重试; 默认 0 不重试
  1783. * @param {boolean} clear 是否在请求完成后清理控制台输出,默认false
  1784. */
  1785. `;
  1786.  
  1787. utils.imgBlobsToPDF.__doc__ = `
  1788. /**
  1789. * 图片blobs合并并导出为单个PDF
  1790. * @param {Array<Blob>} blobs
  1791. * @param {string} title (可选)文档名称, 不含后缀, 默认为"文档"
  1792. * @param {boolean} filter (可选)是否过滤 type 不以 "image/" 开头的 blob; 默认为 true
  1793. * @param {boolean} blob (可选)是否返回 blob
  1794. */
  1795. `;
  1796.  
  1797.  
  1798. /**
  1799. * ---------------------------------------------------------------------
  1800. * 绑定 utils 成员到 wk$,允许外部轻松调用
  1801. * ---------------------------------------------------------------------
  1802. */
  1803.  
  1804. base.superAssign(wk$, utils);
  1805. console.log("wk: `wk$` 已经挂载到全局");
  1806.  
  1807. /**
  1808. * 展开道客巴巴的文档
  1809. */
  1810. async function readAllDoc88() {
  1811. // 获取“继续阅读”按钮
  1812. let continue_btn = wk$("#continueButton")[0];
  1813. // 如果存在“继续阅读”按钮
  1814. if (continue_btn) {
  1815. // 跳转到文末(等同于展开全文)
  1816. let cur_page = wk$("#pageNumInput")[0];
  1817. // 取得最大页码
  1818. let page_max = cur_page.parentElement.textContent.replace(" / ", "");
  1819. // 跳转到尾页
  1820. utils.toPageNo(cur_page, page_max, "keypress");
  1821. // 返回顶部
  1822. await utils.sleep(1000);
  1823. utils.toPageNo(cur_page, "1", "keypress");
  1824. }
  1825. // 文档展开后,显示按钮
  1826. else {
  1827. for (const i of utils.range(1, 6)) {
  1828. utils.toggle_btn(i);
  1829. }
  1830. }
  1831. }
  1832.  
  1833.  
  1834. /**
  1835. * 隐藏选择文字的弹窗
  1836. */
  1837. async function hideSelectPopup() {
  1838. const
  1839. elem = (await wk$$("#left-menu"))[0],
  1840. hide = elem => elem.style.zIndex = -1;
  1841. return utils.untilVisible(elem).then(hide);
  1842. }
  1843.  
  1844.  
  1845. /**
  1846. * 初始化任务
  1847. */
  1848. async function initService() {
  1849. // 初始化
  1850. console.log("正在执行初始化任务");
  1851.  
  1852. // 1. 查找复制文字可能的api名称
  1853. const prop = getCopyAPIValue();
  1854. globalThis.doc88JS._apis = Object
  1855. .getOwnPropertyNames(prop)
  1856. .filter(name => {
  1857. if (!name.startsWith("_")) {
  1858. return false;
  1859. }
  1860. if (prop[name] === "") {
  1861. return true;
  1862. }
  1863. });
  1864. // 2. 隐藏选中文字的提示框
  1865. await hideSelectPopup();
  1866. // 3. 隐藏搜索框
  1867. // hideSearchBox();
  1868. // 4. 移除vip复制弹窗
  1869. // hideCopyPopup();
  1870. }
  1871.  
  1872.  
  1873. /**
  1874. * 取得 doc88JS.copy_api 所指向属性的值
  1875. * @returns
  1876. */
  1877. function getCopyAPIValue() {
  1878. let aim = globalThis;
  1879. for (let name of globalThis.doc88JS.copy_api) {
  1880. aim = aim[name];
  1881. }
  1882. return aim;
  1883. }
  1884.  
  1885.  
  1886. /**
  1887. * 返回选中的文字
  1888. * @returns {string}
  1889. */
  1890. function getSelectedText() {
  1891. // 首次复制文字,需要先找出api
  1892. if (globalThis.doc88JS.copy_api.length === 3) {
  1893. // 拼接出路径,得到属性
  1894. let prop = getCopyAPIValue(); // 此时是属性,尚未取得值
  1895.  
  1896. // 查询值
  1897. for (let name of globalThis.doc88JS._apis) {
  1898. let value = prop[name];
  1899. // 值从空字符串变为非空字符串了,确认是目标api名称
  1900. if (typeof value === 'string'
  1901. && value.length > 0
  1902. && !value.match(/\d/) // 开头不能是数字,因为可能是 '1-179-195' 这种值
  1903. ) {
  1904. globalThis.doc88JS.copy_api.push(name);
  1905. break;
  1906. }
  1907. }
  1908. }
  1909. return getCopyAPIValue();
  1910. }
  1911.  
  1912.  
  1913. /**
  1914. * 输出选中的文字到剪贴板和控制台,返回是否复制了文档
  1915. * @returns {boolean} doc_is_copied
  1916. */
  1917. function copySelected() {
  1918. // 尚未选中文字
  1919. if (getComputedStyle(wk$("#left-menu")[0]).display === "none") {
  1920. console.log("尚未选中文字");
  1921. return false;
  1922. }
  1923. // 输出到控制台和剪贴板
  1924. utils.copyText(getSelectedText());
  1925. return true;
  1926. }
  1927.  
  1928.  
  1929. /**
  1930. * 捕获 ctrl + c 以复制文字
  1931. * @param {KeyboardEvent} e
  1932. * @returns
  1933. */
  1934. function onCtrlC(e) {
  1935. // 判断是否为 ctrl + c
  1936. if (!(e.code === "KeyC" && e.ctrlKey === true)) {
  1937. return;
  1938. }
  1939.  
  1940. // 判断触发间隔
  1941. let now = Date.now();
  1942. // 距离上次小于0.5秒
  1943. if (now - doc88JS.last_copy_time < 500 * 1) {
  1944. doc88JS.last_copy_time = now;
  1945. return;
  1946. }
  1947. // 大于1秒
  1948. // 刷新最近一次触发时间
  1949. doc88JS.last_copy_time = now;
  1950. // 复制文字
  1951. copySelected();
  1952. // if (!copySelected()) return;
  1953. // 停止传播
  1954. e.stopImmediatePropagation();
  1955. e.stopPropagation();
  1956. }
  1957.  
  1958.  
  1959. /**
  1960. * 浏览并加载所有页面
  1961. */
  1962. async function walkThrough$2() {
  1963. // 文档容器
  1964. let container = wk$("#pageContainer")[0];
  1965. container.style.display = "none";
  1966. // 页码
  1967. let page_num = wk$("#pageNumInput")[0];
  1968. // 文末提示
  1969. let tail = wk$("#readEndDiv > p")[0];
  1970. let origin = tail.textContent;
  1971. // 按钮
  1972. wk$('.btns_section > [class*="btn-"]').forEach(
  1973. elem => elem.style.display = "none"
  1974. );
  1975.  
  1976. // 逐页渲染
  1977. let total = parseInt(Config.p_pagecount);
  1978. try {
  1979. for (let i = 1; i <= total; i++) {
  1980. // 前往页码
  1981. GotoPage(i);
  1982. await utils.wait_until(async() => {
  1983. let page = wk$(`#page_${i}`)[0];
  1984. // page无法选中说明有弹窗
  1985. if (!page) {
  1986. // 关闭弹窗,等待,然后递归
  1987. wk$("#ym-window .DOC88Window_close")[0].click();
  1988. await utils.sleep(500);
  1989. walkThrough$2();
  1990. throw new Error("walkThrough 递归完成,终止函数");
  1991. }
  1992. // canvas尚未绘制时width=300
  1993. return page.width !== 300;
  1994. });
  1995. // 凸显页码
  1996. utils.emphasizeText(page_num);
  1997. tail.textContent = `请勿反复点击按钮,耐心等待页面渲染:${i}/${total}`;
  1998. }
  1999. } catch(e) {
  2000. // 捕获退出信号,然后退出
  2001. console.log(e);
  2002. return;
  2003. }
  2004.  
  2005. // 恢复原本显示
  2006. container.style.display = "";
  2007. page_num.style = "";
  2008. tail.textContent = origin;
  2009. // 按钮
  2010. wk$('.btns_section > [class*="btn-"]').forEach(
  2011. elem => elem.style.display = "block"
  2012. );
  2013. wk$(".btns_section > .btn-1")[0].style.display = "none";
  2014. }
  2015.  
  2016.  
  2017. /**
  2018. * 道客巴巴文档下载策略
  2019. */
  2020. async function doc88() {
  2021. // 全局对象
  2022. globalThis.doc88JS = {
  2023. last_copy_time: 0, // 上一次 ctrl + c 的时间戳(毫秒)
  2024. copy_api: ["Core", "Annotation", "api"]
  2025. };
  2026.  
  2027. // 创建脚本启动按钮1、2
  2028. utils.createBtns();
  2029.  
  2030. // 绑定主函数
  2031. let prepare = function() {
  2032. // 获取canvas元素列表
  2033. let node_list = wk$(".inner_page");
  2034. // 获取文档标题
  2035. let title;
  2036. if (wk$(".doctopic h1")[0]) {
  2037. title = wk$(".doctopic h1")[0].title;
  2038. } else {
  2039. title = "文档";
  2040. }
  2041. return [node_list, title];
  2042. };
  2043.  
  2044. // btn_1: 展开文档
  2045. utils.onclick(readAllDoc88, 1);
  2046.  
  2047. // // btn_2: 加载全部页面
  2048. utils.onclick(walkThrough$2, 2, "加载所有页面");
  2049. // btn_3: 导出PDF
  2050. function imgsToPDF() {
  2051. if (confirm("确定每页内容都加载完成了吗?")) {
  2052. utils.runWithProgPopup(
  2053. 3, () => utils.imgsToPDF(...prepare())
  2054. );
  2055. }
  2056. } utils.onclick(imgsToPDF, 3, "导出图片到PDF");
  2057.  
  2058. // btn_4: 导出ZIP
  2059. utils.onclick(() => {
  2060. if (confirm("确定每页内容都加载完成了吗?")) {
  2061. utils.canvasesToZip(...prepare());
  2062. }
  2063. }, 4, "导出图片到ZIP");
  2064.  
  2065. // btn_5: 复制选中文字
  2066. utils.onclick(btn => {
  2067. if (!copySelected()) {
  2068. btn.textContent = "未选中文字";
  2069. } else {
  2070. btn.textContent = "复制成功!";
  2071. }
  2072. }, 5, "复制选中文字");
  2073.  
  2074. // 为 ctrl + c 添加响应
  2075. window.addEventListener("keydown", onCtrlC, true);
  2076. // 执行一次初始化任务
  2077. window.addEventListener(
  2078. "mousedown", initService, { once: true, capture: true }
  2079. );
  2080. }
  2081.  
  2082. function get_title() {
  2083. return document.title.slice(0,-6);
  2084. }
  2085.  
  2086.  
  2087. function canvases_to_pdf() {
  2088. if (!wk$(".hkswf-content2 canvas").length) {
  2089. alert("当前页面不适用此按钮");
  2090. return;
  2091. }
  2092.  
  2093. if (confirm("页面加载完毕了吗?")) {
  2094. utils.imgsToPDF(
  2095. wk$(".hkswf-content2 canvas"),
  2096. get_title()
  2097. );
  2098. }
  2099. }
  2100.  
  2101.  
  2102. function get_base_url() {
  2103. // https://docimg1.docin.com/docinpic.jsp?file=2179420769&width=1000&sid=bZh4STs-f4NA88IA02INyapgA9Z5X3NN1sGo4WnpquIvk4CyflMk1Oxey1BsO1BG&pageno=2&pcimg=1
  2104. return `https://docimg1.docin.com/docinpic.jsp?` +
  2105. `file=` + location.pathname.match(/p-(\d+)[.]html/)[1] +
  2106. `&width=1000&sid=` + window.readerConfig.flash_param_hzq +
  2107. `&pcimg=1&pageno=`;
  2108. }
  2109.  
  2110.  
  2111. function get_page_num() {
  2112. return parseInt(
  2113. wk$(".page_num")[0].textContent.slice(1)
  2114. );
  2115. }
  2116.  
  2117. function init_imgs_to_pdf() {
  2118. const iframe = document.createElement("iframe");
  2119. iframe.src = "https://docimg1.docin.com/?wk=true";
  2120. iframe.style.display = "none";
  2121. let sock;
  2122.  
  2123. /**
  2124. * @param {MessageEvent} event
  2125. */
  2126. function on_client_msg(event) {
  2127. if (event.data.author !== "wk"
  2128. || event.data.action !== "finish"
  2129. ) return;
  2130. sock.notListen(on_client_msg);
  2131. iframe.remove();
  2132. utils.toggle_btn(1);
  2133. }
  2134. return async function() {
  2135. if (!wk$("[id*=img_] img").length) {
  2136. alert("当前页面不适用此按钮");
  2137. return;
  2138. }
  2139. utils.toggle_btn(1);
  2140. document.body.append(iframe);
  2141. await utils.sleep(500);
  2142.  
  2143. sock = new utils.Socket(iframe.contentWindow);
  2144. await sock.connect(false);
  2145. sock.listen(on_client_msg);
  2146. sock.talk({
  2147. author: "wk",
  2148. title: get_title(),
  2149. base_url: get_base_url(),
  2150. max: get_page_num()
  2151. });
  2152. }
  2153. }
  2154.  
  2155.  
  2156. const imgs_to_pdf = init_imgs_to_pdf();
  2157.  
  2158.  
  2159. function main_page() {
  2160. // 创建脚本启动按钮
  2161. utils.createBtns();
  2162. // btn_2: 加载所有页面
  2163. utils.onclick(
  2164. imgs_to_pdf, 1, "合并图片为PDF"
  2165. );
  2166. // btn_3: 导出PDF
  2167. utils.onclick(
  2168. canvases_to_pdf, 2, "合并画布为PDF"
  2169. );
  2170. utils.toggle_btn(2);
  2171. }
  2172.  
  2173.  
  2174.  
  2175. function init_background() {
  2176. const sock = new utils.Socket(window.top);
  2177.  
  2178. /**
  2179. * @param {MessageEvent} event
  2180. */
  2181. async function on_server_msg(event) {
  2182. if (event.data.author !== "wk") return;
  2183. const { title, base_url, max } = event.data;
  2184. const urls = Array
  2185. .from(utils.range(1, max + 1))
  2186. .map(i => (base_url + i));
  2187. await utils.imgURLsToPDF(urls, title);
  2188.  
  2189. sock.talk({
  2190. author: "wk",
  2191. action: "finish"
  2192. });
  2193. sock.notListen(on_server_msg);
  2194. }
  2195. return async function() {
  2196. sock.listen(on_server_msg);
  2197. await sock.connect(true);
  2198. }
  2199. }
  2200.  
  2201.  
  2202. const background = init_background();
  2203.  
  2204.  
  2205. /**
  2206. * 豆丁文档下载策略
  2207. */
  2208. function docin() {
  2209. const host = location.hostname;
  2210. switch (host) {
  2211. case "jz.docin.com":
  2212. case "www.docin.com":
  2213. main_page();
  2214. break;
  2215.  
  2216. case "docimg1.docin.com":
  2217. background();
  2218. break;
  2219. default:
  2220. console.log(`未知域名: ${host}`);
  2221. break;
  2222. }
  2223. }
  2224.  
  2225. function jumpToHost() {
  2226. // https://swf.ishare.down.sina.com.cn/1DrH4Qt2cvKd.jpg?ssig=DUf5x%2BXnKU&Expires=1673867307&KID=sina,ishare&range={}-{}
  2227. let url = wk$(".data-detail img, .data-detail embed")[0].src;
  2228. if (!url) {
  2229. alert("找不到图片元素");
  2230. return;
  2231. }
  2232.  
  2233. let url_obj = new URL(url);
  2234. let path = url_obj.pathname.slice(1);
  2235. let query = url_obj.search.slice(1).split("&range")[0];
  2236. let title = document.title.split(" - ")[0];
  2237. let target = `${url_obj.protocol}//${url_obj.host}?path=${path}&fname=${title}&${query}`;
  2238. // https://swf.ishare.down.sina.com.cn/
  2239. globalThis.open(target, "hostage");
  2240. // 然后在跳板页面发起对图片的请求
  2241. }
  2242.  
  2243.  
  2244. /**
  2245. * 爱问文库下载跳转策略
  2246. */
  2247. function ishare() {
  2248. // 创建按钮区
  2249. utils.createBtns();
  2250.  
  2251. // btn_1: 识别文档类型 -> 导出PDF
  2252. utils.onclick(jumpToHost, 1, "到下载页面");
  2253. // btn_2: 不支持爱问办公
  2254. utils.onclick(() => null, 2, "不支持爱问办公");
  2255. // utils.toggleBtnStatus(4);
  2256. }
  2257.  
  2258. /**
  2259. * 返回包含对于数量svg元素的html元素
  2260. * @param {string} data
  2261. * @returns {HTMLDivElement} article
  2262. */
  2263. function _createDiv(data) {
  2264. let num = utils.countSubStr(data, data.slice(0, 10));
  2265. let article = document.createElement("div");
  2266. article.id = "article";
  2267. article.innerHTML = `
  2268. <style class="wk-settings">
  2269. body {
  2270. margin: 0px;
  2271. width: 100%;
  2272. background-color: rgb(95,99,104);
  2273. }
  2274. #article {
  2275. width: 100%;
  2276. display: flex;
  2277. flex-direction: row;
  2278. justify-content: space-around;
  2279. }
  2280. #root-box {
  2281. display: flex;
  2282. flex-direction: column;
  2283. background-color: white;
  2284. padding: 0 2em;
  2285. }
  2286. .gap {
  2287. height: 50px;
  2288. width: 100%;
  2289. background-color: transparent;
  2290. }
  2291. </style>
  2292. <div id="root-box">
  2293. ${
  2294. `<object class="svg-box"></object>
  2295. <div class="gap"></div>`.repeat(num)
  2296. }
  2297. `;
  2298. // 移除最后一个多出的gap
  2299. Array.from(article.querySelectorAll(".gap")).at(-1).remove();
  2300. return article;
  2301. }
  2302.  
  2303.  
  2304. function setGap(height) {
  2305. let style = wk$(".wk-settings")[0].innerHTML;
  2306. wk$(".wk-settings")[0].innerHTML = style.replace(
  2307. /[.]gap.*?{.*?height:.+?;/s,
  2308. `.gap { height: ${parseInt(height)}px;`
  2309. );
  2310. }
  2311.  
  2312.  
  2313. function setGapGUI() {
  2314. let now = getComputedStyle(wk$(".gap")[0]).height;
  2315. let new_h = prompt(`当前间距:${now}\n请输入新间距:`);
  2316. if (new_h) {
  2317. setGap(new_h);
  2318. }
  2319. }
  2320.  
  2321.  
  2322. function getSVGtext(data) {
  2323. let div = document.createElement("div");
  2324. div.innerHTML = data;
  2325. return div.textContent;
  2326. }
  2327.  
  2328.  
  2329. function toDisplayMode1() {
  2330. let content = globalThis["ishareJS"].content_1;
  2331. if (!content) {
  2332. content = globalThis["ishareJS"].text
  2333. .replace(/\n{2,}/g, "<hr>")
  2334. .replace(/\n/g, "<br>")
  2335. .replace(/\s/g, "&nbsp;")
  2336. .replace(/([a-z])([A-Z])/g, "$1 $2"); // 英文简单分词
  2337.  
  2338. globalThis["ishareJS"].content_1 = content;
  2339. }
  2340.  
  2341. wk$("#root-box")[0].innerHTML = content;
  2342. }
  2343.  
  2344.  
  2345. function toDisplayMode2() {
  2346. let content = globalThis["ishareJS"].content_2;
  2347. if (!content) {
  2348. content = globalThis["ishareJS"].text
  2349. .replace(/\n{2,}/g, "<hr>")
  2350. .replace(/\n/g, "")
  2351. .replace(/\s/g, "&nbsp;")
  2352. .replace(/([a-z])([A-Z])/g, "$1 $2")
  2353. .split("<hr>")
  2354. .map(paragraph => `<p>${paragraph}</p>`)
  2355. .join("");
  2356. globalThis["ishareJS"].content_2 = content;
  2357. wk$(".wk-settings")[0].innerHTML += `
  2358. #root-box > p {
  2359. text-indent: 2em;
  2360. width: 40em;
  2361. word-break: break-word;
  2362. }
  2363. `;
  2364. }
  2365.  
  2366. wk$("#root-box")[0].innerHTML = content;
  2367. }
  2368.  
  2369.  
  2370. function changeDisplayModeWrapper() {
  2371. let flag = true;
  2372.  
  2373. function inner() {
  2374. if (flag) {
  2375. toDisplayMode1();
  2376. } else {
  2377. toDisplayMode2();
  2378. }
  2379. flag = !flag;
  2380. }
  2381. return inner;
  2382. }
  2383.  
  2384.  
  2385. function handleSVGtext() {
  2386. globalThis["ishareJS"].text = getSVGtext(
  2387. globalThis["ishareJS"].data
  2388. );
  2389.  
  2390. let change = changeDisplayModeWrapper();
  2391. utils.onclick(change, 4, "切换显示模式");
  2392.  
  2393. utils.toggle_btn(2);
  2394. utils.toggle_btn(3);
  2395. utils.toggle_btn(4);
  2396. change();
  2397. }
  2398.  
  2399.  
  2400. /**
  2401. * 处理svg的url
  2402. * @param {string} svg_url
  2403. */
  2404. async function handleSVGurl(svg_url) {
  2405. let resp = await fetch(svg_url);
  2406. let data = await resp.text();
  2407. globalThis["ishareJS"].data = data;
  2408.  
  2409. let sep = data.slice(0, 10);
  2410. let svg_texts = data
  2411. .split(sep)
  2412. .slice(1)
  2413. .map(svg_text => sep + svg_text);
  2414.  
  2415. console.log(`共 ${svg_texts.length} 张图片`);
  2416.  
  2417. let article = _createDiv(data);
  2418. let boxes = article.querySelectorAll(".svg-box");
  2419. boxes.forEach((obj, i) => {
  2420. let blob = new Blob([svg_texts[i]], {type: "image/svg+xml"});
  2421. let url = URL.createObjectURL(blob);
  2422. obj.data = url;
  2423. URL.revokeObjectURL(blob);
  2424. });
  2425.  
  2426. let body = wk$("body")[0];
  2427. body.innerHTML = "";
  2428. body.appendChild(article);
  2429.  
  2430. utils.createBtns();
  2431. utils.onclick(utils.hideBtnThenPrint, 1, "打印页面到PDF");
  2432. utils.onclick(setGapGUI, 2, "重设页间距");
  2433. utils.onclick(handleSVGtext, 3, "显示空白点我");
  2434.  
  2435. utils.toggle_btn(2);
  2436. utils.toggle_btn(3);
  2437. }
  2438.  
  2439.  
  2440. /**
  2441. * 取得图片下载地址
  2442. * @param {string} fname
  2443. * @param {string} path
  2444. * @returns
  2445. */
  2446. function getImgUrl(fname, path) {
  2447. if (!fname) {
  2448. throw new Error("URL Param `fname` does not exist.");
  2449. }
  2450. return location.href
  2451. .replace(/[?].+?&ssig/, "?ssig")
  2452. .replace("?", path + "?");
  2453. }
  2454.  
  2455.  
  2456. /**
  2457. * 下载整个图片包
  2458. * @param {string} img_url
  2459. * @returns
  2460. */
  2461. async function getData(img_url) {
  2462. let resp = await fetch(img_url);
  2463. // window.data = await resp.blob();
  2464. // throw Error("stop");
  2465. let buffer = await resp.arrayBuffer();
  2466. return new Uint8Array(buffer);
  2467. }
  2468.  
  2469.  
  2470. /**
  2471. * 分切图片包为若干图片
  2472. * @param {Uint8Array} data 多张图片合集数据包
  2473. * @returns {Array<Uint8Array>} 图片列表
  2474. */
  2475. function parseData(data) {
  2476. // 判断图像类型/拿到文件头
  2477. let head = data.slice(0, 8);
  2478. return utils.splitFiles(data, head);
  2479. }
  2480.  
  2481.  
  2482. /**
  2483. * 图像Uint8数组列表合并然后导出PDF
  2484. * @param {string} fname
  2485. * @param {Array<Uint8Array>} img_data_list
  2486. */
  2487. async function imgDataArrsToPDF(fname, img_data_list) {
  2488. return utils.imgsToPDF(
  2489. img_data_list,
  2490. fname
  2491. );
  2492. }
  2493.  
  2494.  
  2495. /**
  2496. *
  2497. * @param {string} fname 文件名
  2498. * @param {Array<Uint8Array>} img_data_list 数据列表
  2499. */
  2500. async function saveAsZip(fname, img_data_list) {
  2501. await utils.blobsToZip(
  2502. img_data_list,
  2503. "page",
  2504. "png",
  2505. fname
  2506. );
  2507. }
  2508.  
  2509.  
  2510. /**
  2511. * 取得图片集合体并切分,如果是 SVG 则对应处理
  2512. * @returns {Array<Uint8Array>} imgs
  2513. */
  2514. async function getImgs() {
  2515. let [fname, path] = [
  2516. window.ishareJS.fname,
  2517. window.ishareJS.path
  2518. ];
  2519.  
  2520. let img_url = getImgUrl(fname, path);
  2521.  
  2522. // 处理svg
  2523. if (path.includes(".svg")) {
  2524. document.title = fname;
  2525. await handleSVGurl(img_url);
  2526. return;
  2527. }
  2528. // 处理常规图像
  2529. let data = await getData(img_url);
  2530. let img_data_list = parseData(data);
  2531. console.log(`共 ${img_data_list.length} 张图片`);
  2532.  
  2533. window.ishareJS.imgs = img_data_list;
  2534.  
  2535. // 下载完成,可以导出
  2536. utils.onclick(exportPDF$4, 2, "下载并导出PDF");
  2537. utils.toggle_btn(1);
  2538. utils.toggle_btn(2);
  2539. }
  2540.  
  2541.  
  2542. async function exportPDF$4() {
  2543. let args = [
  2544. window.ishareJS.fname,
  2545. window.ishareJS.imgs
  2546. ];
  2547.  
  2548. try {
  2549. await imgDataArrsToPDF(...args);
  2550. } catch(e) {
  2551. console.error(e);
  2552. // 因 jsPDF 字符串拼接溢出导致的 Error
  2553. if (`${e}`.includes("RangeError: Invalid string length")) {
  2554. // 提示失败
  2555. alert("图片合并为 PDF 时失败,请尝试下载图片压缩包");
  2556. // 备选方案:导出图片压缩包
  2557. utils.onclick(
  2558. () => saveAsZip(...args),
  2559. 3,
  2560. "导出ZIP"
  2561. );
  2562. utils.toggle_btn(3); // 显示导出ZIP按钮
  2563. utils.toggle_btn(2); // 隐藏导出PDF按钮
  2564. } else {
  2565. throw e;
  2566. }
  2567. }
  2568.  
  2569. }
  2570.  
  2571.  
  2572. function showHints() {
  2573. wk$("h1")[0].textContent = "wk 温馨提示";
  2574. wk$("p")[0].innerHTML = [
  2575. "下载 270 页的 PPT (70 MB) 需要约 30 秒",
  2576. "请耐心等待,无需反复点击按钮",
  2577. "如果很久没反应,请加 QQ 群反馈问题"
  2578. ].join("<br>");
  2579. wk$("hr")[0].nextSibling.textContent = "403 Page Hostaged By Wenku Doc Downloader";
  2580. }
  2581.  
  2582.  
  2583. /**
  2584. * 爱问文库下载策略
  2585. */
  2586. async function ishareData() {
  2587. // 全局对象
  2588. globalThis["ishareJS"] = {
  2589. data: "",
  2590. imgs: [],
  2591. text: "",
  2592. content_1: "",
  2593. content_2: "",
  2594. fname: utils.getParam("fname"),
  2595. path: utils.getParam("path")
  2596. };
  2597.  
  2598. // 显示提示
  2599. showHints();
  2600.  
  2601. // 创建按钮区
  2602. utils.createBtns();
  2603.  
  2604. // btn_1: 识别文档类型,处理SVG或下载数据
  2605. utils.onclick(getImgs, 1, "下载数据");
  2606. }
  2607.  
  2608. /**
  2609. * 提供提示信息
  2610. */
  2611. function showTips$1() {
  2612. const h2 = document.createElement("h2");
  2613. h2.id = "wk-tips";
  2614. document.body.append(h2);
  2615. }
  2616.  
  2617.  
  2618. /**
  2619. * 更新文字到 h2 元素
  2620. * @param {string} text
  2621. */
  2622. function update(text) {
  2623. wk$("#wk-tips")[0].textContent = text;
  2624. }
  2625.  
  2626.  
  2627. /**
  2628. * 被动连接,取出数据,请求并分割图片,导出PDF
  2629. */
  2630. function mainTask() {
  2631. const sock = new utils.Socket(opener);
  2632. sock.listen(async e => {
  2633. if (e.data.wk && e.data.action) {
  2634. update("图片下载中,请耐心等待...");
  2635.  
  2636. const url = e.data.img_url;
  2637. const resp = await fetch(url);
  2638. update("图片下载完成,正在解析...");
  2639.  
  2640. const buffer = await resp.arrayBuffer();
  2641. const whole_data = new Uint8Array(buffer);
  2642. update("图片解析完成,正在合并...");
  2643. await utils.imgsToPDF(
  2644. utils.splitFiles(whole_data),
  2645. e.data.title
  2646. );
  2647. update("图片合并完成,正在导出 PDF...");
  2648. }
  2649. });
  2650. sock.connect(true);
  2651. }
  2652.  
  2653.  
  2654. /**
  2655. * 爱问文库图片下载策略v2
  2656. * @returns
  2657. */
  2658. function ishareData2() {
  2659. showTips$1();
  2660. if (!(window.opener && window.opener.window)) {
  2661. update("wk: 抱歉,页面出错了");
  2662. return;
  2663. }
  2664. mainTask();
  2665. }
  2666.  
  2667. function getPageNum() {
  2668. // ' / 6 ' -> ' 6 '
  2669. return parseInt(
  2670. wk$("span.counts")[0].textContent.split("/")[1]
  2671. );
  2672. }
  2673.  
  2674.  
  2675. function jumpToHostage() {
  2676. const
  2677. // '/fileroot/2019-9/23/73598bfa-6b91-4cbe-a548-9996f46653a2/73598bfa-6b91-4cbe-a548-9996f46653a21.gif'
  2678. url = new URL(wk$("#pageflash_1 > img")[0].src),
  2679. num = getPageNum(),
  2680. // '七年级上册地理期末试卷精编.doc-得力文库'
  2681. fname = document.title.slice(0, -5),
  2682. path = url.pathname,
  2683. tail = "1.gif";
  2684. if (!path.endsWith(tail)) {
  2685. throw new Error(`url尾部不为【${tail}】!path:【${path}】`);
  2686. }
  2687. const base_path = path.slice(0, -5);
  2688. open(`${url.protocol}//${url.host}/?num=${num}&lmt=${lmt}&fname=${fname}&path=${base_path}`);
  2689. }
  2690.  
  2691.  
  2692. function deliwenku() {
  2693. utils.createBtns();
  2694. utils.onclick(jumpToHostage, 1, "到下载页面");
  2695. }
  2696.  
  2697. function showTips() {
  2698. const body = `
  2699. <style>
  2700. h1 { color: black; }
  2701. #main {
  2702. margin: 1vw 5%;
  2703. border-radius: 10%;
  2704. }
  2705. p { font-size: large; }
  2706. .info {
  2707. color: rgb(230,214,110);
  2708. background: rgb(39,40,34);
  2709. text-align: right;
  2710. font-size: medium;
  2711. padding: 1vw;
  2712. border-radius: 4px;
  2713. }
  2714. </style>
  2715. <div id="main">
  2716. <h1>wk: 跳板页面</h1>
  2717. <p>有时候点一次下载等半天没反应,就再试一次</p>
  2718. <p>如果试了 2 次还不行加 QQ 群反馈吧...</p>
  2719. <p>导出的 PDF 如果页面数量少于应有的,那么意味着免费页数就这么多,我也爱莫能助</p>
  2720. <p>短时间连续使用导出按钮会导致 IP 被封禁</p>
  2721. <hr>
  2722. <div class="info">
  2723. 文档名称:${deliJS.fname}<br>
  2724. 原始文档页数:${deliJS.num}<br>
  2725. 最大免费页数:${deliJS.lmt}<br>
  2726. </div>
  2727. </div>`;
  2728. document.title = utils.getParam("fname"); document.body.innerHTML = body;
  2729. }
  2730.  
  2731.  
  2732. /**
  2733. * url生成器
  2734. * @param {string} base_url
  2735. * @param {number} num
  2736. */
  2737. function* genURLs(base_url, num) {
  2738. for (let i=1; i<=num; i++) {
  2739. yield `${base_url}${i}.gif`;
  2740. }
  2741. }
  2742.  
  2743.  
  2744. function genBaseURL(path) {
  2745. return `${location.protocol}//${location.host}${path}`;
  2746. }
  2747.  
  2748.  
  2749. function parseParamsToDeliJS() {
  2750. const
  2751. base_url = genBaseURL(utils.getParam("path")),
  2752. fname = utils.getParam("fname"),
  2753. num = parseInt(utils.getParam("num"));
  2754.  
  2755. let lmt = parseInt(utils.getParam("lmt"));
  2756. lmt = lmt > 3 ? lmt : 20;
  2757. lmt = lmt > num ? num : lmt;
  2758.  
  2759. window.deliJS = {
  2760. base_url,
  2761. num,
  2762. fname,
  2763. lmt
  2764. };
  2765. }
  2766.  
  2767.  
  2768. function exportPDF$3() {
  2769. return utils.runWithProgPopup(
  2770. 1, () => utils.imgURLsToPDF(
  2771. genURLs(deliJS.base_url, deliJS.num),
  2772. deliJS.fname,
  2773. deliJS.lmt,
  2774. true // 请求完成后清理控制台
  2775. )
  2776. );
  2777. }
  2778.  
  2779.  
  2780. /**
  2781. * 得力文库跳板页面下载策略
  2782. */
  2783. async function deliFile() {
  2784. // 从URL解析文档参数
  2785. parseParamsToDeliJS();
  2786. // 显示提示
  2787. showTips();
  2788.  
  2789. // 创建按钮区
  2790. utils.createBtns();
  2791. // btn_1: 导出PDF
  2792. utils.onclick(exportPDF$3, 1, "导出PDF");
  2793. }
  2794.  
  2795. function readAll360Doc() {
  2796. // 展开文档
  2797. document.querySelector(".article_showall a").click();
  2798. // 隐藏按钮
  2799. utils.toggle_btn(1);
  2800. // 显示按钮
  2801. utils.toggle_btn(2);
  2802. utils.toggle_btn(3);
  2803. utils.toggle_btn(4);
  2804. }
  2805.  
  2806.  
  2807. function saveText_360Doc() {
  2808. // 捕获图片链接
  2809. let images = wk$("#artContent img");
  2810. let content = [];
  2811.  
  2812. for (let i = 0; i < images.length; i++) {
  2813. let src = images[i].src;
  2814. content.push(`图${i+1},链接:${src}`);
  2815. }
  2816. // 捕获文本
  2817. let text = wk$("#artContent")[0].textContent;
  2818. content.push(text);
  2819.  
  2820. // 保存纯文本文档
  2821. let title = wk$("#titiletext")[0].textContent;
  2822. utils.save(`${title}.txt`, content.join("\n"));
  2823. }
  2824.  
  2825.  
  2826. function printPage360Doc() {
  2827. if (!confirm("确定每页内容都加载完成了吗?")) {
  2828. return;
  2829. }
  2830. // # 清理并打印360doc的文档页
  2831. // ## 移除页面上无关的元素
  2832. 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";
  2833. let elem_list = wk$(selector);
  2834. let under_doc_1, under_doc_2;
  2835. try {
  2836. under_doc_1 = wk$("#bgchange p.clearboth")[0].nextElementSibling;
  2837. under_doc_2 = wk$("#bgchange")[0].nextElementSibling.nextElementSibling;
  2838. } catch (e) {}
  2839. // 执行移除
  2840. for (let elem of elem_list) {
  2841. utils.remove(elem);
  2842. }
  2843. utils.remove(under_doc_1);
  2844. utils.remove(under_doc_2);
  2845. // 执行隐藏
  2846. wk$("a[title]")[0].style.display = "none";
  2847.  
  2848. // 使文档居中
  2849. alert("建议使用:\n偏移量: 20\n缩放: 默认\n");
  2850. if (!utils.centerDoc(".a_left", "20")) {
  2851. return; // 如果输入非法,终止函数调用
  2852. }
  2853. // 隐藏按钮,然后打印页面
  2854. utils.hideBtnThenPrint();
  2855. }
  2856.  
  2857.  
  2858. /**
  2859. * 阻止监听器生效
  2860. * @param {Event} e
  2861. */
  2862. function stopSpread(e) {
  2863. e.stopImmediatePropagation();
  2864. e.stopPropagation();
  2865. }
  2866.  
  2867.  
  2868. /**
  2869. * 阻止捕获事件
  2870. */
  2871. function stopCapturing() {
  2872. ["click", "mouseup"].forEach(
  2873. type => {
  2874. document.body.addEventListener(type, stopSpread, true);
  2875. document["on" + type] = undefined;
  2876. }
  2877. );
  2878. ["keypress", "keydown"].forEach(
  2879. type => {
  2880. window.addEventListener(type, stopSpread, true);
  2881. window["on" + type] = undefined;
  2882. }
  2883. );
  2884. }
  2885.  
  2886.  
  2887. /**
  2888. * 重置图像链接和最大宽度
  2889. * @param {Document} doc
  2890. */
  2891. function resetImg(doc=document) {
  2892. wk$.call(doc, "img").forEach(
  2893. elem => {
  2894. elem.style.maxWidth = "100%";
  2895. for (let attr of elem.attributes) {
  2896. if (attr.name.endsWith("-src")) {
  2897. elem.setAttribute("src", attr.value);
  2898. break;
  2899. }
  2900. }
  2901. }
  2902. );
  2903. }
  2904.  
  2905.  
  2906. /**
  2907. * 仅保留全屏文档
  2908. */
  2909. function getFullScreen() {
  2910. FullScreenObj.init();
  2911. wk$("#artContent > p:nth-child(3)")[0]?.remove();
  2912. let data = wk$("#artfullscreen__box_scr > table")[0].outerHTML;
  2913. window.doc360JS = { data };
  2914. let html_str = `
  2915. <html><head></head><body style="display: flex; flex-direction: row; justify-content: space-around">
  2916. ${data}
  2917. </body><html>
  2918. `;
  2919. wk$("html")[0].replaceWith(wk$("html")[0].cloneNode());
  2920. wk$("html")[0].innerHTML = html_str;
  2921. resetImg();
  2922. }
  2923.  
  2924.  
  2925. function cleanPage() {
  2926. getFullScreen();
  2927. stopCapturing();
  2928. }
  2929.  
  2930.  
  2931. /**
  2932. * 360doc个人图书馆下载策略
  2933. */
  2934. function doc360() {
  2935. // 创建按钮区
  2936. utils.createBtns();
  2937. // btn_1: 展开文档
  2938. utils.onclick(readAll360Doc, 1);
  2939. // btn_2: 导出纯文本
  2940. utils.onclick(saveText_360Doc, 2, "导出纯文本");
  2941. // btn_3: 打印页面到PDF
  2942. utils.onclick(printPage360Doc, 3, "打印页面到PDF");
  2943. // btn_3: 清理页面
  2944. utils.onclick(cleanPage, 4, "清理页面(推荐)");
  2945. }
  2946.  
  2947. async function getPDF() {
  2948. if (!window.DEFAULT_URL) {
  2949. alert("当前文档无法解析,请加 QQ 群反馈");
  2950. return;
  2951. }
  2952. let title = document.title.split(" - ")[0] + ".pdf";
  2953. let blob = await utils.xhrGetBlob(DEFAULT_URL);
  2954. utils.save(title, blob);
  2955. }
  2956.  
  2957.  
  2958. function mbalib() {
  2959. utils.createBtns();
  2960. utils.onclick(getPDF, 1, "下载PDF");
  2961. }
  2962.  
  2963. /**
  2964. * 判断是否进入预览模式
  2965. * @returns Boolean
  2966. */
  2967. function isInPreview() {
  2968. let p_elem = wk$("#preview_tips")[0];
  2969. if (p_elem && p_elem.style && p_elem.style.display === "none") {
  2970. return true;
  2971. }
  2972. return false;
  2973. }
  2974.  
  2975.  
  2976. /**
  2977. * 确保进入预览模式
  2978. */
  2979. async function ensureInPreview() {
  2980. while (!isInPreview()) {
  2981. // 如果没有进入预览,则先进入
  2982. if (typeof window.preview !== "function") {
  2983. alert("脚本失效,请加 QQ 群反馈");
  2984. throw new Error("preview 全局函数不存在");
  2985. }
  2986.  
  2987. await utils.sleep(500);
  2988. preview();
  2989. }
  2990. }
  2991.  
  2992.  
  2993. /**
  2994. * 前往页码
  2995. * @param {number} page_num
  2996. */
  2997. function toPage(page_num) {
  2998. // 先尝试官方接口,不行再用模拟的
  2999. try {
  3000. Viewer._GotoPage(page_num);
  3001. } catch(e) {
  3002. console.error(e);
  3003. utils.toPageNo(
  3004. wk$("#pageNumInput")[0],
  3005. page_num,
  3006. "keydown"
  3007. );
  3008. }
  3009. }
  3010.  
  3011.  
  3012. /**
  3013. * 展开全文预览,当展开完成后再次调用时,返回true
  3014. * @returns
  3015. */
  3016. async function walkThrough$1() {
  3017. // 隐藏页面
  3018. wk$("#pageContainer")[0].style.display = "none";
  3019.  
  3020. // 逐页加载
  3021. let lmt = window.dugenJS.lmt;
  3022. for (let i of utils.range(1, lmt + 1)) {
  3023. toPage(i);
  3024. await utils.wait_until(
  3025. () => wk$(`#outer_page_${i}`)[0].style.width.endsWith("px")
  3026. );
  3027. }
  3028.  
  3029. // 恢复显示
  3030. wk$("#pageContainer")[0].style.display = "";
  3031. console.log(`共 ${lmt} 页加载完毕`);
  3032. }
  3033.  
  3034.  
  3035. /**
  3036. * 返回当前未加载页面的页码
  3037. * @returns not_loaded
  3038. */
  3039. function getNotloadedPages() {
  3040. // 已经取得的页码
  3041. let pages = document.querySelectorAll("[id*=pageflash_]");
  3042. let loaded = new Set();
  3043. pages.forEach((page) => {
  3044. let id = page.id.split("_")[1];
  3045. id = parseInt(id);
  3046. loaded.add(id);
  3047. });
  3048. // 未取得的页码
  3049. let not_loaded = [];
  3050. for (let i of utils.range(1, window.dugenJS.lmt + 1)) {
  3051. if (!loaded.has(i)) {
  3052. not_loaded.push(i);
  3053. }
  3054. }
  3055. return not_loaded;
  3056. }
  3057.  
  3058.  
  3059. /**
  3060. * 取得全部文档页面的链接,返回urls;如果有页面未加载,则返回null
  3061. * @returns
  3062. */
  3063. function getImgUrls$1() {
  3064. let pages = wk$("[id*=pageflash_]");
  3065. // 尚未浏览完全部页面,返回false
  3066. if (pages.length < window.dugenJS.lmt) {
  3067. let hints = [
  3068. "尚未加载完全部页面",
  3069. "以下页面需要浏览并加载:",
  3070. getNotloadedPages().join(",")
  3071. ];
  3072. alert(hints.join("\n"));
  3073. return [false, []];
  3074. }
  3075. // 浏览完全部页面,返回urls
  3076. return [true, pages.map(page => page.querySelector("img").src)];
  3077. }
  3078.  
  3079.  
  3080. function exportImgUrls() {
  3081. let [ok, urls] = getImgUrls$1();
  3082. if (!ok) {
  3083. return;
  3084. }
  3085. utils.save("urls.csv", urls.join("\n"));
  3086. }
  3087.  
  3088.  
  3089. function exportPDF$2() {
  3090. let [ok, urls] = getImgUrls$1();
  3091. if (!ok) {
  3092. return;
  3093. }
  3094. let title = document.title.split("-")[0];
  3095. return utils.runWithProgPopup(
  3096. 3, () => utils.imgURLsToPDF(urls, title)
  3097. );
  3098. }
  3099.  
  3100.  
  3101. /**
  3102. * dugen文档下载策略
  3103. */
  3104. async function dugen() {
  3105. await ensureInPreview();
  3106. // 全局对象
  3107. window.dugenJS = {
  3108. lmt: window.lmt ? window.lmt : 20
  3109. };
  3110.  
  3111. // 创建按钮区
  3112. utils.createBtns();
  3113.  
  3114. // 绑定监听器
  3115. // 按钮1:展开文档
  3116. utils.onclick(walkThrough$1, 1, "加载可预览页面");
  3117. // 按钮2:导出图片链接
  3118. utils.onclick(exportImgUrls, 2, "导出图片链接");
  3119. utils.toggle_btn(2);
  3120. // 按钮3:导出PDF
  3121. utils.onclick(exportPDF$2, 3, "导出PDF");
  3122. utils.toggle_btn(3);
  3123. }
  3124.  
  3125. // 域名级全局常量
  3126. const img_tasks = [];
  3127.  
  3128.  
  3129. /**
  3130. * 取得文档类型
  3131. * @returns {String} 文档类型str
  3132. */
  3133. function getDocType() {
  3134. const
  3135. // ["icon", "icon-format", "icon-format-doc"]
  3136. elem = wk$(".title .icon.icon-format")[0],
  3137. // "icon-format-doc"
  3138. cls = elem.classList[2];
  3139. return cls.split("-")[2];
  3140. }
  3141.  
  3142.  
  3143. /**
  3144. * 判断文档类型是否为type_list其中之一
  3145. * @returns 是否为type
  3146. */
  3147. function isTypeof(type_list) {
  3148. const type = getDocType();
  3149. if (type_list.includes(type)) {
  3150. return true;
  3151. }
  3152. return false;
  3153. }
  3154.  
  3155.  
  3156. /**
  3157. * 判断文档类型是否为PPT
  3158. * @returns 是否为PPT
  3159. */
  3160. function is_ppt() {
  3161. return isTypeof(["ppt", "pptx"]);
  3162. }
  3163.  
  3164.  
  3165. /**
  3166. * 判断文档类型是否为Excel
  3167. * @returns 是否为Excel
  3168. */
  3169. function is_excel() {
  3170. return isTypeof(["xls", "xlsm", "xlsx"]);
  3171. }
  3172.  
  3173.  
  3174. /**
  3175. * 取得未加载页面的页码
  3176. * @returns {Array} not_loaded 未加载页码列表
  3177. */
  3178. function getNotLoaded() {
  3179. const loaded = wk$("[data-id] img[src]").map(
  3180. img => parseInt(
  3181. img.closest("[data-id]").getAttribute("data-id")
  3182. )
  3183. );
  3184. return Array.from(
  3185. utils.diff(
  3186. new Set(utils.range(1, book118JS.page_counts)),
  3187. new Set(loaded)
  3188. )
  3189. );
  3190. }
  3191.  
  3192.  
  3193. /**
  3194. * 取得全部文档页的url
  3195. * @returns [<是否全部加载>, <urls列表>, <未加载页码列表>]
  3196. */
  3197. function getUrls() {
  3198. const urls = wk$("[data-id] img[src]").map(
  3199. img => img.src
  3200. );
  3201. // 如果所有页面加载完毕
  3202. if (urls.length === book118JS.page_counts) {
  3203. return [true, urls, []];
  3204. }
  3205. // 否则收集未加载页面的url
  3206. return [false, urls, getNotLoaded()];
  3207. }
  3208.  
  3209.  
  3210. /**
  3211. * 展开全文
  3212. */
  3213. async function walkThrough() {
  3214. // 遍历期间隐藏按钮区
  3215. utils.toggle_box();
  3216.  
  3217. // 取得总页码
  3218. // preview.getPage()
  3219. // {current: 10, actual: 38, preview: 38, remain: 14}
  3220. const { preview: all } = preview.getPage();
  3221. for (let i = 1; i <= all; i++) {
  3222. // 逐页加载
  3223. preview.jump(i);
  3224. await utils.wait_until(
  3225. () => wk$(`[data-id="${i}"] img`)[0].src, 1000
  3226. );
  3227. }
  3228. console.log("遍历完成");
  3229. utils.toggle_box();
  3230. }
  3231.  
  3232.  
  3233. /**
  3234. * btn_2: 导出图片链接
  3235. */
  3236. function wantUrls() {
  3237. let [flag, urls, escaped] = getUrls();
  3238. // 页面都加载完毕,下载urls
  3239. if (!flag) {
  3240. // 没有加载完,提示出未加载好的页码
  3241. const hint = [
  3242. "仍有页面没有加载",
  3243. "请浏览并加载如下页面",
  3244. "是否继续导出图片链接?",
  3245. "[" + escaped.join(",") + "]"
  3246. ].join("\n");
  3247. // 终止导出
  3248. if (!confirm(hint)) {
  3249. return
  3250. }
  3251. }
  3252. utils.save("urls.csv", urls.join("\n"));
  3253. }
  3254.  
  3255.  
  3256. /**
  3257. * 打开PPT预览页面
  3258. */
  3259. async function open_iframe() {
  3260. wk$(".front a")[0].click();
  3261. const iframes = await wk$$("iframe.preview-iframe");
  3262. window.open(iframes[0].src);
  3263. }
  3264.  
  3265.  
  3266. /**
  3267. * 取得最大页码
  3268. * @returns {number} 最大页码
  3269. */
  3270. function getPageCounts$1() {
  3271. return window?.preview?.getPage()?.preview || NaN;
  3272. }
  3273.  
  3274.  
  3275. /**
  3276. * 原创力文档(非PPT或Excel)下载策略
  3277. */
  3278. async function common_doc() {
  3279. await utils.wait_until(
  3280. () => !!wk$(".counts")[0]
  3281. );
  3282.  
  3283. // 创建全局对象
  3284. window.book118JS = {
  3285. doc_type: getDocType(),
  3286. page_counts: getPageCounts$1()
  3287. };
  3288.  
  3289. // 处理非PPT文档
  3290. // 创建按钮组
  3291. utils.createBtns();
  3292. // 绑定监听器到按钮
  3293. // 按钮1:加载全文
  3294. utils.onclick(walkThrough, 1, "加载全文");
  3295. // 按钮2:导出图片链接
  3296. utils.onclick(wantUrls, 2, "导出图片链接");
  3297. utils.toggle_btn(2);
  3298. }
  3299.  
  3300.  
  3301. /**
  3302. * 取得当前页面的excel,返回csv string
  3303. * @returns {String} csv
  3304. */
  3305. function excel2CSV() {
  3306. const
  3307. table = [],
  3308. rows = wk$("tr[id]");
  3309.  
  3310. // 遍历行
  3311. for (let row of rows) {
  3312. const csv_row = [];
  3313. // 遍历列(单元格)
  3314. for (let cell of wk$.call(row, "td[class*=fi], td.tdrl")) {
  3315. // 判断单元格是否存储图片
  3316. const img = cell.querySelector("img");
  3317. if (img) {
  3318. // 如果是图片,保存图片链接
  3319. csv_row.push(img.src);
  3320. } else {
  3321. // 否则保存单元格文本
  3322. csv_row.push(cell.textContent);
  3323. }
  3324. }
  3325. table.push(csv_row.join(","));
  3326. }
  3327. return table.join("\n").replace(/\n{2,}/g, "\n");
  3328. }
  3329.  
  3330.  
  3331. /**
  3332. * 下载当前表格内容,保存为csv(utf-8编码)
  3333. */
  3334. function wantEXCEL() {
  3335. let file_name = "原创力表格_UTF-8.csv";
  3336. utils.save(file_name, excel2CSV());
  3337. }
  3338.  
  3339.  
  3340. /**
  3341. * 在Excel预览页面给出操作提示
  3342. */
  3343. function help$1() {
  3344. let hint = [
  3345. "【导出表格到CSV】只能导出当前sheet,",
  3346. "如果有多张sheet请在每个sheet上用按钮分别导出CSV。",
  3347. "CSV是一种简单的表格格式,可以被Excel打开,",
  3348. "并转为 xls 或 xlsx 格式存储,",
  3349. "但CSV本身不能存储图片,所以用图片链接代替,请自行下载图片",
  3350. "",
  3351. "本功能导出的CSV文件无法直接用Excel打开,因为中文会乱码。",
  3352. "有两个办法:",
  3353. "1. 打开Excel,选择【数据】,选择【从文本/CSV】,",
  3354. " 选择文件,【文件原始格式】选择【65001: Unicode(UTF-8)】,选择【加载】。",
  3355. "2. 用【记事本】打开CSV文件,【文件】->【另存为】->",
  3356. " 【编码】选择【ANSI】->【保存】。现在可以用Excel直接打开它了。"
  3357. ];
  3358. alert(hint.join("\n"));
  3359. }
  3360.  
  3361.  
  3362. /**
  3363. * 原创力文档(EXCEL)下载策略
  3364. */
  3365. function excel() {
  3366. // 创建按钮区
  3367. utils.createBtns();
  3368. // 绑定监听器到按钮
  3369. utils.onclick(wantEXCEL, 1, "导出表格到CSV");
  3370. utils.onclick(help$1, 2, "使用说明");
  3371. // 显示按钮
  3372. utils.toggle_btn(2);
  3373. }
  3374.  
  3375.  
  3376. /**
  3377. * ------------------------------ PPT 策略 ---------------------------------
  3378. */
  3379.  
  3380.  
  3381. /**
  3382. * 返当前页码
  3383. * @returns {number}
  3384. */
  3385. function cur_page_num() {
  3386. return parseInt(
  3387. wk$("#PageIndex")[0].textContent
  3388. );
  3389. }
  3390.  
  3391.  
  3392. function add_page() {
  3393. const view = wk$("#view")[0];
  3394. view.setAttribute("style", "");
  3395.  
  3396. const i = cur_page_num() - 1;
  3397. const cur_view = wk$(`#view${i}`)[0];
  3398.  
  3399. img_tasks.push(
  3400. html2canvas(cur_view)
  3401. );
  3402. utils.btn(1).textContent = `截图: ${img_tasks.length}`;
  3403. }
  3404.  
  3405.  
  3406. function reset_tasks() {
  3407. img_tasks.splice(0);
  3408. utils.btn(1).textContent = `截图: 0`;
  3409. }
  3410.  
  3411.  
  3412. function canvas_to_blob(canvas) {
  3413. return utils.canvas_to_blob(canvas);
  3414. }
  3415.  
  3416.  
  3417. async function export_imgs_as_pdf() {
  3418. alert("正在合并截图,请耐心等待");
  3419. utils.toggle_btn(3);
  3420.  
  3421. try {
  3422. const imgs = await utils.gather(img_tasks);
  3423. const blobs = await utils.gather(
  3424. imgs.map(canvas_to_blob)
  3425. );
  3426. await utils.imgBlobsToPDF(blobs, "原创力幻灯片");
  3427. } catch(err) {
  3428. console.error(err);
  3429. }
  3430. utils.toggle_btn(3);
  3431. }
  3432.  
  3433.  
  3434.  
  3435. function ppt() {
  3436. utils.createBtns();
  3437.  
  3438. const btn1 = utils.btn(1);
  3439. btn1.onclick = add_page;
  3440. btn1.textContent = "截图当前页面";
  3441.  
  3442. utils.onclick(reset_tasks, 2, "清空截图");
  3443. utils.onclick(export_imgs_as_pdf, 3, "合并为PDF");
  3444.  
  3445. utils.toggle_btn(2);
  3446. utils.toggle_btn(3);
  3447. }
  3448.  
  3449.  
  3450. /**
  3451. * 原创力文档下载策略
  3452. */
  3453. function book118() {
  3454. const host = window.location.hostname;
  3455.  
  3456. if (host === 'max.book118.com') {
  3457. if (is_excel()) {
  3458. utils.createBtns();
  3459. utils.onclick(open_iframe, 1, "访问EXCEL");
  3460. } else if (is_ppt()) {
  3461. utils.createBtns();
  3462. utils.onclick(open_iframe, 1, "访问PPT");
  3463. } else {
  3464. common_doc();
  3465. }
  3466. } else if (host === "view-cache.book118.com") {
  3467. if (window.top !== window) return;
  3468. ppt();
  3469. } else if (host.match(/view[0-9]{1,3}.book118.com/)) {
  3470. excel();
  3471. } else {
  3472. console.log(`wk: Unknown host: ${host}`);
  3473. }
  3474. }
  3475.  
  3476. // test url: https://openstd.samr.gov.cn/bzgk/gb/newGbInfo?hcno=E86BBCE32DA8E67F3DA04ED98F2465DB
  3477.  
  3478.  
  3479. /**
  3480. * 绘制0x0的bmp, 作为请求失败时返回的page
  3481. * @returns {Promise<ImageBitmap>} blank_page
  3482. */
  3483. async function blankBMP() {
  3484. let canvas = document.createElement("canvas");
  3485. [canvas.width, canvas.height] = [0, 0];
  3486. return createImageBitmap(canvas);
  3487. }
  3488.  
  3489.  
  3490. /**
  3491. * resp导出bmp
  3492. * @param {string} page_url
  3493. * @param {Promise<Response> | ImageBitmap} pms_or_bmp
  3494. * @returns {Promise<ImageBitmap>} page
  3495. */
  3496. async function respToPage(page_url, pms_or_bmp) {
  3497. let center = globalThis.gb688JS;
  3498. // 此时是bmp
  3499. if (pms_or_bmp instanceof ImageBitmap) {
  3500. return pms_or_bmp;
  3501. }
  3502.  
  3503. // 第一次下载, 且无人处理
  3504. if (!center.pages_status.get(page_url)) {
  3505. // 处理中, 设为占用
  3506. center.pages_status.set(page_url, 1);
  3507.  
  3508. // 处理
  3509. let resp;
  3510. try {
  3511. resp = await pms_or_bmp;
  3512. } catch(err) {
  3513. console.log("下载页面失败");
  3514. console.error(err);
  3515. return blankBMP();
  3516. }
  3517.  
  3518. let page_blob = await resp.blob();
  3519. let page = await createImageBitmap(page_blob);
  3520. center.pages.set(page_url, page);
  3521. // 处理结束, 设为释放
  3522. center.pages_status.set(page_url, 0);
  3523. return page;
  3524. }
  3525.  
  3526. // 有人正在下载且出于处理中
  3527. while (center.pages_status.get(page_url)) {
  3528. await utils.sleep(500);
  3529. }
  3530. return center.pages.get(page_url);
  3531. }
  3532.  
  3533.  
  3534. /**
  3535. * 获得PNG页面
  3536. * @param {string} page_url
  3537. * @returns {Promise<ImageBitmap>} bmp
  3538. */
  3539. async function getPage(page_url) {
  3540. // 如果下载过, 直接返回缓存
  3541. let pages = globalThis.gb688JS.pages;
  3542. if (pages.has(page_url)) {
  3543. return respToPage(page_url, pages.get(page_url));
  3544. }
  3545.  
  3546. // 如果从未下载过, 就下载
  3547. let resp = fetch(page_url, {
  3548. "headers": {
  3549. "accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
  3550. "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
  3551. "proxy-connection": "keep-alive"
  3552. },
  3553. "referrer": location.href,
  3554. "referrerPolicy": "strict-origin-when-cross-origin",
  3555. "body": null,
  3556. "method": "GET",
  3557. "mode": "cors",
  3558. "credentials": "include"
  3559. });
  3560. pages.set(page_url, resp);
  3561. return respToPage(page_url, resp);
  3562. }
  3563.  
  3564.  
  3565. /**
  3566. * 返回文档页div的裁切和粘贴位置信息: [[cut_x, cut_y, paste_x%, paset_y%],...]
  3567. * @param {HTMLDivElement} page_div 文档页元素
  3568. * @returns {Array<Array<number>>} positions
  3569. */
  3570. function getPostions(page_div) {
  3571. let positions = [];
  3572.  
  3573. Array.from(page_div.children).forEach(span => {
  3574. // 'pdfImg-3-8' -> {left: 30%; top: 80%;}
  3575. let paste_pos = span.className.split("-").slice(1).map(
  3576. v => parseInt(v) / 10
  3577. );
  3578. // '-600px 0px' -> [600, 0]
  3579. let cut_pos = span.style.backgroundPosition.split(" ").map(
  3580. v => Math.abs(parseInt(v))
  3581. );
  3582. positions.push([...cut_pos, ...paste_pos]);
  3583. });
  3584. return positions;
  3585. }
  3586.  
  3587.  
  3588. /**
  3589. * 取得文档页的图像url
  3590. * @param {HTMLDivElement} page_div
  3591. * @returns {string} url
  3592. */
  3593. function getPageURL(page_div) {
  3594. // 拿到目标图像url
  3595. let path = location.pathname.split("/").slice(0, -1).join("/");
  3596. let prefix = location.origin + path + "/";
  3597. let url = page_div.getAttribute("bg");
  3598. if (!url) {
  3599. // 'url("viewGbImg?fileName=VS72l67k0jw5g3j0vErP8DTsnWvk5QsqnNLLxaEtX%2FM%3D")'
  3600. url = page_div.children[0].style.backgroundImage.split('"')[1];
  3601. }
  3602. return prefix + url;
  3603. }
  3604.  
  3605.  
  3606. /**
  3607. * 下载目标图像并拆解重绘, 返回canvas
  3608. * @param {number} i 第 i 页 (从0开始)
  3609. * @param {HTMLDivElement} page_div
  3610. * @returns {Promise<Array>} [页码, Canvas]
  3611. */
  3612. async function getAndDrawPage(i, page_div) {
  3613. // 拿到目标图像
  3614. let url = getPageURL(page_div);
  3615. let page = await getPage(url);
  3616.  
  3617. // 绘制空白A4纸背景
  3618. let [page_w, page_h] = [1190, 1680];
  3619. let bg = document.createElement("canvas");
  3620. bg.width = page_w; // 注意canvas作为取景框的大小
  3621. bg.height = page_h; // 如果不设置等于一个很小的取景框
  3622. let bg_ctx = bg.getContext("2d");
  3623. bg_ctx.fillStyle = "white";
  3624. bg_ctx.fillRect(0, 0, page_w, page_h);
  3625.  
  3626. // 逐个区块剪切取出并粘贴
  3627. // wk$("#viewer .page").forEach(page_div => {
  3628. getPostions(page_div).forEach(pos => {
  3629. bg_ctx.drawImage(
  3630. page, // image source
  3631. pos[0], // source x
  3632. pos[1], // source y
  3633. 120, // source width
  3634. 169, // source height
  3635. pos[2] * page_w, // destination x = left: x%
  3636. pos[3] * page_h, // destination y = top: y%
  3637. 120, // destination width
  3638. 169 // destination height
  3639. );
  3640. });
  3641. // });
  3642. return [i, bg];
  3643. }
  3644.  
  3645.  
  3646. /**
  3647. * 页面批量请求、裁剪重绘, 合成PDF并下载
  3648. */
  3649. async function turnPagesToPDF() {
  3650. // 渲染每页
  3651. const tasks = wk$("#viewer .page").map(
  3652. (page_div, i) => getAndDrawPage(i, page_div)
  3653. );
  3654. // 等待每页渲染完成后,排序
  3655. const results = await utils.gather(tasks);
  3656. results.sort((prev, next) => prev[0] - next[0]);
  3657. // 合并为PDF并导出
  3658. return utils.imgsToPDF(
  3659. results.map(item => item[1]),
  3660. // '在线预览|GB 14023-2022'
  3661. document.title.split("|")[1]
  3662. );
  3663. }
  3664.  
  3665.  
  3666. /**
  3667. * 提示预估下载耗时,然后下载
  3668. */
  3669. function hintThenDownload$1() {
  3670. // '/93'
  3671. let page_num = parseInt(wk$("#numPages")[0].textContent.slice(1));
  3672. let estimate = Math.ceil(page_num / 3);
  3673. alert(`页数: ${page_num},预计花费: ${estimate}秒;如遇网络异常可能更久\n请勿反复点击按钮;如果无法导出请 QQ 群反馈`);
  3674. turnPagesToPDF();
  3675. }
  3676.  
  3677.  
  3678. /**
  3679. * gb688文档下载策略
  3680. */
  3681. async function gb688() {
  3682. // 创建全局对象
  3683. globalThis.gb688JS = {
  3684. pages: new Map(), // {url: bmp}
  3685. pages_status: new Map() // {url: 0或1} 0释放, 1占用
  3686. };
  3687.  
  3688. // 创建按钮区
  3689. utils.createBtns();
  3690. // 绑定监听器
  3691. // 按钮1:导出PDF
  3692. utils.onclick(hintThenDownload$1, 1, "导出PDF");
  3693. }
  3694.  
  3695. function getPageCounts() {
  3696. // " / 39"
  3697. const counts_str = wk$(".counts")[0].textContent.split("/")[1];
  3698. const counts = parseInt(counts_str);
  3699. return counts > 20 ? 20 : counts;
  3700. }
  3701.  
  3702.  
  3703. /**
  3704. * 返回图片基础路径
  3705. * @returns {string} base_url
  3706. */
  3707. function getImgBaseURL() {
  3708. return wk$("#dp")[0].value;
  3709. }
  3710.  
  3711.  
  3712. function* genImgURLs$1() {
  3713. let counts = getPageCounts();
  3714. let base_url = getImgBaseURL();
  3715. for (let i = 1; i <= counts; i++) {
  3716. yield base_url + `${i}.gif`;
  3717. }
  3718. }
  3719.  
  3720.  
  3721. /**
  3722. * 下载图片,转为canvas,合并为PDF并下载
  3723. * @returns {Promise<void>}
  3724. */
  3725. function fetchThenExportPDF() {
  3726. // db2092-2014-河北特种设备使用安全管理规范_安全文库网safewk.com
  3727. let title = document.title.split("_")[0];
  3728. return utils.imgURLsToPDF(genImgURLs$1(), title);
  3729. }
  3730.  
  3731.  
  3732. /**
  3733. * 提示预估下载耗时,然后下载
  3734. */
  3735. function hintThenDownload() {
  3736. let hint = [
  3737. "只能导出可预览的页面(最多20页)",
  3738. "请勿短时间反复点击按钮,导出用时大约不到 10 秒",
  3739. "点完后很久没动静请至 QQ 群反馈"
  3740. ];
  3741. alert(hint.join("\n"));
  3742. return utils.runWithProgPopup(
  3743. 1, fetchThenExportPDF
  3744. );
  3745. }
  3746.  
  3747.  
  3748. /**
  3749. * safewk文档下载策略
  3750. */
  3751. async function safewk() {
  3752. // 创建按钮区
  3753. utils.createBtns();
  3754. // 绑定监听器
  3755. // 按钮1:导出PDF
  3756. utils.onclick(
  3757. hintThenDownload, 1, "导出PDF"
  3758. );
  3759. }
  3760.  
  3761. /**
  3762. * 跳转到页码
  3763. * @param {string | number} num
  3764. */
  3765. function _to_page(num) {
  3766. if (window.WebPreview
  3767. && WebPreview.Page
  3768. && WebPreview.Page.jump
  3769. ) {
  3770. WebPreview.Page.jump(parseInt(num));
  3771. } else {
  3772. console.error("window.WebPreview.Page.jump doesn't exist");
  3773. }
  3774. }
  3775.  
  3776.  
  3777. /**
  3778. * 跳转页码GUI版
  3779. */
  3780. function to_page() {
  3781. let num = prompt("请输入要跳转的页码")?.trim();
  3782. if (/^[0-9]+$/.test(num)) {
  3783. _to_page(num);
  3784. } else {
  3785. console.log(`输入值 [${num}] 不是合法整数`);
  3786. }
  3787. }
  3788.  
  3789.  
  3790. function capture_urls() {
  3791. if (!confirm(
  3792. "只能导出已经预览页面的链接,是否继续?"
  3793. )) return;
  3794.  
  3795. const urls = wk$("[data-id] img").map(img => {
  3796. const src = img.src || img.dataset.src;
  3797. if (!src) return;
  3798. return src.startsWith("//") ? "https:" + src : src
  3799. });
  3800. const lacked = [];
  3801. const existed = urls.filter((url, i) => {
  3802. if (url) return true;
  3803. lacked.push(i + 1);
  3804. });
  3805.  
  3806. utils.saveImgURLs(existed);
  3807. alert(
  3808. `已经浏览的页面中有 ${lacked.length} 页图片尚未加载,` +
  3809. `已经从结果中剔除。\n它们的页码是:\n${lacked}`
  3810. );
  3811. }
  3812.  
  3813.  
  3814. function* genImgURLs() {
  3815. const params = window?.previewParams;
  3816. if (!params) throw new Error(
  3817. "接口为空: window.previewParams"
  3818. );
  3819.  
  3820. let i = -4;
  3821. const
  3822. base = "https://openapi.renrendoc.com/preview/getPreview?",
  3823. query = {
  3824. temp_view: 0,
  3825. jsoncallback: "a",
  3826. callback: "b",
  3827. encrypt: params.encrypt,
  3828. doc_id: params.doc_id,
  3829. get _() { return Date.now() },
  3830. get start() { return i += 5; },
  3831. };
  3832. while (true) {
  3833. const keys = Reflect.ownKeys(query);
  3834. yield base + keys.map(
  3835. key => `${key}=${query[key]}`
  3836. ).join("&");
  3837. }
  3838. }
  3839.  
  3840.  
  3841. async function _fetch_preview_urls() {
  3842. let
  3843. is_empty = true,
  3844. switch_counts = 0,
  3845. previews = [];
  3846. for (const [i, url] of utils.enumerate(genImgURLs())) {
  3847. const resp = await fetch(url);
  3848. utils.raise_for_status(resp);
  3849. const raw_data = await resp.text(),
  3850. data = raw_data.slice(2, -1),
  3851. img_urls = JSON
  3852. .parse(data)
  3853. .data
  3854. ?.preview_list
  3855. ?.map(pair => pair.url);
  3856. if (!img_urls) break;
  3857.  
  3858. previews = previews.concat(...img_urls);
  3859. utils.popupText(`已经请求 ${i + 1} 组图片链接`);
  3860. if (is_empty !== (img_urls.length ? false : true)) {
  3861. is_empty = !is_empty;
  3862. switch_counts++;
  3863. }
  3864. if (switch_counts === 2) break;
  3865.  
  3866. await utils.sleep(1000);
  3867. }
  3868. const
  3869. params = window.previewParams,
  3870. free = params.freepage || 20,
  3871. base = params.pre || wk$(".page img")[0].src.slice(0, -5),
  3872. free_urls = Array.from(
  3873. utils.range(1, free + 1)
  3874. ).map(
  3875. n => `${base}${n}.gif`
  3876. );
  3877.  
  3878. const urls = free_urls.concat(...previews);
  3879. utils.saveImgURLs(urls);
  3880. }
  3881.  
  3882.  
  3883. function fetch_preview_urls() {
  3884. return utils.runWithProgPopup(
  3885. 3, _fetch_preview_urls
  3886. );
  3887. }
  3888.  
  3889.  
  3890. function help() {
  3891. alert(
  3892. "【捕获】和【请求】图片链接的区别:\n" +
  3893. " - 【捕获】是从当前已经加载的文档页中提取图片链接\n" +
  3894. " - 【请求】是使用官方接口直接下载图片链接\n" +
  3895. " - 【捕获】使用麻烦,但是稳定\n" +
  3896. " - 【请求】使用简单,速度快,但可能失效"
  3897. );
  3898. }
  3899.  
  3900.  
  3901. /**
  3902. * 人人文档下载策略
  3903. */
  3904. async function renrendoc() {
  3905. utils.createBtns();
  3906. utils.onclick(to_page, 1, "跳转到页码");
  3907. utils.onclick(capture_urls, 2, "捕获图片链接");
  3908. utils.onclick(fetch_preview_urls, 3, "请求图片链接");
  3909. utils.onclick(help, 4, "使用说明");
  3910.  
  3911. utils.toggle_btn(2);
  3912. utils.toggle_btn(3);
  3913. utils.toggle_btn(4);
  3914. }
  3915.  
  3916. /**
  3917. * 取得全部图片连接
  3918. * @returns {Array<string>}
  3919. */
  3920. function getImgUrls() {
  3921. // '../files/large/'
  3922. let pre_path = htmlConfig.bookConfig.largePath;
  3923. if (pre_path instanceof Array) {
  3924. pre_path = pre_path[0];
  3925. }
  3926. const
  3927. base = location.href,
  3928. urls = window.htmlConfig.fliphtml5_pages.map(obj => {
  3929. // "../files/large/d8b6c26f987104455efb3ec5addca7c9.jpg"
  3930. let path = pre_path + obj.n[0].split("?")[0];
  3931. let url = new URL(path, base);
  3932. // https://book.yunzhan365.com/mctl/itid/files/large/d8b6c26f987104455efb3ec5addca7c9.jpg
  3933. return url.href;
  3934. });
  3935.  
  3936. globalThis.img_urls = urls;
  3937. return urls;
  3938. }
  3939.  
  3940.  
  3941. /**
  3942. * 导出图片到PDF
  3943. */
  3944. function exportPDF$1() {
  3945. const
  3946. urls = getImgUrls(),
  3947. title = htmlConfig.meta.title;
  3948.  
  3949. alert("正在下载图片,请稍等,时长取决于图片数量");
  3950. return utils.runWithProgPopup(
  3951. 1, () => utils.imgURLsToPDF(urls, title)
  3952. );
  3953. }
  3954.  
  3955.  
  3956. /**
  3957. * 移除多余空按钮
  3958. */
  3959. function removeSpareBtns() {
  3960. utils.removeMulti(
  3961. wk$(".btns_section [class*=btn-]").slice(1)
  3962. );
  3963. }
  3964.  
  3965.  
  3966. /**
  3967. * 云展网文档下载策略
  3968. */
  3969. async function yunzhan365() {
  3970. // 根据网址分别处理
  3971. if (location.pathname.startsWith("/basic")) {
  3972. return;
  3973. }
  3974.  
  3975. // 创建脚本启动按钮
  3976. utils.createBtns();
  3977. utils.onclick(exportPDF$1, 1, "导出PDF");
  3978. removeSpareBtns();
  3979. }
  3980.  
  3981. /**
  3982. * 截取当前对话,返回canvas
  3983. * @param {Function} once 一次性任务
  3984. * @returns {Promise<HTMLCanvasElement>}
  3985. */
  3986. async function captureChat(once) {
  3987. // 执行一次性任务
  3988. await once();
  3989. return (
  3990. await utils.elementsToCanvases([window.chat])
  3991. )[0];
  3992. }
  3993.  
  3994.  
  3995. /**
  3996. * 导出图片到文件和剪贴板
  3997. * @param {HTMLCanvasElement} canvas
  3998. */
  3999. async function exportCanvas(canvas) {
  4000. const blob = await utils.canvas_to_blob(canvas);
  4001. utils.save("BingAI对话.png", blob);
  4002. utils.copyData(blob);
  4003. }
  4004.  
  4005.  
  4006. /**
  4007. * 截图并导出对话
  4008. */
  4009. async function exportChatAsImage() {
  4010. // 定义一次性任务
  4011. const once = utils.once(() => {
  4012. // 移除video元素
  4013. utils.removeMulti(wk$("video"));
  4014. // 移除对话外元素
  4015. for (let elem of [...document.body.children].slice(2)) {
  4016. utils.remove(elem);
  4017. } // 移除顶部欢迎
  4018. utils.remove(
  4019. wk$.call(window.chat, "cib-welcome-container")[0]
  4020. );
  4021. });
  4022.  
  4023. return exportCanvas(
  4024. await captureChat(once)
  4025. );
  4026. }
  4027.  
  4028.  
  4029. /**
  4030. * 初始化工作
  4031. */
  4032. async function init() {
  4033. const
  4034. box1 = (await wk$$(".cib-serp-main"))[0],
  4035. box2 = (await wk$$.call(box1.shadowRoot, "#cib-conversation-main"))[0],
  4036. chat = (await wk$$.call(box2.shadowRoot, "#cib-chat-main"))[0],
  4037. outer_bar = (await wk$$.call(box1.shadowRoot, "#cib-action-bar-main"))[0],
  4038. bar = (await wk$$.call(outer_bar.shadowRoot, ".root"))[0],
  4039. ori_btn = (await wk$$.call(bar, ".outside-left-container"))[0];
  4040. window.chat = chat;
  4041. if (!(ori_btn instanceof HTMLElement)) {
  4042. throw Error(`${ori_btn} 的类型不是 HTMLElement!`);
  4043. }
  4044.  
  4045. // 复制按钮
  4046. let button = ori_btn.cloneNode(false);
  4047. window.button = button;
  4048. // 更换按钮图标
  4049. button.innerHTML = `
  4050. <div class="button-compose-wrapper">
  4051. <button class="button-compose" type="button" aria-label="新主题" collapsed="">
  4052. <div class="button-compose-content">
  4053. <div size="32" style="--icon-size:32px;" class="button-compose-icon">
  4054. <svg version="1.0" xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32" preserveAspectRatio="xMidYMid meet">
  4055. <metadata>
  4056. Created by potrace 1.15, written by Peter Selinger 2001-2017, edited by Allen Lv 2023
  4057. </metadata>
  4058. <g transform="translate(4.7, 4.7) scale(0.02, 0.02)">
  4059. <g transform="translate(0.000000,1280.000000) scale(0.100000,-0.100000)" fill="#ffffff" stroke="none">
  4060. <path d="M3998 12784 c-62 -33 -58 154 -58 -2439 l0 -2365 -800 0 -800 0 -31
  4061. -28 c-39 -35 -43 -89 -8 -136 66 -90 3316 -4165 3340 -4188 22 -21 39 -28 69
  4062. -28 29 0 47 7 70 28 16 15 779 968 1695 2117 1163 1460 1667 2099 1671 2121 7
  4063. 36 -8 70 -40 96 -19 16 -78 18 -823 18 l-803 0 0 2375 0 2375 -29 32 -29 33
  4064. -1699 2 c-1488 2 -1701 0 -1725 -13z"></path>
  4065. <path d="M1687 4649 l-288 -8 -32 -27 c-17 -15 -332 -286 -699 -602 l-668
  4066. -575 0 -1719 0 -1718 5630 0 5630 0 0 1718 -1 1717 -700 603 -700 603 -252 5
  4067. c-139 3 -267 7 -284 9 l-33 4 0 -800 0 -799 -3645 0 c-2423 0 -3645 -3 -3645
  4068. -10 0 -5 -3 -10 -7 -10 -5 0 -7 364 -5 810 1 445 -1 809 -5 808 -5 0 -137 -5
  4069. -296 -9z"></path></g></g></svg></div>
  4070. <div class="button-compose-text"><font style="vertical-align: inherit;"><font style="vertical-align: inherit;">保存对话</font></font></div></div>
  4071. </button>
  4072. <div class="button-compose-hint"><font style="vertical-align: inherit;"><font style="vertical-align: inherit;">保存对话</font></font></div>
  4073. </div>`;
  4074. // 为点击绑定回调
  4075. button
  4076. .querySelector(".button-compose-content")
  4077. .addEventListener("click", exportChatAsImage);
  4078.  
  4079. // 添加到DOM
  4080. bar.append(button);
  4081. }
  4082.  
  4083.  
  4084. /**
  4085. * BingAI对话辅助工具
  4086. */
  4087. async function bingAIChat() {
  4088. init();
  4089. }
  4090.  
  4091. /**
  4092. * 导出图片链接
  4093. */
  4094. function exportURLs$1() {
  4095. const all = parseInt(
  4096. wk$("#bot-bar-inn > span")[0].textContent.split("/")[1]
  4097. );
  4098. const imgs = wk$("[data-num] img");
  4099. const got = imgs.length;
  4100.  
  4101. if (got < all) {
  4102. if (!confirm(
  4103. `当前浏览页数:${got},总页数:${all}\n建议浏览剩余页面以导出全部链接\n是否继续导出链接?`
  4104. )) {
  4105. return;
  4106. }
  4107. }
  4108. utils.saveImgURLs(
  4109. imgs.map(img => img.src)
  4110. );
  4111. }
  4112.  
  4113.  
  4114. /**
  4115. * 取出图片链接,发给同源页面让其代下载
  4116. */
  4117. async function callAgent() {
  4118. const url = new URL(
  4119. wk$("[data-num] img")[0].src
  4120. );
  4121. const aim = "swf.ishare.down.sina.com.cn";
  4122. if (url.hostname !== aim) {
  4123. alert("当前页面不适用!");
  4124. console.log(url);
  4125. return;
  4126. }
  4127.  
  4128. const sock = new utils.Socket(
  4129. open(`${url.protocol}//${aim}/?wk=true`)
  4130. );
  4131. await sock.connect(false);
  4132.  
  4133. // 移除请求的内容范围,等价于请求整体
  4134. url.searchParams.delete("range");
  4135. sock.talk({
  4136. wk: true,
  4137. action: true,
  4138. img_url: url.href,
  4139. title: document.title.split(" - ")[0].replace(".pdf", ""),
  4140. });
  4141. alert("请于新打开的页面查收 PDF");
  4142. }
  4143.  
  4144.  
  4145. /**
  4146. * 360文库文档下载策略
  4147. */
  4148. function wenku360() {
  4149. utils.createBtns();
  4150. utils.onclick(
  4151. exportURLs$1, 1, "导出图片链接"
  4152. );
  4153.  
  4154. utils.onclick(
  4155. callAgent, 2, "导出PDF"
  4156. );
  4157. utils.toggle_btn(2);
  4158. }
  4159.  
  4160. async function getFileInfo() {
  4161. const
  4162. uid = new URL(location.href).searchParams.get("contentUid"),
  4163. resp = await fetch("https://zyjy-resource.webtrn.cn/sdk/api/u/open/getResourceDetail", {
  4164. "headers": {
  4165. "accept": "application/json, text/javascript, */*; q=0.01",
  4166. "content-type": "application/json",
  4167. },
  4168. "referrer": "https://jg.class.com.cn/",
  4169. "body": `{"params":{"contentUid":"${uid}"}}`,
  4170. "method": "POST",
  4171. }),
  4172. data = await resp.json(),
  4173. url = data["data"]["downloadUrl"],
  4174. fname = data["data"]["title"];
  4175.  
  4176. let ext;
  4177. try {
  4178. // validate the URL format
  4179. // and get the file format
  4180. ext = new URL(url).pathname.split(".").at(-1);
  4181. } catch(e) {
  4182. console.log(data);
  4183. throw new Error("API changed, the script is invalid now.");
  4184. }
  4185. return { url, fname, ext };
  4186. }
  4187.  
  4188.  
  4189. /**
  4190. * 保存文件
  4191. * @param {{fname: string, url: string, ext: string}} info
  4192. */
  4193. async function saveFile(info) {
  4194. const
  4195. resp = await fetch(info.url),
  4196. blob = await resp.blob();
  4197. utils.save(info.fname + `.${info.ext}`, blob);
  4198. }
  4199.  
  4200.  
  4201. /**
  4202. * 劫持保存网页,改为保存文件
  4203. * @param {KeyboardEvent} e
  4204. */
  4205. function onCtrlS(e) {
  4206. if (e.code === "KeyS" &&
  4207. e.ctrlKey) {
  4208. console.log("ctrl + s is captured!!");
  4209. getFileInfo().then(info => saveFile(info));
  4210.  
  4211. e.preventDefault();
  4212. e.stopImmediatePropagation();
  4213. e.stopPropagation();
  4214. }
  4215. }
  4216.  
  4217.  
  4218. /**
  4219. * 技工教育网文档策略
  4220. */
  4221. function jg() {
  4222. window.addEventListener(
  4223. "keydown", onCtrlS, true
  4224. );
  4225. }
  4226.  
  4227. async function estimateTimeCost() {
  4228. wk$(".w-page").at(-1).scrollIntoView();
  4229. await utils.sleep(1000);
  4230.  
  4231. let total = wk$("#pageNumber-text")[0].textContent.split("/")[1];
  4232. total = parseInt(total);
  4233. return confirm([
  4234. "注意,一旦开始截图就无法停止,除非刷新页面。",
  4235. "浏览器窗口最小化会导致截图提前结束!",
  4236. "建议将窗口最大化,这将【显著增大清晰度和文件体积】",
  4237. `预计耗时 ${1.1 * total} 秒,是否继续?`,
  4238. ].join("\n"));
  4239. }
  4240.  
  4241.  
  4242. /**
  4243. * 逐页捕获canvas
  4244. * @returns {Promise<Array<Blob>>}
  4245. */
  4246. async function collectAll() {
  4247. const imgs = [];
  4248. let div = wk$(".w-page")[0];
  4249. let i = 0;
  4250. while (true) {
  4251. // 取得 div
  4252. const anchor = Date.now();
  4253. while (!div && (Date.now() - anchor < 1000)) {
  4254. console.log(`retry on page ${i+1}`);
  4255. await utils.sleep(200);
  4256. }
  4257. if (!div) throw new Error(
  4258. `can not fetch <div>: page ${i}`
  4259. );
  4260. // 移动到 div
  4261. div.scrollIntoView({ behavior: "smooth" });
  4262. await utils.sleep(1000);
  4263. // 取得 canvas
  4264. let canvas = wk$.call(div, "canvas")[0];
  4265. let j = 0;
  4266. while (!canvas && j < 100) {
  4267. div = div.nextElementSibling;
  4268. canvas = wk$.call(div, "canvas")[0];
  4269. j++;
  4270. }
  4271. if (!div) throw new Error(
  4272. `can not fetch <div>: page ${i}*`
  4273. );
  4274.  
  4275. // 存储 canvas
  4276. imgs.push(
  4277. await utils.canvas_to_blob(canvas)
  4278. );
  4279. console.log(`canvas stored: ${++i}`);
  4280.  
  4281. // 下一轮循环
  4282. div = div.nextElementSibling;
  4283. if (!div) break;
  4284. }
  4285. console.log("done");
  4286. return imgs;
  4287. }
  4288.  
  4289.  
  4290. /**
  4291. * 放大或缩小文档画面
  4292. * @param {boolean} up
  4293. */
  4294. async function scale(up) {
  4295. let s = "#magnifyBtn";
  4296. if (!up) {
  4297. s = "#shrinkBtn";
  4298. }
  4299. const btn = wk$(s)[0];
  4300. for (let _ of utils.range(10)) {
  4301. btn.click();
  4302. await utils.sleep(500);
  4303. }
  4304. }
  4305.  
  4306.  
  4307. /**
  4308. * 获取全部canvas,显示功能按钮
  4309. * @returns
  4310. */
  4311. async function prepare() {
  4312. if (! await estimateTimeCost()) {
  4313. return;
  4314. }
  4315.  
  4316. // 隐藏按钮
  4317. utils.toggle_btn(1);
  4318. // 放大画面
  4319. await scale(true);
  4320.  
  4321. let imgs;
  4322. try {
  4323. imgs = await collectAll();
  4324. } catch(e) {
  4325. console.error(e);
  4326. } finally {
  4327. // 缩小画面
  4328. scale(false);
  4329. }
  4330. // window.imgs = imgs;
  4331. // 显示功能按钮
  4332. const fname = "技工教育网文档";
  4333. utils.onclick(
  4334. () => utils.imgBlobsToPDF(imgs, fname),
  4335. 2,
  4336. "导出PDF"
  4337. );
  4338. utils.toggle_btn(2);
  4339.  
  4340. utils.onclick(
  4341. () => utils.blobsToZip(imgs, "page", "png", fname),
  4342. 3,
  4343. "导出ZIP"
  4344. );
  4345. utils.toggle_btn(3);
  4346. }
  4347.  
  4348.  
  4349. /**
  4350. * 技工教育文档预览页面策略
  4351. */
  4352. function jgPreview() {
  4353. utils.createBtns();
  4354. utils.onclick(
  4355. prepare, 1, "截图文档"
  4356. );
  4357. }
  4358.  
  4359. /**
  4360. * 取得文档标题
  4361. * @returns {string}
  4362. */
  4363. function getTitle() {
  4364. return document.title.slice(0, -4);
  4365. }
  4366.  
  4367.  
  4368. /**
  4369. * 取得基础URL
  4370. * @returns {string}
  4371. */
  4372. function getBaseURL$1() {
  4373. return wk$("#dp")[0].value;
  4374. }
  4375.  
  4376.  
  4377. /**
  4378. * 获取总页码
  4379. * @returns {number}
  4380. */
  4381. function getTotalPageNum() {
  4382. const num = wk$(".shop3 > li:nth-child(3)")[0]
  4383. .textContent
  4384. .split("/")[1]
  4385. .trim();
  4386. return parseInt(num);
  4387. }
  4388.  
  4389.  
  4390. /**
  4391. * 返回图片链接生成器
  4392. * @param {string} base 基础图片链接地址
  4393. * @param {number} max 最大数量
  4394. * @returns {Generator<string, void, unknown>}
  4395. */
  4396. function* imgURLsMaker(base, max) {
  4397. for (let i of utils.range(1, max + 1)) {
  4398. yield `${base}${i}.gif`;
  4399. }
  4400. }
  4401.  
  4402.  
  4403. /**
  4404. * 取得当前页面全部图片链接(生成器)
  4405. * @returns {Generator<string, void, unknown>}
  4406. */
  4407. function getImgURLs() {
  4408. const
  4409. base = getBaseURL$1(),
  4410. total = getTotalPageNum();
  4411. return imgURLsMaker(base, total)
  4412. }
  4413.  
  4414.  
  4415. function exportPDF() {
  4416. const urls = getImgURLs();
  4417. const title = getTitle();
  4418. return utils.runWithProgPopup(
  4419. 2, () => utils.imgURLsToPDF(urls, title)
  4420. );
  4421. }
  4422.  
  4423.  
  4424. function exportURLs() {
  4425. const urls = getImgURLs();
  4426. utils.saveImgURLs(urls);
  4427. }
  4428.  
  4429.  
  4430. /**
  4431. * 文库吧文档下载策略
  4432. */
  4433. function wenkub() {
  4434. utils.createBtns();
  4435. utils.onclick(
  4436. exportURLs, 1, "导出图片链接"
  4437. );
  4438.  
  4439. utils.onclick(
  4440. exportPDF, 2, "导出PDF(测试)"
  4441. );
  4442. utils.toggle_btn(2);
  4443. }
  4444.  
  4445. const PDF_LIB_CDN = "https://cdn.staticfile.org/pdf-lib/1.17.1/pdf-lib.min.js";
  4446.  
  4447.  
  4448. function* pageURLGen() {
  4449. const
  4450. url = new URL(location.href),
  4451. params = url.searchParams,
  4452. base = url.origin + (basePath || "/manuscripts/pdf"),
  4453. type = params.get("type") || "pdf",
  4454. id = params.get("id");
  4455. let i = 0;
  4456. while (true) {
  4457. yield [i, `${base}/data/${type}/${id}/${i++}?random=null`];
  4458. }
  4459. }
  4460.  
  4461.  
  4462. /**
  4463. * 合并多个PDF
  4464. * @param {Array<ArrayBuffer | Uint8Array>} pdfs
  4465. * @returns {Promise<Uint8Array>}
  4466. */
  4467. async function joinPDFs(pdfs) {
  4468. if (!window.PDFLib) {
  4469. await utils.loadWebScript(PDF_LIB_CDN);
  4470. }
  4471.  
  4472. const combined = await PDFLib.PDFDocument.create();
  4473.  
  4474. for (const [i, buffer] of utils.enumerate(pdfs)) {
  4475. const pdf = await PDFLib.PDFDocument.load(buffer);
  4476. const pages = await combined.copyPages(
  4477. pdf, pdf.getPageIndices()
  4478. );
  4479.  
  4480. for (const page of pages) {
  4481. combined.addPage(page);
  4482. }
  4483. utils.popupText(`已经合并 ${i + 1} 组`);
  4484. }
  4485.  
  4486. return await combined.save();
  4487. }
  4488.  
  4489.  
  4490. async function downloadPDF() {
  4491. const pdfs = [];
  4492. let
  4493. last_digest = NaN,
  4494. size = 1;
  4495.  
  4496. // 读取每个PDF的页数
  4497. if (window.loadPdfInfo) {
  4498. try {
  4499. const resp = await loadPdfInfo();
  4500. const info = JSON.parse(resp.data);
  4501. size = parseInt(info.size) || size;
  4502. } catch(e) {
  4503. console.error(e);
  4504. }
  4505. }
  4506.  
  4507. for (const [i, url] of pageURLGen()) {
  4508. // 取得数据
  4509. const b64_data = await fetch(url).then(resp => resp.text());
  4510. // 如果获取完毕,则退出
  4511. if (!b64_data.length) break;
  4512. // 计算摘要
  4513. const digest = utils.crc32(b64_data);
  4514. // 如果摘要重复了,说明到达最后一页,退出
  4515. if (digest === last_digest) break;
  4516. // 否则继续
  4517. last_digest = digest;
  4518. pdfs.push(
  4519. utils.base64DecToArr(b64_data)
  4520. );
  4521. utils.popupText(
  4522. `已经获取 ${i + 1} (${(i + 1) * size} 页)`
  4523. );
  4524. }
  4525.  
  4526. const combined = await joinPDFs(pdfs);
  4527. utils.save(
  4528. document.title + ".pdf",
  4529. combined,
  4530. "application/pdf"
  4531. );
  4532. }
  4533.  
  4534.  
  4535. function downloadPDFGUI() {
  4536. return utils.runWithProgPopup(
  4537. 1, async() => {
  4538. try {
  4539. await downloadPDF();
  4540. } catch(e) {
  4541. console.error(e);
  4542. }
  4543. }
  4544. );
  4545. }
  4546.  
  4547.  
  4548. /**
  4549. * 中国社会科学文库文档策略
  4550. */
  4551. function sklib() {
  4552. utils.createBtns();
  4553. utils.onclick(
  4554. downloadPDFGUI, 1, "导出PDF"
  4555. );
  4556. }
  4557.  
  4558. /**
  4559. * 返回基础图片地址,接上 <页码>.gif 即为完整URL
  4560. * @returns {string}
  4561. */
  4562. function getBaseURL() {
  4563. const
  4564. elem = wk$("#page_1 img")[0],
  4565. src = elem.src;
  4566.  
  4567. if (!src) {
  4568. alert("当前页面不能解析!");
  4569. return;
  4570. }
  4571. if (!src.endsWith("1.gif")) {
  4572. alert("当前文档不能解析!");
  4573. throw new Error("第一页图片不以 1.gif 结尾");
  4574. }
  4575. return src.slice(0, -5);
  4576. }
  4577.  
  4578.  
  4579. function* imgURLGen() {
  4580. const
  4581. base = getBaseURL(),
  4582. max = parseInt(
  4583. // ' / 23 '
  4584. wk$(".counts")[0].textContent.split("/")[1]
  4585. );
  4586.  
  4587. for (const i of utils.range(1, max + 1)) {
  4588. yield `${base}${i}.gif`;
  4589. }
  4590. }
  4591.  
  4592.  
  4593. function getURLs() {
  4594. utils.saveImgURLs(
  4595. imgURLGen()
  4596. );
  4597. }
  4598.  
  4599.  
  4600. function jinchutou() {
  4601. utils.createBtns();
  4602. utils.onclick(
  4603. getURLs, 1, "导出图片链接"
  4604. );
  4605. }
  4606.  
  4607. /**
  4608. * 主函数:识别网站,执行对应文档下载策略
  4609. */
  4610. function main() {
  4611. // 显示当前位置
  4612. const host = location.hostname;
  4613. const params = new URL(location.href).searchParams;
  4614. console.log(`当前 host: ${host}`);
  4615.  
  4616. if (host.includes("docin.com")) {
  4617. docin();
  4618. } else if (host === "swf.ishare.down.sina.com.cn") {
  4619. if (params.get("wk") === "true") {
  4620. ishareData2();
  4621. } else {
  4622. ishareData();
  4623. }
  4624. } else if (host.includes("ishare.iask")) {
  4625. ishare();
  4626. } else if (host === "www.deliwenku.com") {
  4627. deliwenku();
  4628. } else if (host.includes("file") && host.includes("deliwenku.com")) {
  4629. deliFile();
  4630. } else if (host === "www.doc88.com") {
  4631. doc88();
  4632. } else if (host === "www.360doc.com") {
  4633. doc360();
  4634. } else if (host === "doc.mbalib.com") {
  4635. mbalib();
  4636. } else if (host === "www.dugen.com") {
  4637. dugen();
  4638. } else if (host === "c.gb688.cn") {
  4639. gb688();
  4640. } else if (host === "www.safewk.com") {
  4641. safewk();
  4642. } else if (host.includes("book118.com")) {
  4643. book118();
  4644. } else if (host === "www.renrendoc.com") {
  4645. renrendoc();
  4646. } else if (host.includes("yunzhan365.com")) {
  4647. yunzhan365();
  4648. } else if (host === "www.bing.com") {
  4649. bingAIChat();
  4650. } else if (host === "wenku.so.com") {
  4651. wenku360();
  4652. } else if (host === "jg.class.com.cn") {
  4653. jg();
  4654. } else if (host === "preview.imm.aliyuncs.com") {
  4655. jgPreview();
  4656. } else if (host === "www.wenkub.com") {
  4657. wenkub();
  4658. } else if (host === "www.sklib.cn") {
  4659. sklib();
  4660. } else if (host === "www.jinchutou.com") {
  4661. jinchutou();
  4662. } else {
  4663. console.log("匹配到了无效网页");
  4664. }
  4665. }
  4666.  
  4667.  
  4668. setTimeout(main, 1000);
  4669.  
  4670. })();