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.stopImmediatePropagation();
  1854. e.stopPropagation();
  1855. }
  1856.  
  1857.  
  1858. /**
  1859. * 浏览并加载所有页面
  1860. */
  1861. async function walkThrough$3() {
  1862. // 文档容器
  1863. let container = wk$("#pageContainer")[0];
  1864. container.style.display = "none";
  1865. // 页码
  1866. let page_num = wk$("#pageNumInput")[0];
  1867. // 文末提示
  1868. let tail = wk$("#readEndDiv > p")[0];
  1869. let origin = tail.textContent;
  1870. // 按钮
  1871. wk$('.btns_section > [class*="btn-"]').forEach(
  1872. elem => elem.style.display = "none"
  1873. );
  1874.  
  1875. // 逐页渲染
  1876. let total = parseInt(Config.p_pagecount);
  1877. try {
  1878. for (let i = 1; i <= total; i++) {
  1879. // 前往页码
  1880. GotoPage(i);
  1881. await utils.waitUntil(async() => {
  1882. let page = wk$(`#page_${i}`)[0];
  1883. // page无法选中说明有弹窗
  1884. if (!page) {
  1885. // 关闭弹窗,等待,然后递归
  1886. wk$("#ym-window .DOC88Window_close")[0].click();
  1887. await utils.sleep(500);
  1888. walkThrough$3();
  1889. throw new Error("walkThrough 递归完成,终止函数");
  1890. }
  1891. // canvas尚未绘制时width=300
  1892. return page.width !== 300;
  1893. });
  1894. // 凸显页码
  1895. utils.emphasizeText(page_num);
  1896. tail.textContent = `请勿反复点击按钮,耐心等待页面渲染:${i}/${total}`;
  1897. }
  1898. } catch(e) {
  1899. // 捕获退出信号,然后退出
  1900. console.log(e);
  1901. return;
  1902. }
  1903.  
  1904. // 恢复原本显示
  1905. container.style.display = "";
  1906. page_num.style = "";
  1907. tail.textContent = origin;
  1908. // 按钮
  1909. wk$('.btns_section > [class*="btn-"]').forEach(
  1910. elem => elem.style.display = "block"
  1911. );
  1912. wk$(".btns_section > .btn-1")[0].style.display = "none";
  1913. }
  1914.  
  1915.  
  1916. /**
  1917. * 道客巴巴文档下载策略
  1918. */
  1919. async function doc88() {
  1920. // 全局对象
  1921. globalThis.doc88JS = {
  1922. last_copy_time: 0, // 上一次 ctrl + c 的时间戳(毫秒)
  1923. copy_api: ["Core", "Annotation", "api"]
  1924. };
  1925.  
  1926. // 创建脚本启动按钮1、2
  1927. utils.createBtns();
  1928.  
  1929. // 绑定主函数
  1930. let prepare = function() {
  1931. // 获取canvas元素列表
  1932. let node_list = wk$(".inner_page");
  1933. // 获取文档标题
  1934. let title;
  1935. if (wk$(".doctopic h1")[0]) {
  1936. title = wk$(".doctopic h1")[0].title;
  1937. } else {
  1938. title = "文档";
  1939. }
  1940. return [node_list, title];
  1941. };
  1942.  
  1943. // btn_1: 展开文档
  1944. utils.setBtnListener(readAllDoc88, "btn_1");
  1945.  
  1946. // // btn_2: 加载全部页面
  1947. utils.setBtnListener(walkThrough$3, "btn_2", "加载所有页面");
  1948. // btn_3: 导出PDF
  1949. utils.setBtnListener(() => {
  1950. if (confirm("确定每页内容都加载完成了吗?")) {
  1951. utils.imgsToPDF(...prepare());
  1952. }
  1953. }, "btn_3", "导出图片到PDF");
  1954.  
  1955. // btn_4: 导出ZIP
  1956. utils.setBtnListener(() => {
  1957. if (confirm("确定每页内容都加载完成了吗?")) {
  1958. utils.canvasesToZip(...prepare());
  1959. }
  1960. }, "btn_4", "导出图片到ZIP");
  1961.  
  1962. // btn_5: 复制选中文字
  1963. utils.setBtnListener(() => {
  1964. copySelected();
  1965. utils.modifyBtnText("btn_5", "复制成功!");
  1966. }, "btn_5", "复制选中文字");
  1967.  
  1968. // 为 ctrl + c 添加响应
  1969. window.addEventListener("keydown", onCtrlC, true);
  1970. // 执行一次初始化任务
  1971. window.addEventListener(
  1972. "mousedown", initService, { once: true, capture: true }
  1973. );
  1974. }
  1975.  
  1976. function showFreePageNum() {
  1977. const free = docinReader.config.previewNum;
  1978. docinJS.free = free;
  1979. alert(`最多导出:${free}页`);
  1980. }
  1981.  
  1982.  
  1983. /**
  1984. * 加载完所有免费页面
  1985. */
  1986. async function walkThrough$2() {
  1987. const max = docinJS.free; // 最大免费页码
  1988. const num_input = wk$("#page_cur")[0]; // 页码输入框
  1989.  
  1990. // 翻页
  1991. for (let i of utils.range(max, 0, -1)) {
  1992. // 跳转到指定页面
  1993. utils.toPageNo(num_input, i, "keydown");
  1994. const s = `[id="page_${i}"] .hkswf-content2 canvas`;
  1995. // 等待页面加载
  1996. await utils.waitUntil(() => wk$(s).length);
  1997. await utils.untilDOMStill(wk$(s)[0], 500);
  1998. // 强调页码
  1999. utils.emphasizeText(num_input);
  2000. }
  2001. // 恢复页码样式
  2002. num_input.style = "";
  2003. }
  2004.  
  2005.  
  2006. function exportPDF$5() {
  2007. if (confirm("页面加载完毕了吗?")) {
  2008. utils.imgsToPDF(
  2009. wk$(".hkswf-content2 canvas"),
  2010. document.title.split(" - ")[0]
  2011. );
  2012. }
  2013. }
  2014.  
  2015.  
  2016. /**
  2017. * 豆丁文档下载策略
  2018. */
  2019. function docin() {
  2020. // 创建脚本启动按钮
  2021. utils.createBtns();
  2022.  
  2023. // 创建全局对象
  2024. window.docinJS = {
  2025. free: docinReader.config.previewNum
  2026. };
  2027.  
  2028. // btn_1: 判断文档类型
  2029. utils.setBtnListener(
  2030. showFreePageNum, "btn_1", "查看免费页数"
  2031. );
  2032. // btn_2: 加载所有页面
  2033. utils.setBtnListener(
  2034. walkThrough$2, "btn_2", "加载所有页面"
  2035. );
  2036. utils.toggleBtn("btn_2");
  2037.  
  2038. // btn_3: 导出PDF
  2039. utils.setBtnListener(
  2040. exportPDF$5, "btn_3", "导出PDF"
  2041. );
  2042. utils.toggleBtn("btn_3");
  2043. }
  2044.  
  2045. function jumpToHost() {
  2046. // https://swf.ishare.down.sina.com.cn/1DrH4Qt2cvKd.jpg?ssig=DUf5x%2BXnKU&Expires=1673867307&KID=sina,ishare&range={}-{}
  2047. let url = wk$(".data-detail img, .data-detail embed")[0].src;
  2048. if (!url) {
  2049. alert("找不到图片元素");
  2050. return;
  2051. }
  2052.  
  2053. let url_obj = new URL(url);
  2054. let path = url_obj.pathname.slice(1);
  2055. let query = url_obj.search.slice(1).split("&range")[0];
  2056. let title = document.title.split(" - ")[0];
  2057. let target = `${url_obj.protocol}//${url_obj.host}?path=${path}&fname=${title}&${query}`;
  2058. // https://swf.ishare.down.sina.com.cn/
  2059. globalThis.open(target, "hostage");
  2060. // 然后在跳板页面发起对图片的请求
  2061. }
  2062.  
  2063.  
  2064. /**
  2065. * 爱问文库下载跳转策略
  2066. */
  2067. function ishare() {
  2068. // 创建按钮区
  2069. utils.createBtns();
  2070.  
  2071. // btn_1: 识别文档类型 -> 导出PDF
  2072. utils.setBtnListener(jumpToHost, "btn_1", "到下载页面");
  2073. // btn_2: 不支持爱问办公
  2074. utils.setBtnListener(() => null, "btn_2", "不支持爱问办公");
  2075. // utils.toggleBtnStatus("btn_4");
  2076. }
  2077.  
  2078. /**
  2079. * 返回包含对于数量svg元素的html元素
  2080. * @param {string} data
  2081. * @returns {HTMLDivElement} article
  2082. */
  2083. function _createDiv(data) {
  2084. let num = utils.countSubStr(data, data.slice(0, 10));
  2085. let article = document.createElement("div");
  2086. article.id = "article";
  2087. article.innerHTML = `
  2088. <style class="wk-settings">
  2089. body {
  2090. margin: 0px;
  2091. width: 100%;
  2092. background-color: rgb(95,99,104);
  2093. }
  2094. #article {
  2095. width: 100%;
  2096. display: flex;
  2097. flex-direction: row;
  2098. justify-content: space-around;
  2099. }
  2100. #root-box {
  2101. display: flex;
  2102. flex-direction: column;
  2103. background-color: white;
  2104. padding: 0 2em;
  2105. }
  2106. .gap {
  2107. height: 50px;
  2108. width: 100%;
  2109. background-color: transparent;
  2110. }
  2111. </style>
  2112. <div id="root-box">
  2113. ${
  2114. `<object class="svg-box"></object>
  2115. <div class="gap"></div>`.repeat(num)
  2116. }
  2117. `;
  2118. // 移除最后一个多出的gap
  2119. Array.from(article.querySelectorAll(".gap")).at(-1).remove();
  2120. return article;
  2121. }
  2122.  
  2123.  
  2124. function setGap(height) {
  2125. let style = wk$(".wk-settings")[0].innerHTML;
  2126. wk$(".wk-settings")[0].innerHTML = style.replace(
  2127. /[.]gap.*?{.*?height:.+?;/s,
  2128. `.gap { height: ${parseInt(height)}px;`
  2129. );
  2130. }
  2131.  
  2132.  
  2133. function setGapGUI() {
  2134. let now = getComputedStyle(wk$(".gap")[0]).height;
  2135. let new_h = prompt(`当前间距:${now}\n请输入新间距:`);
  2136. if (new_h) {
  2137. setGap(new_h);
  2138. }
  2139. }
  2140.  
  2141.  
  2142. function getSVGtext(data) {
  2143. let div = document.createElement("div");
  2144. div.innerHTML = data;
  2145. return div.textContent;
  2146. }
  2147.  
  2148.  
  2149. function toDisplayMode1() {
  2150. let content = globalThis["ishareJS"].content_1;
  2151. if (!content) {
  2152. content = globalThis["ishareJS"].text
  2153. .replace(/\n{2,}/g, "<hr>")
  2154. .replace(/\n/g, "<br>")
  2155. .replace(/\s/g, "&nbsp;")
  2156. .replace(/([a-z])([A-Z])/g, "$1 $2"); // 英文简单分词
  2157.  
  2158. globalThis["ishareJS"].content_1 = content;
  2159. }
  2160.  
  2161. wk$("#root-box")[0].innerHTML = content;
  2162. }
  2163.  
  2164.  
  2165. function toDisplayMode2() {
  2166. let content = globalThis["ishareJS"].content_2;
  2167. if (!content) {
  2168. content = globalThis["ishareJS"].text
  2169. .replace(/\n{2,}/g, "<hr>")
  2170. .replace(/\n/g, "")
  2171. .replace(/\s/g, "&nbsp;")
  2172. .replace(/([a-z])([A-Z])/g, "$1 $2")
  2173. .split("<hr>")
  2174. .map(paragraph => `<p>${paragraph}</p>`)
  2175. .join("");
  2176. globalThis["ishareJS"].content_2 = content;
  2177. wk$(".wk-settings")[0].innerHTML += `
  2178. #root-box > p {
  2179. text-indent: 2em;
  2180. width: 40em;
  2181. word-break: break-word;
  2182. }
  2183. `;
  2184. }
  2185.  
  2186. wk$("#root-box")[0].innerHTML = content;
  2187. }
  2188.  
  2189.  
  2190. function changeDisplayModeWrapper() {
  2191. let flag = true;
  2192.  
  2193. function inner() {
  2194. if (flag) {
  2195. toDisplayMode1();
  2196. } else {
  2197. toDisplayMode2();
  2198. }
  2199. flag = !flag;
  2200. }
  2201. return inner;
  2202. }
  2203.  
  2204.  
  2205. function handleSVGtext() {
  2206. globalThis["ishareJS"].text = getSVGtext(
  2207. globalThis["ishareJS"].data
  2208. );
  2209.  
  2210. let change = changeDisplayModeWrapper();
  2211. utils.setBtnListener(change, "btn_4", "切换显示模式");
  2212.  
  2213. utils.toggleBtn("btn_2");
  2214. utils.toggleBtn("btn_3");
  2215. utils.toggleBtn("btn_4");
  2216. change();
  2217. }
  2218.  
  2219.  
  2220. /**
  2221. * 处理svg的url
  2222. * @param {string} svg_url
  2223. */
  2224. async function handleSVGurl(svg_url) {
  2225. let resp = await fetch(svg_url);
  2226. let data = await resp.text();
  2227. globalThis["ishareJS"].data = data;
  2228.  
  2229. let sep = data.slice(0, 10);
  2230. let svg_texts = data
  2231. .split(sep)
  2232. .slice(1)
  2233. .map(svg_text => sep + svg_text);
  2234.  
  2235. console.log(`共 ${svg_texts.length} 张图片`);
  2236.  
  2237. let article = _createDiv(data);
  2238. let boxes = article.querySelectorAll(".svg-box");
  2239. boxes.forEach((obj, i) => {
  2240. let blob = new Blob([svg_texts[i]], {type: "image/svg+xml"});
  2241. let url = URL.createObjectURL(blob);
  2242. obj.data = url;
  2243. URL.revokeObjectURL(blob);
  2244. });
  2245.  
  2246. let body = wk$("body")[0];
  2247. body.innerHTML = "";
  2248. body.appendChild(article);
  2249.  
  2250. utils.createBtns();
  2251. utils.setBtnListener(utils.hideBtnThenPrint, "btn_1", "打印页面到PDF");
  2252. utils.setBtnListener(setGapGUI, "btn_2", "重设页间距");
  2253. utils.setBtnListener(handleSVGtext, "btn_3", "显示空白点我");
  2254.  
  2255. utils.toggleBtn("btn_2");
  2256. utils.toggleBtn("btn_3");
  2257. }
  2258.  
  2259.  
  2260. /**
  2261. * 取得图片下载地址
  2262. * @param {string} fname
  2263. * @param {string} path
  2264. * @returns
  2265. */
  2266. function getImgUrl(fname, path) {
  2267. if (!fname) {
  2268. throw new Error("URL Param `fname` does not exist.");
  2269. }
  2270. return location.href
  2271. .replace(/[?].+?&ssig/, "?ssig")
  2272. .replace("?", path + "?");
  2273. }
  2274.  
  2275.  
  2276. /**
  2277. * 下载整个图片包
  2278. * @param {string} img_url
  2279. * @returns
  2280. */
  2281. async function getData(img_url) {
  2282. let resp = await fetch(img_url);
  2283. // window.data = await resp.blob();
  2284. // throw Error("stop");
  2285. let buffer = await resp.arrayBuffer();
  2286. return new Uint8Array(buffer);
  2287. }
  2288.  
  2289.  
  2290. /**
  2291. * 分切图片包为若干图片
  2292. * @param {Uint8Array} data 多张图片合集数据包
  2293. * @returns {Array<Uint8Array>} 图片列表
  2294. */
  2295. function parseData(data) {
  2296. // 判断图像类型/拿到文件头
  2297. let head = data.slice(0, 8);
  2298. return utils.splitFiles(data, head);
  2299. }
  2300.  
  2301.  
  2302. /**
  2303. * 图像Uint8数组列表合并然后导出PDF
  2304. * @param {string} fname
  2305. * @param {Array<Uint8Array>} img_data_list
  2306. */
  2307. async function imgDataArrsToPDF(fname, img_data_list) {
  2308. return utils.imgsToPDF(
  2309. img_data_list,
  2310. fname
  2311. );
  2312. }
  2313.  
  2314.  
  2315. /**
  2316. *
  2317. * @param {string} fname 文件名
  2318. * @param {Array<Uint8Array>} img_data_list 数据列表
  2319. */
  2320. async function saveAsZip(fname, img_data_list) {
  2321. await utils.blobsToZip(
  2322. img_data_list,
  2323. "page",
  2324. "png",
  2325. fname
  2326. );
  2327. }
  2328.  
  2329.  
  2330. /**
  2331. * 取得图片集合体并切分,如果是 SVG 则对应处理
  2332. * @returns {Array<Uint8Array>} imgs
  2333. */
  2334. async function getImgs() {
  2335. let [fname, path] = [
  2336. window.ishareJS.fname,
  2337. window.ishareJS.path
  2338. ];
  2339.  
  2340. let img_url = getImgUrl(fname, path);
  2341.  
  2342. // 处理svg
  2343. if (path.includes(".svg")) {
  2344. document.title = fname;
  2345. await handleSVGurl(img_url);
  2346. return;
  2347. }
  2348. // 处理常规图像
  2349. let data = await getData(img_url);
  2350. let img_data_list = parseData(data);
  2351. console.log(`共 ${img_data_list.length} 张图片`);
  2352.  
  2353. window.ishareJS.imgs = img_data_list;
  2354.  
  2355. // 下载完成,可以导出
  2356. utils.setBtnListener(exportPDF$4, "btn_2", "下载并导出PDF");
  2357. utils.toggleBtn("btn_1");
  2358. utils.toggleBtn("btn_2");
  2359. }
  2360.  
  2361.  
  2362. async function exportPDF$4() {
  2363. let args = [
  2364. window.ishareJS.fname,
  2365. window.ishareJS.imgs
  2366. ];
  2367.  
  2368. try {
  2369. await imgDataArrsToPDF(...args);
  2370. } catch(e) {
  2371. console.error(e);
  2372. // 因 jsPDF 字符串拼接溢出导致的 Error
  2373. if (`${e}`.includes("RangeError: Invalid string length")) {
  2374. // 提示失败
  2375. alert("图片合并为 PDF 时失败,请尝试下载图片压缩包");
  2376. // 备选方案:导出图片压缩包
  2377. utils.setBtnListener(
  2378. () => saveAsZip(...args),
  2379. "btn_3",
  2380. "导出ZIP"
  2381. );
  2382. utils.toggleBtn("btn_3"); // 显示导出ZIP按钮
  2383. utils.toggleBtn("btn_2"); // 隐藏导出PDF按钮
  2384. } else {
  2385. throw e;
  2386. }
  2387. }
  2388.  
  2389. }
  2390.  
  2391.  
  2392. function showHints() {
  2393. wk$("h1")[0].textContent = "wk 温馨提示";
  2394. wk$("p")[0].innerHTML = [
  2395. "下载 270 页的 PPT (70 MB) 需要约 30 秒",
  2396. "请耐心等待,无需反复点击按钮",
  2397. "如果很久没反应,请加 QQ 群反馈问题"
  2398. ].join("<br>");
  2399. wk$("hr")[0].nextSibling.textContent = "403 Page Hostaged By Wenku Doc Downloader";
  2400. }
  2401.  
  2402.  
  2403. /**
  2404. * 爱问文库下载策略
  2405. */
  2406. async function ishareData() {
  2407. // 全局对象
  2408. globalThis["ishareJS"] = {
  2409. data: "",
  2410. imgs: [],
  2411. text: "",
  2412. content_1: "",
  2413. content_2: "",
  2414. fname: utils.getParam("fname"),
  2415. path: utils.getParam("path")
  2416. };
  2417.  
  2418. // 显示提示
  2419. showHints();
  2420.  
  2421. // 创建按钮区
  2422. utils.createBtns();
  2423.  
  2424. // btn_1: 识别文档类型,处理SVG或下载数据
  2425. utils.setBtnListener(getImgs, "btn_1", "下载数据");
  2426. }
  2427.  
  2428. /**
  2429. * 提供提示信息
  2430. */
  2431. function showTips$1() {
  2432. const h2 = document.createElement("h2");
  2433. h2.id = "wk-tips";
  2434. document.body.append(h2);
  2435. }
  2436.  
  2437.  
  2438. /**
  2439. * 更新文字到 h2 元素
  2440. * @param {string} text
  2441. */
  2442. function update(text) {
  2443. wk$("#wk-tips")[0].textContent = text;
  2444. }
  2445.  
  2446.  
  2447. /**
  2448. * 被动连接,取出数据,请求并分割图片,导出PDF
  2449. */
  2450. function onConnection() {
  2451. const sock = new utils.Socket(opener);
  2452. sock.listen(async e => {
  2453. if (e.data.wk && e.data.action) {
  2454. update("图片下载中,请耐心等待...");
  2455.  
  2456. const url = e.data.img_url;
  2457. const resp = await fetch(url);
  2458. update("图片下载完成,正在解析...");
  2459.  
  2460. const buffer = await resp.arrayBuffer();
  2461. const whole_data = new Uint8Array(buffer);
  2462. update("图片解析完成,正在合并...");
  2463. await utils.imgsToPDF(
  2464. utils.splitFiles(whole_data),
  2465. e.data.title
  2466. );
  2467. update("图片合并完成,正在导出 PDF...");
  2468. }
  2469. });
  2470. sock.connect(true);
  2471. }
  2472.  
  2473.  
  2474. /**
  2475. * 爱问文库图片下载策略v2
  2476. * @returns
  2477. */
  2478. function ishareData2() {
  2479. showTips$1();
  2480. if (!(window.opener && window.opener.window)) {
  2481. update("wk: 抱歉,页面出错了");
  2482. return;
  2483. }
  2484. onConnection();
  2485. }
  2486.  
  2487. function getPageNum() {
  2488. // ' / 6 ' -> ' 6 '
  2489. return parseInt(
  2490. wk$("span.counts")[0].textContent.split("/")[1]
  2491. );
  2492. }
  2493.  
  2494.  
  2495. function jumpToHostage() {
  2496. const
  2497. // '/fileroot/2019-9/23/73598bfa-6b91-4cbe-a548-9996f46653a2/73598bfa-6b91-4cbe-a548-9996f46653a21.gif'
  2498. url = new URL(wk$("#pageflash_1 > img")[0].src),
  2499. num = getPageNum(),
  2500. // '七年级上册地理期末试卷精编.doc-得力文库'
  2501. fname = document.title.slice(0, -5),
  2502. path = url.pathname,
  2503. tail = "1.gif";
  2504. if (!path.endsWith(tail)) {
  2505. throw new Error(`url尾部不为【${tail}】!path:【${path}】`);
  2506. }
  2507. const base_path = path.slice(0, -5);
  2508. open(`${url.protocol}//${url.host}/?num=${num}&lmt=${lmt}&fname=${fname}&path=${base_path}`);
  2509. }
  2510.  
  2511.  
  2512. function deliwenku() {
  2513. utils.createBtns();
  2514. utils.setBtnListener(jumpToHostage, "btn_1", "到下载页面");
  2515. }
  2516.  
  2517. function showTips() {
  2518. const body = `
  2519. <style>
  2520. h1 { color: black; }
  2521. #main {
  2522. margin: 1vw 5%;
  2523. border-radius: 10%;
  2524. }
  2525. p { font-size: large; }
  2526. .info {
  2527. color: rgb(230,214,110);
  2528. background: rgb(39,40,34);
  2529. text-align: right;
  2530. font-size: medium;
  2531. padding: 1vw;
  2532. border-radius: 4px;
  2533. }
  2534. </style>
  2535. <div id="main">
  2536. <h1>wk: 跳板页面</h1>
  2537. <p>有时候点一次下载等半天没反应,就再试一次</p>
  2538. <p>如果试了 2 次还不行加 QQ 群反馈吧...</p>
  2539. <p>导出的 PDF 如果页面数量少于应有的,那么意味着免费页数就这么多,我也爱莫能助</p>
  2540. <p>短时间连续使用导出按钮会导致 IP 被封禁</p>
  2541. <hr>
  2542. <div class="info">
  2543. 文档名称:${deliJS.fname}<br>
  2544. 原始文档页数:${deliJS.num}<br>
  2545. 最大免费页数:${deliJS.lmt}<br>
  2546. </div>
  2547. </div>`;
  2548. document.title = utils.getParam("fname"); document.body.innerHTML = body;
  2549. }
  2550.  
  2551.  
  2552. /**
  2553. * url生成器
  2554. * @param {string} base_url
  2555. * @param {number} num
  2556. */
  2557. function* genURLs(base_url, num) {
  2558. for (let i=1; i<=num; i++) {
  2559. yield `${base_url}${i}.gif`;
  2560. }
  2561. }
  2562.  
  2563.  
  2564. function genBaseURL(path) {
  2565. return `${location.protocol}//${location.host}${path}`;
  2566. }
  2567.  
  2568.  
  2569. function parseParamsToDeliJS() {
  2570. const
  2571. base_url = genBaseURL(utils.getParam("path")),
  2572. fname = utils.getParam("fname"),
  2573. num = parseInt(utils.getParam("num"));
  2574.  
  2575. let lmt = parseInt(utils.getParam("lmt"));
  2576. lmt = lmt > 3 ? lmt : 20;
  2577. lmt = lmt > num ? num : lmt;
  2578.  
  2579. window.deliJS = {
  2580. base_url,
  2581. num,
  2582. fname,
  2583. lmt
  2584. };
  2585. }
  2586.  
  2587.  
  2588. async function exportPDF$3() {
  2589. return utils.imgURLsToPDF(
  2590. genURLs(deliJS.base_url, deliJS.num),
  2591. deliJS.fname,
  2592. deliJS.lmt,
  2593. true // 请求完成后清理控制台
  2594. );
  2595. }
  2596.  
  2597.  
  2598. /**
  2599. * 得力文库跳板页面下载策略
  2600. */
  2601. async function deliFile() {
  2602. // 从URL解析文档参数
  2603. parseParamsToDeliJS();
  2604. // 显示提示
  2605. showTips();
  2606.  
  2607. // 创建按钮区
  2608. utils.createBtns();
  2609. // btn_1: 导出PDF
  2610. exportPDF$3 = await utils.recTime(exportPDF$3);
  2611. utils.setBtnListener(exportPDF$3, "btn_1", "下载并导出PDF");
  2612. }
  2613.  
  2614. function readAll360Doc() {
  2615. // 展开文档
  2616. document.querySelector(".article_showall a").click();
  2617. // 隐藏按钮
  2618. utils.toggleBtn("btn_1");
  2619. // 显示按钮
  2620. utils.toggleBtn("btn_2");
  2621. utils.toggleBtn("btn_3");
  2622. utils.toggleBtn("btn_4");
  2623. }
  2624.  
  2625.  
  2626. function saveText_360Doc() {
  2627. // 捕获图片链接
  2628. let images = document.querySelectorAll("#artContent img");
  2629. let content = [];
  2630.  
  2631. for (let i = 0; i < images.length; i++) {
  2632. let src = images[i].src;
  2633. content.push(`图${i+1},链接:${src}`);
  2634. }
  2635. // 捕获文本
  2636. let text = document.querySelector("#artContent").textContent;
  2637. content.push(text);
  2638.  
  2639. // 保存纯文本文档
  2640. let title = document.querySelector("#titiletext").textContent;
  2641. utils.saveAs(`${title}.txt`, content.join("\n"));
  2642. }
  2643.  
  2644.  
  2645. function printPage360Doc() {
  2646. if (!confirm("确定每页内容都加载完成了吗?")) {
  2647. return;
  2648. }
  2649. // # 清理并打印360doc的文档页
  2650. // ## 移除页面上无关的元素
  2651. 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";
  2652. let elem_list = document.querySelectorAll(selector);
  2653. let under_doc_1, under_doc_2;
  2654. try {
  2655. under_doc_1 = document.querySelector("#bgchange p.clearboth").nextElementSibling;
  2656. under_doc_2 = document.querySelector("#bgchange").nextElementSibling.nextElementSibling;
  2657. } catch (e) { console.log(); }
  2658. // 执行移除
  2659. for (let elem of elem_list) {
  2660. utils.remove(elem);
  2661. }
  2662. utils.remove(under_doc_1);
  2663. utils.remove(under_doc_2);
  2664. // 执行隐藏
  2665. document.querySelector("a[title]").style.display = "none";
  2666.  
  2667. // 使文档居中
  2668. alert("建议使用:\n偏移量: 20\n缩放: 默认\n");
  2669. if (!utils.centerDoc(".a_left", "20")) {
  2670. return; // 如果输入非法,终止函数调用
  2671. }
  2672. // 隐藏按钮,然后打印页面
  2673. utils.hideBtnThenPrint();
  2674. }
  2675.  
  2676.  
  2677. /**
  2678. * 阻止监听器生效
  2679. * @param {Event} e
  2680. */
  2681. function stopSpread(e) {
  2682. e.stopImmediatePropagation();
  2683. e.stopPropagation();
  2684. }
  2685.  
  2686.  
  2687. /**
  2688. * 阻止捕获事件
  2689. */
  2690. function stopCapturing() {
  2691. ["click", "mouseup"].forEach(
  2692. type => {
  2693. document.body.addEventListener(type, stopSpread, true);
  2694. document["on" + type] = undefined;
  2695. }
  2696. );
  2697. ["keypress", "keydown"].forEach(
  2698. type => {
  2699. window.addEventListener(type, stopSpread, true);
  2700. window["on" + type] = undefined;
  2701. }
  2702. );
  2703. }
  2704.  
  2705.  
  2706. /**
  2707. * 重置图像链接和最大宽度
  2708. * @param {Document} doc
  2709. */
  2710. function resetImg(doc=document) {
  2711. wk$.call(doc, "img").forEach(
  2712. elem => {
  2713. elem.style.maxWidth = "100%";
  2714. for (let attr of elem.attributes) {
  2715. if (attr.name.endsWith("-src")) {
  2716. elem.setAttribute("src", attr.value);
  2717. break;
  2718. }
  2719. }
  2720. }
  2721. );
  2722. }
  2723.  
  2724.  
  2725. /**
  2726. * 仅保留全屏文档
  2727. */
  2728. function getFullScreen() {
  2729. FullScreenObj.init();
  2730. wk$("#artContent > p:nth-child(3)")[0]?.remove();
  2731. let data = wk$("#artfullscreen__box_scr > table")[0].outerHTML;
  2732. window.doc360JS = { data };
  2733. let html_str = `
  2734. <html><head></head><body style="display: flex; flex-direction: row; justify-content: space-around">
  2735. ${data}
  2736. </body><html>
  2737. `;
  2738. wk$("html")[0].replaceWith(wk$("html")[0].cloneNode());
  2739. wk$("html")[0].innerHTML = html_str;
  2740. resetImg();
  2741. }
  2742.  
  2743.  
  2744. function cleanPage() {
  2745. getFullScreen();
  2746. stopCapturing();
  2747. }
  2748.  
  2749.  
  2750. /**
  2751. * 360doc个人图书馆下载策略
  2752. */
  2753. function doc360() {
  2754. // 创建按钮区
  2755. utils.createBtns();
  2756. // btn_1: 展开文档
  2757. utils.setBtnListener(readAll360Doc, "btn_1");
  2758. // btn_2: 导出纯文本
  2759. utils.setBtnListener(saveText_360Doc, "btn_2", "导出纯文本");
  2760. // btn_3: 打印页面到PDF
  2761. utils.setBtnListener(printPage360Doc, "btn_3", "打印页面到PDF");
  2762. // btn_3: 清理页面
  2763. utils.setBtnListener(cleanPage, "btn_4", "清理页面(推荐)");
  2764. }
  2765.  
  2766. async function getPDF() {
  2767. if (!window.DEFAULT_URL) {
  2768. alert("当前文档无法解析,请加 QQ 群反馈");
  2769. return;
  2770. }
  2771. let title = document.title.split(" - ")[0] + ".pdf";
  2772. let blob = await utils.xhrGetBlob(DEFAULT_URL);
  2773. utils.saveAs(title, blob);
  2774. }
  2775.  
  2776.  
  2777. function mbalib() {
  2778. utils.createBtns();
  2779. utils.setBtnListener(getPDF, "btn_1", "下载PDF");
  2780. }
  2781.  
  2782. /**
  2783. * 判断是否进入预览模式
  2784. * @returns Boolean
  2785. */
  2786. function isInPreview() {
  2787. let p_elem = wk$("#preview_tips")[0];
  2788. if (p_elem && p_elem.style && p_elem.style.display === "none") {
  2789. return true;
  2790. }
  2791. return false;
  2792. }
  2793.  
  2794.  
  2795. /**
  2796. * 确保进入预览模式
  2797. */
  2798. async function ensureInPreview() {
  2799. while (!isInPreview()) {
  2800. // 如果没有进入预览,则先进入
  2801. if (typeof window.preview !== "function") {
  2802. alert("脚本失效,请加 QQ 群反馈");
  2803. throw new Error("preview 全局函数不存在");
  2804. }
  2805.  
  2806. await utils.sleep(500);
  2807. preview();
  2808. }
  2809. }
  2810.  
  2811.  
  2812. /**
  2813. * 前往页码
  2814. * @param {number} page_num
  2815. */
  2816. function toPage$1(page_num) {
  2817. // 先尝试官方接口,不行再用模拟的
  2818. try {
  2819. Viewer._GotoPage(page_num);
  2820. } catch(e) {
  2821. console.error(e);
  2822. utils.toPageNo(wk$("#pageNumInput")[0], page_num, "keydown");
  2823. }
  2824. }
  2825.  
  2826.  
  2827. /**
  2828. * 展开全文预览,当展开完成后再次调用时,返回true
  2829. * @returns
  2830. */
  2831. async function walkThrough$1() {
  2832. // 隐藏页面
  2833. wk$("#pageContainer")[0].style.display = "none";
  2834.  
  2835. // 逐页加载
  2836. let lmt = window.dugenJS.lmt;
  2837. for (let i of utils.range(1, lmt + 1)) {
  2838. toPage$1(i);
  2839. await utils.waitUntil(
  2840. () => wk$(`#outer_page_${i}`)[0].style.width.endsWith("px")
  2841. );
  2842. }
  2843.  
  2844. // 恢复显示
  2845. wk$("#pageContainer")[0].style.display = "";
  2846. console.log(`共 ${lmt} 页加载完毕`);
  2847. }
  2848.  
  2849.  
  2850. /**
  2851. * 返回当前未加载页面的页码
  2852. * @returns not_loaded
  2853. */
  2854. function getNotloadedPages() {
  2855. // 已经取得的页码
  2856. let pages = document.querySelectorAll("[id*=pageflash_]");
  2857. let loaded = new Set();
  2858. pages.forEach((page) => {
  2859. let id = page.id.split("_")[1];
  2860. id = parseInt(id);
  2861. loaded.add(id);
  2862. });
  2863. // 未取得的页码
  2864. let not_loaded = [];
  2865. for (let i of utils.range(1, window.dugenJS.lmt + 1)) {
  2866. if (!loaded.has(i)) {
  2867. not_loaded.push(i);
  2868. }
  2869. }
  2870. return not_loaded;
  2871. }
  2872.  
  2873.  
  2874. /**
  2875. * 取得全部文档页面的链接,返回urls;如果有页面未加载,则返回null
  2876. * @returns
  2877. */
  2878. function getImgUrls$1() {
  2879. let pages = wk$("[id*=pageflash_]");
  2880. // 尚未浏览完全部页面,返回false
  2881. if (pages.length < window.dugenJS.lmt) {
  2882. let hints = [
  2883. "尚未加载完全部页面",
  2884. "以下页面需要浏览并加载:",
  2885. getNotloadedPages().join(",")
  2886. ];
  2887. alert(hints.join("\n"));
  2888. return [false, []];
  2889. }
  2890. // 浏览完全部页面,返回urls
  2891. return [true, pages.map(page => page.querySelector("img").src)];
  2892. }
  2893.  
  2894.  
  2895. function exportImgUrls() {
  2896. let [ok, urls] = getImgUrls$1();
  2897. if (!ok) {
  2898. return;
  2899. }
  2900. utils.saveAs("urls.csv", urls.join("\n"));
  2901. }
  2902.  
  2903.  
  2904. function exportPDF$2() {
  2905. let [ok, urls] = getImgUrls$1();
  2906. if (!ok) {
  2907. return;
  2908. }
  2909. let title = document.title.split("-")[0];
  2910. utils.imgURLsToPDF(urls, title);
  2911. }
  2912.  
  2913.  
  2914. /**
  2915. * dugen文档下载策略
  2916. */
  2917. async function dugen() {
  2918. await ensureInPreview();
  2919. // 全局对象
  2920. window.dugenJS = {
  2921. lmt: window.lmt ? window.lmt : 20
  2922. };
  2923.  
  2924. // 创建按钮区
  2925. utils.createBtns();
  2926.  
  2927. // 绑定监听器
  2928. // 按钮1:展开文档
  2929. utils.setBtnListener(walkThrough$1, "btn_1", "加载可预览页面");
  2930. // 按钮2:导出图片链接
  2931. utils.setBtnListener(exportImgUrls, "btn_2", "导出图片链接");
  2932. utils.toggleBtn("btn_2");
  2933. // 按钮3:导出PDF
  2934. utils.setBtnListener(exportPDF$2, "btn_3", "导出PDF");
  2935. utils.toggleBtn("btn_3");
  2936. }
  2937.  
  2938. /**
  2939. * 取得文档类型
  2940. * @returns {String} 文档类型str
  2941. */
  2942. function getDocType() {
  2943. let type_elem = document.querySelector(".title .icon.icon-format");
  2944. // ["icon", "icon-format", "icon-format-doc"]
  2945. let cls_str = type_elem.classList[2];
  2946. // "icon-format-doc"
  2947. let type = cls_str.split("-")[2];
  2948. return type;
  2949. }
  2950.  
  2951.  
  2952. /**
  2953. * 判断文档类型是否为type_list其中之一
  2954. * @returns 是否为type
  2955. */
  2956. function isTypeof(type_list) {
  2957. const type = getDocType();
  2958. if (type_list.includes(type)) {
  2959. return true;
  2960. }
  2961. return false;
  2962. }
  2963.  
  2964.  
  2965. /**
  2966. * 判断文档类型是否为PPT
  2967. * @returns 是否为PPT
  2968. */
  2969. function isPPT() {
  2970. return isTypeof(["ppt", "pptx"]);
  2971. }
  2972.  
  2973.  
  2974. /**
  2975. * 判断文档类型是否为Excel
  2976. * @returns 是否为Excel
  2977. */
  2978. function isEXCEL() {
  2979. return isTypeof(["xls", "xlsm", "xlsx"]);
  2980. }
  2981.  
  2982.  
  2983. /**
  2984. * 取得最大页码
  2985. * @returns {Number} 最大页码
  2986. */
  2987. function getPageCounts$1() {
  2988. return preview.getPage().preview;
  2989. }
  2990.  
  2991.  
  2992. /**
  2993. * 取得未加载页面的页码
  2994. * @returns {Array} not_loaded 未加载页码列表
  2995. */
  2996. function getNotLoaded() {
  2997. const loaded = wk$("[data-id] img[src]").map(
  2998. img => parseInt(
  2999. img.closest("[data-id]").getAttribute("data-id")
  3000. )
  3001. );
  3002. return Array.from(
  3003. utils.diff(
  3004. new Set(utils.range(1, book118JS.page_counts)),
  3005. new Set(loaded)
  3006. )
  3007. );
  3008. }
  3009.  
  3010.  
  3011. /**
  3012. * 取得全部文档页的url
  3013. * @returns [<是否全部加载>, <urls列表>, <未加载页码列表>]
  3014. */
  3015. function getUrls() {
  3016. const urls = wk$("[data-id] img[src]").map(
  3017. img => img.src
  3018. );
  3019. // 如果所有页面加载完毕
  3020. if (urls.length === book118JS.page_counts) {
  3021. return [true, urls, []];
  3022. }
  3023. // 否则收集未加载页面的url
  3024. return [false, urls, getNotLoaded()];
  3025. }
  3026.  
  3027.  
  3028. /**
  3029. * 展开全文
  3030. */
  3031. async function walkThrough() {
  3032. // 遍历期间隐藏按钮区
  3033. utils.toggleBtnsSec();
  3034.  
  3035. // 取得总页码
  3036. // preview.getPage()
  3037. // {current: 10, actual: 38, preview: 38, remain: 14}
  3038. const { preview: all } = preview.getPage();
  3039. for (let i = 1; i <= all; i++) {
  3040. // 逐页加载
  3041. preview.jump(i);
  3042. await utils.waitUntil(
  3043. () => wk$(`[data-id="${i}"] img`)[0].src, 1000
  3044. );
  3045. }
  3046. console.log("遍历完成");
  3047. utils.toggleBtnsSec();
  3048. }
  3049.  
  3050.  
  3051. /**
  3052. * btn_2: 导出图片链接
  3053. */
  3054. function wantUrls() {
  3055. let [flag, urls, escaped] = getUrls();
  3056. // 页面都加载完毕,下载urls
  3057. if (!flag) {
  3058. // 没有加载完,提示出未加载好的页码
  3059. const hint = [
  3060. "仍有页面没有加载",
  3061. "请浏览并加载如下页面",
  3062. "是否继续导出图片链接?",
  3063. "[" + escaped.join(",") + "]"
  3064. ].join("\n");
  3065. // 终止导出
  3066. if (!confirm(hint)) {
  3067. return
  3068. }
  3069. }
  3070. utils.saveAs("urls.csv", urls.join("\n"));
  3071. }
  3072.  
  3073.  
  3074. /**
  3075. * 打开PPT预览页面
  3076. */
  3077. function openPPTpage() {
  3078. alert("请点击【开始预览】按钮以继续......");
  3079. }
  3080.  
  3081.  
  3082. /**
  3083. * 原创力文档(非PPT或Excel)下载策略
  3084. */
  3085. async function book118_CommonDoc() {
  3086. await utils.waitUntil(
  3087. () => !!wk$(".counts")[0]
  3088. );
  3089.  
  3090. // 创建全局对象
  3091. window.book118JS = {
  3092. doc_type: getDocType(),
  3093. page_counts: getPageCounts$1()
  3094. };
  3095.  
  3096. // 处理非PPT文档
  3097. // 创建按钮组
  3098. utils.createBtns();
  3099. // 绑定监听器到按钮
  3100. // 按钮1:加载全文
  3101. utils.setBtnListener(walkThrough, "btn_1", "加载全文");
  3102. // 按钮2:导出图片链接
  3103. utils.setBtnListener(wantUrls, "btn_2", "导出图片链接");
  3104. utils.toggleBtn("btn_2");
  3105. // // 按钮3:自动导出链接
  3106. // utils.setBtnListener(toAPIPage, "btn_3", "自动导出链接(荐)");
  3107. // utils.toggleBtn("btn_3");
  3108. }
  3109.  
  3110.  
  3111. /**
  3112. * 取得PPT文档最大页码
  3113. * @returns PPT文档最大页码int
  3114. */
  3115. async function getPageCountsPPT() {
  3116. await utils.waitUntil(
  3117. () => !!wk$("#PageCount")[0].textContent
  3118. );
  3119. return parseInt(
  3120. wk$("#PageCount")[0].textContent
  3121. );
  3122. }
  3123.  
  3124.  
  3125. /**
  3126. * 取得当前的页码
  3127. * @returns {Number} this_page
  3128. */
  3129. function getThisPage() {
  3130. return parseInt(
  3131. wk$("#PageIndex")[0].textContent
  3132. );
  3133. }
  3134.  
  3135.  
  3136. /**
  3137. * 点击下一动画直到变成下一页,再切回上一页
  3138. * @param {Number} next_page 下一页的页码
  3139. */
  3140. async function __nextFrameUntillNextPage(next_page) {
  3141. // 如果已经抵达下一页,则返回上一页
  3142. const this_page = getThisPage();
  3143.  
  3144. // 最后一页直接退出
  3145. if (next_page > window.book118JS.page_counts) {
  3146. return;
  3147. }
  3148. // 不是最后一页,但完成了翻页动作
  3149. else if (this_page === next_page) {
  3150. // 下一帧动画
  3151. document.querySelector(".btmLeft").click();
  3152. await utils.waitUntil(() => this_page === next_page - 1);
  3153. return;
  3154. }
  3155. // 否则递归的点击下一动画
  3156. document.querySelector(".btmRight").click();
  3157. await utils.sleep(500);
  3158. await __nextFrameUntillNextPage(next_page);
  3159. }
  3160.  
  3161.  
  3162. /**
  3163. * 确保当前页面是最后一帧动画
  3164. */
  3165. async function toLastFrame() {
  3166. // 取得当前页码和下一页页码
  3167. const this_page = getThisPage();
  3168. // 开始点击下一页按钮,直到变成下一页,再点击上一页按钮来返回
  3169. await __nextFrameUntillNextPage(this_page + 1);
  3170. }
  3171.  
  3172.  
  3173. /**
  3174. * (异步)转换当前视图为canvas,添加到book118JS.canvases中。在递归终止时显示btn_2。
  3175. */
  3176. async function docView2Canvas() {
  3177. await toLastFrame();
  3178. // 取得页码
  3179. const cur_page = getThisPage();
  3180. // 取得视图元素,计数从0开始
  3181. const doc_view = wk$(`#view${cur_page - 1}`)[0];
  3182.  
  3183. // 满足 [DOM 不再变化] 并且 [等够秒数] 才能继续
  3184. await Promise.allSettled([
  3185. utils.untilDOMStill(doc_view),
  3186. utils.sleep(book118JS.delay * 1000)
  3187. ]);
  3188.  
  3189. // 转化为canvas
  3190. const canvas = await html2canvas(doc_view);
  3191. book118JS.canvases.push(canvas);
  3192. console.log(`page ${cur_page} finished`);
  3193.  
  3194. // 如果到最后一页
  3195. if (cur_page === book118JS.page_counts) {
  3196. // 终止递归,并且显示导出PDF按钮
  3197. utils.toggleBtn("btn_2");
  3198. return;
  3199. }
  3200. // 否则下一次递归(继续捕获下一页)
  3201. wk$(".pgRight")[0].click();
  3202. await utils.sleep(500);
  3203. await docView2Canvas();
  3204. }
  3205.  
  3206.  
  3207. /**
  3208. * 将捕获的canvases合并,然后导出为pdf
  3209. * @returns
  3210. */
  3211. function canvases2pdf() {
  3212. // 校验数量
  3213. const
  3214. canvases = book118JS.canvases,
  3215. stored = canvases.length,
  3216. all = book118JS.page_counts,
  3217. diff = all - stored;
  3218.  
  3219. if (diff > 0) {
  3220. alert(`缺失了 ${diff} 页`);
  3221. }
  3222. // 导出pdf
  3223. utils.imgsToPDF(canvases, "原创力PPT文档");
  3224. }
  3225.  
  3226.  
  3227. /**
  3228. * 调整等待动画延时
  3229. */
  3230. function adjustDelay() {
  3231. const input = prompt(
  3232. `当前等待动画延时为【${window.book118JS.delay}】秒,改为多少秒?`
  3233. );
  3234. const delay = parseFloat(input);
  3235. if (0 <= delay && delay <= 10) {
  3236. book118JS.delay = delay;
  3237. }
  3238. }
  3239.  
  3240.  
  3241. /**
  3242. * 原创力文档(PPT)下载策略
  3243. */
  3244. async function book118_PPT() {
  3245. // 创建全局对象
  3246. window.book118JS = {
  3247. page_counts: await getPageCountsPPT(),
  3248. canvases: [], // 存储每页文档转化的canvas
  3249. // tasks: []
  3250. delay: 2 // 等待动画的延时(秒)
  3251. };
  3252.  
  3253. // 创建按钮区
  3254. utils.createBtns();
  3255.  
  3256. // 按钮1:捕获页面
  3257. utils.setBtnListener(() => {
  3258. let hint = [
  3259. "正在为文档“截图”,请耐心等待过程完成,不要操作",
  3260. "“截图”效果不佳,可以调整每页动画等待的延时",
  3261. "比如改成 5 秒或 10 秒;默认是 2 秒",
  3262. "但无论怎样,“截图”得到的 PDF 效果很可能不好",
  3263. "请勿就此问题反馈,反馈了我也改不了"
  3264. ];
  3265. alert(hint.join("\n"));
  3266. // 隐藏按钮1
  3267. utils.toggleBtn("btn_1");
  3268. // 开始捕获页面(异步)
  3269. docView2Canvas();
  3270. }, "btn_1", "捕获页面");
  3271.  
  3272. // 按钮2:合并图片到PDF
  3273. utils.setBtnListener(canvases2pdf, "btn_2", "导出PDF");
  3274.  
  3275. // 按钮3:调整等待延时
  3276. utils.setBtnListener(adjustDelay, "btn_3", "调整等待延时");
  3277. utils.toggleBtn("btn_3");
  3278. }
  3279.  
  3280.  
  3281. /**
  3282. * 取得当前页面的excel,返回csv string
  3283. * @returns {String} csv
  3284. */
  3285. function excel2CSV() {
  3286. const
  3287. table = [],
  3288. rows = wk$("tr[id]");
  3289.  
  3290. // 遍历行
  3291. for (let row of rows) {
  3292. const csv_row = [];
  3293. // 遍历列(单元格)
  3294. for (let cell of wk$.call(row, "td[class*=fi], td.tdrl")) {
  3295. // 判断单元格是否存储图片
  3296. const img = cell.querySelector("img");
  3297. if (img) {
  3298. // 如果是图片,保存图片链接
  3299. csv_row.push(img.src);
  3300. } else {
  3301. // 否则保存单元格文本
  3302. csv_row.push(cell.textContent);
  3303. }
  3304. }
  3305. table.push(csv_row.join(","));
  3306. }
  3307. return table.join("\n").replace(/\n{2,}/g, "\n");
  3308. }
  3309.  
  3310.  
  3311. /**
  3312. * 下载当前表格内容,保存为csv(utf-8编码)
  3313. */
  3314. function wantEXCEL() {
  3315. let file_name = "原创力表格_UTF-8.csv";
  3316. utils.saveAs(file_name, excel2CSV());
  3317. }
  3318.  
  3319.  
  3320. /**
  3321. * 在Excel预览页面给出操作提示
  3322. */
  3323. function help() {
  3324. let hint = [
  3325. "【导出表格到CSV】只能导出当前sheet,",
  3326. "如果有多张sheet请在每个sheet上用按钮分别导出CSV。",
  3327. "CSV是一种简单的表格格式,可以被Excel打开,",
  3328. "并转为 xls 或 xlsx 格式存储,",
  3329. "但CSV本身不能存储图片,所以用图片链接代替,请自行下载图片",
  3330. "",
  3331. "本功能导出的CSV文件无法直接用Excel打开,因为中文会乱码。",
  3332. "有两个办法:",
  3333. "1. 打开Excel,选择【数据】,选择【从文本/CSV】,",
  3334. " 选择文件,【文件原始格式】选择【65001: Unicode(UTF-8)】,选择【加载】。",
  3335. "2. 用【记事本】打开CSV文件,【文件】->【另存为】->",
  3336. " 【编码】选择【ANSI】->【保存】。现在可以用Excel直接打开它了。"
  3337. ];
  3338. alert(hint.join("\n"));
  3339. }
  3340.  
  3341.  
  3342. /**
  3343. * 原创力文档(EXCEL)下载策略
  3344. */
  3345. function book118_EXCEL() {
  3346. // 创建按钮区
  3347. utils.createBtns();
  3348. // 绑定监听器到按钮
  3349. utils.setBtnListener(wantEXCEL, "btn_1", "导出表格到CSV");
  3350. utils.setBtnListener(help, "btn_2", "使用说明");
  3351. // 显示按钮
  3352. utils.toggleBtn("btn_2");
  3353. }
  3354.  
  3355.  
  3356. /**
  3357. * 打开Excel预览页面
  3358. */
  3359. function openEXCELpage() {
  3360. openPPTpage();
  3361. }
  3362.  
  3363.  
  3364. // /**
  3365. // * 跳转到图片接口页面
  3366. // * @returns
  3367. // */
  3368. // function toAPIPage() {
  3369. // let type = window?.base?.detail?.preview?.channel;
  3370. // if (type !== "pic") {
  3371. // alert("当前文档类型不适用");
  3372. // return;
  3373. // }
  3374.  
  3375. // let base = window.base;
  3376. // let query = utils.dictToQueryStr({
  3377. // project_id: 1,
  3378. // aid: base.detail.preview.office.aid,
  3379. // t: base.detail.senddate,
  3380. // view_token: base.detail.preview.pic.view_token,
  3381. // filetype: getDocType(),
  3382. // callback: "jQuery123_456",
  3383. // max: base.detail.preview.pic.preview_page,
  3384. // });
  3385.  
  3386. // open(`https://openapi.book118.com/?${query}`);
  3387. // }
  3388.  
  3389.  
  3390. /**
  3391. * 原创力文档下载策略
  3392. */
  3393. function book118() {
  3394. const host = window.location.hostname;
  3395. if (host === 'max.book118.com') {
  3396. if (isEXCEL()) {
  3397. utils.createBtns();
  3398. utils.setBtnListener(openEXCELpage, "btn_1", "访问EXCEL");
  3399. } else if (isPPT()) {
  3400. utils.createBtns();
  3401. utils.setBtnListener(openPPTpage, "btn_1", "访问PPT");
  3402. } else {
  3403. book118_CommonDoc();
  3404. }
  3405. } else if (host === "view-cache.book118.com") {
  3406. book118_PPT();
  3407. } else if (host.match(/view[0-9]{1,3}.book118.com/)) {
  3408. book118_EXCEL();
  3409. } else {
  3410. console.log(`wk: Unknown host: ${host}`);
  3411. }
  3412. }
  3413.  
  3414. // test url: https://openstd.samr.gov.cn/bzgk/gb/newGbInfo?hcno=E86BBCE32DA8E67F3DA04ED98F2465DB
  3415.  
  3416.  
  3417. /**
  3418. * 绘制0x0的bmp, 作为请求失败时返回的page
  3419. * @returns {Promise<ImageBitmap>} blank_page
  3420. */
  3421. async function blankBMP() {
  3422. let canvas = document.createElement("canvas");
  3423. [canvas.width, canvas.height] = [0, 0];
  3424. return createImageBitmap(canvas);
  3425. }
  3426.  
  3427.  
  3428. /**
  3429. * resp导出bmp
  3430. * @param {string} page_url
  3431. * @param {Promise<Response> | ImageBitmap} pms_or_bmp
  3432. * @returns {Promise<ImageBitmap>} page
  3433. */
  3434. async function respToPage(page_url, pms_or_bmp) {
  3435. let center = globalThis.gb688JS;
  3436. // 此时是bmp
  3437. if (pms_or_bmp instanceof ImageBitmap) {
  3438. return pms_or_bmp;
  3439. }
  3440.  
  3441. // 第一次下载, 且无人处理
  3442. if (!center.pages_status.get(page_url)) {
  3443. // 处理中, 设为占用
  3444. center.pages_status.set(page_url, 1);
  3445.  
  3446. // 处理
  3447. let resp;
  3448. try {
  3449. resp = await pms_or_bmp;
  3450. } catch(err) {
  3451. console.log("下载页面失败");
  3452. console.error(err);
  3453. return blankBMP();
  3454. }
  3455.  
  3456. let page_blob = await resp.blob();
  3457. let page = await createImageBitmap(page_blob);
  3458. center.pages.set(page_url, page);
  3459. // 处理结束, 设为释放
  3460. center.pages_status.set(page_url, 0);
  3461. return page;
  3462. }
  3463.  
  3464. // 有人正在下载且出于处理中
  3465. while (center.pages_status.get(page_url)) {
  3466. await utils.sleep(500);
  3467. }
  3468. return center.pages.get(page_url);
  3469. }
  3470.  
  3471.  
  3472. /**
  3473. * 获得PNG页面
  3474. * @param {string} page_url
  3475. * @returns {Promise<ImageBitmap>} bmp
  3476. */
  3477. async function getPage(page_url) {
  3478. // 如果下载过, 直接返回缓存
  3479. let pages = globalThis.gb688JS.pages;
  3480. if (pages.has(page_url)) {
  3481. return respToPage(page_url, pages.get(page_url));
  3482. }
  3483.  
  3484. // 如果从未下载过, 就下载
  3485. let resp = fetch(page_url, {
  3486. "headers": {
  3487. "accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
  3488. "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
  3489. "proxy-connection": "keep-alive"
  3490. },
  3491. "referrer": location.href,
  3492. "referrerPolicy": "strict-origin-when-cross-origin",
  3493. "body": null,
  3494. "method": "GET",
  3495. "mode": "cors",
  3496. "credentials": "include"
  3497. });
  3498. pages.set(page_url, resp);
  3499. return respToPage(page_url, resp);
  3500. }
  3501.  
  3502.  
  3503. /**
  3504. * 返回文档页div的裁切和粘贴位置信息: [[cut_x, cut_y, paste_x%, paset_y%],...]
  3505. * @param {HTMLDivElement} page_div 文档页元素
  3506. * @returns {Array<Array<number>>} positions
  3507. */
  3508. function getPostions(page_div) {
  3509. let positions = [];
  3510.  
  3511. Array.from(page_div.children).forEach(span => {
  3512. // 'pdfImg-3-8' -> {left: 30%; top: 80%;}
  3513. let paste_pos = span.className.split("-").slice(1).map(
  3514. v => parseInt(v) / 10
  3515. );
  3516. // '-600px 0px' -> [600, 0]
  3517. let cut_pos = span.style.backgroundPosition.split(" ").map(
  3518. v => Math.abs(parseInt(v))
  3519. );
  3520. positions.push([...cut_pos, ...paste_pos]);
  3521. });
  3522. return positions;
  3523. }
  3524.  
  3525.  
  3526. /**
  3527. * 取得文档页的图像url
  3528. * @param {HTMLDivElement} page_div
  3529. * @returns {string} url
  3530. */
  3531. function getPageURL(page_div) {
  3532. // 拿到目标图像url
  3533. let path = location.pathname.split("/").slice(0, -1).join("/");
  3534. let prefix = location.origin + path + "/";
  3535. let url = page_div.getAttribute("bg");
  3536. if (!url) {
  3537. // 'url("viewGbImg?fileName=VS72l67k0jw5g3j0vErP8DTsnWvk5QsqnNLLxaEtX%2FM%3D")'
  3538. url = page_div.children[0].style.backgroundImage.split('"')[1];
  3539. }
  3540. return prefix + url;
  3541. }
  3542.  
  3543.  
  3544. /**
  3545. * 下载目标图像并拆解重绘, 返回canvas
  3546. * @param {number} i 第 i 页 (从0开始)
  3547. * @param {HTMLDivElement} page_div
  3548. * @returns {Promise<Array>} [页码, Canvas]
  3549. */
  3550. async function getAndDrawPage(i, page_div) {
  3551. // 拿到目标图像
  3552. let url = getPageURL(page_div);
  3553. let page = await getPage(url);
  3554.  
  3555. // 绘制空白A4纸背景
  3556. let [page_w, page_h] = [1190, 1680];
  3557. let bg = document.createElement("canvas");
  3558. bg.width = page_w; // 注意canvas作为取景框的大小
  3559. bg.height = page_h; // 如果不设置等于一个很小的取景框
  3560. let bg_ctx = bg.getContext("2d");
  3561. bg_ctx.fillStyle = "white";
  3562. bg_ctx.fillRect(0, 0, page_w, page_h);
  3563.  
  3564. // 逐个区块剪切取出并粘贴
  3565. // wk$("#viewer .page").forEach(page_div => {
  3566. getPostions(page_div).forEach(pos => {
  3567. bg_ctx.drawImage(
  3568. page, // image source
  3569. pos[0], // source x
  3570. pos[1], // source y
  3571. 120, // source width
  3572. 169, // source height
  3573. pos[2] * page_w, // destination x = left: x%
  3574. pos[3] * page_h, // destination y = top: y%
  3575. 120, // destination width
  3576. 169 // destination height
  3577. );
  3578. });
  3579. // });
  3580. return [i, bg];
  3581. }
  3582.  
  3583.  
  3584. /**
  3585. * 页面批量请求、裁剪重绘, 合成PDF并下载
  3586. */
  3587. async function turnPagesToPDF() {
  3588. // 渲染每页
  3589. let tasks = [];
  3590. wk$("#viewer .page").forEach((page_div, i) => {
  3591. tasks.push(
  3592. getAndDrawPage(i, page_div)
  3593. );
  3594. });
  3595. // 等待每页渲染完成后,排序
  3596. let results = await utils.gather(tasks);
  3597. results.sort((prev, next) => prev[0] - next[0]);
  3598. // 合并为PDF并导出
  3599. utils.imgsToPDF(
  3600. results.map(item => item[1]),
  3601. // '在线预览|GB 14023-2022'
  3602. document.title.split("|")[1]
  3603. );
  3604. }
  3605.  
  3606.  
  3607. /**
  3608. * 提示预估下载耗时,然后下载
  3609. */
  3610. function hintThenDownload$1() {
  3611. // '/93'
  3612. let page_num = parseInt(wk$("#numPages")[0].textContent.slice(1));
  3613. let estimate = Math.ceil(page_num / 3);
  3614. alert(`页数: ${page_num},预计花费: ${estimate}秒;如遇网络异常可能更久\n请勿反复点击按钮;如果无法导出请 QQ 群反馈`);
  3615. turnPagesToPDF();
  3616. }
  3617.  
  3618.  
  3619. /**
  3620. * gb688文档下载策略
  3621. */
  3622. async function gb688() {
  3623. // 创建全局对象
  3624. globalThis.gb688JS = {
  3625. pages: new Map(), // {url: bmp}
  3626. pages_status: new Map() // {url: 0或1} 0释放, 1占用
  3627. };
  3628.  
  3629. // 创建按钮区
  3630. utils.createBtns();
  3631. // 绑定监听器
  3632. // 按钮1:导出PDF
  3633. turnPagesToPDF = await utils.recTime(turnPagesToPDF);
  3634. utils.setBtnListener(hintThenDownload$1, "btn_1", "导出PDF");
  3635. }
  3636.  
  3637. function getPageCounts() {
  3638. // " / 39"
  3639. let counts_str = wk$(".counts")[0].textContent.split("/")[1];
  3640. let counts = parseInt(counts_str);
  3641. return counts > 20 ? 20 : counts;
  3642. }
  3643.  
  3644.  
  3645. /**
  3646. * 返回图片基础路径
  3647. * @returns {string} base_url
  3648. */
  3649. function getImgBaseURL() {
  3650. return wk$("#dp")[0].value;
  3651. }
  3652.  
  3653.  
  3654. function* genImgURLs() {
  3655. let counts = getPageCounts();
  3656. let base_url = getImgBaseURL();
  3657. for (let i=1; i<=counts; i++) {
  3658. yield base_url + `${i}.gif`;
  3659. }
  3660. }
  3661.  
  3662.  
  3663. /**
  3664. * 下载图片,转为canvas,合并为PDF并下载
  3665. */
  3666. function fetchThenExportPDF() {
  3667. // db2092-2014-河北特种设备使用安全管理规范_安全文库网safewk.com
  3668. let title = document.title.split("_")[0];
  3669. return utils.imgURLsToPDF(genImgURLs(), title);
  3670. }
  3671.  
  3672.  
  3673. /**
  3674. * 提示预估下载耗时,然后下载
  3675. */
  3676. async function hintThenDownload() {
  3677. let hint = [
  3678. "只能导出可预览的页面(最多20页)",
  3679. "请勿短时间反复点击按钮,导出用时大约不到 10 秒",
  3680. "点完后很久没动静请至 QQ 群反馈"
  3681. ];
  3682. alert(hint.join("\n"));
  3683. await fetchThenExportPDF();
  3684. }
  3685.  
  3686.  
  3687. /**
  3688. * safewk文档下载策略
  3689. */
  3690. async function safewk() {
  3691. // 创建按钮区
  3692. utils.createBtns();
  3693. // 绑定监听器
  3694. // 按钮1:导出PDF
  3695. hintThenDownload = await utils.recTime(hintThenDownload);
  3696. utils.setBtnListener(hintThenDownload, "btn_1", "导出PDF");
  3697. }
  3698.  
  3699. /**
  3700. * 跳转到页码
  3701. * @param {string | number} num
  3702. */
  3703. function toPage(num) {
  3704. if (window.WebPreview
  3705. && WebPreview.Page
  3706. && WebPreview.Page.jump
  3707. ) {
  3708. WebPreview.Page.jump(parseInt(num));
  3709. } else {
  3710. console.error("window.WebPreview.Page.jump doesn't exist");
  3711. }
  3712. }
  3713.  
  3714.  
  3715. /**
  3716. * 跳转页码GUI版
  3717. */
  3718. function toPageGUI() {
  3719. let num = prompt("请输入要跳转的页码")?.trim();
  3720. if (/^[0-9]+$/.test(num)) {
  3721. toPage(num);
  3722. } else {
  3723. console.log(`输入值 [${num}] 不是合法整数`);
  3724. }
  3725. }
  3726.  
  3727.  
  3728. /**
  3729. * 记录prop不存在value到控制台
  3730. * @param {string} prop
  3731. * @param {any} value
  3732. */
  3733. function logEmpty(prop, value) {
  3734. console.log(`wk: info's [${prop}] is an empty value: [${value}]`);
  3735. }
  3736.  
  3737.  
  3738. /**
  3739. * 验证info对象是否成功采集各项数据,失败时输出到控制台
  3740. * @param {Object} info
  3741. */
  3742. function isIntact(info) {
  3743. for (let prop in info) {
  3744. let value = info[prop];
  3745.  
  3746. if (value === undefined || value === "" || value === NaN) {
  3747. logEmpty(prop, value);
  3748. return false;
  3749. }
  3750.  
  3751. if (typeof value === "object") {
  3752. if (!isIntact(value)) {
  3753. return false;
  3754. }
  3755. }
  3756. }
  3757. return true;
  3758. }
  3759.  
  3760.  
  3761. /**
  3762. * 更新 WebPreview.Base.data 中的时间戳属性
  3763. */
  3764. function updateStamp() {
  3765. let data = window?.WebPreview?.Base?.data;
  3766. if (data) {
  3767. let now = Date.now();
  3768. data.jsoncallback = 'callback' + now;
  3769. data.callback = 'callback' + now;
  3770. data._ = now;
  3771. }
  3772. }
  3773.  
  3774.  
  3775. /**
  3776. * 收集文档信息,用于跨页面传递
  3777. * @returns
  3778. */
  3779. function collectInfo() {
  3780. let
  3781. win = window,
  3782. params = win.previewParams,
  3783. view = win.WebPreview,
  3784. ver = view?.version,
  3785. base = view?.Base,
  3786. data = view?.Data,
  3787. pages = parseInt(wk$('meta[property="og:document:page"]')[0].content),
  3788. preview = data?.preview_page, // 默认值可能不准,需要从加密图像url链接的请求中获取更新值
  3789. encrypted_at = base?.page?.start,
  3790. query_str = utils.dictToQueryStr(base?.data);
  3791.  
  3792. // WebPreview 为 true 说明>=6页
  3793. // general.encrypted 为 true 说明>=21页
  3794. let info = {
  3795. direct: {
  3796. base_url: params?.pre,
  3797. fake_type: params?.ShowType === 2 ? ".svg" : ".gif"
  3798. },
  3799.  
  3800. encrypted: {
  3801. query_str,
  3802. step: base?.page?.zone,
  3803. api: base?.host + base?.requestUrl
  3804. },
  3805.  
  3806. general: {
  3807. WebPreview: !!view,
  3808. renrendoc_ver: ver,
  3809. ver_followed: ver ? ver === "2022.10.25_2" : "unknown",
  3810. pages,
  3811. encrypted_at,
  3812. preview,
  3813. encrypted:
  3814. preview && encrypted_at ? (
  3815. preview < encrypted_at ? false : true // 预览页码小于加密起始页码,肯定不加密
  3816. ) : ( // 不存在某个页码,说明页数少,不加密
  3817. pages && encrypted_at ? (
  3818. pages < encrypted_at ? false : true // 总页码小于加密起始页码,肯定不加密
  3819. ) : false // 不存在某个页码,说明页数少,不加密
  3820. )
  3821. }
  3822. };
  3823. isIntact(info);
  3824. window.rrdocJS.info = info;
  3825. return info;
  3826. }
  3827.  
  3828.  
  3829. /**
  3830. * 为请求失败抛出异常
  3831. * @param {Response} resp
  3832. */
  3833. function raiseForStatus(resp) {
  3834. let code = resp.status;
  3835. if ("45".includes(`${code}`[0])) {
  3836. throw new Error(`request failed: ${code}`);
  3837. }
  3838. }
  3839.  
  3840. /**
  3841. * 获取加密图片的链接列表的JSON响应
  3842. * @param {Object} info
  3843. * @param {number} begin 请求的起始页码,一般是 5n + 1 且 n >= 21
  3844. * @returns {Promise<Object>}
  3845. */
  3846. async function _getEncryptedImgUrlsJson(info, begin) {
  3847. // 配置请求
  3848. let url = new URL(
  3849. `${info.encrypted.api}?${info.encrypted.query_str}`
  3850. );
  3851. url.searchParams.set("start", begin);
  3852. // 请求图像链接列表
  3853. let resp = await fetch(url);
  3854. raiseForStatus(resp);
  3855. let text = await resp.text();
  3856. let json = text.replace(/callback[0-9]+[(]/, "").slice(0, -1);
  3857. return JSON.parse(json);
  3858. }
  3859.  
  3860.  
  3861. /**
  3862. * 通过请求一次加密图片链接列表来更新可预览页数
  3863. */
  3864. async function updatePreviewPageNum(info) {
  3865. let begin = info.general.encrypted_at;
  3866. let data = await _getEncryptedImgUrlsJson(info, begin);
  3867. console.log(data);
  3868.  
  3869. let prop = window?.WebPreview?.Data;
  3870. if (!prop) {
  3871. logEmpty("window?.WebPreview?.Data", prop);
  3872. return;
  3873. }
  3874. let preview = data?.data?.read_count;
  3875. if (preview) {
  3876. prop.preview_page = parseInt(preview);
  3877. }
  3878. }
  3879.  
  3880.  
  3881. /**
  3882. * 获取加密图片的链接列表(length=5)
  3883. * @param {Object} info
  3884. * @param {number} begin 请求的起始页码,一般是 5n + 1 且 n >= 21
  3885. * @returns {Promise<string>}
  3886. */
  3887. async function getEncryptedImgUrls(info, begin) {
  3888. // 请求JSON
  3889. let data = await _getEncryptedImgUrlsJson(info, begin);
  3890. // 提取列表
  3891. if (data.data && data.data.preview_list) {
  3892. return data.data.preview_list.map(page => "https:" + page.url);
  3893. }
  3894. return [];
  3895. }
  3896.  
  3897.  
  3898. /**
  3899. * 获取全部加密图片链接构成的列表
  3900. * @param {Object} info
  3901. * @returns {Promise<Array<string>>}
  3902. */
  3903. async function getAllEncryptedImgUrls(info) {
  3904. info = await getLatestInfo(info);
  3905. let
  3906. gap = window.rrdocJS.gap,
  3907. max_gap = window.rrdocJS.max_gap,
  3908. begin = info.general.encrypted_at,
  3909. stop = info.general.preview,
  3910. step = info.encrypted.step,
  3911. tasks = [];
  3912. await utils.sleep(gap, max_gap);
  3913. // 总进度条
  3914. window.rrdocJS.all = stop + 1 - begin;
  3915.  
  3916. for (let i of utils.range(begin, stop + 1, step)) {
  3917. tasks.push(getEncryptedImgUrls(info, i));
  3918. // 当前进度
  3919. window.rrdocJS.requested += step;
  3920. // 等待间隔,2-2.5秒
  3921. await utils.sleep(gap, max_gap);
  3922. }
  3923. return (await utils.gather(tasks)).flat();
  3924. }
  3925.  
  3926.  
  3927. function _notNull(value, default_value) {
  3928. return value !== null ? value : default_value;
  3929. }
  3930.  
  3931.  
  3932. /**
  3933. * 获取全部直接请求的图片
  3934. * @param {Object} info
  3935. * @param {number} end 可以手动指定终止页码, 默认为null
  3936. * @param {string} base 可以手动指定基准url, 默认为null
  3937. * @param {string} type 可以手动指定图像类型, 默认为null
  3938. * @returns
  3939. */
  3940. function* genDirectImgUrls(info, end=null, base=null, type=null) {
  3941. let pages = info.general.pages;
  3942. end = pages > 20 ? 20 : pages;
  3943. base = _notNull(base, info.direct.base_url);
  3944. type = _notNull(type, info.direct.fake_type);
  3945.  
  3946. for (let i of utils.range(1, end + 1)) {
  3947. yield `${base}${i}${type}`;
  3948. }
  3949. }
  3950.  
  3951.  
  3952. /**
  3953. * 提取首个图片链接的 [base_url, type]
  3954. * @returns {Array<string>}
  3955. */
  3956. function getBaseUrlOnPage() {
  3957. let img = wk$(".page > img")[0];
  3958. let origin = img.getAttribute("data-original");
  3959. let url = origin ? origin : img.src;
  3960. let type = url.slice(-8).split("1.")[1];
  3961. return [url.replace("1." + type, ""), type];
  3962. }
  3963.  
  3964. /**
  3965. * 以旧info查询并返回新的
  3966. * @param {Object} info
  3967. * @returns {Promise<Object>}
  3968. */
  3969. async function getLatestInfo(info) {
  3970. updateStamp();
  3971. info = collectInfo();
  3972. await updatePreviewPageNum(info);
  3973. return collectInfo();
  3974. }
  3975.  
  3976.  
  3977. /**
  3978. * 初始化进度条弹窗
  3979. */
  3980. function initProgressPopup() {
  3981. let all = -1;
  3982. Object.defineProperty(
  3983. window.rrdocJS,
  3984. "all",
  3985. {
  3986. get: () => all,
  3987. set: val => all = val
  3988. }
  3989. );
  3990.  
  3991. utils.addPopup();
  3992. utils.setPopupHead("下载进度条");
  3993. utils.setPopupBody("进度条初始化中...");
  3994.  
  3995. let sent = 0;
  3996. Object.defineProperty(
  3997. window.rrdocJS,
  3998. "requested",
  3999. {
  4000. get: () => sent,
  4001. set: val => {
  4002. sent = val;
  4003. // 计算进度
  4004. let
  4005. rate = (val / all * 100),
  4006. show_val = val <= all ? val : all,
  4007. remain
  4008. = 0.5 * (
  4009. window.rrdocJS.gap + window.rrdocJS.max_gap
  4010. ) * 0.001 * (all - val)
  4011. / window.rrdocJS.info.encrypted.step;
  4012. rate = (rate <= 100 ? rate : 100).toFixed(2);
  4013. remain = (remain >= 0 ? remain : 0).toFixed(1);
  4014. // 更新进度条
  4015. utils.setPopupBody(
  4016. `当前进度: ${rate}%,${show_val}/${all}(+20)页,预计剩余${remain}秒`
  4017. );
  4018. }
  4019. }
  4020. );
  4021. // 按钮3:显示进度条
  4022. utils.setBtnListener(
  4023. () => utils.toID("wk-popup"),
  4024. "btn_3",
  4025. "显示进度条"
  4026. );
  4027. utils.toggleBtn("btn_3");
  4028. // 按钮4:为什么下载慢
  4029. utils.setBtnListener(
  4030. () => {
  4031. let delay = (window.rrdocJS.gap / 1000).toFixed(0);
  4032. alert(`因网站限制,请求间隔必须大于 ${delay} 秒,请理解`);
  4033. },
  4034. "btn_4",
  4035. "为什么下载慢"
  4036. );
  4037. utils.toggleBtn("btn_4");
  4038. // 显示弹窗
  4039. utils.toID("wk-popup");
  4040. // 隐藏跳转页码以降低触发网络请求的可能性
  4041. utils.toggleBtn("btn_2");
  4042. }
  4043.  
  4044.  
  4045. /**
  4046. * 销毁进度条弹窗
  4047. */
  4048. function destoryProgressPopup() {
  4049. let {all, requested} = window.rrdocJS;
  4050. Object.defineProperties(window.rrdocJS, {
  4051. "all": {
  4052. value: all
  4053. },
  4054. "requested": {
  4055. value: requested
  4056. }
  4057. });
  4058. utils.removePopup();
  4059. // 隐藏按钮3
  4060. utils.toggleBtn("btn_3");
  4061. // 显示跳转页码
  4062. utils.toggleBtn("btn_2");
  4063. }
  4064.  
  4065.  
  4066. function showDocType() {
  4067. let type = window.rrdocJS.doc_type;
  4068. alert(`当前文档类型:${type}\n1类:最多导出5页的链接\n2类:最多导出20页的链接\n3类:不确定`);
  4069. }
  4070.  
  4071.  
  4072. async function judgeFileType() {
  4073. // 创建按钮区
  4074. utils.createBtns();
  4075.  
  4076. let info = collectInfo();
  4077. let pages = info.general.pages;
  4078. let handler, doc_type;
  4079. // 判断页数范围
  4080. // 小于等于5页
  4081. if (pages < 6) {
  4082. doc_type = 1;
  4083. handler = () => {
  4084. let [base, type] = getBaseUrlOnPage();
  4085. utils.saveImgURLs(
  4086. genDirectImgUrls(info, null, base, type)
  4087. );
  4088. };
  4089. }
  4090. // 没有加密图片
  4091. else if (!info.general.encrypted) {
  4092. doc_type = 2;
  4093. handler = () => utils.saveImgURLs(
  4094. genDirectImgUrls(info)
  4095. );
  4096. }
  4097.  
  4098. // 有加密图片
  4099. else if (info.general.encrypted) {
  4100. doc_type = 3;
  4101. handler = async() => {
  4102. utils.toggleBtn("btn_1");
  4103. initProgressPopup();
  4104. let urls = [
  4105. ...genDirectImgUrls(info),
  4106. ...(await getAllEncryptedImgUrls(info))
  4107. ];
  4108. utils.saveImgURLs(urls);
  4109. destoryProgressPopup();
  4110. };
  4111. // 按钮2:转到页码
  4112. utils.setBtnListener(toPageGUI, "btn_2", "转到页码");
  4113. utils.toggleBtn("btn_2");
  4114.  
  4115. // 未知情况
  4116. } else {
  4117. doc_type = -1;
  4118. console.log(info);
  4119. alert("未能处理该文档,请加 QQ 群反馈");
  4120. return;
  4121. }
  4122. window.rrdocJS.doc_type = doc_type;
  4123.  
  4124. // 正版授权文档
  4125. if (!info.base_url || wk$(".tag-stand")[0]) {
  4126. handler = () => {
  4127. if (!confirm("是否预览完毕?")) {
  4128. return;
  4129. }
  4130.  
  4131. // https://www.renrendoc.com/paper/*.html
  4132. let urls = wk$("#page .page img").map(img =>
  4133. !utils.isSameOrigin(img.src) ?
  4134. img.src : img.getAttribute("data-original")
  4135. );
  4136. // https://www.renrendoc.com/p-*.html
  4137. if (urls.length === 0) {
  4138. urls = wk$(".inner_page img").map(img => img.src);
  4139. }
  4140. utils.saveImgURLs(urls);
  4141. };
  4142. }
  4143.  
  4144. // 按钮1:导出图片链接
  4145. utils.setBtnListener(handler, "btn_1", "导出图片链接");
  4146. // 按钮5:为什么不全
  4147. utils.setBtnListener(showDocType, "btn_5", "显示文档类型");
  4148. utils.toggleBtn("btn_5");
  4149. }
  4150.  
  4151.  
  4152. /**
  4153. * 人人文档下载策略
  4154. */
  4155. async function renrendoc() {
  4156. window.rrdocJS = {
  4157. info: {},
  4158. doc_type: null,
  4159. gap: 2000, // 请求间隔, ms
  4160. max_gap: 2500, // 请求间隔的波动上限, ms
  4161. all: -1, // 一共需要请求的页数
  4162. requested: 0 // 已经请求的页数
  4163. };
  4164.  
  4165. await utils.sleep(500);
  4166. judgeFileType(); // 判断完类型会显示按钮1
  4167. }
  4168.  
  4169. /**
  4170. * 取得全部图片连接
  4171. * @returns {Array<string>}
  4172. */
  4173. function getImgUrls() {
  4174. // '../files/large/'
  4175. let pre_path = htmlConfig.bookConfig.largePath;
  4176. if (pre_path instanceof Array) {
  4177. pre_path = pre_path[0];
  4178. }
  4179. let base = location.href;
  4180.  
  4181. let urls = globalThis.htmlConfig.fliphtml5_pages
  4182. .map(obj => {
  4183. // "../files/large/d8b6c26f987104455efb3ec5addca7c9.jpg"
  4184. let path = pre_path + obj.n[0].split("?")[0];
  4185. let url = new URL(path, base);
  4186. // https://book.yunzhan365.com/mctl/itid/files/large/d8b6c26f987104455efb3ec5addca7c9.jpg
  4187. return url.href;
  4188. });
  4189. globalThis.img_urls = urls;
  4190. return urls;
  4191. }
  4192.  
  4193.  
  4194. /**
  4195. * 导出图片到PDF
  4196. */
  4197. async function exportPDF$1() {
  4198. let urls = getImgUrls();
  4199. let title = htmlConfig.meta.title;
  4200.  
  4201. alert("正在下载图片,请稍等,时长取决于图片数量");
  4202. await utils.imgURLsToPDF(urls, title);
  4203. }
  4204.  
  4205.  
  4206. /**
  4207. * 移除多余空按钮
  4208. */
  4209. function removeSpareBtns() {
  4210. utils.removeMulti(
  4211. wk$(".btns_section [class*=btn-]").slice(1)
  4212. );
  4213. }
  4214.  
  4215.  
  4216. /**
  4217. * 云展网文档下载策略
  4218. */
  4219. async function yunzhan365() {
  4220. // 根据网址分别处理
  4221. if (location.pathname.startsWith("/basic")) {
  4222. // utils.setBtnListener(toIndex, "btn_1", "转到全屏页");
  4223. return;
  4224. }
  4225.  
  4226. // 创建脚本启动按钮
  4227. utils.createBtns();
  4228. utils.setBtnListener(exportPDF$1, "btn_1", "导出PDF");
  4229. removeSpareBtns();
  4230. }
  4231.  
  4232. /**
  4233. * 截取当前对话,返回canvas
  4234. * @param {Function} once 一次性任务
  4235. * @returns {Promise<HTMLCanvasElement>}
  4236. */
  4237. async function captureChat(once) {
  4238. // 执行一次性任务
  4239. await once();
  4240. return (
  4241. await utils.elementsToCanvases([window.chat])
  4242. )[0];
  4243. }
  4244.  
  4245.  
  4246. /**
  4247. * 导出图片到文件和剪贴板
  4248. * @param {HTMLCanvasElement} canvas
  4249. */
  4250. async function exportCanvas(canvas) {
  4251. const blob = await utils.canvasToBlob(canvas);
  4252. utils.saveAs("BingAI对话.png", blob);
  4253. utils.copyData(blob);
  4254. }
  4255.  
  4256.  
  4257. /**
  4258. * 截图并导出对话
  4259. */
  4260. async function exportChatAsImage() {
  4261. // 定义一次性任务
  4262. const once = utils.once(() => {
  4263. // 移除video元素
  4264. utils.removeMulti(wk$("video"));
  4265. // 移除对话外元素
  4266. for (let elem of [...document.body.children].slice(2)) {
  4267. utils.remove(elem);
  4268. } // 移除顶部欢迎
  4269. utils.remove(
  4270. wk$.call(window.chat, "cib-welcome-container")[0]
  4271. );
  4272. });
  4273.  
  4274. return exportCanvas(
  4275. await captureChat(once)
  4276. );
  4277. }
  4278.  
  4279.  
  4280. /**
  4281. * 初始化工作
  4282. */
  4283. async function init() {
  4284. const
  4285. box1 = (await wk$$(".cib-serp-main"))[0],
  4286. box2 = (await wk$$.call(box1.shadowRoot, "#cib-conversation-main"))[0],
  4287. chat = (await wk$$.call(box2.shadowRoot, "#cib-chat-main"))[0],
  4288. outer_bar = (await wk$$.call(box1.shadowRoot, "#cib-action-bar-main"))[0],
  4289. bar = (await wk$$.call(outer_bar.shadowRoot, ".root"))[0],
  4290. ori_btn = (await wk$$.call(bar, ".outside-left-container"))[0];
  4291. window.chat = chat;
  4292. if (!(ori_btn instanceof HTMLElement)) {
  4293. throw Error(`${ori_btn} 的类型不是 HTMLElement!`);
  4294. }
  4295.  
  4296. // 复制按钮
  4297. let button = ori_btn.cloneNode(false);
  4298. window.button = button;
  4299. // 更换按钮图标
  4300. button.innerHTML = `
  4301. <div class="button-compose-wrapper">
  4302. <button class="button-compose" type="button" aria-label="新主题" collapsed="">
  4303. <div class="button-compose-content">
  4304. <div size="32" style="--icon-size:32px;" class="button-compose-icon">
  4305. <svg version="1.0" xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 32 32" preserveAspectRatio="xMidYMid meet">
  4306. <metadata>
  4307. Created by potrace 1.15, written by Peter Selinger 2001-2017, edited by Allen Lv 2023
  4308. </metadata>
  4309. <g transform="translate(4.7, 4.7) scale(0.02, 0.02)">
  4310. <g transform="translate(0.000000,1280.000000) scale(0.100000,-0.100000)" fill="#ffffff" stroke="none">
  4311. <path d="M3998 12784 c-62 -33 -58 154 -58 -2439 l0 -2365 -800 0 -800 0 -31
  4312. -28 c-39 -35 -43 -89 -8 -136 66 -90 3316 -4165 3340 -4188 22 -21 39 -28 69
  4313. -28 29 0 47 7 70 28 16 15 779 968 1695 2117 1163 1460 1667 2099 1671 2121 7
  4314. 36 -8 70 -40 96 -19 16 -78 18 -823 18 l-803 0 0 2375 0 2375 -29 32 -29 33
  4315. -1699 2 c-1488 2 -1701 0 -1725 -13z"></path>
  4316. <path d="M1687 4649 l-288 -8 -32 -27 c-17 -15 -332 -286 -699 -602 l-668
  4317. -575 0 -1719 0 -1718 5630 0 5630 0 0 1718 -1 1717 -700 603 -700 603 -252 5
  4318. c-139 3 -267 7 -284 9 l-33 4 0 -800 0 -799 -3645 0 c-2423 0 -3645 -3 -3645
  4319. -10 0 -5 -3 -10 -7 -10 -5 0 -7 364 -5 810 1 445 -1 809 -5 808 -5 0 -137 -5
  4320. -296 -9z"></path></g></g></svg></div>
  4321. <div class="button-compose-text"><font style="vertical-align: inherit;"><font style="vertical-align: inherit;">保存对话</font></font></div></div>
  4322. </button>
  4323. <div class="button-compose-hint"><font style="vertical-align: inherit;"><font style="vertical-align: inherit;">保存对话</font></font></div>
  4324. </div>`;
  4325. // 为点击绑定回调
  4326. button
  4327. .querySelector(".button-compose-content")
  4328. .addEventListener("click", exportChatAsImage);
  4329.  
  4330. // 添加到DOM
  4331. bar.append(button);
  4332. }
  4333.  
  4334.  
  4335. /**
  4336. * BingAI对话辅助工具
  4337. */
  4338. async function bingAIChat() {
  4339. init();
  4340. }
  4341.  
  4342. /**
  4343. * 导出图片链接
  4344. */
  4345. function exportURLs$1() {
  4346. const all = parseInt(
  4347. wk$("#bot-bar-inn > span")[0].textContent.split("/")[1]
  4348. );
  4349. const imgs = wk$("[data-num] img");
  4350. const got = imgs.length;
  4351.  
  4352. if (got < all) {
  4353. if (!confirm(
  4354. `当前浏览页数:${got},总页数:${all}\n建议浏览剩余页面以导出全部链接\n是否继续导出链接?`
  4355. )) {
  4356. return;
  4357. }
  4358. }
  4359. utils.saveImgURLs(
  4360. imgs.map(img => img.src)
  4361. );
  4362. }
  4363.  
  4364.  
  4365. /**
  4366. * 取出图片链接,发给同源页面让其代下载
  4367. */
  4368. async function callAgent() {
  4369. const url = new URL(
  4370. wk$("[data-num] img")[0].src
  4371. );
  4372. const aim = "swf.ishare.down.sina.com.cn";
  4373. if (url.hostname !== aim) {
  4374. alert("当前页面不适用!");
  4375. console.log(url);
  4376. return;
  4377. }
  4378.  
  4379. const sock = new utils.Socket(
  4380. open(`${url.protocol}//${aim}/?wk=true`)
  4381. );
  4382. await sock.connect(false);
  4383.  
  4384. // 移除请求的内容范围,等价于请求整体
  4385. url.searchParams.delete("range");
  4386. sock.talk({
  4387. wk: true,
  4388. action: true,
  4389. img_url: url.href,
  4390. title: document.title.split(" - ")[0].replace(".pdf", ""),
  4391. });
  4392. alert("请于新打开的页面查收 PDF");
  4393. }
  4394.  
  4395.  
  4396. /**
  4397. * 360文库文档下载策略
  4398. */
  4399. function wenku360() {
  4400. utils.createBtns();
  4401. utils.setBtnListener(
  4402. exportURLs$1, "btn_1", "导出图片链接"
  4403. );
  4404.  
  4405. utils.setBtnListener(
  4406. callAgent, "btn_2", "导出PDF"
  4407. );
  4408. utils.toggleBtn("btn_2");
  4409. }
  4410.  
  4411. async function getFileInfo() {
  4412. const
  4413. uid = new URL(location.href).searchParams.get("contentUid"),
  4414. resp = await fetch("https://zyjy-resource.webtrn.cn/sdk/api/u/open/getResourceDetail", {
  4415. "headers": {
  4416. "accept": "application/json, text/javascript, */*; q=0.01",
  4417. "content-type": "application/json",
  4418. },
  4419. "referrer": "https://jg.class.com.cn/",
  4420. "body": `{"params":{"contentUid":"${uid}"}}`,
  4421. "method": "POST",
  4422. }),
  4423. data = await resp.json(),
  4424. url = data["data"]["downloadUrl"],
  4425. fname = data["data"]["title"];
  4426.  
  4427. let ext;
  4428. try {
  4429. // validate the URL format
  4430. // and get the file format
  4431. ext = new URL(url).pathname.split(".").at(-1);
  4432. } catch(e) {
  4433. console.log(data);
  4434. throw new Error("API changed, the script is invalid now.");
  4435. }
  4436. return { url, fname, ext };
  4437. }
  4438.  
  4439.  
  4440. /**
  4441. * 保存文件
  4442. * @param {{fname: string, url: string, ext: string}} info
  4443. */
  4444. async function saveFile(info) {
  4445. const
  4446. resp = await fetch(info.url),
  4447. blob = await resp.blob();
  4448. utils.saveAs(info.fname + `.${info.ext}`, blob);
  4449. }
  4450.  
  4451.  
  4452. /**
  4453. * 劫持保存网页,改为保存文件
  4454. * @param {KeyboardEvent} e
  4455. */
  4456. function onCtrlS(e) {
  4457. if (e.code === "KeyS" &&
  4458. e.ctrlKey) {
  4459. console.log("ctrl + s is captured!!");
  4460. getFileInfo().then(info => saveFile(info));
  4461.  
  4462. e.preventDefault();
  4463. e.stopImmediatePropagation();
  4464. e.stopPropagation();
  4465. }
  4466. }
  4467.  
  4468.  
  4469. /**
  4470. * 技工教育网文档策略
  4471. */
  4472. function jg() {
  4473. window.addEventListener(
  4474. "keydown", onCtrlS, true
  4475. );
  4476. }
  4477.  
  4478. async function estimateTimeCost() {
  4479. wk$(".w-page").at(-1).scrollIntoView();
  4480. await utils.sleep(1000);
  4481.  
  4482. let total = wk$("#pageNumber-text")[0].textContent.split("/")[1];
  4483. total = parseInt(total);
  4484. return confirm([
  4485. "注意,一旦开始截图就无法停止,除非刷新页面。",
  4486. "浏览器窗口最小化会导致截图提前结束!",
  4487. "建议将窗口最大化,这将【显著增大清晰度和文件体积】",
  4488. `预计耗时 ${1.1 * total} 秒,是否继续?`,
  4489. ].join("\n"));
  4490. }
  4491.  
  4492.  
  4493. /**
  4494. * 逐页捕获canvas
  4495. * @returns {Promise<Array<Blob>>}
  4496. */
  4497. async function collectAll() {
  4498. const imgs = [];
  4499. let div = wk$(".w-page")[0];
  4500. let i = 0;
  4501. while (true) {
  4502. // 取得 div
  4503. const anchor = Date.now();
  4504. while (!div && (Date.now() - anchor < 1000)) {
  4505. console.log(`retry on page ${i+1}`);
  4506. await utils.sleep(200);
  4507. }
  4508. if (!div) throw new Error(
  4509. `can not fetch <div>: page ${i}`
  4510. );
  4511. // 移动到 div
  4512. div.scrollIntoView({ behavior: "smooth" });
  4513. await utils.sleep(1000);
  4514. // 取得 canvas
  4515. let canvas = wk$.call(div, "canvas")[0];
  4516. let j = 0;
  4517. while (!canvas && j < 100) {
  4518. div = div.nextElementSibling;
  4519. canvas = wk$.call(div, "canvas")[0];
  4520. j++;
  4521. }
  4522. if (!div) throw new Error(
  4523. `can not fetch <div>: page ${i}*`
  4524. );
  4525.  
  4526. // 存储 canvas
  4527. imgs.push(
  4528. await utils.canvasToBlob(canvas)
  4529. );
  4530. console.log(`canvas stored: ${++i}`);
  4531.  
  4532. // 下一轮循环
  4533. div = div.nextElementSibling;
  4534. if (!div) break;
  4535. }
  4536. console.log("done");
  4537. return imgs;
  4538. }
  4539.  
  4540.  
  4541. /**
  4542. * 放大或缩小文档画面
  4543. * @param {boolean} up
  4544. */
  4545. async function scale(up) {
  4546. let s = "#magnifyBtn";
  4547. if (!up) {
  4548. s = "#shrinkBtn";
  4549. }
  4550. const btn = wk$(s)[0];
  4551. for (let _ of utils.range(10)) {
  4552. btn.click();
  4553. await utils.sleep(500);
  4554. }
  4555. }
  4556.  
  4557.  
  4558. /**
  4559. * 获取全部canvas,显示功能按钮
  4560. * @returns
  4561. */
  4562. async function prepare() {
  4563. if (! await estimateTimeCost()) {
  4564. return;
  4565. }
  4566.  
  4567. // 隐藏按钮
  4568. utils.toggleBtn("btn_1");
  4569. // 放大画面
  4570. await scale(true);
  4571.  
  4572. let imgs;
  4573. try {
  4574. imgs = await collectAll();
  4575. } catch(e) {
  4576. console.error(e);
  4577. } finally {
  4578. // 缩小画面
  4579. scale(false);
  4580. }
  4581. // window.imgs = imgs;
  4582. // 显示功能按钮
  4583. const fname = "技工教育网文档";
  4584. utils.setBtnListener(
  4585. () => utils.imgBlobsToPDF(imgs, fname),
  4586. "btn_2",
  4587. "导出PDF"
  4588. );
  4589. utils.toggleBtn("btn_2");
  4590.  
  4591. utils.setBtnListener(
  4592. () => utils.blobsToZip(imgs, "page", "png", fname),
  4593. "btn_3",
  4594. "导出ZIP"
  4595. );
  4596. utils.toggleBtn("btn_3");
  4597. }
  4598.  
  4599.  
  4600. /**
  4601. * 技工教育文档预览页面策略
  4602. */
  4603. function jgPreview() {
  4604. utils.createBtns();
  4605. utils.setBtnListener(
  4606. prepare, "btn_1", "截图文档"
  4607. );
  4608. }
  4609.  
  4610. /**
  4611. * 取得文档标题
  4612. * @returns {string}
  4613. */
  4614. function getTitle() {
  4615. return document.title.slice(0, -4);
  4616. }
  4617.  
  4618.  
  4619. /**
  4620. * 取得基础URL
  4621. * @returns {string}
  4622. */
  4623. function getBaseURL() {
  4624. return wk$("#dp")[0].value;
  4625. }
  4626.  
  4627.  
  4628. /**
  4629. * 获取总页码
  4630. * @returns {number}
  4631. */
  4632. function getTotalPageNum() {
  4633. const num = wk$(".shop3 > li:nth-child(3)")[0]
  4634. .textContent
  4635. .split("/")[1]
  4636. .trim();
  4637. return parseInt(num);
  4638. }
  4639.  
  4640.  
  4641. /**
  4642. * 返回图片链接生成器
  4643. * @param {string} base 基础图片链接地址
  4644. * @param {number} max 最大数量
  4645. * @returns {Generator<string, void, unknown>}
  4646. */
  4647. function* imgURLsMaker(base, max) {
  4648. for (let i of utils.range(1, max + 1)) {
  4649. yield `${base}${i}.gif`;
  4650. }
  4651. }
  4652.  
  4653.  
  4654. /**
  4655. * 取得当前页面全部图片链接(生成器)
  4656. * @returns {Generator<string, void, unknown>}
  4657. */
  4658. function getImgURLs() {
  4659. const
  4660. base = getBaseURL(),
  4661. total = getTotalPageNum();
  4662. return imgURLsMaker(base, total)
  4663. }
  4664.  
  4665.  
  4666. function exportPDF() {
  4667. // 先隐藏按钮
  4668. utils.toggleBtn("btn_2");
  4669.  
  4670. const urls = getImgURLs();
  4671. const title = getTitle();
  4672. utils
  4673. .imgURLsToPDF(urls, title)
  4674. // 等 PDF 导出后再显示按钮
  4675. .then(() => utils.toggleBtn("btn_2"));
  4676. }
  4677.  
  4678.  
  4679. function exportURLs() {
  4680. const urls = getImgURLs();
  4681. utils.saveImgURLs(urls);
  4682. }
  4683.  
  4684.  
  4685. /**
  4686. * 文库吧文档下载策略
  4687. */
  4688. function wenkub() {
  4689. utils.createBtns();
  4690. utils.setBtnListener(
  4691. exportURLs, "btn_1", "导出图片链接"
  4692. );
  4693.  
  4694. utils.setBtnListener(
  4695. exportPDF, "btn_2", "导出PDF(测试)"
  4696. );
  4697. utils.toggleBtn("btn_2");
  4698. }
  4699.  
  4700. /**
  4701. * 主函数:识别网站,执行对应文档下载策略
  4702. */
  4703. function main() {
  4704. // 显示当前位置
  4705. const host = location.hostname;
  4706. const params = new URL(location.href).searchParams;
  4707. console.log(`当前 host: ${host}`);
  4708. // ---调试用---
  4709. // window.loaded_doc = new DOMParser()
  4710. // .parseFromString(wk$("html")[0].outerHTML, "text/html");
  4711. // console.log(loaded_doc);
  4712. // -----------
  4713.  
  4714. if (host.includes("docin.com")) {
  4715. docin();
  4716. } else if (host === "swf.ishare.down.sina.com.cn") {
  4717. if (params.get("wk") === "true") {
  4718. ishareData2();
  4719. } else {
  4720. ishareData();
  4721. }
  4722. } else if (host.includes("ishare.iask")) {
  4723. ishare();
  4724. } else if (host === "www.deliwenku.com") {
  4725. deliwenku();
  4726. } else if (host.includes("file") && host.includes("deliwenku.com")) {
  4727. deliFile();
  4728. } else if (host === "www.doc88.com") {
  4729. doc88();
  4730. } else if (host === "www.360doc.com") {
  4731. doc360();
  4732. } else if (host === "doc.mbalib.com") {
  4733. mbalib();
  4734. } else if (host === "www.dugen.com") {
  4735. dugen();
  4736. } else if (host === "c.gb688.cn") {
  4737. gb688();
  4738. } else if (host === "www.safewk.com") {
  4739. safewk();
  4740. } else if (host.includes("book118.com")) {
  4741. book118();
  4742. } else if (host === "www.renrendoc.com") {
  4743. renrendoc();
  4744. } else if (host.includes("yunzhan365.com")) {
  4745. yunzhan365();
  4746. } else if (host === "www.bing.com") {
  4747. bingAIChat();
  4748. } else if (host === "wenku.so.com") {
  4749. wenku360();
  4750. } else if (host === "jg.class.com.cn") {
  4751. jg();
  4752. } else if (host === "preview.imm.aliyuncs.com") {
  4753. jgPreview();
  4754. } else if (host === "www.wenkub.com") {
  4755. wenkub();
  4756. } else {
  4757. console.log("匹配到了无效网页");
  4758. }
  4759. }
  4760.  
  4761.  
  4762. /**
  4763. * 当【DOM框架准备好时】或【5秒后】执行主函数
  4764. */
  4765. new Promise((resolve, reject) => {
  4766. document.addEventListener(
  4767. "DOMContentLoaded",
  4768. () => main() && resolve(true),
  4769. true
  4770. );
  4771. setTimeout(
  4772. () => main() && reject(new Error("Timeout Error (>2s)")),
  4773. 2 * 1000
  4774. );
  4775. }).catch(e => {
  4776. if (`${e}`.includes("Timeout Error")) {
  4777. return true;
  4778. }
  4779. throw e;
  4780. });
  4781.  
  4782. })();