nhentai-konnichiwa.user.js

// ==UserScript==
// @name         NHentai Konnichiwa
// @author       naiymu
// @version      1.1.11
// @license      MIT; https://raw.githubusercontent.com/naiymu/nhentai-konnichiwa/main/LICENSE
// @namespace    https://github.com/naiymu/nhentai-konnichiwa
// @homepage     https://github.com/naiymu/nhentai-konnichiwa
// @downloadURL  https://github.com/naiymu/nhentai-konnichiwa/raw/main/nhentai-konnichiwa.user.js
// @updateURL    https://github.com/naiymu/nhentai-konnichiwa/raw/main/nhentai-konnichiwa.user.js
// @supportURL   https://github.com/naiymu/nhentai-konnichiwa/issues
// @description  A simple usercript for downloading doujinshi from NHentai and mirrors
// @match        https://nhentai.net/*
// @match        https://nhentai.xxx/*
// @match        https://nyahentai.red/*
// @match        https://nhentai.to/*
// @match        https://nhentai.website/*
// @exclude      /https:\/\/n.*hentai.(red|net|xxx|to|website)\/g\/[0-9]*\/[0-9]+\/?$/
// @connect      nhentai.xxx
// @connect      cdn.nload.xyz
// @connect      i3.nhentai.net
// @connect      cdn.nhentai.xxx
// @connect      nhentai.com
// @connect      t.dogehls.xyz
// @require      https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.0/jszip.min.js
// @require      https://unpkg.com/comlink@4.3.1/dist/umd/comlink.min.js
// @grant        GM_addStyle
// @grant        GM_setClipboard
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @run-at       document-end
// @icon         https://raw.githubusercontent.com/naiymu/nhentai-konnichiwa/main/assets/icon.png
// ==/UserScript==

GM_addStyle (
`
.relative {
  position: relative !important;
}

.download-check {
  position: absolute;
  top: 0;
  left: 0;
  cursor: pointer;
  height: 20px;
  width: 20px;
  accent-color: #ed2553;
}

.download-check:focus,
.download-check:hover {
  box-shadow: 0 0 10px 0 #ed2553;
}

.red-box {
  position: relative;
  background-color: #ed2553;
  color: white;
  border: none;
  outline: none;
  font-size: 16px;
  width: 80px;
  height: 35px;
  border-radius: 5px;
  display: flex;
  align-items: center;
  justify-content: center;
  text-align: center;
  cursor: pointer;
}

.percent {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%,-50%);
}

.downloading-span,
.compressing-span {
  display: inline-block;
  position: absolute;
  top: 0;
  left: 0;
  width: 50px;
  height: 100%;
  border-radius: 5px;
}

.downloading-span {
  background-color: #03c03c;
}

.compressing-span {
  background-color:  #0047ab;
}

.red-box:hover {
  background-color: #4d4d4d;
}

.red-box>i,
.red-box>.download-check {
  margin-right: 5px;
}

.download-check-all {
  width: 20px;
  height: 20px;
  cursor: pointer;
  accent-color: #1f1f1f;
}

.red-box>.download-check:focus,
.red-box>.download-check:hover {
  box-shadow: none;
}

.red-box:disabled {
  background-color: #1f1f1f;
  cursor: default;
}

.download-div {
  position: fixed;
  bottom: 0;
  left: 0;
  display: flex;
  flex-direction: column;
  gap: 5px;
}

.div-horizontal {
  flex-direction: row !important;
}

.fa-spinner,
.fa-circle-notch {
  animation: spin 1.5s infinite linear;
}

@keyframes spin {
  100% {transform: rotate(359deg)};
}

.config-wrapper {
  position: fixed;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background-color: rgba(0, 0, 0, 0.8);
  z-index: 999999;
  visibility: hidden;
}

.visible {
  visibility: visible;
}

.config-div {
  position: absolute;
  top: 50%;
  left: 50%;
  width: 100%;
  height: 100%;
  max-width: 850px;
  max-height: 550px;
  padding: 50px;
  transform: translate(-50%, -50%);
  background-color: #1f1f1f;
  border-radius: 5px;
  display: flex;
  flex-direction: column;
  align-items: flex-start;
  justify-content: center;
  overflow: scroll;
}

.config-element-div {
  width: 100%;
  display: inline-grid;
  grid: auto / 200px auto;
  margin-bottom: 15px
}

.config-element-div>input {
  color: #000 !important;
}

.config-element-div>label {
  grid-column-start: 1;
}

.config-element-div>input[type='checkbox'] {
  justify-self: left;
}

.config-element-div>*:not(label) {
  grid-column-start: 2;
  border-radius: 0;
  border: none;
  background-color: #d9d9d9 !important;
}

.config-btn-div {
  display: flex;
  flex-direction: row;
  gap: 10px;
  align-items: center;
}

.config-reset:hover {
  cursor: pointer;
  color: #ed2553;
}

.heading {
  width: 100%;
  border-bottom: solid 1px #d9d9d9;
  text-align: left;
}
`
);

