"); } else { description.innerHTML = `${this.chapter.title}`; } anchor.appendChild(description); anchor.onclick = (event) => { event.preventDefault(); this.chapter.onclick?.(this.index); }; return element; } render() { } } function q(selector, parent) { const element = (parent || document).querySelector(selector); if (!element) { throw new Error(`Can't find element: ${selector}`); } return element; } class PageFetcher { chapters = []; chapterIndex = 0; queue; matcher; done = false; beforeInit; afterInit; appendPageLock = false; abortb = false; chaptersSelectionElement; constructor(queue, matcher) { this.queue = queue; this.matcher = matcher; this.chaptersSelectionElement = q("#backChaptersSelection"); this.chaptersSelectionElement.addEventListener("click", () => this.backChaptersSelection()); const debouncer = new Debouncer(); EBUS.subscribe("ifq-on-finished-report", (index) => debouncer.addEvent("APPEND-NEXT-PAGES", () => this.appendPages(index, !this.queue.downloading?.()), 5)); EBUS.subscribe("pf-try-extend", () => debouncer.addEvent("APPEND-NEXT-PAGES", () => !this.queue.downloading?.() && this.appendNextPage(true), 5)); } appendToView(total, nodes, done) { EBUS.emit("pf-on-appended", total, nodes, done); } abort() { this.abortb = true; } async init() { this.chapters = await this.matcher.fetchChapters(); this.chapters.forEach((c) => { c.sourceIter = this.matcher.fetchPagesSource(c); c.onclick = (index) => { EBUS.emit("pf-change-chapter", index); if (this.chapters[index].queue) { this.appendToView(this.chapters[index].queue.length, this.chapters[index].queue, false); if (this.chapters.length > 1) { this.chaptersSelectionElement.hidden = false; } } if (!this.queue.downloading?.()) { this.beforeInit?.(); this.changeChapter(index, true).finally(() => this.afterInit?.()); } }; }); if (this.chapters.length === 1) { this.beforeInit?.(); this.changeChapter(0, true).finally(() => this.afterInit?.()); } if (this.chapters.length > 1) { this.appendToView(this.chapters.length, this.chapters.map((c, i) => new ChapterNode(c, i)), true); } } backChaptersSelection() { EBUS.emit("pf-change-chapter", -1); this.appendToView(this.chapters.length, this.chapters.map((c, i) => new ChapterNode(c, i)), true); this.chaptersSelectionElement.hidden = true; } /// start the chapter by index async changeChapter(index, appendToView) { this.chapterIndex = index; const chapter = this.chapters[this.chapterIndex]; this.queue.restore(index, chapter.queue); if (!chapter.sourceIter) { evLog("error", "chapter sourceIter is not set!"); return; } let first = await chapter.sourceIter.next(); if (!first.done) { await this.appendImages(first.value, appendToView); } this.appendPages(this.queue.length - 1, appendToView); } // append next page until the queue length is 60 more than finished async appendPages(appendedCount, appendToView) { while (true) { if (appendedCount + 60 < this.queue.length) break; if (!await this.appendNextPage(appendToView)) break; } } async appendNextPage(appendToView) { if (this.appendPageLock) return false; try { this.appendPageLock = true; if (this.done || this.abortb) return false; const chapter = this.chapters[this.chapterIndex]; const next = await chapter.sourceIter.next(); if (next.done) { chapter.done = true; this.appendToView(this.queue.length, [], true); return false; } else { await this.appendImages(next.value, appendToView); return true; } } finally { this.appendPageLock = false; } } async appendImages(page, appendToView) { try { const nodes = await this.obtainImageNodeList(page); if (this.abortb) return false; const IFs = nodes.map( (imgNode) => new IMGFetcher(imgNode, this.matcher, this.chapterIndex) ); this.queue.push(...IFs); this.chapters[this.chapterIndex].queue.push(...IFs); if (appendToView) { this.appendToView(this.queue.length, IFs); } return true; } catch (error) { evLog("error", `page fetcher append images error: `, error); return false; } } //从文档的字符串中创建缩略图元素列表 async obtainImageNodeList(page) { let tryTimes = 0; while (tryTimes < 3) { try { return await this.matcher.parseImgNodes(page, this.chapters[this.chapterIndex].id); } catch (error) { evLog("error", "warn: parse image nodes failed, retrying: ", error); tryTimes++; } } evLog("error", "warn: parse image nodes failed: reached max try times!"); return []; } //通过地址请求该页的文档 async fetchDocument(pageURL) { return await window.fetch(pageURL).then((response) => response.text()); } } class GalleryMeta { url; title; originTitle; downloader; tags; constructor(url, title) { this.url = url; this.title = title; this.tags = {}; this.downloader = "https://github.com/MapoMagpie/eh-view-enhance"; } } class BaseMatcher { async fetchChapters() { return [{ id: 1, title: "Default", source: window.location.href, queue: [] }]; } title(doc) { const meta = this.galleryMeta(doc); return meta.originTitle || meta.title || "unknown"; } galleryMeta(doc, _chapter) { return new GalleryMeta(window.location.href, doc.title || "unknown"); } workURLs() { return [this.workURL()]; } async processData(data, contentType, _url) { return [data, contentType]; } } function toMD5(s) { return md5(s); } function get_num(gid, page) { gid = window.atob(gid); page = window.atob(page); let n = toMD5(gid + page).slice(-1).charCodeAt(0); if (gid >= window.atob("MjY4ODUw") && gid <= window.atob("NDIxOTI1")) { n %= 10; } else if (gid >= window.atob("NDIxOTI2")) { n %= 8; } if (n < 10) { return 2 + 2 * n; } else { return 10; } } function drawImage(ctx, e, gid, page) { const width = e.width; const height = e.height; const s = get_num(window.btoa(gid), window.btoa(page)); const l = parseInt((height % s).toString()); const r = width; for (let m = 0; m < s; m++) { let c = Math.floor(height / s); let g = c * m; let w = height - c * (m + 1) - l; 0 == m ? c += l : g += l, ctx.drawImage(e, 0, w, r, c, 0, g, r, c); } } class Comic18Matcher extends BaseMatcher { meta; async fetchChapters() { const ret = []; const thumb = document.querySelector(".thumb-overlay > img"); const chapters = Array.from(document.querySelectorAll(".visible-lg .episode > ul > a")); if (chapters.length > 0) { chapters.forEach((ch, i) => { const title = Array.from(ch.querySelector("li")?.childNodes || []).map((n) => n.textContent?.trim()).filter(Boolean).map((n) => n); ret.push({ id: i, title, source: ch.href, queue: [], thumbimg: thumb?.src }); }); } else { const href = document.querySelector(".read-block > a")?.href; if (href === void 0) throw new Error("No page found"); ret.push({ id: 0, title: "Default", source: href, queue: [] }); } return ret; } async *fetchPagesSource(chapter) { yield chapter.source; } async parseImgNodes(source) { const list = []; const raw = await window.fetch(source).then((resp) => resp.text()); const document2 = new DOMParser().parseFromString(raw, "text/html"); const elements = Array.from(document2.querySelectorAll(".scramble-page:not(.thewayhome)")); for (const element of elements) { const title = element.id; const img = element.querySelector("img"); if (!img) { evLog("error", "warn: cannot find img element", element); continue; } const src = img.getAttribute("data-original"); if (!src) { evLog("error", "warn: cannot find data-original", element); continue; } list.push(new ImageNode("", src, title)); } return list; } async processData(data, contentType, url) { const reg = /(\d+)\/(\d+)\.(\w+)/; const matches = url.match(reg); const gid = matches[1]; let scrambleID = 220980; if (Number(gid) < scrambleID) return [data, contentType]; const page = matches[2]; const ext = matches[3]; if (ext === "gif") return [data, contentType]; const img = await createImageBitmap(new Blob([data], { type: contentType })); const canvas = document.createElement("canvas"); canvas.width = img.width; canvas.height = img.height; const ctx = canvas.getContext("2d"); drawImage(ctx, img, gid, page); return new Promise( (resolve) => canvas.toBlob( (blob) => blob?.arrayBuffer().then((buf) => resolve([new Uint8Array(buf), blob.type])).finally(() => canvas.remove()), contentType ) ); } workURL() { return /18-?comic(freedom)?.(vip|org|xyz)\/album\/\d+/; } galleryMeta(doc) { if (this.meta) return this.meta; const title = doc.querySelector(".panel-heading h1")?.textContent || "UNTITLE"; this.meta = new GalleryMeta(window.location.href, title); this.meta.originTitle = title; const tagTrList = doc.querySelectorAll("div.tag-block > span"); const tags = {}; tagTrList.forEach((tr) => { const cat = tr.getAttribute("data-type")?.trim(); if (cat) { const values = Array.from(tr.querySelectorAll("a")).map((a) => a.textContent).filter(Boolean); if (values.length > 0) { tags[cat] = values; } } }); this.meta.tags = tags; return this.meta; } // https://cdn-msp.18comic.org/media/photos/529221/00004.gif async fetchOriginMeta(url) { return { url }; } } class DanbooruMatcher extends BaseMatcher { tags = {}; count = 0; async *fetchPagesSource() { let doc = document; yield doc; let tryTimes = 0; while (true) { const url = this.nextPage(doc); if (!url) break; try { doc = await window.fetch(url).then((res) => res.text()).then((text) => new DOMParser().parseFromString(text, "text/html")); } catch (e) { tryTimes++; if (tryTimes > 3) throw new Error(`fetch next page failed, ${e}`); continue; } tryTimes = 0; yield doc; } } async fetchOriginMeta(href) { let url = null; const doc = await window.fetch(href).then((res) => res.text()).then((text) => new DOMParser().parseFromString(text, "text/html")); if (conf.fetchOriginal) { url = this.getOriginalURL(doc); } if (!url) { url = this.getNormalURL(doc); } if (!url) throw new Error("Cannot find origin image or video url"); let title; const ext = url.split(".").pop()?.match(/^\w+/)?.[0]; const id = this.extractIDFromHref(href); if (ext && id) { title = `${id}.${ext}`; } return { url, title }; } async parseImgNodes(source) { const list = []; const doc = source; this.queryList(doc).forEach((ele) => { const [imgNode, tags] = this.toImgNode(ele); if (!imgNode) return; this.count++; if (tags !== "") { this.tags[imgNode.title.split(".")[0]] = tags.trim().replaceAll(": ", ":").split(" ").map((v) => v.trim()).filter((v) => v !== ""); } list.push(imgNode); }); return list; } galleryMeta() { const url = new URL(window.location.href); const tags = url.searchParams.get("tags")?.trim(); const meta = new GalleryMeta(window.location.href, `${this.site()}_${tags}_${this.count}`); meta.tags = this.tags; return meta; } } class DanbooruDonmaiMatcher extends DanbooruMatcher { site() { return "danbooru"; } workURL() { return /danbooru.donmai.us\/(posts(?!\/)|$)/; } nextPage(doc) { return doc.querySelector(".paginator a.paginator-next")?.href || null; } queryList(doc) { return Array.from(doc.querySelectorAll(".posts-container > article:not(.blacklisted-active)")); } toImgNode(ele) { const anchor = ele.querySelector("a"); if (!anchor) { evLog("error", "warn: cannot find anchor element", anchor); return [null, ""]; } const img = anchor.querySelector("img"); if (!img) { evLog("error", "warn: cannot find img element", img); return [null, ""]; } const href = anchor.getAttribute("href"); if (!href) { evLog("error", "warn: cannot find href", anchor); return [null, ""]; } return [new ImageNode(img.src, href, `${ele.getAttribute("data-id") || ele.id}.jpg`), ele.getAttribute("data-tags") || ""]; } getOriginalURL(doc) { return doc.querySelector("#image-resize-notice > a")?.href || null; } getNormalURL(doc) { return doc.querySelector("#image")?.getAttribute("src") || null; } extractIDFromHref(href) { return href.match(/posts\/(\d+)/)?.[1]; } } class Rule34Matcher extends DanbooruMatcher { site() { return "rule34"; } workURL() { return /rule34.xxx\/index.php\?page=post&s=list/; } nextPage(doc) { return doc.querySelector(".pagination a[alt=next]")?.href || null; } queryList(doc) { return Array.from(doc.querySelectorAll(".image-list > .thumb:not(.blacklisted-image) > a")); } toImgNode(ele) { const img = ele.querySelector("img"); if (!img) { evLog("error", "warn: cannot find img element", img); return [null, ""]; } const href = ele.getAttribute("href"); if (!href) { evLog("error", "warn: cannot find href", ele); return [null, ""]; } return [new ImageNode(img.src, href, `${ele.id}.jpg`), img.getAttribute("alt") || ""]; } getOriginalURL(doc) { const raw = doc.querySelector("#note-container + script")?.textContent?.trim().replace("image = ", "").replace(";", "").replaceAll("'", '"'); try { if (raw) { const info = JSON.parse(raw); return `${info.domain}/${info.base_dir}/${info.dir}/${info.img}`; } } catch (error) { evLog("error", "get original url failed", error); } return null; } getNormalURL(doc) { return doc.querySelector("#image,#gelcomVideoPlayer > source")?.getAttribute("src") || null; } extractIDFromHref(href) { return href.match(/id=(\d+)/)?.[1]; } } const POST_INFO_REGEX = /Post\.register\((.*)\)/g; class YandereMatcher extends BaseMatcher { infos = {}; count = 0; workURL() { return /yande.re\/post(?!\/show\/.*)/; } async *fetchPagesSource() { let doc = document; yield doc; let tryTimes = 0; while (true) { const url = doc.querySelector("#paginator a.next_page")?.href; if (!url) break; try { doc = await window.fetch(url).then((res) => res.text()).then((text) => new DOMParser().parseFromString(text, "text/html")); } catch (e) { tryTimes++; if (tryTimes > 3) throw new Error(`fetch next page failed, ${e}`); continue; } tryTimes = 0; yield doc; } } async parseImgNodes(source) { const doc = source; const raw = doc.querySelector("body > form + script")?.textContent; if (!raw) throw new Error("cannot find post list from script"); const matches = raw.matchAll(POST_INFO_REGEX); const ret = []; for (const match of matches) { if (!match || match.length < 2) continue; try { const info = JSON.parse(match[1]); this.infos[info.id.toString()] = info; this.count++; ret.push(new ImageNode(info.preview_url, `${window.location.origin}/post/show/${info.id}`, `${info.id}.${info.file_ext}`)); } catch (error) { evLog("error", "parse post info failed", error); continue; } } return ret; } async fetchOriginMeta(href) { let id = href.split("/").pop(); if (!id) { throw new Error(`cannot find id from ${href}`); } let url; if (conf.fetchOriginal) { url = this.infos[id]?.file_url; } else { url = this.infos[id]?.sample_url; } if (!url) { throw new Error(`cannot find url for id ${id}`); } return { url }; } galleryMeta() { const url = new URL(window.location.href); const tags = url.searchParams.get("tags")?.trim(); const meta = new GalleryMeta(window.location.href, `yande_${tags}_${this.count}`); meta["infos"] = this.infos; return meta; } } class GelBooruMatcher extends DanbooruMatcher { site() { return "gelbooru"; } workURL() { return /gelbooru.com\/index.php\?page=post&s=list/; } nextPage(doc) { return doc.querySelector("#paginator a[alt=next]")?.href || null; } queryList(doc) { return Array.from(doc.querySelectorAll(".thumbnail-container > article.thumbnail-preview:not(.blacklisted-image) > a")); } toImgNode(ele) { const img = ele.querySelector("img"); if (!img) { evLog("error", "warn: cannot find img element", img); return [null, ""]; } const href = ele.getAttribute("href"); if (!href) { evLog("error", "warn: cannot find href", ele); return [null, ""]; } return [new ImageNode(img.src, href, `${ele.id}.jpg`), img.getAttribute("alt") || ""]; } getOriginalURL(doc) { return doc.querySelector("head > meta[property='og:image']")?.getAttribute("content") || null; } getNormalURL(doc) { const img = doc.querySelector("#image"); if (img?.src) return img.src; const vidSources = Array.from(doc.querySelectorAll("#gelcomVideoPlayer > source")); if (vidSources.length === 0) return null; return vidSources.find((s) => s.type.endsWith("mp4"))?.src || vidSources[0].src; } extractIDFromHref(href) { return href.match(/id=(\d+)/)?.[1]; } } function parseImagePositions(styles) { return styles.map((st) => { const [x, y] = st.backgroundPosition.split(" ").map((v) => Math.abs(parseInt(v))); return { x, y, width: parseInt(st.width), height: parseInt(st.height) }; }); } function splitSpriteImage(image, positions) { const canvas = document.createElement("canvas"); const ctx = canvas.getContext("2d"); const result = []; for (const pos of positions) { canvas.width = pos.width; canvas.height = pos.height; ctx.drawImage(image, pos.x, pos.y, pos.width, pos.height, 0, 0, pos.width, pos.height); result.push(canvas.toDataURL()); } canvas.remove(); return result; } async function splitImagesFromUrl(url, positions) { let data; for (let i = 0; i < 3; i++) { try { data = await fetchImage(url); break; } catch (err) { } } if (!data) throw new Error("load sprite image error"); url = URL.createObjectURL(data); const img = await new Promise((resolve, reject) => { let img2 = new Image(); img2.onload = () => resolve(img2); img2.onerror = () => reject(new Error("load sprite image error")); img2.src = url; }); URL.revokeObjectURL(url); return splitSpriteImage(img, positions); } const regulars = { /** 有压缩的大图地址 */ normal: /\
* These objects are the currency accepted by SJCL's crypto functions. *
* ** Most of our crypto primitives operate on arrays of 4-byte words internally, * but many of them can take arguments that are not a multiple of 4 bytes. * This library encodes arrays of bits (whose size need not be a multiple of 8 * bits) as arrays of 32-bit words. The bits are packed, big-endian, into an * array of words, 32 bits at a time. Since the words are double-precision * floating point numbers, they fit some extra data. We use this (in a private, * possibly-changing manner) to encode the number of bits actually present * in the last word of the array. *
* ** Because bitwise ops clear this out-of-band data, these arrays can be passed * to ciphers like AES which want arrays of words. *
*/ const bitArray = { /** * Concatenate two bit arrays. * @param {bitArray} a1 The first array. * @param {bitArray} a2 The second array. * @return {bitArray} The concatenation of a1 and a2. */ concat(a1, a2) { if (a1.length === 0 || a2.length === 0) { return a1.concat(a2); } const last = a1[a1.length - 1], shift = bitArray.getPartial(last); if (shift === 32) { return a1.concat(a2); } else { return bitArray._shiftRight(a2, shift, last | 0, a1.slice(0, a1.length - 1)); } }, /** * Find the length of an array of bits. * @param {bitArray} a The array. * @return {Number} The length of a, in bits. */ bitLength(a) { const l = a.length; if (l === 0) { return 0; } const x = a[l - 1]; return (l - 1) * 32 + bitArray.getPartial(x); }, /** * Truncate an array. * @param {bitArray} a The array. * @param {Number} len The length to truncate to, in bits. * @return {bitArray} A new array, truncated to len bits. */ clamp(a, len) { if (a.length * 32 < len) { return a; } a = a.slice(0, Math.ceil(len / 32)); const l = a.length; len = len & 31; if (l > 0 && len) { a[l - 1] = bitArray.partial(len, a[l - 1] & 0x80000000 >> (len - 1), 1); } return a; }, /** * Make a partial word for a bit array. * @param {Number} len The number of bits in the word. * @param {Number} x The bits. * @param {Number} [_end=0] Pass 1 if x has already been shifted to the high side. * @return {Number} The partial word. */ partial(len, x, _end) { if (len === 32) { return x; } return (_end ? x | 0 : x << (32 - len)) + len * 0x10000000000; }, /** * Get the number of bits used by a partial word. * @param {Number} x The partial word. * @return {Number} The number of bits used by the partial word. */ getPartial(x) { return Math.round(x / 0x10000000000) || 32; }, /** Shift an array right. * @param {bitArray} a The array to shift. * @param {Number} shift The number of bits to shift. * @param {Number} [carry=0] A byte to carry in * @param {bitArray} [out=[]] An array to prepend to the output. * @private */ _shiftRight(a, shift, carry, out) { if (out === undefined) { out = []; } for (; shift >= 32; shift -= 32) { out.push(carry); carry = 0; } if (shift === 0) { return out.concat(a); } for (let i = 0; i < a.length; i++) { out.push(carry | a[i] >>> shift); carry = a[i] << (32 - shift); } const last2 = a.length ? a[a.length - 1] : 0; const shift2 = bitArray.getPartial(last2); out.push(bitArray.partial(shift + shift2 & 31, (shift + shift2 > 32) ? carry : out.pop(), 1)); return out; } }; /** @fileOverview Bit array codec implementations. * * @author Emily Stark * @author Mike Hamburg * @author Dan Boneh */ /** * Arrays of bytes * @namespace */ const codec = { bytes: { /** Convert from a bitArray to an array of bytes. */ fromBits(arr) { const bl = bitArray.bitLength(arr); const byteLength = bl / 8; const out = new Uint8Array(byteLength); let tmp; for (let i = 0; i < byteLength; i++) { if ((i & 3) === 0) { tmp = arr[i / 4]; } out[i] = tmp >>> 24; tmp <<= 8; } return out; }, /** Convert from an array of bytes to a bitArray. */ toBits(bytes) { const out = []; let i; let tmp = 0; for (i = 0; i < bytes.length; i++) { tmp = tmp << 8 | bytes[i]; if ((i & 3) === 3) { out.push(tmp); tmp = 0; } } if (i & 3) { out.push(bitArray.partial(8 * (i & 3), tmp)); } return out; } } }; const hash = {}; /** * Context for a SHA-1 operation in progress. * @constructor */ hash.sha1 = class { constructor(hash) { const sha1 = this; /** * The hash's block size, in bits. * @constant */ sha1.blockSize = 512; /** * The SHA-1 initialization vector. * @private */ sha1._init = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]; /** * The SHA-1 hash key. * @private */ sha1._key = [0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6]; if (hash) { sha1._h = hash._h.slice(0); sha1._buffer = hash._buffer.slice(0); sha1._length = hash._length; } else { sha1.reset(); } } /** * Reset the hash state. * @return this */ reset() { const sha1 = this; sha1._h = sha1._init.slice(0); sha1._buffer = []; sha1._length = 0; return sha1; } /** * Input several words to the hash. * @param {bitArray|String} data the data to hash. * @return this */ update(data) { const sha1 = this; if (typeof data === "string") { data = codec.utf8String.toBits(data); } const b = sha1._buffer = bitArray.concat(sha1._buffer, data); const ol = sha1._length; const nl = sha1._length = ol + bitArray.bitLength(data); if (nl > 9007199254740991) { throw new Error("Cannot hash more than 2^53 - 1 bits"); } const c = new Uint32Array(b); let j = 0; for (let i = sha1.blockSize + ol - ((sha1.blockSize + ol) & (sha1.blockSize - 1)); i <= nl; i += sha1.blockSize) { sha1._block(c.subarray(16 * j, 16 * (j + 1))); j += 1; } b.splice(0, 16 * j); return sha1; } /** * Complete hashing and output the hash value. * @return {bitArray} The hash value, an array of 5 big-endian words. TODO */ finalize() { const sha1 = this; let b = sha1._buffer; const h = sha1._h; // Round out and push the buffer b = bitArray.concat(b, [bitArray.partial(1, 1)]); // Round out the buffer to a multiple of 16 words, less the 2 length words. for (let i = b.length + 2; i & 15; i++) { b.push(0); } // append the length b.push(Math.floor(sha1._length / 0x100000000)); b.push(sha1._length | 0); while (b.length) { sha1._block(b.splice(0, 16)); } sha1.reset(); return h; } /** * The SHA-1 logical functions f(0), f(1), ..., f(79). * @private */ _f(t, b, c, d) { if (t <= 19) { return (b & c) | (~b & d); } else if (t <= 39) { return b ^ c ^ d; } else if (t <= 59) { return (b & c) | (b & d) | (c & d); } else if (t <= 79) { return b ^ c ^ d; } } /** * Circular left-shift operator. * @private */ _S(n, x) { return (x << n) | (x >>> 32 - n); } /** * Perform one cycle of SHA-1. * @param {Uint32Array|bitArray} words one block of words. * @private */ _block(words) { const sha1 = this; const h = sha1._h; // When words is passed to _block, it has 16 elements. SHA1 _block // function extends words with new elements (at the end there are 80 elements). // The problem is that if we use Uint32Array instead of Array, // the length of Uint32Array cannot be changed. Thus, we replace words with a // normal Array here. const w = Array(80); // do not use Uint32Array here as the instantiation is slower for (let j = 0; j < 16; j++) { w[j] = words[j]; } let a = h[0]; let b = h[1]; let c = h[2]; let d = h[3]; let e = h[4]; for (let t = 0; t <= 79; t++) { if (t >= 16) { w[t] = sha1._S(1, w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]); } const tmp = (sha1._S(5, a) + sha1._f(t, b, c, d) + e + w[t] + sha1._key[Math.floor(t / 20)]) | 0; e = d; d = c; c = sha1._S(30, b); b = a; a = tmp; } h[0] = (h[0] + a) | 0; h[1] = (h[1] + b) | 0; h[2] = (h[2] + c) | 0; h[3] = (h[3] + d) | 0; h[4] = (h[4] + e) | 0; } }; /** @fileOverview Low-level AES implementation. * * This file contains a low-level implementation of AES, optimized for * size and for efficiency on several browsers. It is based on * OpenSSL's aes_core.c, a public-domain implementation by Vincent * Rijmen, Antoon Bosselaers and Paulo Barreto. * * An older version of this implementation is available in the public * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh, * Stanford University 2008-2010 and BSD-licensed for liability * reasons. * * @author Emily Stark * @author Mike Hamburg * @author Dan Boneh */ const cipher = {}; /** * Schedule out an AES key for both encryption and decryption. This * is a low-level class. Use a cipher mode to do bulk encryption. * * @constructor * @param {Array} key The key as an array of 4, 6 or 8 words. */ cipher.aes = class { constructor(key) { /** * The expanded S-box and inverse S-box tables. These will be computed * on the client so that we don't have to send them down the wire. * * There are two tables, _tables[0] is for encryption and * _tables[1] is for decryption. * * The first 4 sub-tables are the expanded S-box with MixColumns. The * last (_tables[01][4]) is the S-box itself. * * @private */ const aes = this; aes._tables = [[[], [], [], [], []], [[], [], [], [], []]]; if (!aes._tables[0][0][0]) { aes._precompute(); } const sbox = aes._tables[0][4]; const decTable = aes._tables[1]; const keyLen = key.length; let i, encKey, decKey, rcon = 1; if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) { throw new Error("invalid aes key size"); } aes._key = [encKey = key.slice(0), decKey = []]; // schedule encryption keys for (i = keyLen; i < 4 * keyLen + 28; i++) { let tmp = encKey[i - 1]; // apply sbox if (i % keyLen === 0 || (keyLen === 8 && i % keyLen === 4)) { tmp = sbox[tmp >>> 24] << 24 ^ sbox[tmp >> 16 & 255] << 16 ^ sbox[tmp >> 8 & 255] << 8 ^ sbox[tmp & 255]; // shift rows and add rcon if (i % keyLen === 0) { tmp = tmp << 8 ^ tmp >>> 24 ^ rcon << 24; rcon = rcon << 1 ^ (rcon >> 7) * 283; } } encKey[i] = encKey[i - keyLen] ^ tmp; } // schedule decryption keys for (let j = 0; i; j++, i--) { const tmp = encKey[j & 3 ? i : i - 4]; if (i <= 4 || j < 4) { decKey[j] = tmp; } else { decKey[j] = decTable[0][sbox[tmp >>> 24]] ^ decTable[1][sbox[tmp >> 16 & 255]] ^ decTable[2][sbox[tmp >> 8 & 255]] ^ decTable[3][sbox[tmp & 255]]; } } } // public /* Something like this might appear here eventually name: "AES", blockSize: 4, keySizes: [4,6,8], */ /** * Encrypt an array of 4 big-endian words. * @param {Array} data The plaintext. * @return {Array} The ciphertext. */ encrypt(data) { return this._crypt(data, 0); } /** * Decrypt an array of 4 big-endian words. * @param {Array} data The ciphertext. * @return {Array} The plaintext. */ decrypt(data) { return this._crypt(data, 1); } /** * Expand the S-box tables. * * @private */ _precompute() { const encTable = this._tables[0]; const decTable = this._tables[1]; const sbox = encTable[4]; const sboxInv = decTable[4]; const d = []; const th = []; let xInv, x2, x4, x8; // Compute double and third tables for (let i = 0; i < 256; i++) { th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i; } for (let x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) { // Compute sbox let s = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4; s = s >> 8 ^ s & 255 ^ 99; sbox[x] = s; sboxInv[s] = x; // Compute MixColumns x8 = d[x4 = d[x2 = d[x]]]; let tDec = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100; let tEnc = d[s] * 0x101 ^ s * 0x1010100; for (let i = 0; i < 4; i++) { encTable[i][x] = tEnc = tEnc << 24 ^ tEnc >>> 8; decTable[i][s] = tDec = tDec << 24 ^ tDec >>> 8; } } // Compactify. Considerable speedup on Firefox. for (let i = 0; i < 5; i++) { encTable[i] = encTable[i].slice(0); decTable[i] = decTable[i].slice(0); } } /** * Encryption and decryption core. * @param {Array} input Four words to be encrypted or decrypted. * @param dir The direction, 0 for encrypt and 1 for decrypt. * @return {Array} The four encrypted or decrypted words. * @private */ _crypt(input, dir) { if (input.length !== 4) { throw new Error("invalid aes block size"); } const key = this._key[dir]; const nInnerRounds = key.length / 4 - 2; const out = [0, 0, 0, 0]; const table = this._tables[dir]; // load up the tables const t0 = table[0]; const t1 = table[1]; const t2 = table[2]; const t3 = table[3]; const sbox = table[4]; // state variables a,b,c,d are loaded with pre-whitened data let a = input[0] ^ key[0]; let b = input[dir ? 3 : 1] ^ key[1]; let c = input[2] ^ key[2]; let d = input[dir ? 1 : 3] ^ key[3]; let kIndex = 4; let a2, b2, c2; // Inner rounds. Cribbed from OpenSSL. for (let i = 0; i < nInnerRounds; i++) { a2 = t0[a >>> 24] ^ t1[b >> 16 & 255] ^ t2[c >> 8 & 255] ^ t3[d & 255] ^ key[kIndex]; b2 = t0[b >>> 24] ^ t1[c >> 16 & 255] ^ t2[d >> 8 & 255] ^ t3[a & 255] ^ key[kIndex + 1]; c2 = t0[c >>> 24] ^ t1[d >> 16 & 255] ^ t2[a >> 8 & 255] ^ t3[b & 255] ^ key[kIndex + 2]; d = t0[d >>> 24] ^ t1[a >> 16 & 255] ^ t2[b >> 8 & 255] ^ t3[c & 255] ^ key[kIndex + 3]; kIndex += 4; a = a2; b = b2; c = c2; } // Last round. for (let i = 0; i < 4; i++) { out[dir ? 3 & -i : i] = sbox[a >>> 24] << 24 ^ sbox[b >> 16 & 255] << 16 ^ sbox[c >> 8 & 255] << 8 ^ sbox[d & 255] ^ key[kIndex++]; a2 = a; a = b; b = c; c = d; d = a2; } return out; } }; /** * Random values * @namespace */ const random = { /** * Generate random words with pure js, cryptographically not as strong & safe as native implementation. * @param {TypedArray} typedArray The array to fill. * @return {TypedArray} The random values. */ getRandomValues(typedArray) { const words = new Uint32Array(typedArray.buffer); const r = (m_w) => { let m_z = 0x3ade68b1; const mask = 0xffffffff; return function () { m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask; m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask; const result = ((((m_z << 0x10) + m_w) & mask) / 0x100000000) + .5; return result * (Math.random() > .5 ? 1 : -1); }; }; for (let i = 0, rcache; i < typedArray.length; i += 4) { const _r = r((rcache || Math.random()) * 0x100000000); rcache = _r() * 0x3ade67b7; words[i / 4] = (_r() * 0x100000000) | 0; } return typedArray; } }; /** @fileOverview CTR mode implementation. * * Special thanks to Roy Nicholson for pointing out a bug in our * implementation. * * @author Emily Stark * @author Mike Hamburg * @author Dan Boneh */ /** Brian Gladman's CTR Mode. * @constructor * @param {Object} _prf The aes instance to generate key. * @param {bitArray} _iv The iv for ctr mode, it must be 128 bits. */ const mode = {}; /** * Brian Gladman's CTR Mode. * @namespace */ mode.ctrGladman = class { constructor(prf, iv) { this._prf = prf; this._initIv = iv; this._iv = iv; } reset() { this._iv = this._initIv; } /** Input some data to calculate. * @param {bitArray} data the data to process, it must be intergral multiple of 128 bits unless it's the last. */ update(data) { return this.calculate(this._prf, data, this._iv); } incWord(word) { if (((word >> 24) & 0xff) === 0xff) { //overflow let b1 = (word >> 16) & 0xff; let b2 = (word >> 8) & 0xff; let b3 = word & 0xff; if (b1 === 0xff) { // overflow b1 b1 = 0; if (b2 === 0xff) { b2 = 0; if (b3 === 0xff) { b3 = 0; } else { ++b3; } } else { ++b2; } } else { ++b1; } word = 0; word += (b1 << 16); word += (b2 << 8); word += b3; } else { word += (0x01 << 24); } return word; } incCounter(counter) { if ((counter[0] = this.incWord(counter[0])) === 0) { // encr_data in fileenc.c from Dr Brian Gladman's counts only with DWORD j < 8 counter[1] = this.incWord(counter[1]); } } calculate(prf, data, iv) { let l; if (!(l = data.length)) { return []; } const bl = bitArray.bitLength(data); for (let i = 0; i < l; i += 4) { this.incCounter(iv); const e = prf.encrypt(iv); data[i] ^= e[0]; data[i + 1] ^= e[1]; data[i + 2] ^= e[2]; data[i + 3] ^= e[3]; } return bitArray.clamp(data, bl); } }; const misc = { importKey(password) { return new misc.hmacSha1(codec.bytes.toBits(password)); }, pbkdf2(prf, salt, count, length) { count = count || 10000; if (length < 0 || count < 0) { throw new Error("invalid params to pbkdf2"); } const byteLength = ((length >> 5) + 1) << 2; let u, ui, i, j, k; const arrayBuffer = new ArrayBuffer(byteLength); const out = new DataView(arrayBuffer); let outLength = 0; const b = bitArray; salt = codec.bytes.toBits(salt); for (k = 1; outLength < (byteLength || 1); k++) { u = ui = prf.encrypt(b.concat(salt, [k])); for (i = 1; i < count; i++) { ui = prf.encrypt(ui); for (j = 0; j < ui.length; j++) { u[j] ^= ui[j]; } } for (i = 0; outLength < (byteLength || 1) && i < u.length; i++) { out.setInt32(outLength, u[i]); outLength += 4; } } return arrayBuffer.slice(0, length / 8); } }; /** @fileOverview HMAC implementation. * * @author Emily Stark * @author Mike Hamburg * @author Dan Boneh */ /** HMAC with the specified hash function. * @constructor * @param {bitArray} key the key for HMAC. * @param {Object} [Hash=hash.sha1] The hash function to use. */ misc.hmacSha1 = class { constructor(key) { const hmac = this; const Hash = hmac._hash = hash.sha1; const exKey = [[], []]; hmac._baseHash = [new Hash(), new Hash()]; const bs = hmac._baseHash[0].blockSize / 32; if (key.length > bs) { key = new Hash().update(key).finalize(); } for (let i = 0; i < bs; i++) { exKey[0][i] = key[i] ^ 0x36363636; exKey[1][i] = key[i] ^ 0x5C5C5C5C; } hmac._baseHash[0].update(exKey[0]); hmac._baseHash[1].update(exKey[1]); hmac._resultHash = new Hash(hmac._baseHash[0]); } reset() { const hmac = this; hmac._resultHash = new hmac._hash(hmac._baseHash[0]); hmac._updated = false; } update(data) { const hmac = this; hmac._updated = true; hmac._resultHash.update(data); } digest() { const hmac = this; const w = hmac._resultHash.finalize(); const result = new (hmac._hash)(hmac._baseHash[1]).update(w).finalize(); hmac.reset(); return result; } encrypt(data) { if (!this._updated) { this.update(data); return this.digest(data); } else { throw new Error("encrypt on already updated hmac called!"); } } }; /* Copyright (c) 2022 Gildas Lormeau. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ const GET_RANDOM_VALUES_SUPPORTED = typeof crypto != UNDEFINED_TYPE && typeof crypto.getRandomValues == FUNCTION_TYPE; const ERR_INVALID_PASSWORD = "Invalid password"; const ERR_INVALID_SIGNATURE = "Invalid signature"; const ERR_ABORT_CHECK_PASSWORD = "zipjs-abort-check-password"; function getRandomValues(array) { if (GET_RANDOM_VALUES_SUPPORTED) { return crypto.getRandomValues(array); } else { return random.getRandomValues(array); } } /* Copyright (c) 2022 Gildas Lormeau. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ const BLOCK_LENGTH = 16; const RAW_FORMAT = "raw"; const PBKDF2_ALGORITHM = { name: "PBKDF2" }; const HASH_ALGORITHM = { name: "HMAC" }; const HASH_FUNCTION = "SHA-1"; const BASE_KEY_ALGORITHM = Object.assign({ hash: HASH_ALGORITHM }, PBKDF2_ALGORITHM); const DERIVED_BITS_ALGORITHM = Object.assign({ iterations: 1000, hash: { name: HASH_FUNCTION } }, PBKDF2_ALGORITHM); const DERIVED_BITS_USAGE = ["deriveBits"]; const SALT_LENGTH = [8, 12, 16]; const KEY_LENGTH = [16, 24, 32]; const SIGNATURE_LENGTH = 10; const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0]; // deno-lint-ignore valid-typeof const CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE; const subtle = CRYPTO_API_SUPPORTED && crypto.subtle; const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof subtle != UNDEFINED_TYPE; const codecBytes = codec.bytes; const Aes = cipher.aes; const CtrGladman = mode.ctrGladman; const HmacSha1 = misc.hmacSha1; let IMPORT_KEY_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof subtle.importKey == FUNCTION_TYPE; let DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof subtle.deriveBits == FUNCTION_TYPE; class AESDecryptionStream extends TransformStream { constructor({ password, rawPassword, signed, encryptionStrength, checkPasswordOnly }) { super({ start() { Object.assign(this, { ready: new Promise(resolve => this.resolveReady = resolve), password: encodePassword(password, rawPassword), signed, strength: encryptionStrength - 1, pending: new Uint8Array() }); }, async transform(chunk, controller) { const aesCrypto = this; const { password, strength, resolveReady, ready } = aesCrypto; if (password) { await createDecryptionKeys(aesCrypto, strength, password, subarray(chunk, 0, SALT_LENGTH[strength] + 2)); chunk = subarray(chunk, SALT_LENGTH[strength] + 2); if (checkPasswordOnly) { controller.error(new Error(ERR_ABORT_CHECK_PASSWORD)); } else { resolveReady(); } } else { await ready; } const output = new Uint8Array(chunk.length - SIGNATURE_LENGTH - ((chunk.length - SIGNATURE_LENGTH) % BLOCK_LENGTH)); controller.enqueue(append(aesCrypto, chunk, output, 0, SIGNATURE_LENGTH, true)); }, async flush(controller) { const { signed, ctr, hmac, pending, ready } = this; if (hmac && ctr) { await ready; const chunkToDecrypt = subarray(pending, 0, pending.length - SIGNATURE_LENGTH); const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH); let decryptedChunkArray = new Uint8Array(); if (chunkToDecrypt.length) { const encryptedChunk = toBits(codecBytes, chunkToDecrypt); hmac.update(encryptedChunk); const decryptedChunk = ctr.update(encryptedChunk); decryptedChunkArray = fromBits(codecBytes, decryptedChunk); } if (signed) { const signature = subarray(fromBits(codecBytes, hmac.digest()), 0, SIGNATURE_LENGTH); for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) { if (signature[indexSignature] != originalSignature[indexSignature]) { throw new Error(ERR_INVALID_SIGNATURE); } } } controller.enqueue(decryptedChunkArray); } } }); } } class AESEncryptionStream extends TransformStream { constructor({ password, rawPassword, encryptionStrength }) { // deno-lint-ignore prefer-const let stream; super({ start() { Object.assign(this, { ready: new Promise(resolve => this.resolveReady = resolve), password: encodePassword(password, rawPassword), strength: encryptionStrength - 1, pending: new Uint8Array() }); }, async transform(chunk, controller) { const aesCrypto = this; const { password, strength, resolveReady, ready } = aesCrypto; let preamble = new Uint8Array(); if (password) { preamble = await createEncryptionKeys(aesCrypto, strength, password); resolveReady(); } else { await ready; } const output = new Uint8Array(preamble.length + chunk.length - (chunk.length % BLOCK_LENGTH)); output.set(preamble, 0); controller.enqueue(append(aesCrypto, chunk, output, preamble.length, 0)); }, async flush(controller) { const { ctr, hmac, pending, ready } = this; if (hmac && ctr) { await ready; let encryptedChunkArray = new Uint8Array(); if (pending.length) { const encryptedChunk = ctr.update(toBits(codecBytes, pending)); hmac.update(encryptedChunk); encryptedChunkArray = fromBits(codecBytes, encryptedChunk); } stream.signature = fromBits(codecBytes, hmac.digest()).slice(0, SIGNATURE_LENGTH); controller.enqueue(concat(encryptedChunkArray, stream.signature)); } } }); stream = this; } } function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignature) { const { ctr, hmac, pending } = aesCrypto; const inputLength = input.length - paddingEnd; if (pending.length) { input = concat(pending, input); output = expand(output, inputLength - (inputLength % BLOCK_LENGTH)); } let offset; for (offset = 0; offset <= inputLength - BLOCK_LENGTH; offset += BLOCK_LENGTH) { const inputChunk = toBits(codecBytes, subarray(input, offset, offset + BLOCK_LENGTH)); if (verifySignature) { hmac.update(inputChunk); } const outputChunk = ctr.update(inputChunk); if (!verifySignature) { hmac.update(outputChunk); } output.set(fromBits(codecBytes, outputChunk), offset + paddingStart); } aesCrypto.pending = subarray(input, offset); return output; } async function createDecryptionKeys(decrypt, strength, password, preamble) { const passwordVerificationKey = await createKeys$1(decrypt, strength, password, subarray(preamble, 0, SALT_LENGTH[strength])); const passwordVerification = subarray(preamble, SALT_LENGTH[strength]); if (passwordVerificationKey[0] != passwordVerification[0] || passwordVerificationKey[1] != passwordVerification[1]) { throw new Error(ERR_INVALID_PASSWORD); } } async function createEncryptionKeys(encrypt, strength, password) { const salt = getRandomValues(new Uint8Array(SALT_LENGTH[strength])); const passwordVerification = await createKeys$1(encrypt, strength, password, salt); return concat(salt, passwordVerification); } async function createKeys$1(aesCrypto, strength, password, salt) { aesCrypto.password = null; const baseKey = await importKey(RAW_FORMAT, password, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE); const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), baseKey, 8 * ((KEY_LENGTH[strength] * 2) + 2)); const compositeKey = new Uint8Array(derivedBits); const key = toBits(codecBytes, subarray(compositeKey, 0, KEY_LENGTH[strength])); const authentication = toBits(codecBytes, subarray(compositeKey, KEY_LENGTH[strength], KEY_LENGTH[strength] * 2)); const passwordVerification = subarray(compositeKey, KEY_LENGTH[strength] * 2); Object.assign(aesCrypto, { keys: { key, authentication, passwordVerification }, ctr: new CtrGladman(new Aes(key), Array.from(COUNTER_DEFAULT_VALUE)), hmac: new HmacSha1(authentication) }); return passwordVerification; } async function importKey(format, password, algorithm, extractable, keyUsages) { if (IMPORT_KEY_SUPPORTED) { try { return await subtle.importKey(format, password, algorithm, extractable, keyUsages); } catch (_error) { IMPORT_KEY_SUPPORTED = false; return misc.importKey(password); } } else { return misc.importKey(password); } } async function deriveBits(algorithm, baseKey, length) { if (DERIVE_BITS_SUPPORTED) { try { return await subtle.deriveBits(algorithm, baseKey, length); } catch (_error) { DERIVE_BITS_SUPPORTED = false; return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length); } } else { return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length); } } function encodePassword(password, rawPassword) { if (rawPassword === UNDEFINED_VALUE) { return encodeText(password); } else { return rawPassword; } } function concat(leftArray, rightArray) { let array = leftArray; if (leftArray.length + rightArray.length) { array = new Uint8Array(leftArray.length + rightArray.length); array.set(leftArray, 0); array.set(rightArray, leftArray.length); } return array; } function expand(inputArray, length) { if (length && length > inputArray.length) { const array = inputArray; inputArray = new Uint8Array(length); inputArray.set(array, 0); } return inputArray; } function subarray(array, begin, end) { return array.subarray(begin, end); } function fromBits(codecBytes, chunk) { return codecBytes.fromBits(chunk); } function toBits(codecBytes, chunk) { return codecBytes.toBits(chunk); } /* Copyright (c) 2022 Gildas Lormeau. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ const HEADER_LENGTH = 12; class ZipCryptoDecryptionStream extends TransformStream { constructor({ password, passwordVerification, checkPasswordOnly }) { super({ start() { Object.assign(this, { password, passwordVerification }); createKeys(this, password); }, transform(chunk, controller) { const zipCrypto = this; if (zipCrypto.password) { const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH)); zipCrypto.password = null; if (decryptedHeader[HEADER_LENGTH - 1] != zipCrypto.passwordVerification) { throw new Error(ERR_INVALID_PASSWORD); } chunk = chunk.subarray(HEADER_LENGTH); } if (checkPasswordOnly) { controller.error(new Error(ERR_ABORT_CHECK_PASSWORD)); } else { controller.enqueue(decrypt(zipCrypto, chunk)); } } }); } } class ZipCryptoEncryptionStream extends TransformStream { constructor({ password, passwordVerification }) { super({ start() { Object.assign(this, { password, passwordVerification }); createKeys(this, password); }, transform(chunk, controller) { const zipCrypto = this; let output; let offset; if (zipCrypto.password) { zipCrypto.password = null; const header = getRandomValues(new Uint8Array(HEADER_LENGTH)); header[HEADER_LENGTH - 1] = zipCrypto.passwordVerification; output = new Uint8Array(chunk.length + header.length); output.set(encrypt(zipCrypto, header), 0); offset = HEADER_LENGTH; } else { output = new Uint8Array(chunk.length); offset = 0; } output.set(encrypt(zipCrypto, chunk), offset); controller.enqueue(output); } }); } } function decrypt(target, input) { const output = new Uint8Array(input.length); for (let index = 0; index < input.length; index++) { output[index] = getByte(target) ^ input[index]; updateKeys(target, output[index]); } return output; } function encrypt(target, input) { const output = new Uint8Array(input.length); for (let index = 0; index < input.length; index++) { output[index] = getByte(target) ^ input[index]; updateKeys(target, input[index]); } return output; } function createKeys(target, password) { const keys = [0x12345678, 0x23456789, 0x34567890]; Object.assign(target, { keys, crcKey0: new Crc32(keys[0]), crcKey2: new Crc32(keys[2]), }); for (let index = 0; index < password.length; index++) { updateKeys(target, password.charCodeAt(index)); } } function updateKeys(target, byte) { let [key0, key1, key2] = target.keys; target.crcKey0.append([byte]); key0 = ~target.crcKey0.get(); key1 = getInt32(Math.imul(getInt32(key1 + getInt8(key0)), 134775813) + 1); target.crcKey2.append([key1 >>> 24]); key2 = ~target.crcKey2.get(); target.keys = [key0, key1, key2]; } function getByte(target) { const temp = target.keys[2] | 2; return getInt8(Math.imul(temp, (temp ^ 1)) >>> 8); } function getInt8(number) { return number & 0xFF; } function getInt32(number) { return number & 0xFFFFFFFF; } /* Copyright (c) 2022 Gildas Lormeau. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ const COMPRESSION_FORMAT = "deflate-raw"; class DeflateStream extends TransformStream { constructor(options, { chunkSize, CompressionStream, CompressionStreamNative }) { super({}); const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level } = options; const stream = this; let crc32Stream, encryptionStream; let readable = filterEmptyChunks(super.readable); if ((!encrypted || zipCrypto) && signed) { crc32Stream = new Crc32Stream(); readable = pipeThrough(readable, crc32Stream); } if (compressed) { readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStreamNative, CompressionStream); } if (encrypted) { if (zipCrypto) { readable = pipeThrough(readable, new ZipCryptoEncryptionStream(options)); } else { encryptionStream = new AESEncryptionStream(options); readable = pipeThrough(readable, encryptionStream); } } setReadable(stream, readable, () => { let signature; if (encrypted && !zipCrypto) { signature = encryptionStream.signature; } if ((!encrypted || zipCrypto) && signed) { signature = new DataView(crc32Stream.value.buffer).getUint32(0); } stream.signature = signature; }); } } class InflateStream extends TransformStream { constructor(options, { chunkSize, DecompressionStream, DecompressionStreamNative }) { super({}); const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream } = options; let crc32Stream, decryptionStream; let readable = filterEmptyChunks(super.readable); if (encrypted) { if (zipCrypto) { readable = pipeThrough(readable, new ZipCryptoDecryptionStream(options)); } else { decryptionStream = new AESDecryptionStream(options); readable = pipeThrough(readable, decryptionStream); } } if (compressed) { readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize }, DecompressionStreamNative, DecompressionStream); } if ((!encrypted || zipCrypto) && signed) { crc32Stream = new Crc32Stream(); readable = pipeThrough(readable, crc32Stream); } setReadable(this, readable, () => { if ((!encrypted || zipCrypto) && signed) { const dataViewSignature = new DataView(crc32Stream.value.buffer); if (signature != dataViewSignature.getUint32(0, false)) { throw new Error(ERR_INVALID_SIGNATURE); } } }); } } function filterEmptyChunks(readable) { return pipeThrough(readable, new TransformStream({ transform(chunk, controller) { if (chunk && chunk.length) { controller.enqueue(chunk); } } })); } function setReadable(stream, readable, flush) { readable = pipeThrough(readable, new TransformStream({ flush })); Object.defineProperty(stream, "readable", { get() { return readable; } }); } function pipeThroughCommpressionStream(readable, useCompressionStream, options, CodecStreamNative, CodecStream) { try { const CompressionStream = useCompressionStream && CodecStreamNative ? CodecStreamNative : CodecStream; readable = pipeThrough(readable, new CompressionStream(COMPRESSION_FORMAT, options)); } catch (error) { if (useCompressionStream) { try { readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options)); } catch (error) { return readable; } } else { return readable; } } return readable; } function pipeThrough(readable, transformStream) { return readable.pipeThrough(transformStream); } /* Copyright (c) 2022 Gildas Lormeau. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ const MESSAGE_EVENT_TYPE = "message"; const MESSAGE_START = "start"; const MESSAGE_PULL = "pull"; const MESSAGE_DATA = "data"; const MESSAGE_ACK_DATA = "ack"; const MESSAGE_CLOSE = "close"; const CODEC_DEFLATE = "deflate"; const CODEC_INFLATE = "inflate"; class CodecStream extends TransformStream { constructor(options, config) { super({}); const codec = this; const { codecType } = options; let Stream; if (codecType.startsWith(CODEC_DEFLATE)) { Stream = DeflateStream; } else if (codecType.startsWith(CODEC_INFLATE)) { Stream = InflateStream; } let outputSize = 0; let inputSize = 0; const stream = new Stream(options, config); const readable = super.readable; const inputSizeStream = new TransformStream({ transform(chunk, controller) { if (chunk && chunk.length) { inputSize += chunk.length; controller.enqueue(chunk); } }, flush() { Object.assign(codec, { inputSize }); } }); const outputSizeStream = new TransformStream({ transform(chunk, controller) { if (chunk && chunk.length) { outputSize += chunk.length; controller.enqueue(chunk); } }, flush() { const { signature } = stream; Object.assign(codec, { signature, outputSize, inputSize }); } }); Object.defineProperty(codec, "readable", { get() { return readable.pipeThrough(inputSizeStream).pipeThrough(stream).pipeThrough(outputSizeStream); } }); } } class ChunkStream extends TransformStream { constructor(chunkSize) { let pendingChunk; super({ transform, flush(controller) { if (pendingChunk && pendingChunk.length) { controller.enqueue(pendingChunk); } } }); function transform(chunk, controller) { if (pendingChunk) { const newChunk = new Uint8Array(pendingChunk.length + chunk.length); newChunk.set(pendingChunk); newChunk.set(chunk, pendingChunk.length); chunk = newChunk; pendingChunk = null; } if (chunk.length > chunkSize) { controller.enqueue(chunk.slice(0, chunkSize)); transform(chunk.slice(chunkSize), controller); } else { pendingChunk = chunk; } } } } /* Copyright (c) 2022 Gildas Lormeau. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ // deno-lint-ignore valid-typeof let WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE; class CodecWorker { constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, scripts }, onTaskFinished) { const { signal } = streamOptions; Object.assign(workerData, { busy: true, readable: readable .pipeThrough(new ChunkStream(config.chunkSize)) .pipeThrough(new ProgressWatcherStream(readable, streamOptions), { signal }), writable, options: Object.assign({}, options), scripts, transferStreams, terminate() { return new Promise(resolve => { const { worker, busy } = workerData; if (worker) { if (busy) { workerData.resolveTerminated = resolve; } else { worker.terminate(); resolve(); } workerData.interface = null; } else { resolve(); } }); }, onTaskFinished() { const { resolveTerminated } = workerData; if (resolveTerminated) { workerData.resolveTerminated = null; workerData.terminated = true; workerData.worker.terminate(); resolveTerminated(); } workerData.busy = false; onTaskFinished(workerData); } }); return (useWebWorkers && WEB_WORKERS_SUPPORTED ? createWebWorkerInterface : createWorkerInterface)(workerData, config); } } class ProgressWatcherStream extends TransformStream { constructor(readableSource, { onstart, onprogress, size, onend }) { let chunkOffset = 0; super({ async start() { if (onstart) { await callHandler(onstart, size); } }, async transform(chunk, controller) { chunkOffset += chunk.length; if (onprogress) { await callHandler(onprogress, chunkOffset, size); } controller.enqueue(chunk); }, async flush() { readableSource.size = chunkOffset; if (onend) { await callHandler(onend, chunkOffset); } } }); } } async function callHandler(handler, ...parameters) { try { await handler(...parameters); } catch (_error) { // ignored } } function createWorkerInterface(workerData, config) { return { run: () => runWorker$1(workerData, config) }; } function createWebWorkerInterface(workerData, config) { const { baseURL, chunkSize } = config; if (!workerData.interface) { let worker; try { worker = getWebWorker(workerData.scripts[0], baseURL, workerData); } catch (error) { WEB_WORKERS_SUPPORTED = false; return createWorkerInterface(workerData, config); } Object.assign(workerData, { worker, interface: { run: () => runWebWorker(workerData, { chunkSize }) } }); } return workerData.interface; } async function runWorker$1({ options, readable, writable, onTaskFinished }, config) { try { const codecStream = new CodecStream(options, config); await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true }); const { signature, inputSize, outputSize } = codecStream; return { signature, inputSize, outputSize }; } finally { onTaskFinished(); } } async function runWebWorker(workerData, config) { let resolveResult, rejectResult; const result = new Promise((resolve, reject) => { resolveResult = resolve; rejectResult = reject; }); Object.assign(workerData, { reader: null, writer: null, resolveResult, rejectResult, result }); const { readable, options, scripts } = workerData; const { writable, closed } = watchClosedStream(workerData.writable); const streamsTransferred = sendMessage({ type: MESSAGE_START, scripts: scripts.slice(1), options, config, readable, writable }, workerData); if (!streamsTransferred) { Object.assign(workerData, { reader: readable.getReader(), writer: writable.getWriter() }); } const resultValue = await result; if (!streamsTransferred) { await writable.getWriter().close(); } await closed; return resultValue; } function watchClosedStream(writableSource) { let resolveStreamClosed; const closed = new Promise(resolve => resolveStreamClosed = resolve); const writable = new WritableStream({ async write(chunk) { const writer = writableSource.getWriter(); await writer.ready; await writer.write(chunk); writer.releaseLock(); }, close() { resolveStreamClosed(); }, abort(reason) { const writer = writableSource.getWriter(); return writer.abort(reason); } }); return { writable, closed }; } let classicWorkersSupported = true; let transferStreamsSupported = true; function getWebWorker(url, baseURL, workerData) { const workerOptions = { type: "module" }; let scriptUrl, worker; // deno-lint-ignore valid-typeof if (typeof url == FUNCTION_TYPE) { url = url(); } try { scriptUrl = new URL(url, baseURL); } catch (_error) { scriptUrl = url; } if (classicWorkersSupported) { try { worker = new Worker(scriptUrl); } catch (_error) { classicWorkersSupported = false; worker = new Worker(scriptUrl, workerOptions); } } else { worker = new Worker(scriptUrl, workerOptions); } worker.addEventListener(MESSAGE_EVENT_TYPE, event => onMessage(event, workerData)); return worker; } function sendMessage(message, { worker, writer, onTaskFinished, transferStreams }) { try { let { value, readable, writable } = message; const transferables = []; if (value) { if (value.byteLength < value.buffer.byteLength) { message.value = value.buffer.slice(0, value.byteLength); } else { message.value = value.buffer; } transferables.push(message.value); } if (transferStreams && transferStreamsSupported) { if (readable) { transferables.push(readable); } if (writable) { transferables.push(writable); } } else { message.readable = message.writable = null; } if (transferables.length) { try { worker.postMessage(message, transferables); return true; } catch (_error) { transferStreamsSupported = false; message.readable = message.writable = null; worker.postMessage(message); } } else { worker.postMessage(message); } } catch (error) { if (writer) { writer.releaseLock(); } onTaskFinished(); throw error; } } async function onMessage({ data }, workerData) { const { type, value, messageId, result, error } = data; const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData; try { if (error) { const { message, stack, code, name } = error; const responseError = new Error(message); Object.assign(responseError, { stack, code, name }); close(responseError); } else { if (type == MESSAGE_PULL) { const { value, done } = await reader.read(); sendMessage({ type: MESSAGE_DATA, value, done, messageId }, workerData); } if (type == MESSAGE_DATA) { await writer.ready; await writer.write(new Uint8Array(value)); sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData); } if (type == MESSAGE_CLOSE) { close(null, result); } } } catch (error) { sendMessage({ type: MESSAGE_CLOSE, messageId }, workerData); close(error); } function close(error, result) { if (error) { rejectResult(error); } else { resolveResult(result); } if (writer) { writer.releaseLock(); } onTaskFinished(); } } /* Copyright (c) 2022 Gildas Lormeau. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ let pool = []; const pendingRequests = []; let indexWorker = 0; async function runWorker(stream, workerOptions) { const { options, config } = workerOptions; const { transferStreams, useWebWorkers, useCompressionStream, codecType, compressed, signed, encrypted } = options; const { workerScripts, maxWorkers } = config; workerOptions.transferStreams = transferStreams || transferStreams === UNDEFINED_VALUE; const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams; workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers)); workerOptions.scripts = workerOptions.useWebWorkers && workerScripts ? workerScripts[codecType] : []; options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream); return (await getWorker()).run(); async function getWorker() { const workerData = pool.find(workerData => !workerData.busy); if (workerData) { clearTerminateTimeout(workerData); return new CodecWorker(workerData, stream, workerOptions, onTaskFinished); } else if (pool.length < maxWorkers) { const workerData = { indexWorker }; indexWorker++; pool.push(workerData); return new CodecWorker(workerData, stream, workerOptions, onTaskFinished); } else { return new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions })); } } function onTaskFinished(workerData) { if (pendingRequests.length) { const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1); resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished)); } else if (workerData.worker) { clearTerminateTimeout(workerData); terminateWorker(workerData, workerOptions); } else { pool = pool.filter(data => data != workerData); } } } function terminateWorker(workerData, workerOptions) { const { config } = workerOptions; const { terminateWorkerTimeout } = config; if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) { if (workerData.terminated) { workerData.terminated = false; } else { workerData.terminateTimeout = setTimeout(async () => { pool = pool.filter(data => data != workerData); try { await workerData.terminate(); } catch (_error) { // ignored } }, terminateWorkerTimeout); } } } function clearTerminateTimeout(workerData) { const { terminateTimeout } = workerData; if (terminateTimeout) { clearTimeout(terminateTimeout); workerData.terminateTimeout = null; } } function e(e){const t=()=>URL.createObjectURL(new Blob(['const{Array:e,Object:t,Number:n,Math:r,Error:s,Uint8Array:i,Uint16Array:o,Uint32Array:c,Int32Array:f,Map:a,DataView:l,Promise:u,TextEncoder:w,crypto:h,postMessage:d,TransformStream:p,ReadableStream:y,WritableStream:m,CompressionStream:b,DecompressionStream:g}=self,k=void 0,v="undefined",S="function";class z{constructor(e){return class extends p{constructor(t,n){const r=new e(n);super({transform(e,t){t.enqueue(r.append(e))},flush(e){const t=r.flush();t&&e.enqueue(t)}})}}}}const C=[];for(let e=0;256>e;e++){let t=e;for(let e=0;8>e;e++)1&t?t=t>>>1^3988292384:t>>>=1;C[e]=t}class x{constructor(e){this.t=e||-1}append(e){let t=0|this.t;for(let n=0,r=0|e.length;r>n;n++)t=t>>>8^C[255&(t^e[n])];this.t=t}get(){return~this.t}}class A extends p{constructor(){let e;const t=new x;super({transform(e,n){t.append(e),n.enqueue(e)},flush(){const n=new i(4);new l(n.buffer).setUint32(0,t.get()),e.value=n}}),e=this}}const _={concat(e,t){if(0===e.length||0===t.length)return e.concat(t);const n=e[e.length-1],r=_.i(n);return 32===r?e.concat(t):_.o(t,r,0|n,e.slice(0,e.length-1))},l(e){const t=e.length;if(0===t)return 0;const n=e[t-1];return 32*(t-1)+_.i(n)},u(e,t){if(32*e.length
Exclude URL|Site
✖
-
${workURLs.map((r, index) => `
- ${r} `).join("")}
Custom Keyboard
✖
${Object.entries(keyboardEvents.inMain).map(([id]) => `
`).join("")}
${i18n.keyboardCustom.inMain[id].get()}
${Object.entries(keyboardEvents.inFullViewGrid).map(([id]) => `
`).join("")}
${i18n.keyboardCustom.inFullViewGrid[id].get()}
${Object.entries(keyboardEvents.inBigImageMode).map(([id]) => `
`).join("")}
${i18n.keyboardCustom.inBigImageMode[id].get()}
${i18n.help.get()}
`;
guideElement.classList.add("ehvp-full-panel");
guideElement.setAttribute("style", `align-items: center; color: black; text-align: left;`);
guideElement.addEventListener("click", () => guideElement.remove());
if (HTML.root.classList.contains("ehvp-root-collapse")) {
document.body.after(guideElement);
} else {
HTML.root.appendChild(guideElement);
}
}
function showKeyboardCustomEvent() {
createKeyboardCustomPanel(keyboardEvents, HTML.root);
}
function showExcludeURLEvent() {
createExcludeURLPanel(HTML.root);
}
const signal = { first: true };
function main(expand) {
if (HTML.pageHelper) {
if (expand && !HTML.pageHelper.classList.contains("p-helper-extend")) {
HTML.pageHelper.classList.add("p-helper-extend");
showFullViewGrid();
if (signal.first) {
signal.first = false;
PF.init();
}
} else {
HTML.pageHelper.classList.remove("p-helper-extend");
["config", "downloader"].forEach((id) => togglePanelEvent(id, true));
hiddenFullViewGrid();
}
}
}
return {
main,
modNumberConfigEvent,
modBooleanConfigEvent,
modSelectConfigEvent,
modPageHelperPostion,
togglePanelEvent,
showFullViewGrid,
hiddenFullViewGridEvent,
hiddenFullViewGrid,
scrollEvent,
fullViewGridKeyBoardEvent,
bigImageFrameKeyBoardEvent,
keyboardEvent,
showGuideEvent,
collapsePanelEvent,
abortMouseleavePanelEvent,
showKeyboardCustomEvent,
showExcludeURLEvent
};
}
class FullViewGridManager {
root;
// renderRangeRecord: [number, number] = [0, 0];
queue = [];
done = false;
chapterIndex = 0;
constructor(HTML, BIFM) {
this.root = HTML.fullViewGrid;
EBUS.subscribe("pf-on-appended", (_total, nodes, done) => {
this.append(nodes);
this.done = done || false;
setTimeout(() => this.renderCurrView(), 200);
});
EBUS.subscribe("pf-change-chapter", (index) => {
this.chapterIndex = Math.max(0, index);
this.root.innerHTML = "";
this.queue = [];
this.done = false;
});
EBUS.subscribe("ifq-do", (_, imf) => {
if (!BIFM.visible)
return;
if (imf.chapterIndex !== this.chapterIndex)
return;
if (!imf.node.root)
return;
let scrollTo = imf.node.root.offsetTop - window.screen.availHeight / 3;
scrollTo = scrollTo <= 0 ? 0 : scrollTo >= this.root.scrollHeight ? this.root.scrollHeight : scrollTo;
if (this.root.scrollTo.toString().includes("[native code]")) {
this.root.scrollTo({ top: scrollTo, behavior: "smooth" });
} else {
this.root.scrollTop = scrollTo;
}
});
}
append(nodes) {
if (nodes.length > 0) {
const list = nodes.map((n) => {
return {
node: n,
element: n.create()
};
});
this.queue.push(...list);
this.root.append(...list.map((l) => l.element));
}
}
tryExtend() {
if (this.done)
return;
const nodes = Array.from(this.root.childNodes);
if (nodes.length === 0)
return;
const lastImgNode = nodes[nodes.length - 1];
const viewButtom = this.root.scrollTop + this.root.clientHeight;
if (viewButtom + this.root.clientHeight * 2.5 < lastImgNode.offsetTop + lastImgNode.offsetHeight) {
return;
}
EBUS.emit("pf-try-extend");
}
/**
* 当滚动停止时，检查当前显示的页面上的是什么元素，然后渲染图片
*/
renderCurrView() {
const [scrollTop, clientHeight] = [this.root.scrollTop, this.root.clientHeight];
const [start, end] = this.findOutsideRoundView(scrollTop, clientHeight);
this.queue.slice(start, end + 1 + conf.colCount).forEach((e) => e.node.render());
}
findOutsideRoundView(currTop, clientHeight) {
const viewButtom = currTop + clientHeight;
let outsideTop = 0;
let outsideBottom = 0;
for (let i = 0; i < this.queue.length; i += conf.colCount) {
const element = this.queue[i].element;
if (outsideBottom === 0) {
if (element.offsetTop + 2 >= currTop) {
outsideBottom = i + 1;
} else {
outsideTop = i;
}
} else {
outsideBottom = i;
if (element.offsetTop + element.offsetHeight > viewButtom) {
break;
}
}
}
return [outsideTop, Math.min(outsideBottom + conf.colCount, this.queue.length - 1)];
}
}
function dragElement(element, dragHub, callback) {
(dragHub ?? element).addEventListener("mousedown", (event) => {
event.preventDefault();
const wh = window.innerHeight;
const ww = window.innerWidth;
const mouseMove = (event2) => {
event2.preventDefault();
const mouseX = event2.clientX;
const mouseY = event2.clientY;
if (mouseY <= wh / 2) {
element.style.top = Math.max(mouseY, 5) + "px";
element.style.bottom = "unset";
} else {
element.style.bottom = Math.max(wh - mouseY - element.clientHeight, 5) + "px";
element.style.top = "unset";
}
if (mouseX <= ww / 2) {
element.style.left = Math.max(mouseX, 5) + "px";
element.style.right = "unset";
} else {
element.style.right = Math.max(ww - mouseX - element.clientWidth, 5) + "px";
element.style.left = "unset";
}
console.log("drag element: offset top: ", element.style.top, "offset left: ", element.style.left, "offset bottom: ", element.style.bottom, "offset right: ", element.style.right);
};
document.addEventListener("mousemove", mouseMove);
document.addEventListener("mouseup", () => {
document.removeEventListener("mousemove", mouseMove);
callback?.(element.offsetTop, element.offsetLeft);
}, { once: true });
});
}
function createOption(item) {
const i18nKey = item.i18nKey || item.key;
const i18nValue = i18n[i18nKey];
const i18nValueTooltip = i18n[`${i18nKey}Tooltip`];
if (!i18nValue) {
throw new Error(`i18n key ${i18nKey} not found`);
}
let display = true;
if (item.displayInSite) {
display = item.displayInSite.test(location.href);
}
let input = "";
switch (item.typ) {
case "boolean":
input = ``;
break;
case "number":
input = `
`;
break;
case "select":
if (!item.options) {
throw new Error(`options for ${item.key} not found`);
}
const optionsStr = item.options.map((o) => ``).join("");
input = ``;
break;
}
const [start, end] = item.gridColumnRange ? item.gridColumnRange : [1, 11];
return ``;
}
function createHTML() {
const fullViewGrid = document.createElement("div");
fullViewGrid.classList.add("ehvp-root");
fullViewGrid.classList.add("ehvp-root-collapse");
document.body.after(fullViewGrid);
const configItemStr = ConfigItems.map(createOption).join("");
const HTML_STRINGS = `
${configItemStr}
${i18n.showHelp.get()}
${i18n.showKeyboard.get()}
${i18n.showExcludes.get()}
${i18n.letUsStar.get()}
${i18n.imageScale.get()}:
${conf.imgScale}%
-
+
RESET
⋖📖
${i18n.config.get()}
${i18n.download.get()}
1/0/FIN:0
${i18n.autoPagePlay.get()}
${i18n.collapse.get()}
⋗
${i18n.backChapters.get()}
`;
this.frame.appendChild(lockEle);
const ani = lockEle.children[0].animate([{ width: "30vw" }, { width: "0vw" }], { duration: conf.preventScrollPageTime });
this.preventStep = { ele: lockEle, ani, fin: false };
ani.onfinish = () => this.resetPreventStep(true);
ani.oncancel = () => this.resetPreventStep(true);
}
return true;
}
}
isReachedBoundary(oriented) {
if (oriented === "prev") {
return this.frame.scrollTop <= 0;
}
if (oriented === "next") {
return this.frame.scrollTop >= this.frame.scrollHeight - this.frame.offsetHeight;
}
return false;
}
consecutive() {
this.throttler.addEvent("SCROLL", () => {
this.debouncer.addEvent("REDUCE", () => {
if (!this.elements.curr[0])
return;
const distance2 = this.getRealOffsetTop(this.elements.curr[0]) - this.frame.scrollTop;
if (this.tryReduce()) {
this.restoreScrollTop(this.elements.curr[0], distance2);
}
}, 500);
let mediaNodes = this.getMediaNodes();
let index = this.findMediaNodeIndexOnCenter(mediaNodes);
const centerNode = mediaNodes[index];
if (this.elements.curr[0] !== centerNode) {
const oldIndex = parseIndex(this.elements.curr[0]);
const newIndex = parseIndex(centerNode);
const oriented = oldIndex < newIndex ? "next" : "prev";
const queue = this.getChapter(this.chapterIndex).queue;
if (queue.length === 0 || newIndex < 0 || newIndex > queue.length - 1)
return;
const imf = queue[newIndex];
EBUS.emit("ifq-do", newIndex, imf, oriented);
if (this.elements.curr[0] instanceof HTMLVideoElement) {
this.elements.curr[0].pause();
}
this.tryPlayVideo(centerNode);
}
this.elements.curr[0] = centerNode;
const distance = this.getRealOffsetTop(this.elements.curr[0]) - this.frame.scrollTop;
if (this.tryExtend() > 0) {
this.restoreScrollTop(this.elements.curr[0], distance);
}
}, 60);
}
restoreScrollTop(imgNode, distance) {
this.frame.scrollTop = this.getRealOffsetTop(imgNode) - distance;
}
getRealOffsetTop(imgNode) {
return imgNode.offsetTop;
}
tryExtend() {
let indexOffset = 0;
let mediaNodes = [];
let scrollTopFix = 0;
while (true) {
mediaNodes = this.getMediaNodes();
const frist = mediaNodes[0];
if (frist.offsetTop + frist.offsetHeight > this.frame.scrollTop + scrollTopFix) {
const extended = this.extendImgNode(frist, "prev");
if (extended === null) {
break;
} else {
scrollTopFix += extended.offsetHeight;
}
indexOffset++;
} else {
break;
}
}
while (true) {
mediaNodes = this.getMediaNodes();
const last = mediaNodes[mediaNodes.length - 1];
if (last.offsetTop < this.frame.scrollTop + this.frame.offsetHeight) {
if (this.extendImgNode(last, "next") === null)
break;
} else {
break;
}
}
return indexOffset;
}
tryReduce() {
const imgNodes = this.getMediaNodes();
const shouldRemoveNodes = [];
let oriented = "prev";
for (const imgNode of imgNodes) {
if (oriented === "prev") {
if (imgNode.offsetTop + imgNode.offsetHeight < this.frame.scrollTop) {
shouldRemoveNodes.push(imgNode);
} else {
oriented = "next";
shouldRemoveNodes.pop();
}
} else if (oriented === "next") {
if (imgNode.offsetTop > this.frame.scrollTop + this.frame.offsetHeight) {
oriented = "remove";
}
} else {
shouldRemoveNodes.push(imgNode);
}
}
if (shouldRemoveNodes.length === 0)
return false;
for (const imgNode of shouldRemoveNodes) {
imgNode.remove();
}
return true;
}
extendImgNode(mediaNode, oriented) {
let extendedNode;
const index = parseInt(mediaNode.getAttribute("d-index"));
if (isNaN(index)) {
throw new Error("BIFM: extendImgNode: media node index is NaN");
}
const queue = this.getChapter(this.chapterIndex).queue;
if (queue.length === 0)
return null;
if (oriented === "prev") {
if (index === 0)
return null;
extendedNode = this.newMediaNode(index - 1, queue[index - 1]);
mediaNode.before(extendedNode);
} else {
if (index === queue.length - 1)
return null;
extendedNode = this.newMediaNode(index + 1, queue[index + 1]);
mediaNode.after(extendedNode);
}
return extendedNode;
}
newMediaNode(index, imf) {
if (!imf)
throw new Error("BIFM: newMediaNode: img fetcher is null");
if (imf.contentType?.startsWith("video")) {
const vid = document.createElement("video");
vid.classList.add("bifm-img");
vid.classList.add("bifm-vid");
vid.setAttribute("d-index", index.toString());
vid.onloadeddata = () => {
if (this.visible && vid === this.elements.curr[0]) {
this.tryPlayVideo(vid);
}
};
vid.src = imf.blobUrl;
return vid;
} else {
const img = document.createElement("img");
img.decoding = "sync";
img.classList.add("bifm-img");
img.setAttribute("d-index", index.toString());
if (imf.stage === FetchState.DONE) {
img.src = imf.blobUrl;
} else {
img.src = imf.node.src;
}
return img;
}
}
tryPlayVideo(vid) {
if (vid instanceof HTMLVideoElement) {
if (!this.vidController) {
this.vidController = new VideoControl(this.html.root);
}
this.vidController.attach(vid);
} else {
this.vidController?.hidden();
}
}
/**
* @param fix: 1 or -1, means scale up or down
* @param rate: step of scale, eg: current scale is 80, rate is 10, then new scale is 90
* @param _percent: directly set width percent
*/
scaleBigImages(fix, rate, _percent) {
const rule = queryCSSRules(this.html.styleSheel, ".bifm-img");
if (!rule)
return 0;
let percent = _percent || parseInt(conf.readMode === "pagination" ? rule.style.height : rule.style.width);
if (isNaN(percent))
percent = 100;
percent = percent + rate * fix;
switch (conf.readMode) {
case "pagination":
percent = Math.max(percent, 100);
percent = Math.min(percent, 300);
rule.style.height = `${percent}vh`;
break;
case "continuous":
percent = Math.max(percent, 20);
percent = Math.min(percent, 100);
rule.style.width = `${percent}vw`;
break;
}
if (conf.readMode === "pagination") {
this.checkFrameOverflow();
rule.style.minWidth = percent > 100 ? "" : "100vw";
if (percent === 100) {
this.resetScaleBigImages(true);
return 100;
}
}
conf.imgScale = percent;
saveConf(conf);
this.flushImgScaleBar();
return percent;
}
checkFrameOverflow() {
const flexRule = queryCSSRules(this.html.styleSheel, ".bifm-flex");
if (flexRule) {
if (this.frame.offsetWidth < this.frame.scrollWidth) {
flexRule.style.justifyContent = "flex-start";
} else {
flexRule.style.justifyContent = "center";
}
}
}
resetScaleBigImages(syncConf) {
const rule = queryCSSRules(this.html.styleSheel, ".bifm-img");
if (!rule)
return;
rule.style.minWidth = "";
rule.style.minHeight = "";
rule.style.maxWidth = "";
rule.style.maxHeight = "";
rule.style.height = "";
rule.style.width = "";
rule.style.margin = "";
if (conf.readMode === "pagination") {
rule.style.height = "100vh";
rule.style.margin = "0";
if (conf.paginationIMGCount === 1)
rule.style.minWidth = "100vw";
} else {
const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Mobile/i.test(navigator.userAgent);
rule.style.maxWidth = "100vw";
rule.style.width = isMobile ? "100vw" : "80vw";
rule.style.margin = "0 auto";
}
if (syncConf) {
conf.imgScale = 0;
saveConf(conf);
}
this.flushImgScaleBar();
}
initImgScaleStyle() {
this.resetScaleBigImages(false);
if (conf.imgScale && conf.imgScale > 0) {
this.scaleBigImages(1, 0, conf.imgScale);
}
}
stickyMouse(event, lastMouse) {
if (conf.readMode !== "pagination" || conf.stickyMouse === "disable")
return;
let [distanceY, distanceX] = [event.clientY - lastMouse.y, event.clientX - lastMouse.x];
if (conf.stickyMouse === "enable")
[distanceY, distanceX] = [-distanceY, -distanceX];
const overflowY = this.frame.scrollHeight - this.frame.offsetHeight;
if (overflowY > 0) {
const rateY = overflowY / (this.frame.offsetHeight / 4) * 3;
let scrollTop = this.frame.scrollTop + distanceY * rateY;
scrollTop = Math.max(scrollTop, 0);
scrollTop = Math.min(scrollTop, overflowY);
this.frame.scrollTop = scrollTop;
}
const overflowX = this.frame.scrollWidth - this.frame.offsetWidth;
if (overflowX > 0) {
const rateX = overflowX / (this.frame.offsetWidth / 4) * 3;
let scrollLeft = this.frame.scrollLeft + distanceX * rateX;
if (conf.reversePages) {
scrollLeft = Math.min(scrollLeft, 0);
scrollLeft = Math.max(scrollLeft, -overflowX);
} else {
scrollLeft = Math.max(scrollLeft, 0);
scrollLeft = Math.min(scrollLeft, overflowX);
}
this.frame.scrollLeft = scrollLeft;
}
}
findMediaNodeIndexOnCenter(imgNodes) {
const centerLine = this.frame.offsetHeight / 2;
for (let i = 0; i < imgNodes.length; i++) {
const imgNode = imgNodes[i];
const realOffsetTop = imgNode.offsetTop - this.frame.scrollTop;
if (realOffsetTop < centerLine && realOffsetTop + imgNode.offsetHeight >= centerLine) {
return i;
}
}
return 0;
}
}
class AutoPage {
bifm;
status;
button;
lockVer;
restart;
constructor(BIFM, root) {
this.bifm = BIFM;
this.status = "stop";
this.button = root;
this.lockVer = 0;
this.restart = false;
this.bifm.callbackOnWheel = () => {
if (this.status === "running") {
this.stop();
this.start(this.lockVer);
}
};
EBUS.subscribe("bifm-on-hidden", () => this.stop());
EBUS.subscribe("bifm-on-show", () => conf.autoPlay && this.start(this.lockVer));
this.initPlayButton();
}
initPlayButton() {
this.button.addEventListener("click", () => {
if (this.status === "stop") {
this.start(this.lockVer);
} else {
this.stop();
}
});
}
async start(lockVer) {
this.status = "running";
this.button.firstElementChild.innerText = i18n.autoPagePause.get();
const b = this.bifm.frame;
if (this.bifm.frame.classList.contains("big-img-frame-collapse")) {
const queue = this.bifm.getChapter(this.bifm.chapterIndex).queue;
if (queue.length === 0)
return;
const index = Math.max(parseIndex(this.bifm.elements.curr[0]), 0);
this.bifm.show(queue[index]);
}
const progress = q("#auto-page-progress", this.button);
while (true) {
await sleep(10);
progress.style.animation = `${conf.autoPageInterval ?? 1e4}ms linear main-progress`;
await sleep(conf.autoPageInterval ?? 1e4);
if (this.lockVer !== lockVer) {
return;
}
if (this.restart) {
this.restart = false;
continue;
}
progress.style.animation = ``;
if (this.status !== "running") {
break;
}
if (this.bifm.elements.curr.length === 0)
break;
const index = parseInt(this.bifm.elements.curr[0]?.getAttribute("d-index"));
const queue = this.bifm.getChapter(this.bifm.chapterIndex).queue;
if (index < 0 || index >= queue.length)
break;
const deltaY = this.bifm.frame.offsetHeight / 2;
if (this.bifm.isReachedBoundary("next")) {
this.bifm.onWheel(new WheelEvent("wheel", { deltaY }), false, true);
if (conf.readMode === "pagination")
continue;
}
b.scrollBy({ top: deltaY, behavior: "smooth" });
}
this.stop();
}
stop() {
this.status = "stop";
const progress = q("#auto-page-progress", this.button);
progress.style.animation = ``;
this.lockVer += 1;
this.button.firstElementChild.innerText = i18n.autoPagePlay.get();
}
}
function parseIndex(ele) {
if (!ele)
return -1;
const d = ele.getAttribute("d-index") || "";
const i = parseInt(d);
return isNaN(i) ? -1 : i;
}
function revertMonkeyPatch(element) {
const originalScrollTo = Element.prototype.scrollTo;
Object.defineProperty(element, "scrollTo", {
value: originalScrollTo,
writable: true,
configurable: true
});
}
function main(MATCHER) {
const HTML = createHTML();
[HTML.fullViewGrid, HTML.bigImageFrame].forEach((e) => revertMonkeyPatch(e));
const IFQ = IMGFetcherQueue.newQueue();
const IL = new IdleLoader(IFQ);
const PF = new PageFetcher(IFQ, MATCHER);
const DL = new Downloader(HTML, IFQ, IL, PF, MATCHER);
const PH = new PageHelper(HTML, (index) => PF.chapters[index]);
const BIFM = new BigImageFrameManager(HTML, (index) => PF.chapters[index]);
const FVGM = new FullViewGridManager(HTML, BIFM);
const events = initEvents(HTML, BIFM, FVGM, IFQ, PF, IL, PH);
addEventListeners(events, HTML, BIFM, DL);
EBUS.subscribe("downloader-canvas-on-click", (index) => {
IFQ.currIndex = index;
if (IFQ.chapterIndex !== BIFM.chapterIndex)
return;
BIFM.show(IFQ[index]);
});
PF.beforeInit = () => HTML.pageLoading.style.display = "flex";
PF.afterInit = () => {
HTML.pageLoading.style.display = "none";
IL.processingIndexList = [0];
IL.start();
};
if (conf["first"]) {
events.showGuideEvent();
conf["first"] = false;
saveConf(conf);
}
if (conf.autoOpen)
events.main(true);
return () => {
console.log("destory eh-view-enhance");
PF.abort();
IL.abort();
IFQ.length = 0;
EBUS.reset();
HTML.root.remove();
return sleep(500);
};
}
(() => {
let oldPushState = history.pushState;
history.pushState = function pushState(...args) {
let ret = oldPushState.apply(this, args);
window.dispatchEvent(new Event("pushstate"));
window.dispatchEvent(new Event("locationchange"));
return ret;
};
let oldReplaceState = history.replaceState;
history.replaceState = function replaceState(...args) {
let ret = oldReplaceState.apply(this, args);
window.dispatchEvent(new Event("replacestate"));
window.dispatchEvent(new Event("locationchange"));
return ret;
};
window.addEventListener("popstate", () => {
window.dispatchEvent(new Event("locationchange"));
});
})();
let destoryFunc;
const debouncer = new Debouncer();
window.addEventListener("locationchange", () => {
debouncer.addEvent("LOCATION-CHANGE", () => {
const newStart = () => {
if (document.querySelector(".ehvp-root"))
return;
const matcher2 = adaptMatcher(window.location.href);
matcher2 && (destoryFunc = main(matcher2));
};
if (destoryFunc) {
console.log("locationchange");
destoryFunc().then(newStart);
} else {
newStart();
}
}, 10);
});
const matcher = adaptMatcher(window.location.href);
if (matcher !== null) {
destoryFunc = main(matcher);
}
})();