ComicFuzDownloader

Manga downloader for comic-fuz.com
Visiter le site de l'auteur pour obtenir de l'aide, poser une question, écrire un avis, ou signaler le script.
Enveloppe les lignes
// ==UserScript==
// @name         ComicFuzDownloader
// @namespace    https://github.com/Timesient/manga-download-scripts
// @version      0.9
// @license      GPL-3.0
// @author       Timesient
// @description  Manga downloader for comic-fuz.com
// @icon         https://comic-fuz.com/favicons/favicon-32x32.png
// @homepageURL  https://greasyfork.org/scripts/451863-comicfuzdownloader
// @supportURL   https://github.com/Timesient/manga-download-scripts/issues
// @match        https://comic-fuz.com/*
// @require      https://unpkg.com/[email protected]/dist/axios.min.js
// @require      https://unpkg.com/[email protected]/dist/jszip.min.js
// @require      https://unpkg.com/[email protected]/dist/FileSaver.min.js
// @require      https://update.greasyfork.org/scripts/451810/1398192/ImageDownloaderLib.js
// @grant        GM_info
// @grant        GM_xmlhttpRequest
// ==/UserScript==

(async function(axios, JSZip, saveAs, ImageDownloader) {
  'use strict';

  // if not in specific manga chapter
  const re4Path = /https:\/\/comic-fuz\.com\/manga\/\d+.*/;
  const timer4Path = setInterval(() => {
    if (re4Path.test(window.location.href)) {
      const currentTitle = document.querySelector('[class*=Chapter_chapter__isReading] h3[class*=Chapter_chapter__name]')?.textContent;
      const chapters = __NEXT_DATA__?.props?.pageProps?.chapters?.reduce((acc, cur) => acc.concat(cur.chapters), []);
      if (currentTitle && chapters) {
        for (const chapter of chapters) {
          if (chapter.chapterMainName === currentTitle) {
            clearInterval(timer4Path)
            window.location.href = `https://comic-fuz.com/manga/viewer/${chapter.chapterId}`;
          }
        }
      }
    }
  }, 200);

  // reload page when enter or leave chapter
  const re = /https:\/\/comic-fuz\.com\/(manga|book|magazine)\/(viewer|\d+).*/;
  const oldHref = window.location.href;
  const timer = setInterval(() => {
    const newHref = window.location.href;
    if (newHref === oldHref) return;
    if (re.test(newHref) || re.test(oldHref)) {
      clearInterval(timer);
      window.location.reload();
    }
  }, 200);

  // return if not reading chapter now
  if (!re.test(oldHref)) return;

  // get type and id
  const { type, id } = window.location.pathname.match(/\/(?<type>.*)\/viewer\/(?<id>.*)/).groups;

  // set the endpoint of API request
  const endpoint = ({
    'manga': 'manga_viewer',
    'book': 'book_viewer_2',
    'magazine': 'magazine_viewer_2',
  })[type];

  // set the body of API request
  const requestBody = ({
    'manga': {
      deviceInfo: { deviceType: 2 },
      chapterId: id,
      useTicket: false,
      consumePoint: { event: 0, paid: 0 }
    },
    'book': {
      deviceInfo: { deviceType: 2 },
      bookIssueId: id,
      purchaseRequest: false,
      consumePaidPoint: 0
    },
    'magazine': {
      deviceInfo: { deviceType: 2 },
      magazineIssueId: id,
      purchaseRequest: false,
      consumePaidPoint: 0
    },
  })[type];

  // get config data from API
  const url = `https://api.comic-fuz.com/v1/${endpoint}`;
  const config = await fetch(url, {
    method: 'POST',
    body: createInfoSchema().encodeInfo(requestBody),
    credentials: 'include',
  }).then(res => res.text());

  // get encrypted image data
  const imageDataRegexp = /(\/[fkh].*&e=\d{10}).*([0-9a-z]{32})"@([0-9a-z]{64})/gm;
  const encryptedImageData = Array.from(config.matchAll(imageDataRegexp)).map(item => ({ url: 'https://img.comic-fuz.com' + item[1], iv: item[2], key: item[3] }));

  // setup ImageDownloader
  ImageDownloader.init({
    maxImageAmount: encryptedImageData.length,
    getImagePromises,
    title: `comic-fuz-${type}-${id}`
  });

  // collect promises of image
  function getImagePromises(startNum, endNum) {
    return encryptedImageData
      .slice(startNum - 1, endNum)
      .map(data => getDecryptedImage(data)
        .then(ImageDownloader.fulfillHandler)
        .catch(ImageDownloader.rejectHandler)
      );
  }

  // get promise of decrypted image
  async function getDecryptedImage(data) {
    function En(e) {
      const t = e.match(/.{1,2}/g);
      return new Uint8Array(t.map((function (e) {
        return parseInt(e, 16)
      })));
    }

    const encryptedImage = await axios.get(data.url, { responseType: 'arraybuffer' }).then(res => res.data);
    const key = await crypto.subtle.importKey('raw', En(data.key), "AES-CBC", false, ['decrypt']);
    const decryptedImage = await crypto.subtle.decrypt({ name: 'AES-CBC', iv: En(data.iv) }, key, encryptedImage);

    return decryptedImage;
  }

  // I copy these code from somewhere else before, but I cant find the source now.
  // But surely they are related to 'protobuf' and 'protobufjs'
  function createInfoSchema() {
    const exports = {};

    exports.encodeInfo = function (message) {
      var bb = popByteBuffer();
      _encodeInfo(message, bb);
      return toUint8Array(bb);
    }

    function _encodeInfo(message, bb) {
      // optional DeviceInfo deviceInfo = 1;
      var $deviceInfo = message.deviceInfo;
      if ($deviceInfo !== undefined) {
        writeVarint32(bb, 10);
        var nested = popByteBuffer();
        _encodeDeviceInfo($deviceInfo, nested);
        writeVarint32(bb, nested.limit);
        writeByteBuffer(bb, nested);
        pushByteBuffer(nested);
      }

      // optional uint32 chapterId = 2;
      var $chapterId = message.chapterId;
      if ($chapterId !== undefined) {
        writeVarint32(bb, 16);
        writeVarint32(bb, $chapterId);
      }

      // I try this and it works!
      var $bookIssueId = message.bookIssueId;
      if ($bookIssueId !== undefined) {
        writeVarint32(bb, 16);
        writeVarint32(bb, $bookIssueId);
      }

      // I try this and it works!
      var $magazineIssueId = message.magazineIssueId;
      if ($magazineIssueId !== undefined) {
        writeVarint32(bb, 16);
        writeVarint32(bb, $magazineIssueId);
      }

      // optional bool useTicket = 3;
      var $useTicket = message.useTicket;
      if ($useTicket !== undefined) {
        writeVarint32(bb, 24);
        writeByte(bb, $useTicket ? 1 : 0);
      }

      // optional ConsumePoint consumePoint = 4;
      var $consumePoint = message.consumePoint;
      if ($consumePoint !== undefined) {
        writeVarint32(bb, 34);
        var nested = popByteBuffer();
        _encodeConsumePoint($consumePoint, nested);
        writeVarint32(bb, nested.limit);
        writeByteBuffer(bb, nested);
        pushByteBuffer(nested);
      }
    };

    exports.decodeInfo = function (binary) {
      return _decodeInfo(wrapByteBuffer(binary));
    }

    function _decodeInfo(bb) {
      var message = {};

      end_of_message: while (!isAtEnd(bb)) {
        var tag = readVarint32(bb);

        switch (tag >>> 3) {
          case 0:
            break end_of_message;

            // optional DeviceInfo deviceInfo = 1;
          case 1: {
            var limit = pushTemporaryLength(bb);
            message.deviceInfo = _decodeDeviceInfo(bb);
            bb.limit = limit;
            break;
          }

            // optional uint32 chapterId = 2;
          case 2: {
            message.chapterId = readVarint32(bb) >>> 0;
            break;
          }

            // optional bool useTicket = 3;
          case 3: {
            message.useTicket = !!readByte(bb);
            break;
          }

            // optional ConsumePoint consumePoint = 4;
          case 4: {
            var limit = pushTemporaryLength(bb);
            message.consumePoint = _decodeConsumePoint(bb);
            bb.limit = limit;
            break;
          }

          default:
            skipUnknownField(bb, tag & 7);
        }
      }

      return message;
    };

    exports.encodeDeviceInfo = function (message) {
      var bb = popByteBuffer();
      _encodeDeviceInfo(message, bb);
      return toUint8Array(bb);
    }

    function _encodeDeviceInfo(message, bb) {
      // optional uint32 deviceType = 3;
      var $deviceType = message.deviceType;
      if ($deviceType !== undefined) {
        writeVarint32(bb, 24);
        writeVarint32(bb, $deviceType);
      }
    };

    exports.decodeDeviceInfo = function (binary) {
      return _decodeDeviceInfo(wrapByteBuffer(binary));
    }

    function _decodeDeviceInfo(bb) {
      var message = {};

      end_of_message: while (!isAtEnd(bb)) {
        var tag = readVarint32(bb);

        switch (tag >>> 3) {
          case 0:
            break end_of_message;

            // optional uint32 deviceType = 3;
          case 3: {
            message.deviceType = readVarint32(bb) >>> 0;
            break;
          }

          default:
            skipUnknownField(bb, tag & 7);
        }
      }

      return message;
    };

    exports.encodeConsumePoint = function (message) {
      var bb = popByteBuffer();
      _encodeConsumePoint(message, bb);
      return toUint8Array(bb);
    }

    function _encodeConsumePoint(message, bb) {
      // optional uint32 event = 1;
      var $event = message.event;
      if ($event !== undefined) {
        writeVarint32(bb, 8);
        writeVarint32(bb, $event);
      }

      // optional uint32 paid = 2;
      var $paid = message.paid;
      if ($paid !== undefined) {
        writeVarint32(bb, 16);
        writeVarint32(bb, $paid);
      }
    };

    exports.decodeConsumePoint = function (binary) {
      return _decodeConsumePoint(wrapByteBuffer(binary));
    }

    function _decodeConsumePoint(bb) {
      var message = {};

      end_of_message: while (!isAtEnd(bb)) {
        var tag = readVarint32(bb);

        switch (tag >>> 3) {
          case 0:
            break end_of_message;

            // optional uint32 event = 1;
          case 1: {
            message.event = readVarint32(bb) >>> 0;
            break;
          }

            // optional uint32 paid = 2;
          case 2: {
            message.paid = readVarint32(bb) >>> 0;
            break;
          }

          default:
            skipUnknownField(bb, tag & 7);
        }
      }

      return message;
    };

    function pushTemporaryLength(bb) {
      var length = readVarint32(bb);
      var limit = bb.limit;
      bb.limit = bb.offset + length;
      return limit;
    }

    function skipUnknownField(bb, type) {
      switch (type) {
        case 0: while (readByte(bb) & 0x80) { } break;
        case 2: skip(bb, readVarint32(bb)); break;
        case 5: skip(bb, 4); break;
        case 1: skip(bb, 8); break;
        default: throw new Error("Unimplemented type: " + type);
      }
    }

    // The code below was modified from https://github.com/protobufjs/bytebuffer.js
    // which is under the Apache License 2.0.

    var f32 = new Float32Array(1);
    var f32_u8 = new Uint8Array(f32.buffer);

    var f64 = new Float64Array(1);
    var f64_u8 = new Uint8Array(f64.buffer);

    var bbStack = [];

    function popByteBuffer() {
      const bb = bbStack.pop();
      if (!bb) return { bytes: new Uint8Array(64), offset: 0, limit: 0 };
      bb.offset = bb.limit = 0;
      return bb;
    }

    function pushByteBuffer(bb) {
      bbStack.push(bb);
    }

    function wrapByteBuffer(bytes) {
      return { bytes, offset: 0, limit: bytes.length };
    }

    function toUint8Array(bb) {
      var bytes = bb.bytes;
      var limit = bb.limit;
      return bytes.length === limit ? bytes : bytes.subarray(0, limit);
    }

    function skip(bb, offset) {
      if (bb.offset + offset > bb.limit) {
        throw new Error('Skip past limit');
      }
      bb.offset += offset;
    }

    function isAtEnd(bb) {
      return bb.offset >= bb.limit;
    }

    function grow(bb, count) {
      var bytes = bb.bytes;
      var offset = bb.offset;
      var limit = bb.limit;
      var finalOffset = offset + count;
      if (finalOffset > bytes.length) {
        var newBytes = new Uint8Array(finalOffset * 2);
        newBytes.set(bytes);
        bb.bytes = newBytes;
      }
      bb.offset = finalOffset;
      if (finalOffset > limit) {
        bb.limit = finalOffset;
      }
      return offset;
    }

    function advance(bb, count) {
      var offset = bb.offset;
      if (offset + count > bb.limit) {
        throw new Error('Read past limit');
      }
      bb.offset += count;
      return offset;
    }

    function writeByteBuffer(bb, buffer) {
      var offset = grow(bb, buffer.limit);
      var from = bb.bytes;
      var to = buffer.bytes;

      // This for loop is much faster than subarray+set on V8
      for (var i = 0, n = buffer.limit; i < n; i++) {
        from[i + offset] = to[i];
      }
    }

    function readByte(bb) {
      return bb.bytes[advance(bb, 1)];
    }

    function writeByte(bb, value) {
      var offset = grow(bb, 1);
      bb.bytes[offset] = value;
    }

    function readVarint32(bb) {
      var c = 0;
      var value = 0;
      var b;
      do {
        b = readByte(bb);
        if (c < 32) value |= (b & 0x7F) << c;
        c += 7;
      } while (b & 0x80);
      return value;
    }

    function writeVarint32(bb, value) {
      value >>>= 0;
      while (value >= 0x80) {
        writeByte(bb, (value & 0x7f) | 0x80);
        value >>>= 7;
      }
      writeByte(bb, value);
    }

    return exports;
  }

})(axios, JSZip, saveAs, ImageDownloader);