const netMediaUrl = "https://i3.nhentai.net/galleries/";
const btnStates = {
    enabled: "<i class='fa fa-download'></i>",
    fetching: "<i id='btn-spinner' class='fa fa-spinner'></i>",
    downloading: "<i id='btn-spinner' class='fa fa-circle-notch'></i>",
    config: "<i class='fa fa-cog'></i>",
};
const titleFormats = {
    PR: "pretty",
    EN: "english",
    JP: "japanese",
    ID: "id",
};
const saveJSONModes = {
    NO: "Don't save",
    FI: "Save as JSON file",
    CB: "Copy to clipboard",
};
const fileNameSeps = {
    SP: "Space",
    HY: "Hyphen",
    US: "Underscore",
};
const btnOrientations = {
    VR: "Vertical",
    HR: "Horizontal",
};
const CONFIG = {
    simulN: {
        label: 'Download batch size',
        type: 'int',
        min: 1,
        max: 50,
        default: 10,
    },
    compressionLevel: {
        label: 'Compression level',
        type: 'int',
        min: 0,
        max: 9,
        default: 0,
    },
    titleFormat: {
        label: 'Title format',
        type: 'select',
        options: [titleFormats.PR,titleFormats.EN,titleFormats.JP,
                  titleFormats.ID],
        default: titleFormats.PR,
    },
     fileNamePrep: {
        label: 'Filename to prepend',
        type: 'text',
        size: 30,
        default: "",
    },
     fileNameSep: {
        label: 'Filename separator',
        type: 'select',
        options: [fileNameSeps.SP,fileNameSeps.HY,fileNameSeps.US],
        default: fileNameSeps.SP,
    },
    saveJSONMode: {
         label: 'Save JSON',
         type: 'select',
         options: [saveJSONModes.NO,saveJSONModes.FI,saveJSONModes.CB],
         default: saveJSONModes.NO,
     },
    includeGroups: {
        label: 'Include groups in authors',
        type: 'checkbox',
        default: false,
    },
    btnOrientation: {
        label: 'Button orientation',
        type: 'select',
        options: [btnOrientations.VR, btnOrientations.HR],
        default: btnOrientations.VR,
    },
    openInNewTab: {
        label: 'Open galleries in new tab',
        type: 'checkbox',
        default: true,
    },
    autorestart: {
        label: 'Auto restart downloads',
        type: 'checkbox',
        default: true,
    }
};

const WORKER_THREAD_NUM = ((navigator && navigator.hardwareConcurrency) || 2) - 1;

