Wenku Doc Downloader

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

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

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