☰

Kemono zip download

Download kemono post in a zip file

  1. // ==UserScript==
  2. // @name               Kemono zip download
  3. // @name:zh-CN         Kemono 下载为ZIP文件
  4. // @namespace          https://greasyfork.org/users/667968-pyudng
  5. // @version            0.10
  6. // @description        Download kemono post in a zip file
  7. // @description:zh-CN  下载Kemono的内容为ZIP压缩文档
  8. // @author             PY-DNG
  9. // @license            MIT
  10. // @match              http*://*.kemono.su/*
  11. // @match              http*://*.kemono.party/*
  12. // @require            data:application/javascript,window.setImmediate%20%3D%20window.setImmediate%20%7C%7C%20((f%2C%20...args)%20%3D%3E%20window.setTimeout(()%20%3D%3E%20f(args)%2C%200))%3B
  13. // @require            https://update.greasyfork.org/scripts/456034/1546794/Basic%20Functions%20%28For%20userscripts%29.js
  14. // @require            https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js
  15. // @require            https://update.greasyfork.org/scripts/458132/1138364/ItemSelector.js
  16. // @resource           vue-js      https://unpkg.com/vue@3.5.13/dist/vue.global.prod.js
  17. // @resource           quasar-icon https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900|Material+Icons
  18. // @resource           quasar-css  https://cdn.jsdelivr.net/npm/quasar@2.15.1/dist/quasar.prod.css
  19. // @resource           quasar-js   https://cdn.jsdelivr.net/npm/quasar@2.15.1/dist/quasar.umd.prod.js
  20. // @connect            kemono.su
  21. // @connect            kemono.party
  22. // @icon               https://kemono.su/favicon.ico
  23. // @grant              GM_xmlhttpRequest
  24. // @grant              GM_registerMenuCommand
  25. // @grant              GM_addElement
  26. // @grant              GM_getResourceText
  27. // @grant              GM_setValue
  28. // @grant              GM_getValue
  29. // @grant              GM_addValueChangeListener
  30. // @run-at             document-start
  31. // ==/UserScript==
  32.  
  33. /* eslint-disable no-multi-spaces */
  34. /* eslint-disable no-return-assign */
  35.  
  36. /* global LogLevel DoLog Err Assert $ $All $CrE $AEL $$CrE addStyle detectDom destroyEvent copyProp copyProps parseArgs escJsStr replaceText getUrlArgv dl_browser dl_GM AsyncManager queueTask FunctionLoader loadFuncs require isLoaded */
  37. /* global setImmediate JSZip ItemSelector Vue Quasar */
  38.  
  39. (function __MAIN__() {
  40.     'use strict';
  41.  
  42. 	const CONST = {
  43. 		TextAllLang: {
  44. 			DEFAULT: 'en-US',
  45. 			'zh-CN': {
  46.                 DownloadZip: '下载为ZIP文件',
  47.                 DownloadPost: '下载当前作品为ZIP文件',
  48.                 DownloadCreator: '下载当前创作者为ZIP文件',
  49.                 Downloading: '正在下载...',
  50.                 SelectAll: '全选',
  51.                 TotalProgress: '总进度',
  52.                 ProgressBoardTitle: '下载进度',
  53.                 Settings: '设置',
  54.                 SaveContent: '保存文字内容到html文件',
  55.                 SaveApijson: '保存api结果到json文件',
  56.                 NoPrefix: '保存文件时不添加文件名前缀',
  57.                 FlattenFiles: '保存主文件和附件到同一级文件夹',
  58.                 FlattenFilesCaption: '主文件一般是封面图',
  59.             },
  60.             'en-US': {
  61.                 DownloadZip: 'Download as ZIP file',
  62.                 DownloadPost: 'Download post as ZIP file',
  63.                 DownloadCreator: 'Download creator as ZIP file',
  64.                 Downloading: 'Downloading...',
  65.                 SelectAll: 'Select All',
  66.                 TotalProgress: 'Total Progress',
  67.                 ProgressBoardTitle: 'Download Progress',
  68.                 Settings: 'Settings',
  69.                 SaveContent: 'Save text content',
  70.                 SaveApijson: 'Save api result',
  71.                 NoPrefix: 'Do not add filename prefix',
  72.                 FlattenFiles: 'Save main file and attachments to same folder',
  73.                 FlattenFilesCaption: '"Main file" is usually the cover image',
  74.             }
  75. 		}
  76. 	};
  77.  
  78. 	// Init language
  79. 	const i18n = Object.keys(CONST.TextAllLang).includes(navigator.language) ? navigator.language : CONST.TextAllLang.DEFAULT;
  80. 	CONST.Text = CONST.TextAllLang[i18n];
  81.  
  82.     loadFuncs([{
  83.         id: 'utils',
  84.         async func() {
  85.             const win = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
  86.  
  87.             function fillNumber(number, length) {
  88.                 const str = number.toString();
  89.                 return '0'.repeat(length - str.length) + str;
  90.             }
  91.  
  92.             /**
  93.              * Async task progress manager \
  94.              * when awaiting async tasks, replace `await task` with `await manager.progress(task)` \
  95.              * suppoerts sub-tasks, just `manager.sub(sub_steps, sub_callback)`
  96.              */
  97.             class ProgressManager {
  98.                 /** @type {*} */
  99.                 info;
  100.                 /** @type {number} */
  101.                 steps;
  102.                 /** @type {progressCallback} */
  103.                 callback;
  104.                 /** @type {number} */
  105.                 finished;
  106.                 /** @type {ProgressManager[]} */
  107.                 #children;
  108.                 /** @type {ProgressManager} */
  109.                 #parent;
  110.  
  111.                 /**
  112.                  * This callback is called each time a promise resolves
  113.                  * @callback progressCallback
  114.                  * @param {number} resolved_count
  115.                  * @param {number} total_count
  116.                  * @param {ProgressManager} manager
  117.                  */
  118.  
  119.                 /**
  120.                  * @param {number} [steps=0] - total steps count of the task
  121.                  * @param {progressCallback} [callback] - callback each time progress updates
  122.                  * @param {*} [info] - attach any data about this manager if need
  123.                  */
  124.                 constructor(steps=0, callback=function() {}, info=undefined) {
  125.                     this.steps = steps;
  126.                     this.callback = callback;
  127.                     this.info = info;
  128.                     this.finished = 0;
  129.  
  130.                     this.#children = [];
  131.                     this.#callCallback();
  132.                 }
  133.  
  134.                 add() { this.steps++; }
  135.  
  136.                 /**
  137.                  * @template {Promise | null} task
  138.                  * @param {task} [promise] - task to await, null is acceptable if no task to await
  139.                  * @param {number} [finished] - set this.finished to this value, defaults to this.finished+1
  140.                  * @returns {Awaited<task>}
  141.                  */
  142.                 async progress(promise, finished) {
  143.                     const val = await Promise.resolve(promise);
  144.                     try {
  145.                         this.finished = typeof finished === 'number' ? finished : this.finished + 1;
  146.                         this.#callCallback();
  147.                         //this.finished === this.steps && this.#parent && this.#parent.progress();
  148.                     } finally {
  149.                         return val;
  150.                     }
  151.                 }
  152.  
  153.                 /**
  154.                  * Creates a new ProgressManager as a sub-progress of this
  155.                  * @param {number} [steps=0] - total steps count of the task
  156.                  * @param {progressCallback} [callback] - callback each time progress updates, defaulting to parent.callback
  157.                  * @param {*} [info] - attach any data about the sub-manager if need
  158.                  */
  159.                 sub(steps, callback, info) {
  160.                     const manager = new ProgressManager(steps ?? 0, callback ?? this.callback, info);
  161.                     manager.#parent = this;
  162.                     this.#children.push(manager);
  163.                     return manager;
  164.                 }
  165.  
  166.                 #callCallback() {
  167.                     this.callback(this.finished, this.steps, this);
  168.                 }
  169.  
  170.                 get children() {
  171.                     return [...this.#children];
  172.                 }
  173.  
  174.                 get parent() {
  175.                     return this.#parent;
  176.                 }
  177.  
  178.                 /**
  179.                  * Resolves after all promise resolved, and callback each time one of them resolves
  180.                  * @param {Array<Promise>} promises
  181.                  * @param {progressCallback} callback
  182.                  */
  183.                 static async all(promises, callback) {
  184.                     const manager = new ProgressManager(promises.length, callback);
  185.                     await Promise.all(promises.map(promise => manager.progress(promise, callback)));
  186.                 }
  187.             }
  188.  
  189.             const PerformanceManager = (function() {
  190.                 class RunRecord {
  191.                     static #id = 0;
  192.  
  193.                     /** @typedef {'initialized' | 'running' | 'finished'} run_status */
  194.                     /** @type {number} */
  195.                     id;
  196.                     /** @type {number} */
  197.                     start;
  198.                     /** @type {number} */
  199.                     end;
  200.                     /** @type {number} */
  201.                     duration;
  202.                     /** @type {run_status} */
  203.                     status;
  204.                     /**
  205.                      * Anything for programmers to mark and read, uses as a description for this run
  206.                      * @type {*}
  207.                      */
  208.                     info;
  209.  
  210.                     /**
  211.                      * @param {*} [info] - Anything for programmers to mark and read, uses as a description for this run
  212.                      */
  213.                     constructor(info) {
  214.                         this.id = RunRecord.#id++;
  215.                         this.status = 'initialized';
  216.                         this.info = info;
  217.                     }
  218.  
  219.                     run() {
  220.                         const time = performance.now();
  221.                         this.start = time;
  222.                         this.status = 'running';
  223.                         return this;
  224.                     }
  225.  
  226.                     stop() {
  227.                         const time = performance.now();
  228.                         this.end = time;
  229.                         this.duration = this.end - this.start;
  230.                         this.status = 'finished';
  231.                         return this;
  232.                     }
  233.                 }
  234.                 class Task {
  235.                     /** @typedef {number | string | symbol} task_id */
  236.                     /** @type {task_id} */
  237.                     id;
  238.                     /** @type {RunRecord[]} */
  239.                     runs;
  240.  
  241.                     /**
  242.                      * @param {task_id} id
  243.                      */
  244.                     constructor(id) {
  245.                         this.id = id;
  246.                         this.runs = [];
  247.                     }
  248.  
  249.                     run(info) {
  250.                         const record = new RunRecord(info);
  251.                         record.run();
  252.                         this.runs.push(record);
  253.                         return record;
  254.                     }
  255.  
  256.                     get time() {
  257.                         return this.runs.reduce((time, record) => {
  258.                             if (record.status === 'finished') {
  259.                                 time += record.duration;
  260.                             }
  261.                             return time;
  262.                         }, 0)
  263.                     }
  264.                 }
  265.                 class PerformanceManager {
  266.                     /** @type {Task[]} */
  267.                     tasks;
  268.  
  269.                     constructor() {
  270.                         this.tasks = [];
  271.                     }
  272.  
  273.                     /**
  274.                      * @param {task_id} id
  275.                      * @returns {Task | null}
  276.                      */
  277.                     getTask(id) {
  278.                         return this.tasks.find(task => task.id === id);
  279.                     }
  280.  
  281.                     /**
  282.                      * Creates a new task
  283.                      * @param {task_id} id
  284.                      * @returns {Task}
  285.                      */
  286.                     newTask(id) {
  287.                         Assert(!this.getTask(id), `given task id ${escJsStr(id)} is already in use`, TypeError);
  288.  
  289.                         const task = new Task(id);
  290.                         this.tasks.push(task);
  291.                         return task;
  292.                     }
  293.  
  294.                     /**
  295.                      * Runs a task
  296.                      * @param {task_id} id
  297.                      * @param {*} run_info - Anything for programmers to mark and read, uses as a description for this run
  298.                      * @returns {RunRecord}
  299.                      */
  300.                     run(task_id, run_info) {
  301.                         const task = this.getTask(task_id);
  302.                         Assert(task, `task of id ${escJsStr(task_id)} not found`, TypeError);
  303.  
  304.                         return task.run(run_info);
  305.                     }
  306.  
  307.                     totalTime(id) {
  308.                         if (id) {
  309.                             return this.getTask(id).time;
  310.                         } else {
  311.                             return this.tasks.reduce((timetable, task) => {
  312.                                 timetable[task.id] = task.time;
  313.                                 return timetable;
  314.                             }, {});
  315.                         }
  316.                     }
  317.  
  318.                     meanTime(id) {
  319.                         if (id) {
  320.                             const task = this.getTask(id);
  321.                             return task.time / task.runs.length;
  322.                         } else {
  323.                             return this.tasks.reduce((timetable, task) => {
  324.                                 timetable[task.id] = task.time / task.runs.length;
  325.                                 return timetable;
  326.                             }, {});
  327.                         }
  328.                     }
  329.                 }
  330.  
  331.                 return PerformanceManager;
  332.             }) ();
  333.  
  334.             return {
  335.                 window: win,
  336.                 fillNumber, ProgressManager, PerformanceManager
  337.             }
  338.         }
  339.     }, {
  340.         id: 'dependencies',
  341.         desc: 'load dependencies like vue into the page',
  342.         detectDom: ['head', 'body'],
  343.         async func() {
  344.             const deps = [{
  345.                 name: 'vue-js',
  346.                 type: 'script',
  347.             }, {
  348.                 name: 'quasar-icon',
  349.                 type: 'style'
  350.             }, {
  351.                 name: 'quasar-css',
  352.                 type: 'style'
  353.             }, {
  354.                 name: 'quasar-js',
  355.                 type: 'script'
  356.             }];
  357.  
  358.             await Promise.all(deps.map(dep => {
  359.                 return new Promise((resolve, reject) => {
  360.                     switch (dep.type) {
  361.                         case 'script': {
  362.                             // Once load, dispatch load event on messager
  363.                             const evt_name = `load:${dep.name};${Date.now()}`;
  364.                             const rand = Math.random().toString();
  365.                             const messager = new EventTarget();
  366.                             const load_code = [
  367.                                 '\n;',
  368.                                 `window[${escJsStr(rand)}].dispatchEvent(new Event(${escJsStr(evt_name)}));`,
  369.                                 `delete window[${escJsStr(rand)}];\n`
  370.                             ].join('\n');
  371.                             unsafeWindow[rand] = messager;
  372.                             $AEL(messager, evt_name, resolve);
  373.                             GM_addElement(document.head, 'script', {
  374.                                 textContent: GM_getResourceText(dep.name) + load_code,
  375.                             });
  376.                             break;
  377.                         }
  378.                         case 'style': {
  379.                             GM_addElement(document.head, 'style', {
  380.                                 textContent: GM_getResourceText(dep.name),
  381.                             });
  382.                             resolve();
  383.                             break;
  384.                         }
  385.                     }
  386.                 });
  387.             }));
  388.         }
  389.     }, {
  390.         id: 'api',
  391.         desc: 'api for kemono',
  392.         async func() {
  393.             let api_key = null;
  394.  
  395.             const Posts = {
  396.                 /**
  397.                  * Get a list of creator posts
  398.                  * @param {string} service - The service where the post is located
  399.                  * @param {number | string} creator_id - The ID of the creator
  400.                  * @param {string} [q] - Search query
  401.                  * @param {number} [o] - Result offset, stepping of 50 is enforced
  402.                  */
  403.                 posts(service, creator_id, q, o) {
  404.                     const search = {};
  405.                     q && (search.q = q);
  406.                     o && (search.o = o);
  407.                     return callApi({
  408.                         endpoint: `/${service}/user/${creator_id}`,
  409.                         search
  410.                     });
  411.                 },
  412.  
  413.                 /**
  414.                  * Get a specific post
  415.                  * @param {string} service
  416.                  * @param {number | string} creator_id
  417.                  * @param {number | string} post_id
  418.                  * @returns {Promise<Object>}
  419.                  */
  420.                 post(service, creator_id, post_id) {
  421.                     return callApi({
  422.                         endpoint: `/${service}/user/${creator_id}/post/${post_id}`
  423.                     });
  424.                 }
  425.             };
  426.             const Creators = {
  427.                 /**
  428.                  * Get a creator
  429.                  * @param {string} service - The service where the creator is located
  430.                  * @param {number | string} creator_id - The ID of the creator
  431.                  * @returns
  432.                  */
  433.                 profile(service, creator_id) {
  434.                     return callApi({
  435.                         endpoint: `/${service}/user/${creator_id}/profile`
  436.                     });
  437.                 }
  438.             };
  439.             const Custom = {
  440.                 /**
  441.                  * Get a list of creator's ALL posts, calling Post.posts for multiple times and joins the results
  442.                  * @param {string} service - The service where the post is located
  443.                  * @param {number | string} creator_id - The ID of the creator
  444.                  * @param {string} [q] - Search query
  445.                  */
  446.                 async all_posts(service, creator_id, q) {
  447.                     const posts = [];
  448.                     let offset = 0;
  449.                     let api_result = null;
  450.                     while (!api_result || api_result.length === 50) {
  451.                         api_result = await Posts.posts(service, creator_id, q, offset);
  452.                         posts.push(...api_result);
  453.                         offset += 50;
  454.                     }
  455.                     return posts;
  456.                 }
  457.             };
  458.             const API = {
  459.                 get key() { return api_key; },
  460.                 set key(val) { api_key = val; },
  461.                 Posts, Creators,
  462.                 Custom,
  463.                 callApi
  464.             };
  465.             return API;
  466.  
  467.             /**
  468.              * callApi detail object
  469.              * @typedef {Object} api_detail
  470.              * @property {string} endpoint - api endpoint
  471.              * @property {Object} [search] - search params
  472.              * @property {string} [method='GET']
  473.              * @property {boolean | string} [auth=false] - whether to use api-key in this request; true for send, false for not, and string for sending a specific key (instead of pre-configured `api_key`); defaults to false
  474.              */
  475.  
  476.             /**
  477.              * Do basic kemono api request
  478.              * This is the queued version of _callApi
  479.              * @param {api_detail} detail
  480.              * @returns
  481.              */
  482.             function callApi(...args) {
  483.                 return queueTask(() => _callApi(...args), 'callApi');
  484.             }
  485.  
  486.             /**
  487.              * Do basic kemono api request
  488.              * @param {api_detail} detail
  489.              * @returns
  490.              */
  491.             function _callApi(detail) {
  492.                 const search_string = new URLSearchParams(detail.search).toString();
  493.                 const url = `https://kemono.su/api/v1/${detail.endpoint.replace(/^\//, '')}` + (search_string ? '?' + search_string : '');
  494.                 const method = detail.method ?? 'GET';
  495.                 const auth = detail.auth ?? false;
  496.  
  497.                 return new Promise((resolve, reject) => {
  498.                     auth && api_key === null && reject('api key not found');
  499.  
  500.                     const options = {
  501.                         method, url,
  502.                         headers: {
  503.                             accept: 'application/json'
  504.                         },
  505.                         onload(e) {
  506.                             try {
  507.                                 e.status === 200 ? resolve(JSON.parse(e.responseText)) : reject(e.responseText);
  508.                             } catch(err) {
  509.                                 reject(err);
  510.                             }
  511.                         },
  512.                         onerror: err => reject(err)
  513.                     }
  514.                     if (typeof auth === 'string') {
  515.                         options.headers.Cookie = auth;
  516.                     } else if (auth === true) {
  517.                         options.headers.Cookie = api_key;
  518.                     }
  519.                     GM_xmlhttpRequest(options);
  520.                 });
  521.             }
  522.         }
  523.     }, {
  524.         id: 'gui',
  525.         desc: 'reusable GUI components',
  526.         dependencies: 'dependencies',
  527.         async func() {
  528.             class ProgressBoard {
  529.                 /** @type {Vue} */
  530.                 app;
  531.  
  532.                 /** Vue component instance */
  533.                 instance;
  534.  
  535.                 /** @typedef {{ finished: number, total: number }} progress */
  536.                 /** @typedef {{ name: string, progress: progress }} item */
  537.                 /** @type {item[]} */
  538.                 items;
  539.  
  540.                 constructor() {
  541.                     const that = this;
  542.                     this.items = [];
  543.                     
  544.                     // GUI
  545.                     const container = $$CrE({ tagName: 'div', styles: { position: 'fixed', zIndex: '-1' } });
  546.                     const board = $$CrE({
  547.                         tagName: 'div',
  548.                         classes: 'board'
  549.                     });
  550.                     board.innerHTML = `
  551.                         <q-layout view="hhh lpr fff">
  552.                             <q-dialog v-model="show" :class="{ mobile: $q.platform.is.mobile }" :position="$q.platform.is.mobile ? 'standard' : 'bottom'" seamless :full-width="$q.platform.is.mobile" :full-height="$q.platform.is.mobile">
  553.                                 <q-card class="container-card">
  554.                                     <q-card-section class="header row">
  555.                                         <div class="text-h6">${ CONST.Text.ProgressBoardTitle }</div>
  556.                                         <q-space></q-space>
  557.                                         <q-btn :icon="minimized ? 'expand_less' : 'expand_more'" flat round dense @click="minimized = !minimized"></q-btn>
  558.                                         <q-btn icon="close" flat round dense v-close-popup></q-btn>
  559.                                     </q-card-section>
  560.                                     <q-slide-transition>
  561.                                         <q-card-section class="body" v-show="!minimized">
  562.                                             <q-list class="list" :class="{ minimized: minimized }">
  563.                                                 <q-item tag="div" v-for="item of items">
  564.                                                     <q-item-section>
  565.                                                         <q-item-label>{{ item.name }}</q-item-label>
  566.                                                     </q-item-section>
  567.                                                     <q-item-section>
  568.                                                         <q-linear-progress animation-speed="500" :indeterminate="item.progress.total === 0" :value="item.progress.total > 0 ? item.progress.finished / item.progress.total : 0" :color="item.progress.total > 0 && item.progress.total === item.progress.finished ? 'green' : 'blue'"></q-linear-progress>
  569.                                                     </q-item-section>
  570.                                                 </q-item>
  571.                                             </q-list>
  572.                                         </q-card-section>
  573.                                     </q-slide-transition>
  574.                                 </q-card>
  575.                             </q-dialog>
  576.                         </q-layout>
  577.                     `;
  578.                     container.append(board);
  579.                     detectDom('html').then(html => html.append(container));
  580.  
  581.                     detectDom('head').then(head => addStyle(`
  582.                         :is(.container-card):not(.mobile *) {
  583.                             max-width: 45vw;
  584.                         }
  585.                         :is(.header, .body):not(.mobile *) {
  586.                             width: 40vw;
  587.                         }
  588.                         :is(.body .list):not(.mobile *) {
  589.                             height: 40vh;
  590.                             overflow-y: auto;
  591.                         }
  592.                         :is(.body .list.minimized):not(.mobile *) {
  593.                             overflow-y: hidden;
  594.                         }
  595.                     `, 'progress-board-style'));
  596.  
  597.                     this.app = Vue.createApp({
  598.                         data() {
  599.                             return {
  600.                                 items: that.items,
  601.                                 minimized: false,
  602.                                 show: false
  603.                             }
  604.                         },
  605.                         methods: {
  606.                             debug() {
  607.                                 debugger;
  608.                             }
  609.                         },
  610.                         mounted() {
  611.                             that.instance = this;
  612.                         }
  613.                     });
  614.                     this.app.use(Quasar);
  615.                     this.app.mount(board);
  616.                     Quasar.Dark.set(true);
  617.                 }
  618.  
  619.                 /**
  620.                  * update item's progress display on progress_board
  621.                  * @param {string} name - must be unique among all items
  622.                  * @param {progress} progress
  623.                  */
  624.                 update(name, progress) {
  625.                     let item = this.instance.items.find(item => item.name === name);
  626.                     if (!item) {
  627.                         item = { name, progress };
  628.                         this.instance.items.push(item);
  629.                     }
  630.                     item.progress = progress;
  631.                 }
  632.  
  633.                 /**
  634.                  * remove an item
  635.                  * @param {string} name
  636.                  */
  637.                 remove(name) {
  638.                     let item_index = this.instance.items.findIndex(item => item.name === name);
  639.                     if (item_index === -1) { return null; }
  640.                     return this.instance.items.splice(item_index, 1)[0];
  641.                 }
  642.  
  643.                 /**
  644.                  * remove all existing items
  645.                  */
  646.                 clear() {
  647.                    this.instance.items.splice(0, this.instance.items.length);
  648.                 }
  649.  
  650.                 get minimized() {
  651.                     return this.instance.minimized;
  652.                 }
  653.  
  654.                 set minimized(val) {
  655.                     this.instance.minimized = !!val;
  656.                 }
  657.  
  658.                 get closed() {
  659.                     return !this.instance.show;
  660.                 }
  661.  
  662.                 set closed(val) {
  663.                     this.instance.show = !val;
  664.                 }
  665.             }
  666.  
  667.             const board = new ProgressBoard();
  668.  
  669.             return { ProgressBoard, board };
  670.         }
  671.     }, {
  672.         id: 'downloader',
  673.         desc: 'core zip download utils',
  674.         dependencies: ['utils', 'api', 'settings'],
  675.         async func() {
  676.             const utils = require('utils');
  677.             const API = require('api');
  678.             const settings = require('settings');
  679.  
  680.             // Performance record
  681.             const perfmon = new utils.PerformanceManager();
  682.             perfmon.newTask('fetchPost');
  683.             perfmon.newTask('saveAs');
  684.             perfmon.newTask('_fetchBlob');
  685.  
  686.  
  687.             class DownloaderItem {
  688.                 /** @typedef {'file' | 'folder'} downloader_item_type */
  689.                 /**
  690.                  * Name of the item, CANNOT BE PATH
  691.                  * @type {string}
  692.                  */
  693.                 name;
  694.                 /** @type {downloader_item_type} */
  695.                 type;
  696.  
  697.                 /**
  698.                  * @param {string} name
  699.                  * @param {downloader_item_type} type
  700.                  */
  701.                 constructor(name, type) {
  702.                     this.name = name;
  703.                     this.type = type;
  704.                 }
  705.             }
  706.  
  707.             class DownloaderFile extends DownloaderItem{
  708.                 /** @type {Blob} */
  709.                 data;
  710.                 /** @type {Date} */
  711.                 date;
  712.                 /** @type {string} */
  713.                 comment;
  714.  
  715.                 /**
  716.                  * @param {string} name - name only, CANNOT BE PATH
  717.                  * @param {Blob} data
  718.                  * @param {Object} detail
  719.                  * @property {Date} [date]
  720.                  * @property {string} [comment]
  721.                  */
  722.                 constructor(name, data, detail) {
  723.                     super(name, 'file');
  724.                     this.data = data;
  725.                     Object.assign(this, detail);
  726.                 }
  727.  
  728.                 zip(jszip_instance) {
  729.                     const z = jszip_instance ?? new JSZip();
  730.                     const options = {};
  731.                     this.date && (options.date = this.date);
  732.                     this.comment && (options.comment = this.comment);
  733.                     z.file(this.name, this.data, options);
  734.                     return z;
  735.                 }
  736.             }
  737.  
  738.             class DownloaderFolder extends DownloaderItem {
  739.                 /** @type {Array<DownloaderFile | DownloaderFolder>} */
  740.                 children;
  741.  
  742.                 /**
  743.                  * @param {string} name - name only, CANNOT BE PATH
  744.                  * @param {Array<DownloaderFile | DownloaderFolder>} [children]
  745.                  */
  746.                 constructor(name, children) {
  747.                     super(name, 'folder');
  748.                     this.children = children && children.length ? children : [];
  749.                 }
  750.  
  751.                 zip(jszip_instance) {
  752.                     const z = jszip_instance ?? new JSZip();
  753.                     for (const child of this.children) {
  754.                         switch (child.type) {
  755.                             case 'file': {
  756.                                 child.zip(z);
  757.                                 break;
  758.                             }
  759.                             case 'folder': {
  760.                                 const sub_z = z.folder(child.name);
  761.                                 child.zip(sub_z);
  762.                             }
  763.                         }
  764.                     }
  765.                     return z;
  766.                 }
  767.             }
  768.  
  769.             /**
  770.              * @typedef {Object} JSZip
  771.              */
  772.             /**
  773.              * @typedef {Object} zipObject
  774.              */
  775.  
  776.             /**
  777.              * Download one post in zip file
  778.              * @param {string} service
  779.              * @param {number | string} creator_id
  780.              * @param {number | string} post_id
  781.              * @param {function} [callback] - called each time made some progress, with two numeric arguments: finished_steps and total_steps
  782.              */
  783.             async function downloadPost(service, creator_id, post_id, callback = function() {}) {
  784.                 const manager = new utils.ProgressManager(3, callback, {
  785.                     layer: 'root', service, creator_id, post_id
  786.                 });
  787.                 const data = await manager.progress(API.Posts.post(service, creator_id, post_id));
  788.                 const folder = await manager.progress(fetchPost(data, manager));
  789.                 const zip = folder.zip();
  790.                 const filename = `${data.post.title}.zip`;
  791.                 manager.progress(await saveAs(filename, zip, manager));
  792.             }
  793.  
  794.             /**
  795.              * @typedef {Object} PostInfo
  796.              * @property {string} service,
  797.              * @property {number} creator_id
  798.              * @property {number} post_id
  799.              */
  800.  
  801.             /**
  802.              * Download one or multiple posts in zip file, one folder for each post
  803.              * @param {PostInfo | PostInfo[]} posts
  804.              * @param {string} filename - file name of final zip file to be delivered to the user
  805.              * @param {*} callback - Progress callback, like downloadPost's callback param
  806.              */
  807.             async function downloadPosts(posts, filename, callback = function() {}) {
  808.                 Array.isArray(posts) || (posts = [posts]);
  809.                 const manager = new utils.ProgressManager(posts.length + 1, callback, {
  810.                     layer: 'root', posts, filename
  811.                 });
  812.  
  813.                 // Fetch posts
  814.                 const post_folders = await Promise.all(
  815.                     posts.map(async post => {
  816.                         const data = await API.Posts.post(post.service, post.creator_id, post.post_id);
  817.                         const folder = await fetchPost(data, manager);
  818.                         await manager.progress();
  819.                         return folder;
  820.                     })
  821.                 );
  822.  
  823.                 // Merge all post's folders into one
  824.                 const folder = new DownloaderFolder(filename);
  825.                 post_folders.map(async post_folder => {
  826.                     folder.children.push(post_folder);
  827.                 })
  828.  
  829.                 // Convert folder to zip
  830.                 const zip = folder.zip();
  831.  
  832.                 // Deliver to user
  833.                 await manager.progress(saveAs(filename, zip, manager));
  834.             }
  835.  
  836.             /**
  837.              * Fetch one post
  838.              * @param {Object} api_data - kemono post api returned data object
  839.              * @param {utils.ProgressManager} [manager]
  840.              * @returns {Promise<DownloaderFolder>}
  841.              */
  842.             async function fetchPost(api_data, manager) {
  843.                 const perfmon_run = perfmon.run('fetchPost', api_data);
  844.                 const sub_manager = manager.sub(0, manager.callback, {
  845.                     layer: 'post', data: api_data
  846.                 });
  847.  
  848.                 const date = new Date(api_data.post.edited);
  849.                 const folder = new DownloaderFolder(escapePath(api_data.post.title), [
  850.                     ...settings.save_apijson ? [new DownloaderFile('data.json', JSON.stringify(api_data))] : [],
  851.                     ...settings.save_content ? [new DownloaderFile('content.html', api_data.post.content, { date })] : []
  852.                 ]);
  853.  
  854.                 let attachments_folder = folder;
  855.                 if (api_data.post.attachments.length && !settings.flatten_files) {
  856.                     attachments_folder = new DownloaderFolder('attachments');
  857.                     folder.children.push(attachments_folder);
  858.                 }
  859.                 const tasks = [
  860.                     // api_data.post.file
  861.                     (async function(file) {
  862.                         if (!file.path) { return; }
  863.                         sub_manager.add();
  864.                         const prefix = settings.no_prefix ? '' : 'file-';
  865.                         const ori_name = getFileName(file);
  866.                         const name = escapePath(prefix + ori_name);
  867.                         const url = getFileUrl(file);
  868.                         const blob = await sub_manager.progress(fetchBlob(url, sub_manager));
  869.                         folder.children.push(new DownloaderFile(
  870.                             name, blob, {
  871.                                 date,
  872.                                 comment: JSON.stringify(file)
  873.                             }
  874.                         ));
  875.                     }) (api_data.post.file),
  876.  
  877.                     // api_data.post.attachments
  878.                     ...api_data.post.attachments.map(async (attachment, i) => {
  879.                         if (!attachment.path) { return; }
  880.                         sub_manager.add();
  881.                         const prefix = settings.no_prefix ? '' : `${ utils.fillNumber(i+1, api_data.post.attachments.length.toString().length) }-`;
  882.                         const ori_name = getFileName(attachment);
  883.                         const name = escapePath(prefix + ori_name);
  884.                         const url = getFileUrl(attachment);
  885.                         const blob = await sub_manager.progress(fetchBlob(url, sub_manager));
  886.                         attachments_folder.children.push(new DownloaderFile(
  887.                             name, blob, {
  888.                                 date,
  889.                                 comment: JSON.stringify(attachment)
  890.                             }
  891.                         ));
  892.                     }),
  893.                 ];
  894.                 await Promise.all(tasks);
  895.  
  896.                 // Make sure sub_manager finishes even when no async tasks
  897.                 if (sub_manager.steps === 0) {
  898.                     sub_manager.steps = 1;
  899.                     await sub_manager.progress();
  900.                 }
  901.  
  902.                 perfmon_run.stop();
  903.  
  904.                 return folder;
  905.  
  906.                 function getFileName(file) {
  907.                     return file.name || file.path.slice(file.path.lastIndexOf('/')+1);
  908.                 }
  909.  
  910.                 function getFileUrl(file) {
  911.                     return (file.server ?? 'https://n1.kemono.su') + '/data' + file.path;
  912.                 }
  913.             }
  914.  
  915.             /**
  916.              * Deliver zip file to user
  917.              * @param {string} filename - filename (with extension, e.g. "file.zip")
  918.              * @param {JSZip} zip,
  919.              * @param {string | null} comment - zip file comment
  920.              */
  921.             async function saveAs(filename, zip, manager, comment=null) {
  922.                 const perfmon_run = perfmon.run('saveAs', filename);
  923.                 const sub_manager = manager.sub(100, manager.callback, {
  924.                     layer: 'zip', filename, zip
  925.                 });
  926.  
  927.                 const options = { type: 'blob' };
  928.                 comment !== null && (options.comment = comment);
  929.                 const blob = await zip.generateAsync(options, metadata => sub_manager.progress(null, metadata.percent));
  930.                 const url = URL.createObjectURL(blob);
  931.                 const a = $$CrE({
  932.                     tagName: 'a',
  933.                     attrs: {
  934.                         download: filename,
  935.                         href: url
  936.                     }
  937.                 });
  938.                 a.click();
  939.  
  940.                 perfmon_run.stop();
  941.             }
  942.  
  943.             /**
  944.              * Fetch blob data from given url \
  945.              * Queued function of _fetchBlob
  946.              * @param {string} url
  947.              * @param {utils.ProgressManager} [manager]
  948.              * @returns {Promise<Blob>}
  949.              */
  950.             function fetchBlob(...args) {
  951.                 if (!fetchBlob.initialized) {
  952.                     queueTask.fetchBlob = {
  953.                         max: 3,
  954.                         sleep: 0
  955.                     };
  956.                     fetchBlob.initialized = true;
  957.                 }
  958.  
  959.                 return queueTask(() => _fetchBlob(...args), 'fetchBlob');
  960.             }
  961.  
  962.             /**
  963.              * Fetch blob data from given url
  964.              * @param {string} url
  965.              * @param {utils.ProgressManager} [manager]
  966.              * @param {number} [retry=3] - times to retry before throwing an error
  967.              * @returns {Promise<Blob>}
  968.              */
  969.             async function _fetchBlob(url, manager, retry = 3) {
  970.                 const perfmon_run = perfmon.run('_fetchBlob', url);
  971.                 const sub_manager = manager.sub(0, manager.callback, {
  972.                     layer: 'file', url
  973.                 });
  974.  
  975.                 const blob = await new Promise((resolve, reject) => {
  976.                     GM_xmlhttpRequest({
  977.                         method: 'GET', url,
  978.                         responseType: 'blob',
  979.                         async onprogress(e) {
  980.                             sub_manager.steps = e.total;
  981.                             await sub_manager.progress(null, e.loaded);
  982.                         },
  983.                         onload(e) {
  984.                             e.status === 200 ? resolve(e.response) : onerror(e)
  985.                         },
  986.                         onerror
  987.                     });
  988.  
  989.                     async function onerror(err) {
  990.                         if (retry) {
  991.                             await sub_manager.progress(null, -1);
  992.                             const result = await _fetchBlob(url, manager, retry - 1);
  993.                             resolve(result);
  994.                         } else {
  995.                             reject(err)
  996.                         }
  997.                     }
  998.                 });
  999.  
  1000.                 perfmon_run.stop();
  1001.  
  1002.                 return blob;
  1003.             }
  1004.  
  1005.             /**
  1006.              * Replace unallowed special characters in a path part
  1007.              * @param {string} path - a part of path, such as a folder name / file name
  1008.              */
  1009.             function escapePath(path) {
  1010.                 // Replace special characters
  1011.                 const chars_bank = {
  1012.                     '\\': '＼',
  1013.                     '/': '／',
  1014.                     ':': '：',
  1015.                     '*': '＊',
  1016.                     '?': '？',
  1017.                     '"': "'",
  1018.                     '<': '＜',
  1019.                     '>': '＞',
  1020.                     '|': '｜'
  1021.                 };
  1022.                 for (const [char, replacement] of Object.entries(chars_bank)) {
  1023.                     path = path.replaceAll(char, replacement);
  1024.                 }
  1025.  
  1026.                 // Disallow ending with dots
  1027.                 path.endsWith('.') && (path += '_');
  1028.                 return path;
  1029.             }
  1030.  
  1031.             return {
  1032.                 downloadPost, downloadPosts,
  1033.                 fetchPost, saveAs,
  1034.                 perfmon
  1035.             };
  1036.         }
  1037.     }, {
  1038.         id: 'settings',
  1039.         detectDom: 'html',
  1040.         dependencies: 'dependencies',
  1041.         params: ['GM_setValue', 'GM_getValue'],
  1042.         async func(GM_setValue, GM_getValue) {
  1043.             // settings 数据，所有设置项在这里配置
  1044.             /**
  1045.              * @typedef {Object} setting
  1046.              * @property {string} title - 设置项名称
  1047.              * @property {string | null} [caption] - 设置项副标题，可以省略；为假值时不渲染副标题元素
  1048.              * @property {string} key - 用作settings 读/写对象的prop名称，也用作v-model值
  1049.              * @property {string} storage - GM存储key
  1050.              * @property {*} default - 用户未设置过时的默认值（初始值）
  1051.              */
  1052.             /** @type {setting[]} */
  1053.             const settings_data = [{
  1054.                 title: CONST.Text.SaveContent,
  1055.                 caption: 'content.html',
  1056.                 key: 'save_content',
  1057.                 storage: 'save_content',
  1058.                 default: true,
  1059.             }, {
  1060.                 title: CONST.Text.SaveApijson,
  1061.                 caption: 'data.json',
  1062.                 key: 'save_apijson',
  1063.                 storage: 'save_apijson',
  1064.                 default: true,
  1065.             }, {
  1066.                 title: CONST.Text.NoPrefix,
  1067.                 key: 'no_prefix',
  1068.                 storage: 'no_prefix',
  1069.                 default: false,
  1070.             }, {
  1071.                 title: CONST.Text.FlattenFiles,
  1072.                 caption: CONST.Text.FlattenFilesCaption,
  1073.                 key: 'flatten_files',
  1074.                 storage: 'flatten_files',
  1075.                 default: false
  1076.             }];
  1077.  
  1078.             // settings 读/写对象，既用于oFunc内读写，也直接作为oFunc返回值提供给其他功能函数
  1079.             const settings = {};
  1080.             settings_data.forEach(setting => {
  1081.                 Object.defineProperty(settings, setting.key, {
  1082.                     get() {
  1083.                         return GM_getValue(setting.storage, setting.default);
  1084.                     },
  1085.                     set(val) {
  1086.                         GM_setValue(setting.storage, !!val);
  1087.                     }
  1088.                 });
  1089.             });
  1090.  
  1091.             // 创建设置界面
  1092.             const container = $$CrE({
  1093.                 tagName: 'div',
  1094.                 styles: { all: 'initial', position: 'fixed' }
  1095.             })
  1096.             const app_elm = $CrE('div');
  1097.             app_elm.innerHTML = `
  1098.                 <q-layout view="hhh lpr fff">
  1099.                     <q-dialog v-model="show">
  1100.                         <q-card>
  1101.                             <q-card-section>
  1102.                                 <div class="text-h6">${ CONST.Text.Settings }</div>
  1103.                             </q-card-section>
  1104.                             <q-card-section>
  1105.                                 <q-list>
  1106.                                     <q-item tag="label" v-for="setting of settings_data" v-ripple>
  1107.                                         <q-item-section>
  1108.                                             <q-item-label>{{ setting.title }}</q-item-label>
  1109.                                             <q-item-label caption v-if="setting.caption">{{ setting.caption }}</q-item-label>
  1110.                                         </q-item-section>
  1111.                                         <q-item-section avatar>
  1112.                                             <q-toggle color="orange" v-model="settings[setting.key]" @update:model-value="val => settings[setting.key] = val"></q-toggle>
  1113.                                         </q-item-section>
  1114.                                     </q-item>
  1115.                                 </q-list>
  1116.                             </q-card-section>
  1117.                         </q-card>
  1118.                     </q-dialog>
  1119.                 </q-layout>
  1120.             `;
  1121.             container.append(app_elm);
  1122.             $('html').append(container);
  1123.             const app = Vue.createApp({
  1124.                 data() {
  1125.                     return {
  1126.                         show: false,
  1127.                         settings_data,
  1128.                         settings
  1129.                     };
  1130.                 },
  1131.                 mounted() {
  1132.                     GM_registerMenuCommand(CONST.Text.Settings, e => this.show = true);
  1133.                     GM_addValueChangeListener('settings', () => {
  1134.                         this.save_content = settings.save_content;
  1135.                         this.save_apijson = settings.save_apijson;
  1136.                     });
  1137.                 }
  1138.             });
  1139.             app.use(Quasar);
  1140.             app.mount(app_elm);
  1141.             Quasar.Dark.set(true);
  1142.  
  1143.             return settings;
  1144.         }
  1145.     }, {
  1146.         id: 'user-interface',
  1147.         dependencies: ['utils', 'api', 'downloader', 'gui'],
  1148.         async func() {
  1149.             const utils = require('utils');
  1150.             const api = require('api');
  1151.             const downloader = require('downloader');
  1152.             const gui = require('gui');
  1153.  
  1154.             let downloading = false;
  1155.             let selector = null;
  1156.  
  1157.             // Console User Interface
  1158.             const ConsoleUI = utils.window.ZIP = {
  1159.                 version: GM_info.script.version,
  1160.                 require,
  1161.  
  1162.                 api, downloader,
  1163.                 get ui() { return require('user-interface') },
  1164.  
  1165.                 downloadCurrentPost, downloadCurrentCreator, userDownload, getPageType
  1166.             };
  1167.  
  1168.             // Menu User Interface
  1169.             GM_registerMenuCommand(CONST.Text.DownloadPost, downloadCurrentPost);
  1170.             GM_registerMenuCommand(CONST.Text.DownloadCreator, downloadCurrentCreator);
  1171.  
  1172.             // Graphical User Interface
  1173.             // Make button
  1174.             const dlbtn = $$CrE({
  1175.                 tagName: 'button',
  1176.                 styles: {
  1177.                     'background-color': 'transparent',
  1178.                     'color': 'white',
  1179.                     'border': 'transparent'
  1180.                 },
  1181.                 listeners: [['click', userDownload]]
  1182.             });
  1183.             const dltext = $$CrE({
  1184.                 tagName: 'span',
  1185.                 props: {
  1186.                     innerText: CONST.Text.DownloadZip
  1187.                 }
  1188.             });
  1189.             const dlprogress = $$CrE({
  1190.                 tagName: 'span',
  1191.                 styles: {
  1192.                     display: 'none',
  1193.                     'margin-left': '10px'
  1194.                 }
  1195.             });
  1196.             dlbtn.append(dltext);
  1197.             dlbtn.append(dlprogress);
  1198.  
  1199.             const board = gui.board;
  1200.  
  1201.             // Place button each time a new action panel appears (meaning navigating into a post page)
  1202.             let observer;
  1203.             detectDom({
  1204.                 selector: '.post__actions, .user-header__actions',
  1205.                 callback: action_panel => {
  1206.                     // Hide dlprogress, its content is still for previous page
  1207.                     dlprogress.style.display = 'none';
  1208.  
  1209.                     // Append to action panel
  1210.                     action_panel.append(dlbtn);
  1211.  
  1212.                     // Disconnect old observer
  1213.                     observer?.disconnect();
  1214.  
  1215.                     // Observe action panel content change, always put download button in last place
  1216.                     observer = detectDom({
  1217.                         root: action_panel,
  1218.                         selector: 'button',
  1219.                         callback: btn => btn !== dlbtn && action_panel.append(dlbtn)
  1220.                     });
  1221.                 }
  1222.             });
  1223.  
  1224.             return {
  1225.                 ConsoleUI,
  1226.                 dlbtn, dltext,
  1227.                 get ['selector']() { return selector; },
  1228.                 downloadCurrentPost, downloadCurrentCreator,
  1229.                 getCurrentPost, getCurrentCreator, getPageType
  1230.             }
  1231.  
  1232.             function userDownload() {
  1233.                 const page_type = getPageType();
  1234.                 const func = ({
  1235.                     post: downloadCurrentPost,
  1236.                     creator: downloadCurrentCreator
  1237.                 })[page_type] ?? function() {};
  1238.                 return func();
  1239.             }
  1240.  
  1241.             async function downloadCurrentPost() {
  1242.                 const post_info = getCurrentPost();
  1243.                 if (downloading) { return; }
  1244.                 if (!post_info) { return; }
  1245.  
  1246.                 try {
  1247.                     downloading = true;
  1248.                     dlprogress.style.display = 'inline';
  1249.                     dltext.innerText = CONST.Text.Downloading;
  1250.                     board.minimized = false;
  1251.                     board.closed = false;
  1252.                     board.clear();
  1253.                     await downloader.downloadPost(
  1254.                         post_info.service,
  1255.                         post_info.creator_id,
  1256.                         post_info.post_id,
  1257.                         on_progress
  1258.                     );
  1259.                 } finally {
  1260.                     downloading = false;
  1261.                     dltext.innerText = CONST.Text.DownloadZip;
  1262.                 }
  1263.  
  1264.                 function on_progress(finished_steps, total_steps, manager) {
  1265.                     const info = manager.info;
  1266.                     info.layer === 'root' && (dlprogress.innerText = `(${finished_steps}/${total_steps})`);
  1267.  
  1268.                     const progress = { finished: finished_steps, total: total_steps };
  1269.                     info.layer === 'root' && board.update(CONST.Text.TotalProgress, progress);
  1270.                     info.layer === 'post' && board.update(info.data.post.title, progress);
  1271.                     info.layer === 'file' && board.update(info.url, progress);
  1272.                     info.layer === 'zip' && board.update(info.filename, progress);
  1273.                     board.closed = false;
  1274.                 }
  1275.             }
  1276.  
  1277.             async function downloadCurrentCreator() {
  1278.                 const creator_info = getCurrentCreator();
  1279.                 if (downloading) { return; }
  1280.                 if (!creator_info) { return; }
  1281.  
  1282.                 try {
  1283.                     downloading = true;
  1284.                     const profile = await api.Creators.profile(creator_info.service, creator_info.creator_id);
  1285.                     const posts = await api.Custom.all_posts(creator_info.service, creator_info.creator_id);
  1286.                     const selected_posts = await new Promise((resolve, reject) => {
  1287.                         if (!selector) {
  1288.                             selector = new ItemSelector();
  1289.                             selector.setTheme('dark');
  1290.                             selector.elements.container.style.setProperty('z-index', '1');
  1291.                         }
  1292.                         selector.show({
  1293.                             text: CONST.Text.SelectAll,
  1294.                             children: posts.map(post => ({
  1295.                                 post,
  1296.                                 text: post.title
  1297.                             }))
  1298.                         }, {
  1299.                             title: CONST.Text.DownloadCreator,
  1300.                             onok(e, json) {
  1301.                                 const posts = json.children.map(obj => obj.post);
  1302.                                 resolve(posts);
  1303.                             },
  1304.                             oncancel: e => resolve(null),
  1305.                             onclose: e => resolve(null)
  1306.                         });
  1307.                     });
  1308.                     if (selected_posts) {
  1309.                         dlprogress.style.display = 'inline';
  1310.                         dltext.innerText = CONST.Text.Downloading;
  1311.                         board.minimized = false;
  1312.                         board.closed = false;
  1313.                         board.clear();
  1314.                         await downloader.downloadPosts(selected_posts.map(post => ({
  1315.                             service: creator_info.service,
  1316.                             creator_id: creator_info.creator_id,
  1317.                             post_id: post.id
  1318.                         })), `${profile.name}.zip`, on_progress);
  1319.                     }
  1320.                 } finally {
  1321.                     downloading = false;
  1322.                     dltext.innerText = CONST.Text.DownloadZip;
  1323.                 }
  1324.  
  1325.                 function on_progress(finished_steps, total_steps, manager) {
  1326.                     const info = manager.info;
  1327.                     info.layer === 'root' && (dlprogress.innerText = `(${finished_steps}/${total_steps})`);
  1328.  
  1329.                     const progress = { finished: finished_steps, total: total_steps };
  1330.                     info.layer === 'root' && board.update(CONST.Text.TotalProgress, progress);
  1331.                     info.layer === 'post' && board.update(info.data.post.title, progress);
  1332.                     info.layer === 'file' && board.update(info.url, progress);
  1333.                     info.layer === 'zip' && board.update(info.filename, progress);
  1334.                     board.closed = false;
  1335.                 }
  1336.             }
  1337.  
  1338.             /**
  1339.              * @typedef {Object} PostInfo
  1340.              * @property {string} service,
  1341.              * @property {number} creator_id
  1342.              * @property {number} post_id
  1343.              */
  1344.             /**
  1345.              * Get post info in current page
  1346.              * @returns {PostInfo | null}
  1347.              */
  1348.             function getCurrentPost() {
  1349.                 const regpath = /^\/([a-zA-Z]+)\/user\/(\d+)\/post\/(\d+)/;
  1350.                 const match = location.pathname.match(regpath);
  1351.                 if (!match) {
  1352.                     return null;
  1353.                 } else {
  1354.                     return {
  1355.                         service: match[1],
  1356.                         creator_id: parseInt(match[2], 10),
  1357.                         post_id: parseInt(match[3], 10)
  1358.                     }
  1359.                 }
  1360.             }
  1361.  
  1362.             /**
  1363.              * @typedef {Object} CreatorInfo
  1364.              * @property {string} service
  1365.              * @property {number} creator_id
  1366.              */
  1367.             /**
  1368.              * Get creator info in current page
  1369.              * @returns {CreatorInfo | null}
  1370.              */
  1371.             function getCurrentCreator() {
  1372.                 const regpath = /^\/([a-zA-Z]+)\/user\/(\d+)/;
  1373.                 const match = location.pathname.match(regpath);
  1374.                 if (!match) {
  1375.                     return null;
  1376.                 } else {
  1377.                     return {
  1378.                         service: match[1],
  1379.                         creator_id: parseInt(match[2], 10)
  1380.                     }
  1381.                 }
  1382.             }
  1383.  
  1384.             /** @typedef { 'post' | 'creator' } page_type */
  1385.             /**
  1386.              * @returns {page_type}
  1387.              */
  1388.             function getPageType() {
  1389.                 const matchers = {
  1390.                     post: {
  1391.                         type: 'regpath',
  1392.                         value: /^\/([a-zA-Z]+)\/user\/(\d+)\/post\/(\d+)/
  1393.                     },
  1394.                     creator: {
  1395.                         type: 'func',
  1396.                         value: () => /^\/([a-zA-Z]+)\/user\/(\d+)/.test(location.pathname) && !location.pathname.includes('/post/')
  1397.                     },
  1398.                 }
  1399.                 for (const [type, matcher] of Object.entries(matchers)) {
  1400.                     if (FunctionLoader.testCheckers(matcher)) {
  1401.                         return type;
  1402.                     }
  1403.                 }
  1404.             }
  1405.         },
  1406.     }]);
  1407. }) ();