class JSZipWorkerPool {
    constructor() {
        this.pool = [];
        this.WORKER_URL = URL.createObjectURL(
            new Blob(
                [
                    `importScripts(
                         'https://unpkg.com/comlink/dist/umd/comlink.min.js',
                         'https://cdnjs.cloudflare.com/ajax/libs/jszip/3.7.1/jszip.min.js'
                     );
                     class JSZipWorker {
                         constructor() {
                             this.zip = new JSZip;
                         }
                         file(title, name, {data:data}) {
                             this.zip.folder(title).file(name, data);
                         }
                         async generateAsync(options, onUpdate) {
                             const data = await this.zip.generateAsync(options, onUpdate);
                             const url = URL.createObjectURL(data);
                             return Comlink.transfer({url:url});
                         }
                     }
                     Comlink.expose(JSZipWorker);`
                ],
                {type: 'text/javascript'}
            )
        );
        for(let id=0; id<WORKER_THREAD_NUM; id++) {
            this.pool.push({
                id,
                JSZip: null,
                idle: true,
            });
        }
    }
    createWorker() {
        const worker = new Worker(this.WORKER_URL);
        return Comlink.wrap(worker);
    }
    async generateAsync(files, options, onUpdate) {
        const worker = this.pool.find(({idle}) => idle);
        if(!worker) throw new Error('No available JSZip worker');
        worker.idle = false;
        if(!worker.JSZip) worker.JSZip = this.createWorker();
        const zip = await new worker.JSZip();
        for(const {title, name, data} of files) {
            await zip.file(title, name, Comlink.transfer({data}, [data]));
        }
        return zip
               .generateAsync(
                   options,
                   Comlink.proxy((data) => onUpdate({workerId: worker.id, ...data}))
               )
               .then(({url}) => {
                   worker.idle = true;
                   return url;
               });
    }
}

const jsZipPool = new JSZipWorkerPool();

class JSZip {
    constructor() {
        this.files = [];
    }
    file(title, name, data) {
        this.files.push({title, name, data});
    }
    generateAsync(options, onUpdate) {
        return jsZipPool.generateAsync(this.files, options, onUpdate);
    }
}

// nhentai.net API URL
const netAPI = "https://nhentai.net/api/gallery/";
// nhentai.xxx page URL
const xxxPage = "https://nhentai.xxx/g/";
// If we are on nhentai.net
const onNET = location.hostname == 'nhentai.net';
// DOM parser for later
var parser = new DOMParser();
// Saved config options
var configOptions = JSON.parse(GM_getValue('configOptions') || '{}');
// Buttons and Divs
var downloadDiv,
    downloadBtn,
    downloadPercent,
    downloadingSpan,
    compressingSpan,
    configWrapper,
    configDiv;
// Download info
var downloading = false,
    cancelled = false,
    total = 0,
    downloaded = 0,
    currentDownloads = 0,
    queue = [],
    info = JSON.parse(sessionStorage.getItem('info') || '[]');
// Final zip
var zip;

function disableButton(btnState) {
    downloadingSpan.style.width = 0;
    compressingSpan.style.width = 0;
    downloadBtn.disabled = true;
    downloadPercent.innerHTML = btnState;
}

function enableButton() {
    downloadingSpan.style.width = 0;
    compressingSpan.style.width = 0;
    downloadBtn.disabled = false;
    downloadPercent.innerHTML = btnStates.enabled;
}

function createNode(element, classes=[]) {
    var node = document.createElement(element);
    for(let cls of classes) {
        node.classList.add(cls);
    }
    return node;
}

function createLabel(id, text) {
    var label = createNode('label');
    label.innerHTML = text;
    label.setAttribute('for', id);
    return label;
}

function getExtension(type) {
    switch(type) {
        case 'j': return '.jpg';
        case 'p': return '.png';
        case 'g': return '.gif';
    }
}

function saveConfig(reset=false) {
    const oldOpenInNewTab = configOptions.openInNewTab;
    for(const [key, value] of Object.entries(CONFIG)) {
        var element = document.getElementById(`config-${key}`);
        var configValue;
        switch(value.type) {
            case 'checkbox':
                configValue = element.checked;
                break;
            case 'int':
                configValue = element.value;
                if(configValue > value.max) {
                    configValue = value.max;
                }
                if(configValue < value.min) {
                    configValue = value.min;
                }
                break;
            default:
                configValue = element.value;
        }
        configValue = reset ? value.default : configValue;
        configOptions[key] = configValue;
        element.value = configValue;
        if(value.type == 'checkbox') element.checked = configValue;
    }
    if(configOptions.btnOrientation == btnOrientations.HR) {
        downloadDiv.classList.add('div-horizontal');
    }
    else {
        downloadDiv.classList.remove('div-horizontal');
    }
    GM_setValue('configOptions', JSON.stringify(configOptions));
    if(configOptions.openInNewTab != oldOpenInNewTab) {
        var gLinks = document.querySelectorAll('.gallery > a, .gallerythumb');
        for(let a of gLinks) {
            if(configOptions.openInNewTab) {
                a.setAttribute('target', '_blank');
            }
            else {
                a.removeAttribute('target');
            }
        }
    }
}

function addConfigMenu() {
    var saveConfigBtn, closeConfigBtn, cancelAnchor, resetConfigAnchor;

    var heading = createNode('h3', ['heading']);
    heading.innerHTML = "nhentai-konnichiwa";
    configDiv.appendChild(heading);

    for(const [key, value] of Object.entries(CONFIG)) {
        var div = createNode('div', ['config-element-div']);
        var element, id, label;
        switch(value.type) {
            case 'select':
                element = createNode('select');
                for(let i=0; i<value.options.length; i++) {
                    var optionElement = createNode('option');
                    var option = value.options[i];
                    optionElement.text = option;
                    optionElement.value = option;
                    element.appendChild(optionElement);
                }
                break;
            case 'int':
                element = createNode('input');
                element.type = 'number';
                if(value.min != undefined) {
                    element.min = value.min;
                }
                if(value.max != undefined) {
                    element.max = value.max;
                }
                break;
            case 'checkbox':
                element = createNode('input');
                element.type = 'checkbox';
                break;
            case 'text':
                element = createNode('input');
                element.type = 'text';
                element.maxLength = value.size;
                element.defaultValue = value.default;
                break;
        }
        id = `config-${key}`;
        element.id = id;
        var configValue = (configOptions.hasOwnProperty(key))
                          ? configOptions[key]
                          : value.default;
        if(value.type == 'checkbox') {
            element.checked = configValue;
        }
        else {
            element.value = configValue;
        }
        // If key does not exist in configOptions, add it
        if(!configOptions[key]) {
            configOptions[key] = configValue;
        }
        label = createLabel(id, value.label);

        div.appendChild(label);
        div.appendChild(element);

        configDiv.appendChild(div);
    }

    var btnDiv = createNode('div', ['config-btn-div']);
    saveConfigBtn = createNode('button', ['red-box']);
    saveConfigBtn.innerHTML = "Save";
    saveConfigBtn.addEventListener('click', () => {
        saveConfig();
    });

    closeConfigBtn = createNode('button', ['red-box']);
    closeConfigBtn.innerHTML = "Close";
    closeConfigBtn.addEventListener('click', () => {
        configWrapper.classList.remove('visible');
    });

    cancelAnchor = createNode('a', ['config-reset']);
    cancelAnchor.innerHTML = "Cancel downloads";
    cancelAnchor.addEventListener('click', () => {
        cancelDownload();
    });

    resetConfigAnchor = createNode('a', ['config-reset']);
    resetConfigAnchor.innerHTML = 'Reset to default';
    resetConfigAnchor.addEventListener('click', () => {
        saveConfig(true);
    });

    btnDiv.appendChild(saveConfigBtn);
    btnDiv.appendChild(closeConfigBtn);
    btnDiv.appendChild(cancelAnchor);
    btnDiv.appendChild(resetConfigAnchor);

    configDiv.appendChild(btnDiv);
}

(async function() {
    'use strict';

    window.addEventListener('beforeunload', (e) => {
        if(downloading) {
            e.preventDefault();
            return '';
        }
    });

    var aList, configBtn, checkAllDiv, checkAll;

    configWrapper = createNode('div', ['config-wrapper']);
    configDiv = createNode('div', ['config-div']);
    configWrapper.addEventListener('click', () => {
        if(event.target != configWrapper) {
            return;
        }
        configWrapper.classList.remove('visible');
    });
    configWrapper.appendChild(configDiv);
    addConfigMenu();

    aList = document.querySelectorAll(".gallery > a, #cover > a");
    for(let a of aList) {
        if(configOptions.openInNewTab) a.setAttribute('target', '_blank');
        var ref = a.href;
        var parent = a.parentElement;
        var code;
        code = ref.split("/g/")[1];
        if(code.endsWith("/")) {
            code = code.split("/")[0];
        }
        var check = createNode('input', ['download-check']);
        check.type = 'checkbox';
        check.value = code;
        parent.classList.add("relative");
        parent.appendChild(check);
    }
    if(configOptions.openInNewTab) {
        aList = document.getElementsByClassName("gallerythumb");
        for(let a of aList) {
            a.setAttribute('target', '_blank');
        }
    }
    let classes = ['download-div'];
    if(configOptions.btnOrientation == btnOrientations.HR) {
        classes.push('div-horizontal');
    }
    downloadDiv = createNode('div', classes);

    downloadBtn = createNode('button', ['red-box']);
    downloadPercent = createNode('span', ['percent']);
    downloadingSpan = createNode('span', ['downloading-span']);
    compressingSpan = createNode('span', ['compressing-span']);
    enableButton();
    downloadBtn.appendChild(downloadingSpan);
    downloadBtn.appendChild(compressingSpan);
    downloadBtn.appendChild(downloadPercent);

    configBtn = createNode('button', ['red-box']);
    configBtn.innerHTML = btnStates.config;
    configBtn.addEventListener("click", (event) => {
        configWrapper.classList.add('visible');
    });

    checkAllDiv = createNode('div', ['red-box', 'relative']);
    checkAll = createNode('input', ['download-check-all']);
    checkAll.type = 'checkbox';
    checkAll.addEventListener('change', () => {
        let toCheck = checkAll.checked;
        let boxes = document.querySelectorAll('.download-check');
        for(let box of boxes) {
            if(box === checkAll) {
                continue;
            }
            box.checked = toCheck;
        }
    });
    checkAllDiv.appendChild(checkAll);

    downloadBtn.addEventListener("click", async () => {
        var checked = document.querySelectorAll(".download-check:checked");
        if(checked.length > 0) {
            disableButton(btnStates.fetching);
        }
        else {
            return;
        }
        zip = await new JSZip();
        switch(configOptions.fileNameSep) {
            case fileNameSeps.SP: configOptions.fileNameSep = " "; break;
            case fileNameSeps.HY: configOptions.fileNameSep = "-"; break;
            case fileNameSeps.US: configOptions.fileNameSep = "_"; break;
        }
        for(let c of checked) {
            c.checked = false;
        }
        for(const c of checked) {
            var code = c.getAttribute("value");
            await addInfo(code);
            sessionStorage.setItem('info', JSON.stringify(info));
        }
        startDownload();
    });

    downloadDiv.appendChild(downloadBtn);
    downloadDiv.appendChild(configBtn);
    downloadDiv.appendChild(checkAllDiv);

    document.body.appendChild(downloadDiv);
    document.body.appendChild(configWrapper);

    if(info.length > 0) {
        if(configOptions.autorestart) {
            queue = [];
            startDownload();
        }
        else {
            info = [];
            sessionStorage.removeItem('info');
        }
    }
})();

function startDownload() {
    downloading = true;
    cancelled = false;
    currentDownloads = 0;
    downloaded = 0;
    zip = new JSZip();
    populateQueue();
    total = queue.length;
    disableButton(btnStates.downloading);
    downloadQueue();
}

function cancelDownload() {
    info = [];
    queue = [];
    sessionStorage.removeItem('info');
    currentDownloads = 0;
    downloading = false;
    cancelled = true;
    enableButton();
}

function cleanString(string) {
    string = string.replace(/(\.+$)|(^\.+)|(\|)/g, '');
    string = string.replace(/\\\/\:\;/g, configOptions.fileNameSep);
    string = string.replace(/\s\s+/, ' ');
    string = string.trim();
    return string;
}

async function makeGetRequest(url, code = null) {
    return new Promise((resolve, reject) => {
        if(onNET) {
            fetch(url, {
                method: 'GET',
                mode: 'same-origin',
                credentials: 'same-origin',
                headers: {
                    'Content-Type': 'application/json'
                },
                referrerPolicy: 'same-origin',
            })
            .then(response => resolve(response.json()));
        }
        else {
            GM_xmlhttpRequest({
                method: "GET",
                url: url,
                onload: (response) => {
                    resolve(parseXXXResponse(response, code));
                },
                onerror: (error) => {
                    reject(error);
                }
            });
        }
    });
}

function addInfoNET(obj, code) {
    var title;
    if(configOptions.titleFormat == 'id') {
        title = `${obj.id}`;
    }
    else {
        title = obj.title[configOptions.titleFormat];
        title = cleanString(title);
    }
    var pages = obj.num_pages;
    var tagList = obj.tags;
    var artists = [];
    var tags = [];
    for(let i=0; i<tagList.length; i++) {
        let tagItem = tagList[i];
        if(tagItem.type == "artist"
            || (configOptions.includeGroups && tagItem.type == "group")) {
            artists.push(tagItem.name);
        }
        if(tagItem.type == "tag") {
            tags.push(tagItem.name);
        }
    }
    var mediaUrl = `${netMediaUrl}${obj.media_id}/`;
    const constTitleExists = info.some((el) => el.title === title);
    if(constTitleExists) {
        title += " - "+code;
    }
    var fileNamePrep = configOptions.fileNamePrep;
    fileNamePrep = cleanString(fileNamePrep);
    var namePrep = "";
    if(fileNamePrep != "") {
        namePrep = fileNamePrep + configOptions.fileNameSep;
    }
    var coverExtension = getExtension(obj.images.pages[0].t);
    info.push({
        code: code,
        title: title,
        artists: artists,
        tags: tags,
        pages: pages,
        mediaUrl: mediaUrl,
        namePrep: namePrep,
        coverExtension: coverExtension,
        pagesInfo: obj.images.pages,
    });
}

async function addInfo(code) {
    var apiUrl, obj;
    if(onNET) {
        apiUrl = netAPI + code;
        obj = await makeGetRequest(apiUrl);
        addInfoNET(obj, code);
    }
    else {
        apiUrl = xxxPage + code;
        obj = await makeGetRequest(apiUrl, code);
        info.push(obj);
    }
}

function parseXXXResponse(response, code) {
    var htmlDoc = parser.parseFromString(response.responseText,
                                         'text/html');
    var title, artists = [], tags = [], pages, mediaUrl, pagesInfo = [], coverExtension;
    var titleTemplate = string => {
        return `${string}.title > span`;
    }
    const cleanRegex = /(\[[^\]]*\])|(\([^)]*\))|(\{[^}]*\})|([\.\|\~]*)/g;
    switch(configOptions.titleFormat) {
        case 'english':
            title = htmlDoc.querySelector(titleTemplate('h1'));
            title = title.textContent;
            break;
        case 'japanese':
            title = htmlDoc.querySelector(titleTemplate('h2'));
            title = title.textContent;
            break;
        case 'pretty':
        default:
            title = htmlDoc.querySelector(titleTemplate('h1'));
            title = title.textContent;
            title = title.replace(cleanRegex, '');
            title = title.replace(/\s\s+/g, ' ');
            title = title.trim();
            title = title.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
    }
    var tagTemplate = string => {
        return `a[href*='${string}/'] > span.name`;
    }
    var artistSpans = htmlDoc.querySelectorAll(tagTemplate('artist'));
    for(var artist of artistSpans) {
        artists.push(artist.textContent);
    }
    if(configOptions.includeGroups) {
        var groupSpans = htmlDoc.querySelectorAll(tagTemplate('group'));
        for(var group of groupSpans) {
            artists.push(group.textContent);
        }
    }
    var tagSpans = htmlDoc.querySelectorAll(tagTemplate('tag'));
    for(var tag of tagSpans) {
        tags.push(tag.textContent);
    }
    pages = htmlDoc.querySelector(".tag[href*='#'] > span.name");
    pages = parseInt(pages.textContent);
    var fileNamePrep = configOptions.fileNamePrep;
    fileNamePrep = cleanString(fileNamePrep);
    var namePrep = "";
    if(fileNamePrep != "") {
        namePrep = fileNamePrep + configOptions.fileNameSep;
    }
    var thumbs = htmlDoc.querySelectorAll("a.gallerythumb > img");
    mediaUrl = thumbs[0].src;
    mediaUrl = mediaUrl.substring(0, mediaUrl.lastIndexOf("/")+1);
    for(var thumb of thumbs) {
        var extension = thumb.src.split('.').pop().charAt(0);
        pagesInfo.push({t: extension});
    }
    coverExtension = getExtension(pagesInfo[0].t);
    var obj = {
        code: code,
        title: title,
        artists: artists,
        tags: tags,
        pages: pages,
        mediaUrl: mediaUrl,
        namePrep: namePrep,
        coverExtension: coverExtension,
        pagesInfo: pagesInfo,
    }
    return obj;
}

async function addToQueue(item, mediaId=null) {
    var pages = item.pages;
    var title = item.title;
    var namePrep = item.namePrep;
    var mediaUrl = item.mediaUrl;
    for(let i=0; i<pages; i++) {
        var extension = getExtension(item.pagesInfo[i].t);
        let page = i + 1;
        var imgUrl = `${mediaUrl}${page}${extension}`;
        queue.push({
            page: page,
            url: imgUrl,
            title: title,
            namePrep: namePrep,
            extension: extension,
        });
    }
}

function populateQueue() {
    for(const item of info) {
        addToQueue(item);
    }
}

async function downloadQueue() {
    while(queue.length > 0) {
        if(currentDownloads >= configOptions.simulN) {
            await sleep(125);
            continue;
        }
        var item = queue.shift();
        download(item);
    }
}

function saveJSON(fileName) {
    var data = [];
    for(var item of info) {
        data.push({
            dirName: item.title,
            dirCover: `${item.namePrep}1${item.coverExtension}`,
            authors: item.artists,
            tags: item.tags,
        });
    }
    var fileContent = {
        'directories': data
    };
    fileContent = JSON.stringify(fileContent, null, 2);
    if(configOptions.saveJSONMode == saveJSONModes.CB) {
        GM_setClipboard(fileContent, 'text');
        return;
    }
    fileContent = new TextEncoder().encode(fileContent);
    zip.file('', fileName, fileContent.buffer);
}

function generateZip() {
    var dateName = Date.now();
    var compressionType = configOptions.compressionLevel == 0
                          ? 'STORE'
                          : 'DEFLATE';
    var zipName = `${dateName}.zip`;
    var jsonName = `${dateName}.json`;
    if(configOptions.saveJSONMode != saveJSONModes.NO) {
        saveJSON(jsonName);
    }
    zip.generateAsync(
        {
        type: 'blob',
        compression: compressionType,
        compressionOptions: {
            level: configOptions.compressionLevel,
        }},
        ({workerId, percent, currentFile}) => {
            var fraction = percent / 100;
            if(fraction == 1) {
                enableButton();
                return;
            }
            downloadPercent.innerHTML = `${percent.toFixed(2)}%`;
            compressingSpan.style.width = fraction * downloadBtn.offsetWidth + 'px';
        }
    )
    .then((url) => {
        var a = createNode('a');
        a.download = zipName;
        a.href = url;
        a.click();
    })
    .then(() => {
        info = [];
        sessionStorage.removeItem('info');
        downloading = false;
    });
}

function download(item) {
    currentDownloads++;
    const fileName = `${item.namePrep}${item.page}${item.extension}`;
    GM_xmlhttpRequest({
        method: 'GET',
        url: item.url,
        responseType: 'arraybuffer',
        onload: (response) => {
            if(cancelled) return;
            var data = response.response;
            zip.file(item.title, fileName, data);

            currentDownloads--;

            downloaded++;
            var fraction = downloaded/total;
            downloadPercent.innerHTML = `${(fraction * 100).toFixed(2)}%`;
            downloadingSpan.style.width = fraction * downloadBtn.offsetWidth + 'px';

            if(queue.length == 0 && currentDownloads <= 0) {
                disableButton(btnStates.downloading);
                generateZip();
            }
        },
        onerror: (error) => {
            currentDownloads--;
            console.warn(`Could not download '${item.title}' - page ${item.page}`);
        }
    });
}

function sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
}