From cde3a755669294398e02e3b7e11103312a1364ea Mon Sep 17 00:00:00 2001 From: coomdev Date: Tue, 19 Jul 2022 17:29:49 +0200 Subject: [PATCH] Experimental native JPG support --- README.md | 2 +- chrome/dist/main.js | 2304 +++++++++++++++++++++++++++---- chrome/manifest.json | 2 +- dist/main.js | 2617 +++++++++++++++++++++++++++++------ firefox/dist/background.js | 23 +- firefox/dist/main.js | 2672 ++++++++++++++++++++++++++++++------ firefox/manifest.json | 2 +- firefox_update.json | 2 +- main.d.ts | 10 + main.meta.js | 2 +- main.user.js | 2619 +++++++++++++++++++++++++++++------ package-lock.json | 28 +- package.json | 1 + src/Components/App.svelte | 8 + src/jpg.ts | 57 +- src/main.ts | 16 +- src/stores.ts | 1 + 17 files changed, 8736 insertions(+), 1630 deletions(-) diff --git a/README.md b/README.md index e127db9..b6973b7 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ PNGExtraEmbedder (PEE) ======================== -Can embed any file in a PNG/WebM/GIF and upload it to a third-party host through 4chan. +Can embed any file in a PNG/WebM/GIF/JPEG and upload it to a third-party host through 4chan. Requires a userscript manager, such as ViolentMonkey. It should work with 4chan's native extension but 4ChanX is highly recommended as it is much more tested. Also supports desuarchive. diff --git a/chrome/dist/main.js b/chrome/dist/main.js index 0296520..77a3b44 100644 --- a/chrome/dist/main.js +++ b/chrome/dist/main.js @@ -14,20 +14,20 @@ }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { - for (let key of __getOwnPropNames(from)) - if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + for (let key2 of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key2) && key2 !== except) + __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable }); } return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod)); - var __decorateClass = (decorators, target, key, kind) => { - var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; + var __decorateClass = (decorators, target, key2, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key2) : target; for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) - result = (kind ? decorator(target, key, result) : decorator(result)) || result; + result = (kind ? decorator(target, key2, result) : decorator(result)) || result; if (kind && result) - __defProp(target, key, result); + __defProp(target, key2, result); return result; }; var __toBinary = /* @__PURE__ */ (() => { @@ -51,7 +51,7 @@ var define_BUILD_VERSION_default; var init_define_BUILD_VERSION = __esm({ ""() { - define_BUILD_VERSION_default = [0, 260]; + define_BUILD_VERSION_default = [0, 261]; } }); @@ -2246,12 +2246,12 @@ } if (arguments.length === 0) { var keys = Object.keys(events); - var key; + var key2; for (i = 0; i < keys.length; ++i) { - key = keys[i]; - if (key === "removeListener") + key2 = keys[i]; + if (key2 === "removeListener") continue; - this.removeAllListeners(key); + this.removeAllListeners(key2); } this.removeAllListeners("removeListener"); this._events = /* @__PURE__ */ Object.create(null); @@ -2410,24 +2410,24 @@ for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { - ownKeys(Object(source), true).forEach(function(key) { - _defineProperty(target, key, source[key]); + ownKeys(Object(source), true).forEach(function(key2) { + _defineProperty(target, key2, source[key2]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { - ownKeys(Object(source)).forEach(function(key) { - Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + ownKeys(Object(source)).forEach(function(key2) { + Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2)); }); } } return target; } - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + function _defineProperty(obj, key2, value) { + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); } else { - obj[key] = value; + obj[key2] = value; } return obj; } @@ -3443,8 +3443,8 @@ init_esbuild_inject(); var objectKeys = Object.keys || function(obj) { var keys2 = []; - for (var key in obj) { - keys2.push(key); + for (var key2 in obj) { + keys2.push(key2); } return keys2; }; @@ -3533,8 +3533,8 @@ var buffer = require_buffer(); var Buffer18 = buffer.Buffer; function copyProps(src, dst) { - for (var key in src) { - dst[key] = src[key]; + for (var key2 in src) { + dst[key2] = src[key2]; } } if (Buffer18.from && Buffer18.alloc && Buffer18.allocUnsafe && Buffer18.allocUnsafeSlow) { @@ -3957,11 +3957,11 @@ init_define_BUILD_VERSION(); init_esbuild_inject(); var _Object$setPrototypeO; - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + function _defineProperty(obj, key2, value) { + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); } else { - obj[key] = value; + obj[key2] = value; } return obj; } @@ -10318,7 +10318,7 @@ return this; }; EventEmitter.prototype.removeAllListeners = function(type) { - var key, listeners; + var key2, listeners; if (!this._events) return this; if (!this._events.removeListener) { @@ -10329,10 +10329,10 @@ return this; } if (arguments.length === 0) { - for (key in this._events) { - if (key === "removeListener") + for (key2 in this._events) { + if (key2 === "removeListener") continue; - this.removeAllListeners(key); + this.removeAllListeners(key2); } this.removeAllListeners("removeListener"); this._events = {}; @@ -10772,6 +10772,1642 @@ } }); + // node_modules/f5stegojs/f5stego.js + var require_f5stego = __commonJS({ + "node_modules/f5stegojs/f5stego.js"(exports, module) { + init_define_BUILD_VERSION(); + init_esbuild_inject(); + (function(root, factory) { + "use strict"; + if (typeof define === "function" && define.amd) { + define([], factory); + } else if (typeof exports === "object") { + module.exports = factory(); + } else { + root.f5stego = factory(); + } + })(exports, function() { + "use strict"; + var f5stego = function(key2, maxPixels) { + this.maxPixels = maxPixels || 4096 * 4096; + this.shuffleInit(key2); + }; + f5stego.prototype.shuffleInit = function(key2) { + this.randPool = new ArrayBuffer(this.maxPixels * 4.125); + if (!key2.length) + throw "key needed"; + var i = 0, j = 0, t = 0, k = 0, S = new Uint8Array(256), rnd = new Uint8Array(this.randPool); + for (i = 0; i < 256; ++i) + S[i] = i; + for (i = 0; i < 256; ++i) { + j = j + S[i] + key2[i % key2.length] & 255; + t = S[i]; + S[i] = S[j]; + S[j] = t; + } + i = 0; + j = 0; + for (k = 0; k < this.maxPixels * 4.125; ++k) { + i = i + 1 & 255; + j = j + S[i] & 255; + t = S[i]; + S[i] = S[j]; + S[j] = t; + rnd[k] = S[t + S[i] & 255]; + } + }; + f5stego.prototype.stegShuffle = function(pm) { + var t, l, k, random_index, rand32Array = new Uint32Array(this.randPool); + if (typeof pm == "number") { + l = pm; + pm = new Uint32Array(l); + for (k = 1; k < l; k++) { + random_index = rand32Array[k] % (k + 1); + if (random_index != k) + pm[k] = pm[random_index]; + pm[random_index] = k; + } + } else { + l = pm.length; + for (k = 1; k < l; k++) { + random_index = rand32Array[k] % (k + 1); + t = pm[k]; + pm[k] = pm[random_index]; + pm[random_index] = t; + } + } + return { pm, gamma: new Uint8Array(this.randPool, l * 4) }; + }; + f5stego.prototype._analyze = function(coeff) { + var _one = 0, _zero = 0, _large, _ratio, usable, i, k, embedded, matched, changed; + for (i = 0; i < coeff.length; i++) { + if (i % 64 === 0) + continue; + if (coeff[i] === 0) + _zero++; + if (coeff[i] == 1 || coeff[i] == -1) + _one++; + } + _large = coeff.length - _zero - _one - coeff.length / 64; + _ratio = _one / (_large + _one); + var res = { + "capacity": [0, (_large + 0.49 * _one >> 3) - 1], + "coeff_total": coeff.length, + "coeff_large": _large, + "coeff_zero": _zero, + "coeff_one": _one, + "coeff_one_ratio": _one / (_large + _one) + }; + for (i = 2; i < 17; i++) { + k = (1 << i) - 1; + usable = _large + _one; + embedded = 0; + while (usable > k) { + matched = usable / k / (1 << i) / (1 << i) | 0; + usable -= matched * k; + changed = usable * (1 - _ratio) / k * 0.96 | 0; + usable -= changed * k; + embedded += changed + matched; + k++; + } + res.capacity[i] = (i * embedded >> 3) - 1; + } + return res; + }; + f5stego.prototype._f5write = function(coeff, data, k) { + var coeff_count = coeff.length; + var _changed = 0, _embedded = 0, _examined = 0, _thrown = 0, shuffled_index = 0, i, n, ii; + var pm = this.stegShuffle(coeff_count); + var gamma = pm.gamma, gammaI = 0; + pm = pm.pm; + var next_bit_to_embed = 0, byte_to_embed = data.length, data_idx = 0, available_bits_to_embed = 0; + n = (1 << k) - 1; + byte_to_embed = k - 1; + byte_to_embed ^= gamma[gammaI++]; + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed = 3; + for (ii = 0; ii < coeff_count; ii++) { + shuffled_index = pm[ii]; + if (shuffled_index % 64 === 0 || coeff[shuffled_index] === 0) + continue; + var cc = coeff[shuffled_index]; + _examined++; + if (cc > 0 && (cc & 1) != next_bit_to_embed) { + coeff[shuffled_index]--; + _changed++; + } else if (cc < 0 && (cc & 1) == next_bit_to_embed) { + coeff[shuffled_index]++; + _changed++; + } + if (coeff[shuffled_index] !== 0) { + _embedded++; + if (available_bits_to_embed === 0) { + if (k != 1 || data_idx >= data.length) + break; + byte_to_embed = data[data_idx++]; + byte_to_embed ^= gamma[gammaI++]; + available_bits_to_embed = 8; + } + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed--; + } else { + _thrown++; + } + } + if (k == 1 && _embedded < data.length * 8) + throw "capacity exceeded " + _embedded / 8 + " " + data.length; + if (k != 1) { + var is_last_byte = false, k_bits_to_embed = 0; + while (!is_last_byte || available_bits_to_embed !== 0 && is_last_byte) { + k_bits_to_embed = 0; + for (i = 0; i < k; i++) { + if (available_bits_to_embed === 0) { + if (data_idx >= data.length) { + is_last_byte = true; + break; + } + byte_to_embed = data[data_idx++]; + byte_to_embed ^= gamma[gammaI++]; + available_bits_to_embed = 8; + } + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed--; + k_bits_to_embed |= next_bit_to_embed << i; + } + var code_word = []; + var ci = null; + for (i = 0; i < n; i++) { + while (true) { + if (++ii >= coeff_count) { + throw "capacity exceeded " + _embedded / 8; + } + ci = pm[ii]; + if (ci % 64 !== 0 && coeff[ci] !== 0) + break; + } + code_word.push(ci); + } + _examined += n; + while (true) { + var vhash = 0, extracted_bit; + for (i = 0; i < code_word.length; i++) { + if (coeff[code_word[i]] > 0) { + extracted_bit = coeff[code_word[i]] & 1; + } else { + extracted_bit = 1 - (coeff[code_word[i]] & 1); + } + if (extracted_bit == 1) + vhash ^= i + 1; + } + i = vhash ^ k_bits_to_embed; + if (!i) { + _embedded += k; + break; + } + i--; + coeff[code_word[i]] += coeff[code_word[i]] < 0 ? 1 : -1; + _changed++; + if (coeff[code_word[i]] === 0) { + _thrown++; + code_word.splice(i, 1); + while (true) { + if (++ii >= coeff_count) { + throw "capacity exceeded " + _embedded / 8; + } + ci = pm[ii]; + if (ci % 64 !== 0 && coeff[ci] !== 0) + break; + } + _examined++; + code_word.push(ci); + } else { + _embedded += k; + break; + } + } + } + } + return { + "k": k, + "embedded": _embedded / 8, + "examined": _examined, + "changed": _changed, + "thrown": _thrown, + "efficiency": (_embedded / _changed).toFixed(2) + }; + }; + f5stego.prototype.analyze = function() { + var i, comp = this.frame.components[0]; + if (comp.componentId != 1) { + for (i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + return this._analyze(comp.blocks); + }; + f5stego.prototype.f5put = function(data, k) { + var t, i, comp = this.frame.components[0]; + if (data.length > 8388607) + throw "Data too big. Max 8388607 bytes allowed."; + if (data.length < 32768) { + t = new Uint8Array(2 + data.length); + t[0] = data.length & 255; + t[1] = data.length >>> 8; + t.set(data, 2); + } else { + t = new Uint8Array(3 + data.length); + t[0] = data.length & 255; + t[1] = (data.length >>> 8 & 127) + 128; + t[2] = data.length >>> 15; + t.set(data, 3); + } + if (comp.componentId != 1) { + for (i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + if (k) { + return this._f5write(comp.blocks, t, k); + } + var ret, prop = this._analyze(comp.blocks); + k = 0; + for (i = prop.capacity.length - 1; i >= 0; i--) { + if (prop.capacity[i] >= t.length) { + k = i; + break; + } + } + if (k === 0) + throw "capacity exceeded"; + try { + ret = this._f5write(comp.blocks, t, k); + } catch (e) { + k--; + if (k === 0) + throw "capacity exceeded"; + ret = this._f5write(comp.blocks, t, k); + } + ret["stats"] = prop; + return ret; + }; + f5stego.prototype.f5get = function() { + var comp = this.frame.components[0]; + if (comp.componentId != 1) { + for (var i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + var coeff = new Int16Array(comp.blocks.length); + coeff.set(comp.blocks); + var pos = -1, extrBit = 0, cCount = coeff.length - 1; + var pm = this.stegShuffle(coeff), gamma = pm.gamma, gammaI = 0; + var n, k = 0; + var out = new Uint8Array(coeff.length / 8 | 0), extrByte = 0, outPos = 0, bitsAvail = 0, code = 0, hash2 = 0; + while (bitsAvail < 4) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + k |= extrBit << bitsAvail; + bitsAvail++; + } + k = (k ^ gamma[gammaI++] & 15) + 1; + n = (1 << k) - 1; + bitsAvail = 0; + if (k == 1) { + while (pos < cCount) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + extrByte |= extrBit << bitsAvail; + bitsAvail++; + if (bitsAvail == 8) { + out[outPos++] = extrByte ^ gamma[gammaI++]; + extrByte = 0; + bitsAvail = 0; + } + } + } else { + while (pos < cCount) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + hash2 ^= extrBit * ++code; + if (code == n) { + extrByte |= hash2 << bitsAvail; + bitsAvail += k; + code = 0; + hash2 = 0; + while (bitsAvail >= 8) { + out[outPos++] = extrByte & 255 ^ gamma[gammaI++]; + bitsAvail -= 8; + extrByte = extrByte >> 8; + } + } + } + } + while (bitsAvail > 0) { + out[outPos++] = extrByte & 255 ^ gamma[gammaI++]; + bitsAvail -= 8; + extrByte = extrByte >> 8; + } + var s = 2, l = out[0]; + if (out[1] & 128) { + s++; + l += ((out[1] & 127) << 8) + (out[2] << 15); + } else { + l += out[1] << 8; + } + return out.subarray(s, s + l); + }; + f5stego.prototype.parse = function(data) { + var offset = 0; + function _buildHuffmanTable(nrcodes, values) { + var codevalue = 0, pos_in_table = 0, HT = new Uint16Array(65536); + for (var k = 0; k < 16; k++) { + for (var j2 = 0; j2 < nrcodes[k]; j2++) { + for (var i2 = codevalue << 15 - k, cntTo = codevalue + 1 << 15 - k; i2 < cntTo; i2++) { + HT[i2] = values[pos_in_table] + (k + 1 << 8); + } + pos_in_table++; + codevalue++; + } + codevalue *= 2; + } + return HT; + } + function decodeScan(data2, offset2, frame, components2, resetInterval2, spectralStart2, spectralEnd2, successivePrev, successive) { + var startOffset = offset2, bitsData = 0, bitsCount = 0, eobrun = 0, p1 = 1 << successive, m1 = -1 << successive; + function decodeBaseline(component2, pos) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + var t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535]; + if (!t) + throw "invalid huffman sequence"; + bitsCount -= t >>> 8; + t &= 255; + var diff = 0; + if (t !== 0) { + while (bitsCount < t) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + diff = bitsData >>> bitsCount - t & (1 << t) - 1; + bitsCount -= t; + if (diff < 1 << t - 1) + diff += (-1 << t) + 1; + } + component2.blocksDC[pos >> 6] = component2.pred += diff; + var k2 = 1, s, r; + while (k2 < 64) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s === 0) { + if (r < 15) { + break; + } + k2 += 16; + continue; + } + k2 += r; + while (bitsCount < s) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1; + bitsCount -= s; + if (component2.blocks[pos + k2] < 1 << s - 1) + component2.blocks[pos + k2] += (-1 << s) + 1; + k2++; + } + } + function decodeDCFirst(component2, pos) { + var diff = 0; + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + var t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535]; + if (!t) + throw "invalid huffman sequence"; + bitsCount -= t >>> 8; + t &= 255; + if (t !== 0) { + while (bitsCount < t) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + diff = bitsData >>> bitsCount - t & (1 << t) - 1; + bitsCount -= t; + if (diff < 1 << t - 1) + diff += (-1 << t) + 1; + } + component2.blocksDC[pos >> 6] = component2.pred += diff << successive; + } + function decodeDCSuccessive(component2, pos) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocksDC[pos >> 6] |= (bitsData >>> --bitsCount & 1) << successive; + } + function decodeACFirst(component2, pos) { + if (eobrun > 0) { + eobrun--; + return; + } + var k2 = spectralStart2, s, r; + while (k2 <= spectralEnd2) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s === 0) { + if (r != 15) { + eobrun = (1 << r) - 1; + if (r) { + while (bitsCount < r) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + eobrun += bitsData >>> bitsCount - r & (1 << r) - 1; + bitsCount -= r; + } + break; + } + k2 += 16; + continue; + } + k2 += r; + while (bitsCount < s) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1; + bitsCount -= s; + if (component2.blocks[pos + k2] < 1 << s - 1) + component2.blocks[pos + k2] += (-1 << s) + 1; + component2.blocks[pos + k2] *= p1; + k2++; + } + } + function decodeACSuccessive(component2, pos) { + var k2 = spectralStart2, r, s; + if (!eobrun) { + while (k2 <= spectralEnd2) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s) { + if (s != 1) + throw "bad jpeg"; + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + s = bitsData >>> --bitsCount & 1 ? p1 : m1; + } else { + if (r != 15) { + eobrun = 1 << r; + if (r) { + while (bitsCount < r) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + eobrun += bitsData >>> bitsCount - r & (1 << r) - 1; + bitsCount -= r; + } + break; + } + } + while (k2 <= spectralEnd2) { + if (component2.blocks[pos + k2]) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1); + } else { + if (--r < 0) + break; + } + k2++; + } + if (s) + component2.blocks[pos + k2] = s; + k2++; + } + } + if (eobrun) { + while (k2 <= spectralEnd2) { + if (component2.blocks[pos + k2]) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1); + } + k2++; + } + eobrun--; + } + } + var decodeFn; + if (frame.progressive) { + if (spectralStart2 === 0) + decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; + else + decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; + } else { + decodeFn = decodeBaseline; + } + var marker, mcuExpected, i2, j2, k, n, mcusPerLine2, mcusPerRow, x, y; + if (components2.length == 1) { + mcusPerLine2 = components2[0].blocksPerLine; + mcusPerRow = components2[0].blocksPerColumn; + mcuExpected = mcusPerRow * mcusPerLine2; + if (!resetInterval2) + resetInterval2 = mcuExpected; + n = resetInterval2; + components2[0].pred = 0; + eobrun = 0; + for (y = 0; y < mcusPerRow; y++) { + for (x = 0; x < mcusPerLine2; x++) { + if (!n) { + n = resetInterval2; + components2[0].pred = 0; + eobrun = 0; + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + bitsCount = 0; + marker = data2[offset2] << 8 | data2[offset2 + 1]; + if (marker >= 65488 && marker <= 65495) { + offset2 += 2; + } else { + if (marker <= 65280) { + throw "bad jpeg"; + } + break; + } + } + n--; + for (i2 = 0; i2 < components2.length; i2++) { + decodeFn(components2[i2], (y * components2[i2].blocksPerLineForMcu + x) * 64); + } + } + } + } else { + mcusPerLine2 = frame.mcusPerLine; + mcusPerRow = frame.mcusPerColumn; + mcuExpected = mcusPerRow * mcusPerLine2; + if (!resetInterval2) + resetInterval2 = mcuExpected; + n = resetInterval2; + for (i2 = 0; i2 < components2.length; i2++) + components2[i2].pred = 0; + eobrun = 0; + for (y = 0; y < mcusPerRow; y++) { + for (x = 0; x < mcusPerLine2; x++) { + if (!n) { + n = resetInterval2; + for (i2 = 0; i2 < components2.length; i2++) + components2[i2].pred = 0; + eobrun = 0; + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + bitsCount = 0; + marker = data2[offset2] << 8 | data2[offset2 + 1]; + if (marker >= 65488 && marker <= 65495) { + offset2 += 2; + } else { + if (marker <= 65280) { + throw "bad jpeg"; + } + break; + } + } + n--; + for (i2 = 0; i2 < components2.length; i2++) { + for (j2 = 0; j2 < components2[i2].v; j2++) { + for (k = 0; k < components2[i2].h; k++) { + decodeFn(components2[i2], ((y * components2[i2].v + j2) * components2[i2].blocksPerLineForMcu + x * components2[i2].h + k) * 64); + } + } + } + } + } + } + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + return offset2 - startOffset; + } + function readUint16() { + var value = data[offset] << 8 | data[offset + 1]; + offset += 2; + return value; + } + function readDataBlock() { + var length = readUint16(); + var array = data.subarray(offset, offset + length - 2); + offset += array.length; + return array; + } + this["_raw"] = data; + this["jfif"] = null; + this["APPn"] = []; + this["qts"] = []; + this["frame"] = null; + this["tail"] = null; + var markerHi, markerLo, i, j, resetInterval, component; + var huffmanTablesAC = [], huffmanTablesDC = []; + while (1) { + if (offset >= data.length) + throw "unexpected EOF"; + markerHi = data[offset++]; + markerLo = data[offset++]; + if (markerHi == 255) { + if (markerLo == 224) { + this.jfif = readDataBlock(); + } + if (markerLo > 224 && markerLo < 240 || markerLo == 254) { + this.APPn.push({ + "app": markerLo, + "data": readDataBlock() + }); + } + if (markerLo == 219) { + this.qts.push(readDataBlock()); + } + if (markerLo >= 192 && markerLo <= 194) { + if (this.frame) + throw "Only single frame JPEGs supported"; + readUint16(); + this.frame = { + "extended": markerLo === 193, + "progressive": markerLo === 194, + "precision": data[offset++], + "scanLines": readUint16(), + "samplesPerLine": readUint16(), + "components": [], + "componentIds": {}, + "maxH": 1, + "maxV": 1 + }; + if (this.frame.scanLines * this.frame.samplesPerLine > this.maxPixels) + throw "Image is too big."; + var componentsCount = data[offset++], componentId; + var maxH = 0, maxV = 0; + for (i = 0; i < componentsCount; i++) { + componentId = data[offset]; + var h = data[offset + 1] >> 4; + var v = data[offset + 1] & 15; + if (maxH < h) + maxH = h; + if (maxV < v) + maxV = v; + var qId = data[offset + 2]; + var l = this.frame.components.push({ + "componentId": componentId, + "h": h, + "v": v, + "quantizationTable": qId + }); + this.frame.componentIds[componentId] = l - 1; + offset += 3; + } + this.frame.maxH = maxH; + this.frame.maxV = maxV; + var mcusPerLine = Math.ceil(this.frame.samplesPerLine / 8 / maxH); + var mcusPerColumn = Math.ceil(this.frame.scanLines / 8 / maxV); + for (i = 0; i < this.frame.components.length; i++) { + component = this.frame.components[i]; + var blocksPerLine = Math.ceil(Math.ceil(this.frame.samplesPerLine / 8) * component.h / maxH); + var blocksPerColumn = Math.ceil(Math.ceil(this.frame.scanLines / 8) * component.v / maxV); + var blocksPerLineForMcu = mcusPerLine * component.h; + var blocksPerColumnForMcu = mcusPerColumn * component.v; + component["blocks"] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu * 64); + component["blocksDC"] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu); + component["blocksPerLine"] = blocksPerLine; + component["blocksPerColumn"] = blocksPerColumn; + component["blocksPerLineForMcu"] = blocksPerLineForMcu; + component["blocksPerColumnForMcu"] = blocksPerColumnForMcu; + } + this.frame["mcusPerLine"] = mcusPerLine; + this.frame["mcusPerColumn"] = mcusPerColumn; + } + if (markerLo == 196) { + var huffmanLength = readUint16(); + for (i = 2; i < huffmanLength; ) { + var huffmanTableSpec = data[offset++]; + var codeLengths = new Uint8Array(16); + var codeLengthSum = 0; + for (j = 0; j < 16; j++, offset++) + codeLengthSum += codeLengths[j] = data[offset]; + var huffmanValues = new Uint8Array(codeLengthSum); + for (j = 0; j < codeLengthSum; j++, offset++) + huffmanValues[j] = data[offset]; + i += 17 + codeLengthSum; + (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = _buildHuffmanTable(codeLengths, huffmanValues); + } + } + if (markerLo == 221) { + resetInterval = readUint16(); + } + if (markerLo == 218) { + readUint16(); + var selectorsCount = data[offset++]; + var components = []; + for (i = 0; i < selectorsCount; i++) { + var componentIndex = this.frame.componentIds[data[offset++]]; + component = this.frame.components[componentIndex]; + var tableSpec = data[offset++]; + component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]; + component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]; + components.push(component); + } + var spectralStart = data[offset++]; + var spectralEnd = data[offset++]; + var successiveApproximation = data[offset++]; + var processed = decodeScan(data, offset, this.frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15); + offset += processed; + } + if (markerLo == 217) { + break; + } + } else { + if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) { + offset -= 3; + } + while (data[offset] != 255 && offset < data.length) { + offset++; + } + if (data[offset] != 255) { + throw "bad jpeg "; + } + } + } + if (!this.frame) + throw "bad jpeg"; + if (offset < data.length) + this.tail = data.subarray(offset); + return this; + }; + var bitcode = new Array(65535), category = new Array(65535), std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125], std_ac_luminance_values = [ + 1, + 2, + 3, + 0, + 4, + 17, + 5, + 18, + 33, + 49, + 65, + 6, + 19, + 81, + 97, + 7, + 34, + 113, + 20, + 50, + 129, + 145, + 161, + 8, + 35, + 66, + 177, + 193, + 21, + 82, + 209, + 240, + 36, + 51, + 98, + 114, + 130, + 9, + 10, + 22, + 23, + 24, + 25, + 26, + 37, + 38, + 39, + 40, + 41, + 42, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250 + ], std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119], std_ac_chrominance_values = [ + 0, + 1, + 2, + 3, + 17, + 4, + 5, + 33, + 49, + 6, + 18, + 65, + 81, + 7, + 97, + 113, + 19, + 34, + 50, + 129, + 8, + 20, + 66, + 145, + 161, + 177, + 193, + 9, + 35, + 51, + 82, + 240, + 21, + 98, + 114, + 209, + 10, + 22, + 36, + 52, + 225, + 37, + 241, + 23, + 24, + 25, + 26, + 38, + 39, + 40, + 41, + 42, + 53, + 54, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250 + ]; + function _initCategoryNumber() { + var nrlower = 1; + var nrupper = 2; + for (var cat = 1; cat <= 15; cat++) { + for (var nr = nrlower; nr < nrupper; nr++) { + category[32767 + nr] = cat; + bitcode[32767 + nr] = []; + bitcode[32767 + nr][1] = cat; + bitcode[32767 + nr][0] = nr; + } + for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) { + category[32767 + nrneg] = cat; + bitcode[32767 + nrneg] = []; + bitcode[32767 + nrneg][1] = cat; + bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg; + } + nrlower <<= 1; + nrupper <<= 1; + } + } + _initCategoryNumber(); + function _computeHuffmanTbl(nrcodes, std_table) { + var codevalue = 0; + var pos_in_table = 0; + var HT = []; + for (var k = 1; k <= 16; k++) { + for (var j = 1; j <= nrcodes[k]; j++) { + HT[std_table[pos_in_table]] = []; + HT[std_table[pos_in_table]][0] = codevalue; + HT[std_table[pos_in_table]][1] = k; + pos_in_table++; + codevalue++; + } + codevalue *= 2; + } + return HT; + } + var YDC_HT = _computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values), UVDC_HT = _computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values), YAC_HT = _computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values), UVAC_HT = _computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values); + f5stego.prototype.pack = function() { + var byteout, bytenew, bytepos, poslast, outpos, byte; + function writeByte(value) { + var t; + byteout[outpos++] = value; + if (outpos > poslast) { + t = new Uint8Array(byteout.length * 2); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + } + function writeWord(value) { + writeByte(value >> 8 & 255); + writeByte(value & 255); + } + function writeBlock(block) { + var t; + if (outpos + block.length > poslast) { + t = new Uint8Array(byteout.length * 2 + block.length); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + byteout.set(block, outpos); + outpos += block.length; + } + function writeAPP0(self) { + writeWord(65504); + if (!self.jfif) { + writeWord(16); + writeByte(74); + writeByte(70); + writeByte(73); + writeByte(70); + writeByte(0); + writeByte(1); + writeByte(1); + writeByte(0); + writeWord(1); + writeWord(1); + writeByte(0); + writeByte(0); + } else { + writeWord(self.jfif.length + 2); + writeBlock(self.jfif); + } + } + function writeDQT(self) { + for (var i2 = 0; i2 < self.qts.length; i2++) { + writeWord(65499); + writeWord(self.qts[i2].length + 2); + writeBlock(self.qts[i2]); + } + } + function writeAPPn(self) { + for (var i2 = 0; i2 < self.APPn.length; i2++) { + writeWord(65280 | self.APPn[i2].app); + writeWord(self.APPn[i2].data.length + 2); + writeBlock(self.APPn[i2].data); + } + } + function writeSOF0(self) { + writeWord(65472); + writeWord(8 + self.frame.components.length * 3); + writeByte(self.frame.precision); + writeWord(self.frame.scanLines); + writeWord(self.frame.samplesPerLine); + writeByte(self.frame.components.length); + for (var i2 = 0; i2 < self.frame.components.length; i2++) { + var c2 = self.frame.components[i2]; + writeByte(c2.componentId); + writeByte(c2.h << 4 | c2.v); + writeByte(c2.quantizationTable); + } + } + function writeDHT(self) { + writeWord(65476); + writeWord(31); + writeByte(0); + for (var i2 = 0; i2 < 16; i2++) { + writeByte(std_dc_luminance_nrcodes[i2 + 1]); + } + for (var j = 0; j <= 11; j++) { + writeByte(std_dc_luminance_values[j]); + } + writeWord(65476); + writeWord(181); + writeByte(16); + for (var k = 0; k < 16; k++) { + writeByte(std_ac_luminance_nrcodes[k + 1]); + } + for (var l = 0; l <= 161; l++) { + writeByte(std_ac_luminance_values[l]); + } + if (self.frame.components.length != 1) { + writeWord(65476); + writeWord(31); + writeByte(1); + for (var m = 0; m < 16; m++) { + writeByte(std_dc_chrominance_nrcodes[m + 1]); + } + for (var n = 0; n <= 11; n++) { + writeByte(std_dc_chrominance_values[n]); + } + writeWord(65476); + writeWord(181); + writeByte(17); + for (var o = 0; o < 16; o++) { + writeByte(std_ac_chrominance_nrcodes[o + 1]); + } + for (var p = 0; p <= 161; p++) { + writeByte(std_ac_chrominance_values[p]); + } + } + } + function writeSOS(self) { + writeWord(65498); + writeWord(6 + self.frame.components.length * 2); + writeByte(self.frame.components.length); + for (var i2 = 0; i2 < self.frame.components.length; i2++) { + var c2 = self.frame.components[i2]; + writeByte(c2.componentId); + if (i2 === 0) { + writeByte(0); + } else { + writeByte(17); + } + } + writeByte(0); + writeByte(63); + writeByte(0); + } + function processDU(comp, POS, DC, HTDC, HTAC) { + var pos, posval, t; + if (bytepos === 0) + bytenew = 0; + var Diff = comp.blocksDC[POS >> 6] - DC; + DC = comp.blocksDC[POS >> 6]; + if (Diff === 0) { + posval = HTDC[0][1]; + bytenew <<= posval; + bytenew += HTDC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } else { + pos = 32767 + Diff; + posval = HTDC[category[pos]][1]; + bytenew <<= posval; + bytenew += HTDC[category[pos]][0]; + bytepos += posval; + posval = bitcode[pos][1]; + bytenew <<= posval; + bytenew += bitcode[pos][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + var end0pos = 63; + for (; end0pos > 0 && comp.blocks[POS + end0pos] === 0; end0pos--) { + } + if (end0pos === 0) { + posval = HTAC[0][1]; + bytenew <<= posval; + bytenew += HTAC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + return DC; + } + var i2 = 1; + var lng; + while (i2 <= end0pos) { + var startpos = i2; + for (; comp.blocks[POS + i2] === 0 && i2 <= end0pos; ++i2) { + } + var nrzeroes = i2 - startpos; + if (nrzeroes >= 16) { + lng = nrzeroes >> 4; + for (var nrmarker = 1; nrmarker <= lng; ++nrmarker) { + posval = HTAC[240][1]; + bytenew <<= posval; + bytenew += HTAC[240][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + nrzeroes = nrzeroes & 15; + } + pos = 32767 + comp.blocks[POS + i2]; + posval = HTAC[(nrzeroes << 4) + category[pos]][1]; + bytenew <<= posval; + bytenew += HTAC[(nrzeroes << 4) + category[pos]][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + posval = bitcode[pos][1]; + bytenew <<= posval; + bytenew += bitcode[pos][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + i2++; + } + if (end0pos != 63) { + posval = HTAC[0][1]; + bytenew <<= posval; + bytenew += HTAC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + if (outpos > poslast) { + t = new Uint8Array(byteout.length * 2); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + return DC; + } + byteout = new Uint8Array(65536); + poslast = 65536 - 128; + outpos = 0; + bytenew = 0; + bytepos = 0; + writeWord(65496); + writeAPP0(this); + writeAPPn(this); + writeDQT(this); + writeSOF0(this); + writeDHT(this); + writeSOS(this); + bytenew = 0; + bytepos = 0; + var c, mcuRow, mcuCol, blockRow, blockCol, mcu, i, v, h; + var DCdiff = []; + for (i = 0; i < this.frame.components.length; i++) { + DCdiff.push(0); + } + for (mcu = 0; mcu < this.frame.mcusPerLine * this.frame.mcusPerColumn; mcu++) { + mcuRow = mcu / this.frame.mcusPerLine | 0; + mcuCol = mcu % this.frame.mcusPerLine; + for (i = 0; i < this.frame.components.length; i++) { + c = this.frame.components[i]; + for (v = 0; v < c.v; v++) { + blockRow = mcuRow * c.v + v; + for (h = 0; h < c.h; h++) { + blockCol = mcuCol * c.h + h; + if (i === 0) { + DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], YDC_HT, YAC_HT); + } else { + DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], UVDC_HT, UVAC_HT); + } + } + } + } + } + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + } + if (bytepos > 0) { + bytenew <<= 8 - bytepos; + bytenew += (1 << 8 - bytepos) - 1; + byteout[outpos++] = 255 & bytenew; + } + writeWord(65497); + if (this.tail) + writeBlock(this.tail); + return byteout.slice(0, outpos); + }; + f5stego.prototype.clearTail = function() { + if (!this.tail) + return null; + var t = this.tail; + this.tail = null; + return t; + }; + f5stego.prototype.setTail = function(data) { + this.tail = data; + }; + f5stego.prototype.getTail = function() { + return this.tail; + }; + f5stego.prototype.clearAPPs = function() { + var t = this.APPn; + this.APPn = []; + return t; + }; + f5stego.prototype.getAPPn = function(id, remove) { + var i, t, ret = new Uint8Array(0), n = []; + id &= 255; + if (id < 16) + id += 224; + if (id === 224) + return this.jfif; + for (i = 0; i < this.APPn.length; i++) { + if (this.APPn[i].app == id) { + t = new Uint8Array(ret.length + this.APPn[i].data.length); + t.set(ret); + t.set(this.APPn[i].data, ret.length); + ret = t; + } else if (remove) + n.push(this.APPn[i]); + } + if (remove) + this.APPn = n; + if (ret.length === 0) + return null; + return ret; + }; + f5stego.prototype.setAPPn = function(id, data) { + var i, t, ret; + id &= 255; + if (id < 16) + id += 224; + if (id === 224) { + t = this.jfif; + this.jfif = data; + return t; + } + ret = this.getAPPn(id, true); + if (data.length < 65534) { + this.APPn.push({ "app": id, "data": data }); + return ret; + } + i = 0; + while (i < data.length) { + this.APPn.push({ "app": id, "data": data.subarray(i, i + 65533) }); + i += 65533; + } + return ret; + }; + f5stego.prototype.strip = function() { + this.clearTail(); + this.clearAPPs(); + return true; + }; + f5stego.prototype.embed = function(image, data) { + this.parse(image).f5put(data); + return this.pack(); + }; + f5stego.prototype.extract = function(image) { + return this.parse(image).f5get(); + }; + return f5stego; + }); + } + }); + // node_modules/jpeg-js/lib/encoder.js var require_encoder = __commonJS({ "node_modules/jpeg-js/lib/encoder.js"(exports, module) { @@ -13134,11 +14770,11 @@ function set_input_value(input, value) { input.value = value == null ? "" : value; } - function set_style(node, key, value, important) { + function set_style(node, key2, value, important) { if (value === null) { - node.style.removeProperty(key); + node.style.removeProperty(key2); } else { - node.style.setProperty(key, value, important ? "important" : ""); + node.style.setProperty(key2, value, important ? "important" : ""); } } function select_option(select, value) { @@ -13294,12 +14930,12 @@ return true; }; } - function setContext(key, context) { - get_current_component().$$.context.set(key, context); + function setContext(key2, context) { + get_current_component().$$.context.set(key2, context); return context; } - function getContext(key) { - return get_current_component().$$.context.get(key); + function getContext(key2) { + return get_current_component().$$.context.get(key2); } function bubble(component, event) { const callbacks = component.$$.callbacks[event.type]; @@ -13533,17 +15169,17 @@ i = n; while (i--) { const child_ctx = get_context(ctx, list, i); - const key = get_key(child_ctx); - let block = lookup.get(key); + const key2 = get_key(child_ctx); + let block = lookup.get(key2); if (!block) { - block = create_each_block8(key, child_ctx); + block = create_each_block8(key2, child_ctx); block.c(); } else if (dynamic) { block.p(child_ctx, dirty); } - new_lookup.set(key, new_blocks[i] = block); - if (key in old_indexes) - deltas.set(key, Math.abs(i - old_indexes[key])); + new_lookup.set(key2, new_blocks[i] = block); + if (key2 in old_indexes) + deltas.set(key2, Math.abs(i - old_indexes[key2])); } const will_move = /* @__PURE__ */ new Set(); const did_move = /* @__PURE__ */ new Set(); @@ -13687,8 +15323,8 @@ connectedCallback() { const { on_mount } = this.$$; this.$$.on_disconnect = on_mount.map(run).filter(is_function); - for (const key in this.$$.slotted) { - this.appendChild(this.$$.slotted[key]); + for (const key2 in this.$$.slotted) { + this.appendChild(this.$$.slotted[key2]); } } attributeChangedCallback(attr2, _oldValue, newValue) { @@ -13787,8 +15423,8 @@ } // src/stores.ts - var localLoad = (key, def) => "__pee__" + key in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key)) : def; - var localSet = (key, value) => localStorage.setItem("__pee__" + key, JSON.stringify(value)); + var localLoad = (key2, def) => "__pee__" + key2 in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key2)) : def; + var localSet = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value)); var initial_settings = localLoad("settingsv2", { ...localLoad("settings", {}), loop: true, @@ -13812,6 +15448,7 @@ mdist: -1, phash: false, hotlink: false, + jpeg: false, vercheck: false, cache: void 0, fhost: 0, @@ -14093,8 +15730,8 @@ // src/platform.ts var lqueue = {}; - var localLoad2 = (key, def) => "__pee__" + key in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key)) : def; - var localSet2 = (key, value) => localStorage.setItem("__pee__" + key, JSON.stringify(value)); + var localLoad2 = (key2, def) => "__pee__" + key2 in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key2)) : def; + var localSet2 = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value)); var { port1, port2 } = new MessageChannel(); console.log("chrome_api", false); if (true) { @@ -14421,7 +16058,7 @@ // src/filehosts.ts function parseForm(data) { const form = new FormData(); - Object.entries(data).filter(([key, value]) => value !== null).map(([key, value]) => form.append(key, value)); + Object.entries(data).filter(([key2, value]) => value !== null).map(([key2, value]) => form.append(key2, value)); return form; } var lolisafe = (domain, serving = domain) => ({ @@ -16706,7 +18343,7 @@ }; var inject_data = async (container, injb) => { let magic3 = false; - const [writestream, extract6] = BufferWriteStream2(); + const [writestream, extract7] = BufferWriteStream2(); const encoder = new PNGEncoder(writestream); const decoder = new PNGDecoder(container.stream().getReader()); for await (const [name, chunk, crc, offset] of decoder.chunks()) { @@ -16725,7 +18362,7 @@ async () => Promise.resolve(0), 0 ]); - return extract6(); + return extract7(); }; var inject = async (container, links) => { links = links.map((link) => { @@ -17010,7 +18647,7 @@ } }; var inject3 = async (container, links) => { - const [writestream, extract6] = BufferWriteStream(); + const [writestream, extract7] = BufferWriteStream(); const writer = writestream.getWriter(); const inj = import_buffer5.Buffer.from(links.join(" ")); xor3(inj, password3); @@ -17025,7 +18662,7 @@ await writer.write(contbuff.slice(0, endo)); await write_embedding(writer, import_buffer5.Buffer.from(inj)); await writer.write(contbuff.slice(endo)); - return extract6(); + return extract7(); }; var has_embed3 = (gif) => { const field = gif.readUInt8(10); @@ -17062,6 +18699,11 @@ init_define_BUILD_VERSION(); init_esbuild_inject(); var import_buffer6 = __toESM(require_buffer(), 1); + var import_f5stegojs = __toESM(require_f5stego(), 1); + var csettings3; + settings.subscribe((b) => { + csettings3 = b; + }); var convertToPng = async (f) => { const can = document.createElement("canvas"); const url = URL.createObjectURL(f); @@ -17101,18 +18743,48 @@ URL.revokeObjectURL(url); } }; + var key = import_buffer6.Buffer.from("CUNNYCUNNYCUNNY"); + var f5inst = new import_f5stegojs.default(key); + var injectTrue = async (b, links) => { + if (b.size / 20 < links.join(" ").length) + throw "Image too small to embed."; + const arr = new Uint8Array(await b.arrayBuffer()); + const buff = f5inst.embed(arr, import_buffer6.Buffer.from(links.join(" "))); + return import_buffer6.Buffer.from(buff); + }; var inject4 = async (b, links) => { + if (csettings3.jpeg) + return injectTrue(b, links); const pngfile = await convertToPng(b); if (!pngfile || pngfile.size > 3e3 * 1024) { throw new Error("Couldn't convert file to PNG: resulting filesize too big."); } return pngv3_default.inject(new File([pngfile], b.name), links); }; + var has_embed4 = (b) => { + if (!csettings3.jpeg) + return false; + try { + const res = f5inst.extract(b); + if (!res) + return; + if (res.length > 1024) + return; + const str = import_buffer6.Buffer.from(res).toString(); + if (!str.match(/^[a-zA-Z0-9:/.\-_ ]+$/)) + return; + return str; + } catch { + return; + } + }; + var extract4 = (b, ex) => { + return decodeCoom3Payload(import_buffer6.Buffer.from(ex)); + }; var jpg_default = { - skip: true, match: (fn) => !!fn.match(/\.jpe?g$/), - has_embed: () => false, - extract: () => [], + has_embed: has_embed4, + extract: extract4, inject: inject4 }; @@ -17179,9 +18851,9 @@ }; // src/thirdeye.ts - var csettings3; + var csettings4; settings.subscribe((b) => { - csettings3 = b; + csettings4 = b; }); var gelquirk = (prefix) => (a) => { let base = a.post || a.data || a; @@ -17236,7 +18908,7 @@ return []; } }; - var extract4 = async (b, fn) => { + var extract5 = async (b, fn) => { let result; let booru; for (const e of Object.values(boorus)) { @@ -17258,8 +18930,8 @@ url: result[0].page }, filename: fn.substring(0, 33) + result[0].ext, - thumbnail: csettings3.hotlink ? prev || full : import_buffer7.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()), - data: csettings3.hotlink ? full || prev : async (lsn) => { + thumbnail: csettings4.hotlink ? prev || full : import_buffer7.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()), + data: csettings4.hotlink ? full || prev : async (lsn) => { if (!cachedFile) cachedFile = await (await ifetch(full || prev, void 0, lsn)).arrayBuffer(); return import_buffer7.Buffer.from(cachedFile); @@ -17279,7 +18951,7 @@ } return acc; }; - var has_embed4 = async (b, fn, prevlink) => { + var has_embed5 = async (b, fn, prevlink) => { if (import_buffer7.Buffer.from(fn, "hex").equals(b)) return false; let result = void 0; @@ -17311,8 +18983,8 @@ }; var thirdeye_default = { skip: true, - extract: extract4, - has_embed: has_embed4, + extract: extract5, + has_embed: has_embed5, match: (fn) => !!fn.match(/^[0-9a-f]{32}\.....?/) }; @@ -17325,9 +18997,9 @@ { host: "Litter", prefix: "litter.catbox.moe/" }, { host: "Zzzz", prefix: "z.zz.fo/" } ]; - var csettings4; + var csettings5; settings.subscribe((b) => { - csettings4 = b; + csettings5 = b; }); var getExt = (fn) => { const isB64 = fn.match(/^((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=))?\.(gif|jpe?g|png|webm)/); @@ -17352,7 +19024,7 @@ } return { ext, source }; }; - var extract5 = async (b, fn) => { + var extract6 = async (b, fn) => { const { ext, source } = getExt(fn); let rsource; for (const cs of sources) { @@ -17367,7 +19039,7 @@ } return [{ filename: ext, - data: csettings4.hotlink ? rsource : async (lsn) => { + data: csettings5.hotlink ? rsource : async (lsn) => { try { return import_buffer8.Buffer.from(await (await ifetch(rsource, void 0, lsn)).arrayBuffer()); } catch (e) { @@ -17376,7 +19048,7 @@ thumbnail: import_buffer8.Buffer.from(hasembed_default) }]; }; - var has_embed5 = async (b, fn) => { + var has_embed6 = async (b, fn) => { const { ext, source } = getExt(fn); if (!ext) return false; @@ -17393,8 +19065,8 @@ }; var pomf_default = { skip: true, - extract: extract5, - has_embed: has_embed5, + extract: extract6, + has_embed: has_embed6, match: (fn) => !!getExt(fn) }; @@ -19064,8 +20736,8 @@ const get_key = (ctx2) => ctx2[10][0]; for (let i = 0; i < each_value.length; i += 1) { let child_ctx = get_each_context(ctx, each_value, i); - let key = get_key(child_ctx); - each_1_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx)); + let key2 = get_key(child_ctx); + each_1_lookup.set(key2, each_blocks[i] = create_each_block(key2, child_ctx)); } return { c() { @@ -19393,30 +21065,30 @@ } function get_each_context2(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[57] = list[i]; + child_ctx[58] = list[i]; return child_ctx; } function get_each_context_12(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[60] = list[i]; + child_ctx[61] = list[i]; return child_ctx; } function get_each_context_2(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[63] = list[i]; - child_ctx[65] = i; + child_ctx[64] = list[i]; + child_ctx[66] = i; return child_ctx; } function get_each_context_3(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[66] = list[i]; - child_ctx[65] = i; + child_ctx[67] = list[i]; + child_ctx[66] = i; return child_ctx; } function get_each_context_4(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[68] = list[i]; - child_ctx[65] = i; + child_ctx[69] = list[i]; + child_ctx[66] = i; return child_ctx; } function create_if_block6(ctx) { @@ -19469,7 +21141,7 @@ if (!current || dirty[0] & 1) set_data(t1, ctx2[0]); const tabs_changes = {}; - if (dirty[0] & 1006 | dirty[2] & 256) { + if (dirty[0] & 1006 | dirty[2] & 512) { tabs_changes.$$scope = { dirty, ctx: ctx2 }; } tabs.$set(tabs_changes); @@ -19703,27 +21375,27 @@ }, p(ctx2, dirty) { const tab0_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab0_changes.$$scope = { dirty, ctx: ctx2 }; } tab0.$set(tab0_changes); const tab1_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab1_changes.$$scope = { dirty, ctx: ctx2 }; } tab1.$set(tab1_changes); const tab2_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab2_changes.$$scope = { dirty, ctx: ctx2 }; } tab2.$set(tab2_changes); const tab3_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab3_changes.$$scope = { dirty, ctx: ctx2 }; } tab3.$set(tab3_changes); const tab4_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab4_changes.$$scope = { dirty, ctx: ctx2 }; } tab4.$set(tab4_changes); @@ -19808,7 +21480,7 @@ input.checked = ctx[7].ho; append(label, t); if (!mounted) { - dispose = listen(input, "change", ctx[28]); + dispose = listen(input, "change", ctx[29]); mounted = true; } }, @@ -19873,7 +21545,7 @@ if_block1.m(target, anchor); insert(target, if_block1_anchor, anchor); if (!mounted) { - dispose = listen(input, "input", ctx[36]); + dispose = listen(input, "input", ctx[37]); mounted = true; } }, @@ -19988,8 +21660,8 @@ set_input_value(input1, ctx[7].auto_tags); if (!mounted) { dispose = [ - listen(input0, "input", ctx[37]), - listen(input1, "input", ctx[38]) + listen(input0, "input", ctx[38]), + listen(input1, "input", ctx[39]) ]; mounted = true; } @@ -20018,65 +21690,70 @@ let label0; let input0; let t0; - let t1; + let a0; + let t2; let label1; let input1; - let t2; let t3; + let t4; let label2; let input2; - let t4; let t5; + let t6; let label3; let input3; - let t6; let t7; + let t8; let label4; let input4; - let t8; let t9; + let t10; let label5; let input5; - let t10; let t11; + let t12; let label6; let input6; - let t12; let t13; + let t14; let label7; let input7; - let t14; let t15; let t16; let label8; let input8; let t17; let t18; + let t19; let label9; let input9; - let t19; let t20; + let t21; let label10; let input10; - let t21; let t22; + let t23; let label11; let input11; - let t23; let t24; + let t25; let label12; let input12; - let t25; let t26; + let t27; let label13; let input13; - let t27; - let a; + let t28; let t29; let label14; let input14; let t30; - let t31; + let a1; + let t32; + let label15; + let input15; + let t33; + let t34; let if_block1_anchor; let mounted; let dispose; @@ -20086,73 +21763,80 @@ c() { label0 = element("label"); input0 = element("input"); - t0 = text("\n Try to load embeds from server cache"); - t1 = space(); + t0 = text("\n Enable JPGs support (JPG embed and extract)\n "); + a0 = element("a"); + a0.textContent = "?"; + t2 = space(); label1 = element("label"); input1 = element("input"); - t2 = text("\n Display view counts"); - t3 = space(); + t3 = text("\n Try to load embeds from server cache"); + t4 = space(); label2 = element("label"); input2 = element("input"); - t4 = text("\n Check for new versions at startup."); - t5 = space(); + t5 = text("\n Display view counts"); + t6 = space(); label3 = element("label"); input3 = element("input"); - t6 = text("\n Autoexpand Images on opening."); - t7 = space(); + t7 = text("\n Check for new versions at startup."); + t8 = space(); label4 = element("label"); input4 = element("input"); - t8 = text("\n Autoexpand Videos on opening."); - t9 = space(); + t9 = text("\n Autoexpand Images on opening."); + t10 = space(); label5 = element("label"); input5 = element("input"); - t10 = text("\n Loop media content."); - t11 = space(); + t11 = text("\n Autoexpand Videos on opening."); + t12 = space(); label6 = element("label"); input6 = element("input"); - t12 = text("\n Disable hover preview."); - t13 = space(); + t13 = text("\n Loop media content."); + t14 = space(); label7 = element("label"); input7 = element("input"); - t14 = text("\n Hide embedded content behind an eye."); - t15 = space(); - if (if_block0) - if_block0.c(); + t15 = text("\n Disable hover preview."); t16 = space(); label8 = element("label"); input8 = element("input"); - t17 = text("\n Preload external files."); + t17 = text("\n Hide embedded content behind an eye."); t18 = space(); + if (if_block0) + if_block0.c(); + t19 = space(); label9 = element("label"); input9 = element("input"); - t19 = text("\n Preload external files when they are in view."); - t20 = space(); + t20 = text("\n Preload external files."); + t21 = space(); label10 = element("label"); input10 = element("input"); - t21 = text("\n Hotlink content."); - t22 = space(); + t22 = text("\n Preload external files when they are in view."); + t23 = space(); label11 = element("label"); input11 = element("input"); - t23 = text("\n Control audio on videos with mouse wheel."); - t24 = space(); + t24 = text("\n Hotlink content."); + t25 = space(); label12 = element("label"); input12 = element("input"); - t25 = text("\n Show Minimap"); - t26 = space(); + t26 = text("\n Control audio on videos with mouse wheel."); + t27 = space(); label13 = element("label"); input13 = element("input"); - t27 = text("\n \n Disable embedded file preloading"); - a = element("a"); - a.textContent = "?"; + t28 = text("\n Show Minimap"); t29 = space(); label14 = element("label"); input14 = element("input"); - t30 = text("\n \n Enable Hydrus Integration"); - t31 = space(); + t30 = text("\n \n Disable embedded file preloading"); + a1 = element("a"); + a1.textContent = "?"; + t32 = space(); + label15 = element("label"); + input15 = element("input"); + t33 = text("\n \n Enable Hydrus Integration"); + t34 = space(); if (if_block1) if_block1.c(); if_block1_anchor = empty(); attr(input0, "type", "checkbox"); + attr(a0, "title", "JPG embed detection is relatively slow, heavy, so you might want to also enable server cache loading"); attr(input1, "type", "checkbox"); attr(input2, "type", "checkbox"); attr(input3, "type", "checkbox"); @@ -20166,89 +21850,96 @@ attr(input11, "type", "checkbox"); attr(input12, "type", "checkbox"); attr(input13, "type", "checkbox"); - attr(a, "title", "You might still want to enable 'preload external files'"); attr(input14, "type", "checkbox"); + attr(a1, "title", "You might still want to enable 'preload external files'"); + attr(input15, "type", "checkbox"); }, m(target, anchor) { insert(target, label0, anchor); append(label0, input0); - input0.checked = ctx[9]; + input0.checked = ctx[7].jpeg; append(label0, t0); - insert(target, t1, anchor); + append(label0, a0); + insert(target, t2, anchor); insert(target, label1, anchor); append(label1, input1); - input1.checked = ctx[7].dvc; - append(label1, t2); - insert(target, t3, anchor); + input1.checked = ctx[9]; + append(label1, t3); + insert(target, t4, anchor); insert(target, label2, anchor); append(label2, input2); - input2.checked = ctx[7].vercheck; - append(label2, t4); - insert(target, t5, anchor); + input2.checked = ctx[7].dvc; + append(label2, t5); + insert(target, t6, anchor); insert(target, label3, anchor); append(label3, input3); - input3.checked = ctx[7].xpi; - append(label3, t6); - insert(target, t7, anchor); + input3.checked = ctx[7].vercheck; + append(label3, t7); + insert(target, t8, anchor); insert(target, label4, anchor); append(label4, input4); - input4.checked = ctx[7].xpv; - append(label4, t8); - insert(target, t9, anchor); + input4.checked = ctx[7].xpi; + append(label4, t9); + insert(target, t10, anchor); insert(target, label5, anchor); append(label5, input5); - input5.checked = ctx[7].loop; - append(label5, t10); - insert(target, t11, anchor); + input5.checked = ctx[7].xpv; + append(label5, t11); + insert(target, t12, anchor); insert(target, label6, anchor); append(label6, input6); - input6.checked = ctx[7].dh; - append(label6, t12); - insert(target, t13, anchor); + input6.checked = ctx[7].loop; + append(label6, t13); + insert(target, t14, anchor); insert(target, label7, anchor); append(label7, input7); - input7.checked = ctx[7].eye; - append(label7, t14); - insert(target, t15, anchor); - if (if_block0) - if_block0.m(target, anchor); + input7.checked = ctx[7].dh; + append(label7, t15); insert(target, t16, anchor); insert(target, label8, anchor); append(label8, input8); - input8.checked = ctx[7].pre; + input8.checked = ctx[7].eye; append(label8, t17); insert(target, t18, anchor); + if (if_block0) + if_block0.m(target, anchor); + insert(target, t19, anchor); insert(target, label9, anchor); append(label9, input9); - input9.checked = ctx[7].prev; - append(label9, t19); - insert(target, t20, anchor); + input9.checked = ctx[7].pre; + append(label9, t20); + insert(target, t21, anchor); insert(target, label10, anchor); append(label10, input10); - input10.checked = ctx[7].hotlink; - append(label10, t21); - insert(target, t22, anchor); + input10.checked = ctx[7].prev; + append(label10, t22); + insert(target, t23, anchor); insert(target, label11, anchor); append(label11, input11); - input11.checked = ctx[7].ca; - append(label11, t23); - insert(target, t24, anchor); + input11.checked = ctx[7].hotlink; + append(label11, t24); + insert(target, t25, anchor); insert(target, label12, anchor); append(label12, input12); - input12.checked = ctx[7].sh; - append(label12, t25); - insert(target, t26, anchor); + input12.checked = ctx[7].ca; + append(label12, t26); + insert(target, t27, anchor); insert(target, label13, anchor); append(label13, input13); - input13.checked = ctx[7].ep; - append(label13, t27); - append(label13, a); + input13.checked = ctx[7].sh; + append(label13, t28); insert(target, t29, anchor); insert(target, label14, anchor); append(label14, input14); - input14.checked = ctx[7].hyd; + input14.checked = ctx[7].ep; append(label14, t30); - insert(target, t31, anchor); + append(label14, a1); + insert(target, t32, anchor); + insert(target, label15, anchor); + append(label15, input15); + input15.checked = ctx[7].hyd; + append(label15, t33); + insert(target, t34, anchor); if (if_block1) if_block1.m(target, anchor); insert(target, if_block1_anchor, anchor); @@ -20262,41 +21953,45 @@ listen(input5, "change", ctx[25]), listen(input6, "change", ctx[26]), listen(input7, "change", ctx[27]), - listen(input8, "change", ctx[29]), + listen(input8, "change", ctx[28]), listen(input9, "change", ctx[30]), listen(input10, "change", ctx[31]), listen(input11, "change", ctx[32]), listen(input12, "change", ctx[33]), listen(input13, "change", ctx[34]), - listen(input14, "change", ctx[35]) + listen(input14, "change", ctx[35]), + listen(input15, "change", ctx[36]) ]; mounted = true; } }, p(ctx2, dirty) { + if (dirty[0] & 128) { + input0.checked = ctx2[7].jpeg; + } if (dirty[0] & 512) { - input0.checked = ctx2[9]; + input1.checked = ctx2[9]; } if (dirty[0] & 128) { - input1.checked = ctx2[7].dvc; + input2.checked = ctx2[7].dvc; } if (dirty[0] & 128) { - input2.checked = ctx2[7].vercheck; + input3.checked = ctx2[7].vercheck; } if (dirty[0] & 128) { - input3.checked = ctx2[7].xpi; + input4.checked = ctx2[7].xpi; } if (dirty[0] & 128) { - input4.checked = ctx2[7].xpv; + input5.checked = ctx2[7].xpv; } if (dirty[0] & 128) { - input5.checked = ctx2[7].loop; + input6.checked = ctx2[7].loop; } if (dirty[0] & 128) { - input6.checked = ctx2[7].dh; + input7.checked = ctx2[7].dh; } if (dirty[0] & 128) { - input7.checked = ctx2[7].eye; + input8.checked = ctx2[7].eye; } if (ctx2[7].eye) { if (if_block0) { @@ -20304,32 +21999,32 @@ } else { if_block0 = create_if_block_10(ctx2); if_block0.c(); - if_block0.m(t16.parentNode, t16); + if_block0.m(t19.parentNode, t19); } } else if (if_block0) { if_block0.d(1); if_block0 = null; } if (dirty[0] & 128) { - input8.checked = ctx2[7].pre; + input9.checked = ctx2[7].pre; } if (dirty[0] & 128) { - input9.checked = ctx2[7].prev; + input10.checked = ctx2[7].prev; } if (dirty[0] & 128) { - input10.checked = ctx2[7].hotlink; + input11.checked = ctx2[7].hotlink; } if (dirty[0] & 128) { - input11.checked = ctx2[7].ca; + input12.checked = ctx2[7].ca; } if (dirty[0] & 128) { - input12.checked = ctx2[7].sh; + input13.checked = ctx2[7].sh; } if (dirty[0] & 128) { - input13.checked = ctx2[7].ep; + input14.checked = ctx2[7].ep; } if (dirty[0] & 128) { - input14.checked = ctx2[7].hyd; + input15.checked = ctx2[7].hyd; } if (ctx2[7].hyd) { if (if_block1) { @@ -20348,59 +22043,59 @@ if (detaching) detach(label0); if (detaching) - detach(t1); + detach(t2); if (detaching) detach(label1); if (detaching) - detach(t3); + detach(t4); if (detaching) detach(label2); if (detaching) - detach(t5); + detach(t6); if (detaching) detach(label3); if (detaching) - detach(t7); + detach(t8); if (detaching) detach(label4); if (detaching) - detach(t9); + detach(t10); if (detaching) detach(label5); if (detaching) - detach(t11); + detach(t12); if (detaching) detach(label6); if (detaching) - detach(t13); + detach(t14); if (detaching) detach(label7); - if (detaching) - detach(t15); - if (if_block0) - if_block0.d(detaching); if (detaching) detach(t16); if (detaching) detach(label8); if (detaching) detach(t18); + if (if_block0) + if_block0.d(detaching); + if (detaching) + detach(t19); if (detaching) detach(label9); if (detaching) - detach(t20); + detach(t21); if (detaching) detach(label10); if (detaching) - detach(t22); + detach(t23); if (detaching) detach(label11); if (detaching) - detach(t24); + detach(t25); if (detaching) detach(label12); if (detaching) - detach(t26); + detach(t27); if (detaching) detach(label13); if (detaching) @@ -20408,7 +22103,11 @@ if (detaching) detach(label14); if (detaching) - detach(t31); + detach(t32); + if (detaching) + detach(label15); + if (detaching) + detach(t34); if (if_block1) if_block1.d(detaching); if (detaching) @@ -20458,7 +22157,7 @@ $$scope: { ctx } }; dialog = new Dialog_default({ props: dialog_props }); - ctx[50](dialog); + ctx[51](dialog); let each_value_3 = ctx[7].blacklist; let each_blocks = []; for (let i = 0; i < each_value_3.length; i += 1) { @@ -20545,9 +22244,9 @@ current = true; if (!mounted) { dispose = [ - listen(input0, "change", ctx[40]), - listen(button, "click", ctx[45]), - listen(input1, "keydown", ctx[52]) + listen(input0, "change", ctx[41]), + listen(button, "click", ctx[46]), + listen(input1, "keydown", ctx[53]) ]; mounted = true; } @@ -20601,7 +22300,7 @@ check_outros(); } const dialog_changes = {}; - if (dirty[0] & 2 | dirty[2] & 256) { + if (dirty[0] & 2 | dirty[2] & 512) { dialog_changes.$$scope = { dirty, ctx: ctx2 }; } dialog.$set(dialog_changes); @@ -20677,7 +22376,7 @@ detach(button); if (detaching) detach(t8); - ctx[50](null); + ctx[51](null); destroy_component(dialog, detaching); if (detaching) detach(t9); @@ -20727,7 +22426,7 @@ append(label, t0); append(label, a); if (!mounted) { - dispose = listen(input, "input", ctx[41]); + dispose = listen(input, "input", ctx[42]); mounted = true; } }, @@ -20764,17 +22463,17 @@ let tag; let current; function func(...args) { - return ctx[42](ctx[68], ...args); + return ctx[43](ctx[69], ...args); } function remove_handler() { - return ctx[43](ctx[68]); + return ctx[44](ctx[69]); } function toggle_handler() { - return ctx[44](ctx[68]); + return ctx[45](ctx[69]); } tag = new Tag_default({ props: { - tag: ctx[68].name, + tag: ctx[69].name, toggleable: true, toggled: !ctx[7].rsources.find(func)?.disabled } @@ -20793,7 +22492,7 @@ ctx = new_ctx; const tag_changes = {}; if (dirty[0] & 128) - tag_changes.tag = ctx[68].name; + tag_changes.tag = ctx[69].name; if (dirty[0] & 128) tag_changes.toggled = !ctx[7].rsources.find(func)?.disabled; tag.$set(tag_changes); @@ -20898,10 +22597,10 @@ append(div, button); if (!mounted) { dispose = [ - listen(input0, "input", ctx[46]), - listen(input1, "input", ctx[47]), - listen(input2, "input", ctx[48]), - listen(input3, "input", ctx[49]), + listen(input0, "input", ctx[47]), + listen(input1, "input", ctx[48]), + listen(input2, "input", ctx[49]), + listen(input3, "input", ctx[50]), listen(button, "click", ctx[11]) ]; mounted = true; @@ -20933,9 +22632,9 @@ let tag; let current; function toggle_handler_1() { - return ctx[51](ctx[66]); + return ctx[52](ctx[67]); } - tag = new Tag_default({ props: { tag: ctx[66] } }); + tag = new Tag_default({ props: { tag: ctx[67] } }); tag.$on("toggle", toggle_handler_1); return { c() { @@ -20949,7 +22648,7 @@ ctx = new_ctx; const tag_changes = {}; if (dirty[0] & 128) - tag_changes.tag = ctx[66]; + tag_changes.tag = ctx[67]; tag.$set(tag_changes); }, i(local) { @@ -20999,7 +22698,7 @@ insert(target, if_block_anchor, anchor); current = true; if (!mounted) { - dispose = listen(input, "change", ctx[39]); + dispose = listen(input, "change", ctx[40]); mounted = true; } }, @@ -21053,14 +22752,14 @@ } function create_each_block_2(ctx) { let option; - let t_value = ctx[63].domain + ""; + let t_value = ctx[64].domain + ""; let t; let option_value_value; return { c() { option = element("option"); t = text(t_value); - option.__value = option_value_value = ctx[65]; + option.__value = option_value_value = ctx[66]; option.value = option.__value; }, m(target, anchor) { @@ -21103,7 +22802,7 @@ t3 = text("Maximum number of embedded links to display\n "); input = element("input"); if (ctx[7].fhost === void 0) - add_render_callback(() => ctx[53].call(select)); + add_render_callback(() => ctx[54].call(select)); attr(input, "type", "number"); attr(input, "class", "svelte-2r0xqp"); attr(label, "class", "svelte-2r0xqp"); @@ -21123,8 +22822,8 @@ set_input_value(input, ctx[7].maxe); if (!mounted) { dispose = [ - listen(select, "change", ctx[53]), - listen(input, "input", ctx[54]) + listen(select, "change", ctx[54]), + listen(input, "input", ctx[55]) ]; mounted = true; } @@ -21248,14 +22947,14 @@ let div; let a; let t0; - let t1_value = ctx[60].id + ""; + let t1_value = ctx[61].id + ""; let t1; let a_href_value; let t2; - let t3_value = ctx[60].pees + ""; + let t3_value = ctx[61].pees + ""; let t3; let t4; - let t5_value = ctx[60].eyes + ctx[60].other + ""; + let t5_value = ctx[61].eyes + ctx[61].other + ""; let t5; let t6; return { @@ -21269,7 +22968,7 @@ t4 = text(" / "); t5 = text(t5_value); t6 = text(")\n "); - attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[14] + "/thread/" + ctx[60].id); + attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[14] + "/thread/" + ctx[61].id); attr(div, "class", "mbepis"); }, m(target, anchor) { @@ -21284,14 +22983,14 @@ append(div, t6); }, p(ctx2, dirty) { - if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[60].id + "")) + if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[61].id + "")) set_data(t1, t1_value); - if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[14] + "/thread/" + ctx2[60].id)) { + if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[14] + "/thread/" + ctx2[61].id)) { attr(a, "href", a_href_value); } - if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[60].pees + "")) + if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[61].pees + "")) set_data(t3, t3_value); - if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[60].eyes + ctx2[60].other + "")) + if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[61].eyes + ctx2[61].other + "")) set_data(t5, t5_value); }, d(detaching) { @@ -21342,7 +23041,7 @@ if_block.m(target, anchor); insert(target, if_block_anchor, anchor); if (!mounted) { - dispose = listen(input, "change", ctx[55]); + dispose = listen(input, "change", ctx[56]); mounted = true; } }, @@ -21440,11 +23139,11 @@ } function create_each_block2(ctx) { let h3; - let t0_value = ctx[57].title + ""; + let t0_value = ctx[58].title + ""; let t0; let t1; let p; - let t2_value = ctx[57].content + ""; + let t2_value = ctx[58].content + ""; let t2; return { c() { @@ -21462,9 +23161,9 @@ append(p, t2); }, p(ctx2, dirty) { - if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[57].title + "")) + if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[58].title + "")) set_data(t0, t0_value); - if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[57].content + "")) + if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[58].content + "")) set_data(t2, t2_value); }, d(detaching) { @@ -21675,32 +23374,32 @@ }, p(ctx2, dirty) { const tablist_changes = {}; - if (dirty[0] & 256 | dirty[2] & 256) { + if (dirty[0] & 256 | dirty[2] & 512) { tablist_changes.$$scope = { dirty, ctx: ctx2 }; } tablist.$set(tablist_changes); const tabpanel0_changes = {}; - if (dirty[0] & 896 | dirty[2] & 256) { + if (dirty[0] & 896 | dirty[2] & 512) { tabpanel0_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel0.$set(tabpanel0_changes); const tabpanel1_changes = {}; - if (dirty[0] & 134 | dirty[2] & 256) { + if (dirty[0] & 134 | dirty[2] & 512) { tabpanel1_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel1.$set(tabpanel1_changes); const tabpanel2_changes = {}; - if (dirty[0] & 128 | dirty[2] & 256) { + if (dirty[0] & 128 | dirty[2] & 512) { tabpanel2_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel2.$set(tabpanel2_changes); const tabpanel3_changes = {}; - if (dirty[0] & 224 | dirty[2] & 256) { + if (dirty[0] & 224 | dirty[2] & 512) { tabpanel3_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel3.$set(tabpanel3_changes); const tabpanel4_changes = {}; - if (dirty[0] & 8 | dirty[2] & 256) { + if (dirty[0] & 8 | dirty[2] & 512) { tabpanel4_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel4.$set(tabpanel4_changes); @@ -21900,34 +23599,38 @@ const select_handler = () => updateThreads(); const select_handler_1 = () => updateNews(); function input0_change_handler() { + $settings.jpeg = this.checked; + settings.set($settings); + } + function input1_change_handler() { $cached = this.checked; cached.set($cached); } - function input1_change_handler() { + function input2_change_handler() { $settings.dvc = this.checked; settings.set($settings); } - function input2_change_handler() { + function input3_change_handler() { $settings.vercheck = this.checked; settings.set($settings); } - function input3_change_handler() { + function input4_change_handler() { $settings.xpi = this.checked; settings.set($settings); } - function input4_change_handler() { + function input5_change_handler() { $settings.xpv = this.checked; settings.set($settings); } - function input5_change_handler() { + function input6_change_handler() { $settings.loop = this.checked; settings.set($settings); } - function input6_change_handler() { + function input7_change_handler() { $settings.dh = this.checked; settings.set($settings); } - function input7_change_handler() { + function input8_change_handler() { $settings.eye = this.checked; settings.set($settings); } @@ -21935,31 +23638,31 @@ $settings.ho = this.checked; settings.set($settings); } - function input8_change_handler() { + function input9_change_handler() { $settings.pre = this.checked; settings.set($settings); } - function input9_change_handler() { + function input10_change_handler() { $settings.prev = this.checked; settings.set($settings); } - function input10_change_handler() { + function input11_change_handler() { $settings.hotlink = this.checked; settings.set($settings); } - function input11_change_handler() { + function input12_change_handler() { $settings.ca = this.checked; settings.set($settings); } - function input12_change_handler() { + function input13_change_handler() { $settings.sh = this.checked; settings.set($settings); } - function input13_change_handler() { + function input14_change_handler() { $settings.ep = this.checked; settings.set($settings); } - function input14_change_handler() { + function input15_change_handler() { $settings.hyd = this.checked; settings.set($settings); } @@ -22068,14 +23771,15 @@ input5_change_handler, input6_change_handler, input7_change_handler, - input_change_handler, input8_change_handler, + input_change_handler, input9_change_handler, input10_change_handler, input11_change_handler, input12_change_handler, input13_change_handler, input14_change_handler, + input15_change_handler, input_input_handler, input0_input_handler, input1_input_handler, @@ -23418,8 +25122,8 @@ const get_key = (ctx2) => ctx2[4].id; for (let i = 0; i < each_value.length; i += 1) { let child_ctx = get_each_context6(ctx, each_value, i); - let key = get_key(child_ctx); - each_1_lookup.set(key, each_blocks[i] = create_each_block6(key, child_ctx)); + let key2 = get_key(child_ctx); + each_1_lookup.set(key2, each_blocks[i] = create_each_block6(key2, child_ctx)); } return { c() { @@ -23963,8 +25667,8 @@ check: function check(token) { return this.get("validate", token.toString(), token); }, - get: function get(key, operator, token) { - var option = this[key]; + get: function get(key2, operator, token) { + var option = this[key2]; if (!option) { return option; } @@ -23973,13 +25677,13 @@ case "function": return option(operator, token.t); case "object": - optionValue = token.t in option ? option[token.t] : defaults[key]; + optionValue = token.t in option ? option[token.t] : defaults[key2]; return typeof optionValue === "function" ? optionValue(operator, token.t) : optionValue; } return option; }, - getObject: function getObject(key, operator, token) { - var option = this[key]; + getObject: function getObject(key2, operator, token) { + var option = this[key2]; return typeof option === "function" ? option(operator, token.t) : option; } }; @@ -24776,7 +26480,7 @@ if (!supportedMainDomain(location.host) && !supportedAltDomain(location.host)) throw "PEE not supported here, skipping"; var qp; - var csettings5 = initial_settings; + var csettings6 = initial_settings; var processors = [thirdeye_default, pomf_default, pngv3_default, jpg_default, webm_default, gif_default]; var cappState; settings.subscribe(async (b) => { @@ -24796,9 +26500,9 @@ } } } - csettings5 = b; + csettings6 = b; processors = [ - ...!csettings5.te ? [thirdeye_default] : [], + ...!csettings6.te ? [thirdeye_default] : [], pngv3_default, pomf_default, jpg_default, @@ -24838,12 +26542,16 @@ } else { chunk = { done: false, value }; cumul = import_buffer11.Buffer.concat([cumul, value]); - found = await proc.has_embed(cumul); + const v = await proc.has_embed(cumul); + if (typeof v == "string") { + return [await proc.extract(cumul, v), false]; + } + found = v; } } while (found !== false && !chunk.done); succ = true; await iter.next(true); - if (found === false) { + if (found !== true) { return; } return [await proc.extract(cumul), false]; @@ -24856,7 +26564,7 @@ var textToElement = (s) => document.createRange().createContextualFragment(s).children[0]; var pendingPosts = []; var signalNewEmbeds = debounce(async () => { - if (!csettings5.tm) + if (!csettings6.tm) return; try { const boardname = location.pathname.match(/\/([^/]*)\//)[1]; @@ -24878,7 +26586,7 @@ var shouldUseCache = () => { if (cappState.isCatalog) return false; - return typeof csettings5.cache == "boolean" ? csettings5.cache : location.hostname.includes("b4k"); + return typeof csettings6.cache == "boolean" ? csettings6.cache : location.hostname.includes("b4k"); }; var processPost = async (post) => { const origlink = qp.getImageLink(post); @@ -24889,7 +26597,7 @@ return; let res2 = void 0; const reportEmbed = () => { - if (csettings5.tm) { + if (csettings6.tm) { if (["boards.4chan.org", "boards.4channel.org"].includes(location.host)) { if (!cappState.isCatalog) { const op = +location.pathname.match(/\/thread\/(.*)/)[1]; @@ -24936,7 +26644,7 @@ navigator.clipboard.writeText(text3); } var scrapeBoard = async (self) => { - if (csettings5.tm) { + if (csettings6.tm) { fireNotification("success", "Scrapping board with telemetry on! Thank you for your service, selfless stranger ;_;7"); } self.disabled = true; @@ -24976,7 +26684,11 @@ } else { chunk = { done: false, value }; cumul = import_buffer11.Buffer.concat([cumul, value]); - found = await proc.has_embed(cumul); + const v = await proc.has_embed(cumul); + if (typeof v == "string") { + return true; + } + found = v; } } while (found !== false && !chunk.done); await iter.next(true); @@ -25060,7 +26772,7 @@ Use the WebExtension version of PEE if you want to use b4k!`); return; else qp = lqp; - if (csettings5.vercheck) + if (csettings6.vercheck) versionCheck(); const postQuote = ({ scanner, parser, utils }) => { const { CLOSEANGLEBRACKET: CLOSEANGLEBRACKET2, NUM: NUM2 } = scanner.tokens; diff --git a/chrome/manifest.json b/chrome/manifest.json index a289ace..4a6c1f0 100644 --- a/chrome/manifest.json +++ b/chrome/manifest.json @@ -2,7 +2,7 @@ "manifest_version": 3, "name": "PngExtraEmbedder", "description": "Discover embedded files on 4chan and archives!", - "version": "0.260", + "version": "0.261", "icons": { "64": "1449696017588.png" }, diff --git a/dist/main.js b/dist/main.js index cad82a1..c6b3c89 100644 --- a/dist/main.js +++ b/dist/main.js @@ -14,20 +14,20 @@ }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { - for (let key of __getOwnPropNames(from)) - if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + for (let key2 of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key2) && key2 !== except) + __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable }); } return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod)); - var __decorateClass = (decorators, target, key, kind) => { - var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; + var __decorateClass = (decorators, target, key2, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key2) : target; for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) - result = (kind ? decorator(target, key, result) : decorator(result)) || result; + result = (kind ? decorator(target, key2, result) : decorator(result)) || result; if (kind && result) - __defProp(target, key, result); + __defProp(target, key2, result); return result; }; var __toBinary = /* @__PURE__ */ (() => { @@ -51,7 +51,7 @@ var define_BUILD_VERSION_default; var init_define_BUILD_VERSION = __esm({ ""() { - define_BUILD_VERSION_default = [0, 255]; + define_BUILD_VERSION_default = [0, 261]; } }); @@ -2246,12 +2246,12 @@ } if (arguments.length === 0) { var keys = Object.keys(events); - var key; + var key2; for (i = 0; i < keys.length; ++i) { - key = keys[i]; - if (key === "removeListener") + key2 = keys[i]; + if (key2 === "removeListener") continue; - this.removeAllListeners(key); + this.removeAllListeners(key2); } this.removeAllListeners("removeListener"); this._events = /* @__PURE__ */ Object.create(null); @@ -2410,24 +2410,24 @@ for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { - ownKeys(Object(source), true).forEach(function(key) { - _defineProperty(target, key, source[key]); + ownKeys(Object(source), true).forEach(function(key2) { + _defineProperty(target, key2, source[key2]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { - ownKeys(Object(source)).forEach(function(key) { - Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + ownKeys(Object(source)).forEach(function(key2) { + Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2)); }); } } return target; } - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + function _defineProperty(obj, key2, value) { + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); } else { - obj[key] = value; + obj[key2] = value; } return obj; } @@ -3443,8 +3443,8 @@ init_esbuild_inject(); var objectKeys = Object.keys || function(obj) { var keys2 = []; - for (var key in obj) { - keys2.push(key); + for (var key2 in obj) { + keys2.push(key2); } return keys2; }; @@ -3533,8 +3533,8 @@ var buffer = require_buffer(); var Buffer18 = buffer.Buffer; function copyProps(src, dst) { - for (var key in src) { - dst[key] = src[key]; + for (var key2 in src) { + dst[key2] = src[key2]; } } if (Buffer18.from && Buffer18.alloc && Buffer18.allocUnsafe && Buffer18.allocUnsafeSlow) { @@ -3957,11 +3957,11 @@ init_define_BUILD_VERSION(); init_esbuild_inject(); var _Object$setPrototypeO; - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + function _defineProperty(obj, key2, value) { + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); } else { - obj[key] = value; + obj[key2] = value; } return obj; } @@ -10318,7 +10318,7 @@ return this; }; EventEmitter.prototype.removeAllListeners = function(type) { - var key, listeners; + var key2, listeners; if (!this._events) return this; if (!this._events.removeListener) { @@ -10329,10 +10329,10 @@ return this; } if (arguments.length === 0) { - for (key in this._events) { - if (key === "removeListener") + for (key2 in this._events) { + if (key2 === "removeListener") continue; - this.removeAllListeners(key); + this.removeAllListeners(key2); } this.removeAllListeners("removeListener"); this._events = {}; @@ -10772,6 +10772,1642 @@ } }); + // node_modules/f5stegojs/f5stego.js + var require_f5stego = __commonJS({ + "node_modules/f5stegojs/f5stego.js"(exports, module) { + init_define_BUILD_VERSION(); + init_esbuild_inject(); + (function(root, factory) { + "use strict"; + if (typeof define === "function" && define.amd) { + define([], factory); + } else if (typeof exports === "object") { + module.exports = factory(); + } else { + root.f5stego = factory(); + } + })(exports, function() { + "use strict"; + var f5stego = function(key2, maxPixels) { + this.maxPixels = maxPixels || 4096 * 4096; + this.shuffleInit(key2); + }; + f5stego.prototype.shuffleInit = function(key2) { + this.randPool = new ArrayBuffer(this.maxPixels * 4.125); + if (!key2.length) + throw "key needed"; + var i = 0, j = 0, t = 0, k = 0, S = new Uint8Array(256), rnd = new Uint8Array(this.randPool); + for (i = 0; i < 256; ++i) + S[i] = i; + for (i = 0; i < 256; ++i) { + j = j + S[i] + key2[i % key2.length] & 255; + t = S[i]; + S[i] = S[j]; + S[j] = t; + } + i = 0; + j = 0; + for (k = 0; k < this.maxPixels * 4.125; ++k) { + i = i + 1 & 255; + j = j + S[i] & 255; + t = S[i]; + S[i] = S[j]; + S[j] = t; + rnd[k] = S[t + S[i] & 255]; + } + }; + f5stego.prototype.stegShuffle = function(pm) { + var t, l, k, random_index, rand32Array = new Uint32Array(this.randPool); + if (typeof pm == "number") { + l = pm; + pm = new Uint32Array(l); + for (k = 1; k < l; k++) { + random_index = rand32Array[k] % (k + 1); + if (random_index != k) + pm[k] = pm[random_index]; + pm[random_index] = k; + } + } else { + l = pm.length; + for (k = 1; k < l; k++) { + random_index = rand32Array[k] % (k + 1); + t = pm[k]; + pm[k] = pm[random_index]; + pm[random_index] = t; + } + } + return { pm, gamma: new Uint8Array(this.randPool, l * 4) }; + }; + f5stego.prototype._analyze = function(coeff) { + var _one = 0, _zero = 0, _large, _ratio, usable, i, k, embedded, matched, changed; + for (i = 0; i < coeff.length; i++) { + if (i % 64 === 0) + continue; + if (coeff[i] === 0) + _zero++; + if (coeff[i] == 1 || coeff[i] == -1) + _one++; + } + _large = coeff.length - _zero - _one - coeff.length / 64; + _ratio = _one / (_large + _one); + var res = { + "capacity": [0, (_large + 0.49 * _one >> 3) - 1], + "coeff_total": coeff.length, + "coeff_large": _large, + "coeff_zero": _zero, + "coeff_one": _one, + "coeff_one_ratio": _one / (_large + _one) + }; + for (i = 2; i < 17; i++) { + k = (1 << i) - 1; + usable = _large + _one; + embedded = 0; + while (usable > k) { + matched = usable / k / (1 << i) / (1 << i) | 0; + usable -= matched * k; + changed = usable * (1 - _ratio) / k * 0.96 | 0; + usable -= changed * k; + embedded += changed + matched; + k++; + } + res.capacity[i] = (i * embedded >> 3) - 1; + } + return res; + }; + f5stego.prototype._f5write = function(coeff, data, k) { + var coeff_count = coeff.length; + var _changed = 0, _embedded = 0, _examined = 0, _thrown = 0, shuffled_index = 0, i, n, ii; + var pm = this.stegShuffle(coeff_count); + var gamma = pm.gamma, gammaI = 0; + pm = pm.pm; + var next_bit_to_embed = 0, byte_to_embed = data.length, data_idx = 0, available_bits_to_embed = 0; + n = (1 << k) - 1; + byte_to_embed = k - 1; + byte_to_embed ^= gamma[gammaI++]; + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed = 3; + for (ii = 0; ii < coeff_count; ii++) { + shuffled_index = pm[ii]; + if (shuffled_index % 64 === 0 || coeff[shuffled_index] === 0) + continue; + var cc = coeff[shuffled_index]; + _examined++; + if (cc > 0 && (cc & 1) != next_bit_to_embed) { + coeff[shuffled_index]--; + _changed++; + } else if (cc < 0 && (cc & 1) == next_bit_to_embed) { + coeff[shuffled_index]++; + _changed++; + } + if (coeff[shuffled_index] !== 0) { + _embedded++; + if (available_bits_to_embed === 0) { + if (k != 1 || data_idx >= data.length) + break; + byte_to_embed = data[data_idx++]; + byte_to_embed ^= gamma[gammaI++]; + available_bits_to_embed = 8; + } + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed--; + } else { + _thrown++; + } + } + if (k == 1 && _embedded < data.length * 8) + throw "capacity exceeded " + _embedded / 8 + " " + data.length; + if (k != 1) { + var is_last_byte = false, k_bits_to_embed = 0; + while (!is_last_byte || available_bits_to_embed !== 0 && is_last_byte) { + k_bits_to_embed = 0; + for (i = 0; i < k; i++) { + if (available_bits_to_embed === 0) { + if (data_idx >= data.length) { + is_last_byte = true; + break; + } + byte_to_embed = data[data_idx++]; + byte_to_embed ^= gamma[gammaI++]; + available_bits_to_embed = 8; + } + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed--; + k_bits_to_embed |= next_bit_to_embed << i; + } + var code_word = []; + var ci = null; + for (i = 0; i < n; i++) { + while (true) { + if (++ii >= coeff_count) { + throw "capacity exceeded " + _embedded / 8; + } + ci = pm[ii]; + if (ci % 64 !== 0 && coeff[ci] !== 0) + break; + } + code_word.push(ci); + } + _examined += n; + while (true) { + var vhash = 0, extracted_bit; + for (i = 0; i < code_word.length; i++) { + if (coeff[code_word[i]] > 0) { + extracted_bit = coeff[code_word[i]] & 1; + } else { + extracted_bit = 1 - (coeff[code_word[i]] & 1); + } + if (extracted_bit == 1) + vhash ^= i + 1; + } + i = vhash ^ k_bits_to_embed; + if (!i) { + _embedded += k; + break; + } + i--; + coeff[code_word[i]] += coeff[code_word[i]] < 0 ? 1 : -1; + _changed++; + if (coeff[code_word[i]] === 0) { + _thrown++; + code_word.splice(i, 1); + while (true) { + if (++ii >= coeff_count) { + throw "capacity exceeded " + _embedded / 8; + } + ci = pm[ii]; + if (ci % 64 !== 0 && coeff[ci] !== 0) + break; + } + _examined++; + code_word.push(ci); + } else { + _embedded += k; + break; + } + } + } + } + return { + "k": k, + "embedded": _embedded / 8, + "examined": _examined, + "changed": _changed, + "thrown": _thrown, + "efficiency": (_embedded / _changed).toFixed(2) + }; + }; + f5stego.prototype.analyze = function() { + var i, comp = this.frame.components[0]; + if (comp.componentId != 1) { + for (i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + return this._analyze(comp.blocks); + }; + f5stego.prototype.f5put = function(data, k) { + var t, i, comp = this.frame.components[0]; + if (data.length > 8388607) + throw "Data too big. Max 8388607 bytes allowed."; + if (data.length < 32768) { + t = new Uint8Array(2 + data.length); + t[0] = data.length & 255; + t[1] = data.length >>> 8; + t.set(data, 2); + } else { + t = new Uint8Array(3 + data.length); + t[0] = data.length & 255; + t[1] = (data.length >>> 8 & 127) + 128; + t[2] = data.length >>> 15; + t.set(data, 3); + } + if (comp.componentId != 1) { + for (i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + if (k) { + return this._f5write(comp.blocks, t, k); + } + var ret, prop = this._analyze(comp.blocks); + k = 0; + for (i = prop.capacity.length - 1; i >= 0; i--) { + if (prop.capacity[i] >= t.length) { + k = i; + break; + } + } + if (k === 0) + throw "capacity exceeded"; + try { + ret = this._f5write(comp.blocks, t, k); + } catch (e) { + k--; + if (k === 0) + throw "capacity exceeded"; + ret = this._f5write(comp.blocks, t, k); + } + ret["stats"] = prop; + return ret; + }; + f5stego.prototype.f5get = function() { + var comp = this.frame.components[0]; + if (comp.componentId != 1) { + for (var i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + var coeff = new Int16Array(comp.blocks.length); + coeff.set(comp.blocks); + var pos = -1, extrBit = 0, cCount = coeff.length - 1; + var pm = this.stegShuffle(coeff), gamma = pm.gamma, gammaI = 0; + var n, k = 0; + var out = new Uint8Array(coeff.length / 8 | 0), extrByte = 0, outPos = 0, bitsAvail = 0, code = 0, hash2 = 0; + while (bitsAvail < 4) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + k |= extrBit << bitsAvail; + bitsAvail++; + } + k = (k ^ gamma[gammaI++] & 15) + 1; + n = (1 << k) - 1; + bitsAvail = 0; + if (k == 1) { + while (pos < cCount) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + extrByte |= extrBit << bitsAvail; + bitsAvail++; + if (bitsAvail == 8) { + out[outPos++] = extrByte ^ gamma[gammaI++]; + extrByte = 0; + bitsAvail = 0; + } + } + } else { + while (pos < cCount) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + hash2 ^= extrBit * ++code; + if (code == n) { + extrByte |= hash2 << bitsAvail; + bitsAvail += k; + code = 0; + hash2 = 0; + while (bitsAvail >= 8) { + out[outPos++] = extrByte & 255 ^ gamma[gammaI++]; + bitsAvail -= 8; + extrByte = extrByte >> 8; + } + } + } + } + while (bitsAvail > 0) { + out[outPos++] = extrByte & 255 ^ gamma[gammaI++]; + bitsAvail -= 8; + extrByte = extrByte >> 8; + } + var s = 2, l = out[0]; + if (out[1] & 128) { + s++; + l += ((out[1] & 127) << 8) + (out[2] << 15); + } else { + l += out[1] << 8; + } + return out.subarray(s, s + l); + }; + f5stego.prototype.parse = function(data) { + var offset = 0; + function _buildHuffmanTable(nrcodes, values) { + var codevalue = 0, pos_in_table = 0, HT = new Uint16Array(65536); + for (var k = 0; k < 16; k++) { + for (var j2 = 0; j2 < nrcodes[k]; j2++) { + for (var i2 = codevalue << 15 - k, cntTo = codevalue + 1 << 15 - k; i2 < cntTo; i2++) { + HT[i2] = values[pos_in_table] + (k + 1 << 8); + } + pos_in_table++; + codevalue++; + } + codevalue *= 2; + } + return HT; + } + function decodeScan(data2, offset2, frame, components2, resetInterval2, spectralStart2, spectralEnd2, successivePrev, successive) { + var startOffset = offset2, bitsData = 0, bitsCount = 0, eobrun = 0, p1 = 1 << successive, m1 = -1 << successive; + function decodeBaseline(component2, pos) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + var t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535]; + if (!t) + throw "invalid huffman sequence"; + bitsCount -= t >>> 8; + t &= 255; + var diff = 0; + if (t !== 0) { + while (bitsCount < t) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + diff = bitsData >>> bitsCount - t & (1 << t) - 1; + bitsCount -= t; + if (diff < 1 << t - 1) + diff += (-1 << t) + 1; + } + component2.blocksDC[pos >> 6] = component2.pred += diff; + var k2 = 1, s, r; + while (k2 < 64) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s === 0) { + if (r < 15) { + break; + } + k2 += 16; + continue; + } + k2 += r; + while (bitsCount < s) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1; + bitsCount -= s; + if (component2.blocks[pos + k2] < 1 << s - 1) + component2.blocks[pos + k2] += (-1 << s) + 1; + k2++; + } + } + function decodeDCFirst(component2, pos) { + var diff = 0; + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + var t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535]; + if (!t) + throw "invalid huffman sequence"; + bitsCount -= t >>> 8; + t &= 255; + if (t !== 0) { + while (bitsCount < t) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + diff = bitsData >>> bitsCount - t & (1 << t) - 1; + bitsCount -= t; + if (diff < 1 << t - 1) + diff += (-1 << t) + 1; + } + component2.blocksDC[pos >> 6] = component2.pred += diff << successive; + } + function decodeDCSuccessive(component2, pos) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocksDC[pos >> 6] |= (bitsData >>> --bitsCount & 1) << successive; + } + function decodeACFirst(component2, pos) { + if (eobrun > 0) { + eobrun--; + return; + } + var k2 = spectralStart2, s, r; + while (k2 <= spectralEnd2) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s === 0) { + if (r != 15) { + eobrun = (1 << r) - 1; + if (r) { + while (bitsCount < r) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + eobrun += bitsData >>> bitsCount - r & (1 << r) - 1; + bitsCount -= r; + } + break; + } + k2 += 16; + continue; + } + k2 += r; + while (bitsCount < s) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1; + bitsCount -= s; + if (component2.blocks[pos + k2] < 1 << s - 1) + component2.blocks[pos + k2] += (-1 << s) + 1; + component2.blocks[pos + k2] *= p1; + k2++; + } + } + function decodeACSuccessive(component2, pos) { + var k2 = spectralStart2, r, s; + if (!eobrun) { + while (k2 <= spectralEnd2) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s) { + if (s != 1) + throw "bad jpeg"; + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + s = bitsData >>> --bitsCount & 1 ? p1 : m1; + } else { + if (r != 15) { + eobrun = 1 << r; + if (r) { + while (bitsCount < r) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + eobrun += bitsData >>> bitsCount - r & (1 << r) - 1; + bitsCount -= r; + } + break; + } + } + while (k2 <= spectralEnd2) { + if (component2.blocks[pos + k2]) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1); + } else { + if (--r < 0) + break; + } + k2++; + } + if (s) + component2.blocks[pos + k2] = s; + k2++; + } + } + if (eobrun) { + while (k2 <= spectralEnd2) { + if (component2.blocks[pos + k2]) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1); + } + k2++; + } + eobrun--; + } + } + var decodeFn; + if (frame.progressive) { + if (spectralStart2 === 0) + decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; + else + decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; + } else { + decodeFn = decodeBaseline; + } + var marker, mcuExpected, i2, j2, k, n, mcusPerLine2, mcusPerRow, x, y; + if (components2.length == 1) { + mcusPerLine2 = components2[0].blocksPerLine; + mcusPerRow = components2[0].blocksPerColumn; + mcuExpected = mcusPerRow * mcusPerLine2; + if (!resetInterval2) + resetInterval2 = mcuExpected; + n = resetInterval2; + components2[0].pred = 0; + eobrun = 0; + for (y = 0; y < mcusPerRow; y++) { + for (x = 0; x < mcusPerLine2; x++) { + if (!n) { + n = resetInterval2; + components2[0].pred = 0; + eobrun = 0; + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + bitsCount = 0; + marker = data2[offset2] << 8 | data2[offset2 + 1]; + if (marker >= 65488 && marker <= 65495) { + offset2 += 2; + } else { + if (marker <= 65280) { + throw "bad jpeg"; + } + break; + } + } + n--; + for (i2 = 0; i2 < components2.length; i2++) { + decodeFn(components2[i2], (y * components2[i2].blocksPerLineForMcu + x) * 64); + } + } + } + } else { + mcusPerLine2 = frame.mcusPerLine; + mcusPerRow = frame.mcusPerColumn; + mcuExpected = mcusPerRow * mcusPerLine2; + if (!resetInterval2) + resetInterval2 = mcuExpected; + n = resetInterval2; + for (i2 = 0; i2 < components2.length; i2++) + components2[i2].pred = 0; + eobrun = 0; + for (y = 0; y < mcusPerRow; y++) { + for (x = 0; x < mcusPerLine2; x++) { + if (!n) { + n = resetInterval2; + for (i2 = 0; i2 < components2.length; i2++) + components2[i2].pred = 0; + eobrun = 0; + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + bitsCount = 0; + marker = data2[offset2] << 8 | data2[offset2 + 1]; + if (marker >= 65488 && marker <= 65495) { + offset2 += 2; + } else { + if (marker <= 65280) { + throw "bad jpeg"; + } + break; + } + } + n--; + for (i2 = 0; i2 < components2.length; i2++) { + for (j2 = 0; j2 < components2[i2].v; j2++) { + for (k = 0; k < components2[i2].h; k++) { + decodeFn(components2[i2], ((y * components2[i2].v + j2) * components2[i2].blocksPerLineForMcu + x * components2[i2].h + k) * 64); + } + } + } + } + } + } + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + return offset2 - startOffset; + } + function readUint16() { + var value = data[offset] << 8 | data[offset + 1]; + offset += 2; + return value; + } + function readDataBlock() { + var length = readUint16(); + var array = data.subarray(offset, offset + length - 2); + offset += array.length; + return array; + } + this["_raw"] = data; + this["jfif"] = null; + this["APPn"] = []; + this["qts"] = []; + this["frame"] = null; + this["tail"] = null; + var markerHi, markerLo, i, j, resetInterval, component; + var huffmanTablesAC = [], huffmanTablesDC = []; + while (1) { + if (offset >= data.length) + throw "unexpected EOF"; + markerHi = data[offset++]; + markerLo = data[offset++]; + if (markerHi == 255) { + if (markerLo == 224) { + this.jfif = readDataBlock(); + } + if (markerLo > 224 && markerLo < 240 || markerLo == 254) { + this.APPn.push({ + "app": markerLo, + "data": readDataBlock() + }); + } + if (markerLo == 219) { + this.qts.push(readDataBlock()); + } + if (markerLo >= 192 && markerLo <= 194) { + if (this.frame) + throw "Only single frame JPEGs supported"; + readUint16(); + this.frame = { + "extended": markerLo === 193, + "progressive": markerLo === 194, + "precision": data[offset++], + "scanLines": readUint16(), + "samplesPerLine": readUint16(), + "components": [], + "componentIds": {}, + "maxH": 1, + "maxV": 1 + }; + if (this.frame.scanLines * this.frame.samplesPerLine > this.maxPixels) + throw "Image is too big."; + var componentsCount = data[offset++], componentId; + var maxH = 0, maxV = 0; + for (i = 0; i < componentsCount; i++) { + componentId = data[offset]; + var h = data[offset + 1] >> 4; + var v = data[offset + 1] & 15; + if (maxH < h) + maxH = h; + if (maxV < v) + maxV = v; + var qId = data[offset + 2]; + var l = this.frame.components.push({ + "componentId": componentId, + "h": h, + "v": v, + "quantizationTable": qId + }); + this.frame.componentIds[componentId] = l - 1; + offset += 3; + } + this.frame.maxH = maxH; + this.frame.maxV = maxV; + var mcusPerLine = Math.ceil(this.frame.samplesPerLine / 8 / maxH); + var mcusPerColumn = Math.ceil(this.frame.scanLines / 8 / maxV); + for (i = 0; i < this.frame.components.length; i++) { + component = this.frame.components[i]; + var blocksPerLine = Math.ceil(Math.ceil(this.frame.samplesPerLine / 8) * component.h / maxH); + var blocksPerColumn = Math.ceil(Math.ceil(this.frame.scanLines / 8) * component.v / maxV); + var blocksPerLineForMcu = mcusPerLine * component.h; + var blocksPerColumnForMcu = mcusPerColumn * component.v; + component["blocks"] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu * 64); + component["blocksDC"] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu); + component["blocksPerLine"] = blocksPerLine; + component["blocksPerColumn"] = blocksPerColumn; + component["blocksPerLineForMcu"] = blocksPerLineForMcu; + component["blocksPerColumnForMcu"] = blocksPerColumnForMcu; + } + this.frame["mcusPerLine"] = mcusPerLine; + this.frame["mcusPerColumn"] = mcusPerColumn; + } + if (markerLo == 196) { + var huffmanLength = readUint16(); + for (i = 2; i < huffmanLength; ) { + var huffmanTableSpec = data[offset++]; + var codeLengths = new Uint8Array(16); + var codeLengthSum = 0; + for (j = 0; j < 16; j++, offset++) + codeLengthSum += codeLengths[j] = data[offset]; + var huffmanValues = new Uint8Array(codeLengthSum); + for (j = 0; j < codeLengthSum; j++, offset++) + huffmanValues[j] = data[offset]; + i += 17 + codeLengthSum; + (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = _buildHuffmanTable(codeLengths, huffmanValues); + } + } + if (markerLo == 221) { + resetInterval = readUint16(); + } + if (markerLo == 218) { + readUint16(); + var selectorsCount = data[offset++]; + var components = []; + for (i = 0; i < selectorsCount; i++) { + var componentIndex = this.frame.componentIds[data[offset++]]; + component = this.frame.components[componentIndex]; + var tableSpec = data[offset++]; + component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]; + component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]; + components.push(component); + } + var spectralStart = data[offset++]; + var spectralEnd = data[offset++]; + var successiveApproximation = data[offset++]; + var processed = decodeScan(data, offset, this.frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15); + offset += processed; + } + if (markerLo == 217) { + break; + } + } else { + if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) { + offset -= 3; + } + while (data[offset] != 255 && offset < data.length) { + offset++; + } + if (data[offset] != 255) { + throw "bad jpeg "; + } + } + } + if (!this.frame) + throw "bad jpeg"; + if (offset < data.length) + this.tail = data.subarray(offset); + return this; + }; + var bitcode = new Array(65535), category = new Array(65535), std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125], std_ac_luminance_values = [ + 1, + 2, + 3, + 0, + 4, + 17, + 5, + 18, + 33, + 49, + 65, + 6, + 19, + 81, + 97, + 7, + 34, + 113, + 20, + 50, + 129, + 145, + 161, + 8, + 35, + 66, + 177, + 193, + 21, + 82, + 209, + 240, + 36, + 51, + 98, + 114, + 130, + 9, + 10, + 22, + 23, + 24, + 25, + 26, + 37, + 38, + 39, + 40, + 41, + 42, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250 + ], std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119], std_ac_chrominance_values = [ + 0, + 1, + 2, + 3, + 17, + 4, + 5, + 33, + 49, + 6, + 18, + 65, + 81, + 7, + 97, + 113, + 19, + 34, + 50, + 129, + 8, + 20, + 66, + 145, + 161, + 177, + 193, + 9, + 35, + 51, + 82, + 240, + 21, + 98, + 114, + 209, + 10, + 22, + 36, + 52, + 225, + 37, + 241, + 23, + 24, + 25, + 26, + 38, + 39, + 40, + 41, + 42, + 53, + 54, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250 + ]; + function _initCategoryNumber() { + var nrlower = 1; + var nrupper = 2; + for (var cat = 1; cat <= 15; cat++) { + for (var nr = nrlower; nr < nrupper; nr++) { + category[32767 + nr] = cat; + bitcode[32767 + nr] = []; + bitcode[32767 + nr][1] = cat; + bitcode[32767 + nr][0] = nr; + } + for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) { + category[32767 + nrneg] = cat; + bitcode[32767 + nrneg] = []; + bitcode[32767 + nrneg][1] = cat; + bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg; + } + nrlower <<= 1; + nrupper <<= 1; + } + } + _initCategoryNumber(); + function _computeHuffmanTbl(nrcodes, std_table) { + var codevalue = 0; + var pos_in_table = 0; + var HT = []; + for (var k = 1; k <= 16; k++) { + for (var j = 1; j <= nrcodes[k]; j++) { + HT[std_table[pos_in_table]] = []; + HT[std_table[pos_in_table]][0] = codevalue; + HT[std_table[pos_in_table]][1] = k; + pos_in_table++; + codevalue++; + } + codevalue *= 2; + } + return HT; + } + var YDC_HT = _computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values), UVDC_HT = _computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values), YAC_HT = _computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values), UVAC_HT = _computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values); + f5stego.prototype.pack = function() { + var byteout, bytenew, bytepos, poslast, outpos, byte; + function writeByte(value) { + var t; + byteout[outpos++] = value; + if (outpos > poslast) { + t = new Uint8Array(byteout.length * 2); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + } + function writeWord(value) { + writeByte(value >> 8 & 255); + writeByte(value & 255); + } + function writeBlock(block) { + var t; + if (outpos + block.length > poslast) { + t = new Uint8Array(byteout.length * 2 + block.length); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + byteout.set(block, outpos); + outpos += block.length; + } + function writeAPP0(self) { + writeWord(65504); + if (!self.jfif) { + writeWord(16); + writeByte(74); + writeByte(70); + writeByte(73); + writeByte(70); + writeByte(0); + writeByte(1); + writeByte(1); + writeByte(0); + writeWord(1); + writeWord(1); + writeByte(0); + writeByte(0); + } else { + writeWord(self.jfif.length + 2); + writeBlock(self.jfif); + } + } + function writeDQT(self) { + for (var i2 = 0; i2 < self.qts.length; i2++) { + writeWord(65499); + writeWord(self.qts[i2].length + 2); + writeBlock(self.qts[i2]); + } + } + function writeAPPn(self) { + for (var i2 = 0; i2 < self.APPn.length; i2++) { + writeWord(65280 | self.APPn[i2].app); + writeWord(self.APPn[i2].data.length + 2); + writeBlock(self.APPn[i2].data); + } + } + function writeSOF0(self) { + writeWord(65472); + writeWord(8 + self.frame.components.length * 3); + writeByte(self.frame.precision); + writeWord(self.frame.scanLines); + writeWord(self.frame.samplesPerLine); + writeByte(self.frame.components.length); + for (var i2 = 0; i2 < self.frame.components.length; i2++) { + var c2 = self.frame.components[i2]; + writeByte(c2.componentId); + writeByte(c2.h << 4 | c2.v); + writeByte(c2.quantizationTable); + } + } + function writeDHT(self) { + writeWord(65476); + writeWord(31); + writeByte(0); + for (var i2 = 0; i2 < 16; i2++) { + writeByte(std_dc_luminance_nrcodes[i2 + 1]); + } + for (var j = 0; j <= 11; j++) { + writeByte(std_dc_luminance_values[j]); + } + writeWord(65476); + writeWord(181); + writeByte(16); + for (var k = 0; k < 16; k++) { + writeByte(std_ac_luminance_nrcodes[k + 1]); + } + for (var l = 0; l <= 161; l++) { + writeByte(std_ac_luminance_values[l]); + } + if (self.frame.components.length != 1) { + writeWord(65476); + writeWord(31); + writeByte(1); + for (var m = 0; m < 16; m++) { + writeByte(std_dc_chrominance_nrcodes[m + 1]); + } + for (var n = 0; n <= 11; n++) { + writeByte(std_dc_chrominance_values[n]); + } + writeWord(65476); + writeWord(181); + writeByte(17); + for (var o = 0; o < 16; o++) { + writeByte(std_ac_chrominance_nrcodes[o + 1]); + } + for (var p = 0; p <= 161; p++) { + writeByte(std_ac_chrominance_values[p]); + } + } + } + function writeSOS(self) { + writeWord(65498); + writeWord(6 + self.frame.components.length * 2); + writeByte(self.frame.components.length); + for (var i2 = 0; i2 < self.frame.components.length; i2++) { + var c2 = self.frame.components[i2]; + writeByte(c2.componentId); + if (i2 === 0) { + writeByte(0); + } else { + writeByte(17); + } + } + writeByte(0); + writeByte(63); + writeByte(0); + } + function processDU(comp, POS, DC, HTDC, HTAC) { + var pos, posval, t; + if (bytepos === 0) + bytenew = 0; + var Diff = comp.blocksDC[POS >> 6] - DC; + DC = comp.blocksDC[POS >> 6]; + if (Diff === 0) { + posval = HTDC[0][1]; + bytenew <<= posval; + bytenew += HTDC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } else { + pos = 32767 + Diff; + posval = HTDC[category[pos]][1]; + bytenew <<= posval; + bytenew += HTDC[category[pos]][0]; + bytepos += posval; + posval = bitcode[pos][1]; + bytenew <<= posval; + bytenew += bitcode[pos][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + var end0pos = 63; + for (; end0pos > 0 && comp.blocks[POS + end0pos] === 0; end0pos--) { + } + if (end0pos === 0) { + posval = HTAC[0][1]; + bytenew <<= posval; + bytenew += HTAC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + return DC; + } + var i2 = 1; + var lng; + while (i2 <= end0pos) { + var startpos = i2; + for (; comp.blocks[POS + i2] === 0 && i2 <= end0pos; ++i2) { + } + var nrzeroes = i2 - startpos; + if (nrzeroes >= 16) { + lng = nrzeroes >> 4; + for (var nrmarker = 1; nrmarker <= lng; ++nrmarker) { + posval = HTAC[240][1]; + bytenew <<= posval; + bytenew += HTAC[240][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + nrzeroes = nrzeroes & 15; + } + pos = 32767 + comp.blocks[POS + i2]; + posval = HTAC[(nrzeroes << 4) + category[pos]][1]; + bytenew <<= posval; + bytenew += HTAC[(nrzeroes << 4) + category[pos]][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + posval = bitcode[pos][1]; + bytenew <<= posval; + bytenew += bitcode[pos][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + i2++; + } + if (end0pos != 63) { + posval = HTAC[0][1]; + bytenew <<= posval; + bytenew += HTAC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + if (outpos > poslast) { + t = new Uint8Array(byteout.length * 2); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + return DC; + } + byteout = new Uint8Array(65536); + poslast = 65536 - 128; + outpos = 0; + bytenew = 0; + bytepos = 0; + writeWord(65496); + writeAPP0(this); + writeAPPn(this); + writeDQT(this); + writeSOF0(this); + writeDHT(this); + writeSOS(this); + bytenew = 0; + bytepos = 0; + var c, mcuRow, mcuCol, blockRow, blockCol, mcu, i, v, h; + var DCdiff = []; + for (i = 0; i < this.frame.components.length; i++) { + DCdiff.push(0); + } + for (mcu = 0; mcu < this.frame.mcusPerLine * this.frame.mcusPerColumn; mcu++) { + mcuRow = mcu / this.frame.mcusPerLine | 0; + mcuCol = mcu % this.frame.mcusPerLine; + for (i = 0; i < this.frame.components.length; i++) { + c = this.frame.components[i]; + for (v = 0; v < c.v; v++) { + blockRow = mcuRow * c.v + v; + for (h = 0; h < c.h; h++) { + blockCol = mcuCol * c.h + h; + if (i === 0) { + DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], YDC_HT, YAC_HT); + } else { + DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], UVDC_HT, UVAC_HT); + } + } + } + } + } + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + } + if (bytepos > 0) { + bytenew <<= 8 - bytepos; + bytenew += (1 << 8 - bytepos) - 1; + byteout[outpos++] = 255 & bytenew; + } + writeWord(65497); + if (this.tail) + writeBlock(this.tail); + return byteout.slice(0, outpos); + }; + f5stego.prototype.clearTail = function() { + if (!this.tail) + return null; + var t = this.tail; + this.tail = null; + return t; + }; + f5stego.prototype.setTail = function(data) { + this.tail = data; + }; + f5stego.prototype.getTail = function() { + return this.tail; + }; + f5stego.prototype.clearAPPs = function() { + var t = this.APPn; + this.APPn = []; + return t; + }; + f5stego.prototype.getAPPn = function(id, remove) { + var i, t, ret = new Uint8Array(0), n = []; + id &= 255; + if (id < 16) + id += 224; + if (id === 224) + return this.jfif; + for (i = 0; i < this.APPn.length; i++) { + if (this.APPn[i].app == id) { + t = new Uint8Array(ret.length + this.APPn[i].data.length); + t.set(ret); + t.set(this.APPn[i].data, ret.length); + ret = t; + } else if (remove) + n.push(this.APPn[i]); + } + if (remove) + this.APPn = n; + if (ret.length === 0) + return null; + return ret; + }; + f5stego.prototype.setAPPn = function(id, data) { + var i, t, ret; + id &= 255; + if (id < 16) + id += 224; + if (id === 224) { + t = this.jfif; + this.jfif = data; + return t; + } + ret = this.getAPPn(id, true); + if (data.length < 65534) { + this.APPn.push({ "app": id, "data": data }); + return ret; + } + i = 0; + while (i < data.length) { + this.APPn.push({ "app": id, "data": data.subarray(i, i + 65533) }); + i += 65533; + } + return ret; + }; + f5stego.prototype.strip = function() { + this.clearTail(); + this.clearAPPs(); + return true; + }; + f5stego.prototype.embed = function(image, data) { + this.parse(image).f5put(data); + return this.pack(); + }; + f5stego.prototype.extract = function(image) { + return this.parse(image).f5get(); + }; + return f5stego; + }); + } + }); + // node_modules/jpeg-js/lib/encoder.js var require_encoder = __commonJS({ "node_modules/jpeg-js/lib/encoder.js"(exports, module) { @@ -13134,11 +14770,11 @@ function set_input_value(input, value) { input.value = value == null ? "" : value; } - function set_style(node, key, value, important) { + function set_style(node, key2, value, important) { if (value === null) { - node.style.removeProperty(key); + node.style.removeProperty(key2); } else { - node.style.setProperty(key, value, important ? "important" : ""); + node.style.setProperty(key2, value, important ? "important" : ""); } } function select_option(select, value) { @@ -13294,12 +14930,12 @@ return true; }; } - function setContext(key, context) { - get_current_component().$$.context.set(key, context); + function setContext(key2, context) { + get_current_component().$$.context.set(key2, context); return context; } - function getContext(key) { - return get_current_component().$$.context.get(key); + function getContext(key2) { + return get_current_component().$$.context.get(key2); } function bubble(component, event) { const callbacks = component.$$.callbacks[event.type]; @@ -13533,17 +15169,17 @@ i = n; while (i--) { const child_ctx = get_context(ctx, list, i); - const key = get_key(child_ctx); - let block = lookup.get(key); + const key2 = get_key(child_ctx); + let block = lookup.get(key2); if (!block) { - block = create_each_block8(key, child_ctx); + block = create_each_block8(key2, child_ctx); block.c(); } else if (dynamic) { block.p(child_ctx, dirty); } - new_lookup.set(key, new_blocks[i] = block); - if (key in old_indexes) - deltas.set(key, Math.abs(i - old_indexes[key])); + new_lookup.set(key2, new_blocks[i] = block); + if (key2 in old_indexes) + deltas.set(key2, Math.abs(i - old_indexes[key2])); } const will_move = /* @__PURE__ */ new Set(); const did_move = /* @__PURE__ */ new Set(); @@ -13687,8 +15323,8 @@ connectedCallback() { const { on_mount } = this.$$; this.$$.on_disconnect = on_mount.map(run).filter(is_function); - for (const key in this.$$.slotted) { - this.appendChild(this.$$.slotted[key]); + for (const key2 in this.$$.slotted) { + this.appendChild(this.$$.slotted[key2]); } } attributeChangedCallback(attr2, _oldValue, newValue) { @@ -13787,8 +15423,8 @@ } // src/stores.ts - var localLoad = (key, def) => "__pee__" + key in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key)) : def; - var localSet = (key, value) => localStorage.setItem("__pee__" + key, JSON.stringify(value)); + var localLoad = (key2, def) => "__pee__" + key2 in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key2)) : def; + var localSet = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value)); var initial_settings = localLoad("settingsv2", { ...localLoad("settings", {}), loop: true, @@ -13812,6 +15448,7 @@ mdist: -1, phash: false, hotlink: false, + jpeg: false, vercheck: false, cache: void 0, fhost: 0, @@ -13819,50 +15456,7 @@ conc: 8, ho: false, blacklist: ["guro", "scat", "ryona", "gore"], - rsources: [ - { - name: "Gelbooru", - domain: "gelbooru.com", - endpoint: "/index.php?page=dapi&s=post&q=index&json=1&tags=md5:", - view: "https://gelbooru.com/index.php?page=post&s=view&id=" - }, - { - name: "Yandere", - domain: "yande.re", - endpoint: "/post.json?tags=md5:", - view: `https://yande.re/post/show/` - }, - { - name: "Sankaku", - domain: "capi-v2.sankakucomplex.com", - endpoint: "/posts/keyset?tags=md5:", - view: `https://chan.sankakucomplex.com/post/show/` - }, - { - name: "Rule34", - domain: "api.rule34.xxx", - endpoint: "/index.php?page=dapi&s=post&q=index&json=1&tags=md5:", - view: "https://rule34.xxx/index.php?page=post&s=view&id=" - }, - { - name: "Danbooru", - domain: "danbooru.donmai.us", - endpoint: "/posts.json?tags=md5:", - view: "https://danbooru.donmai.us/posts/" - }, - { - name: "Lolibooru", - domain: "lolibooru.moe", - endpoint: "/post.json?tags=md5:", - view: "https://lolibooru.moe/post/show/" - }, - { - name: "ATFbooru", - domain: "booru.allthefallen.moe", - endpoint: "/posts.json?tags=md5:", - view: "https://booru.allthefallen.moe/posts/" - } - ], + rsources: [], ...localLoad("settingsv2", {}) }); var settings = writable(initial_settings); @@ -14159,6 +15753,8 @@ // src/platform.ts var lqueue = {}; + var localLoad2 = (key2, def) => "__pee__" + key2 in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key2)) : def; + var localSet2 = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value)); var { port1, port2 } = new MessageChannel(); console.log("userscript", "false"); if (false) { @@ -14202,10 +15798,31 @@ for (const k of keys) ctor[k] = bridge(k, ctor[k]); }; + var altdomains = [ + "desuarchive.org", + "archived.moe", + "archive.nyafuu.org", + "arch.b4k.co", + "archive.wakarimasen.moe", + "b4k.co", + "fireden.net", + "thebarchive.com", + "archiveofsins.com" + ]; function supportedAltDomain(s) { - if (true) - return GM.info.script.matches.slice(2).some((m) => m.includes(s)); - return !location.host.includes("boards.4chan"); + return altdomains.includes(s); + } + function supportedMainDomain(s) { + return ["boards.4channel.org", "boards.4chan.org"].includes(s); + } + if (false) { + popupport = chrome.runtime.connect({ name: "popup" }); + popupport.onMessage.addListener((msg) => { + if (msg.id in pendingcmds) { + pendingcmds[msg.id](msg); + delete pendingcmds[msg.id]; + } + }); } var Platform = class { static async openInTab(src, opts) { @@ -14218,7 +15835,14 @@ i = (await obj.tabs.getCurrent()).index + 1; return obj.tabs.create({ active: opts.active, url: src, index: i }); } + static getValue(name, def) { + return localLoad2(name, def); + } + static setValue(name, val) { + localSet2(name, val); + } }; + Platform.cmdid = 0; Platform = __decorateClass([ Bridged ], Platform); @@ -14269,7 +15893,7 @@ // src/filehosts.ts function parseForm(data) { const form = new FormData(); - Object.entries(data).filter(([key, value]) => value !== null).map(([key, value]) => form.append(key, value)); + Object.entries(data).filter(([key2, value]) => value !== null).map(([key2, value]) => form.append(key2, value)); return form; } var lolisafe = (domain, serving = domain) => ({ @@ -16554,7 +18178,7 @@ }; var inject_data = async (container, injb) => { let magic3 = false; - const [writestream, extract6] = BufferWriteStream2(); + const [writestream, extract7] = BufferWriteStream2(); const encoder = new PNGEncoder(writestream); const decoder = new PNGDecoder(container.stream().getReader()); for await (const [name, chunk, crc, offset] of decoder.chunks()) { @@ -16573,7 +18197,7 @@ async () => Promise.resolve(0), 0 ]); - return extract6(); + return extract7(); }; var inject = async (container, links) => { links = links.map((link) => { @@ -16858,7 +18482,7 @@ } }; var inject3 = async (container, links) => { - const [writestream, extract6] = BufferWriteStream(); + const [writestream, extract7] = BufferWriteStream(); const writer = writestream.getWriter(); const inj = import_buffer5.Buffer.from(links.join(" ")); xor3(inj, password3); @@ -16873,7 +18497,7 @@ await writer.write(contbuff.slice(0, endo)); await write_embedding(writer, import_buffer5.Buffer.from(inj)); await writer.write(contbuff.slice(endo)); - return extract6(); + return extract7(); }; var has_embed3 = (gif) => { const field = gif.readUInt8(10); @@ -16910,6 +18534,11 @@ init_define_BUILD_VERSION(); init_esbuild_inject(); var import_buffer6 = __toESM(require_buffer(), 1); + var import_f5stegojs = __toESM(require_f5stego(), 1); + var csettings3; + settings.subscribe((b) => { + csettings3 = b; + }); var convertToPng = async (f) => { const can = document.createElement("canvas"); const url = URL.createObjectURL(f); @@ -16949,18 +18578,48 @@ URL.revokeObjectURL(url); } }; + var key = import_buffer6.Buffer.from("CUNNYCUNNYCUNNY"); + var f5inst = new import_f5stegojs.default(key); + var injectTrue = async (b, links) => { + if (b.size / 20 < links.join(" ").length) + throw "Image too small to embed."; + const arr = new Uint8Array(await b.arrayBuffer()); + const buff = f5inst.embed(arr, import_buffer6.Buffer.from(links.join(" "))); + return import_buffer6.Buffer.from(buff); + }; var inject4 = async (b, links) => { + if (csettings3.jpeg) + return injectTrue(b, links); const pngfile = await convertToPng(b); if (!pngfile || pngfile.size > 3e3 * 1024) { throw new Error("Couldn't convert file to PNG: resulting filesize too big."); } - return pngv3_default.inject(new File([pngfile], b.name), links); + return pngv3_default.inject(new File([pngfile], b.name), links); + }; + var has_embed4 = (b) => { + if (!csettings3.jpeg) + return false; + try { + const res = f5inst.extract(b); + if (!res) + return; + if (res.length > 1024) + return; + const str = import_buffer6.Buffer.from(res).toString(); + if (!str.match(/^[a-zA-Z0-9:/.\-_ ]+$/)) + return; + return str; + } catch { + return; + } + }; + var extract4 = (b, ex) => { + return decodeCoom3Payload(import_buffer6.Buffer.from(ex)); }; var jpg_default = { - skip: true, match: (fn) => !!fn.match(/\.jpe?g$/), - has_embed: () => false, - extract: () => [], + has_embed: has_embed4, + extract: extract4, inject: inject4 }; @@ -17027,9 +18686,9 @@ }; // src/thirdeye.ts - var csettings3; + var csettings4; settings.subscribe((b) => { - csettings3 = b; + csettings4 = b; }); var gelquirk = (prefix) => (a) => { let base = a.post || a.data || a; @@ -17084,7 +18743,7 @@ return []; } }; - var extract4 = async (b, fn) => { + var extract5 = async (b, fn) => { let result; let booru; for (const e of Object.values(boorus)) { @@ -17106,8 +18765,8 @@ url: result[0].page }, filename: fn.substring(0, 33) + result[0].ext, - thumbnail: csettings3.hotlink ? prev || full : import_buffer7.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()), - data: csettings3.hotlink ? full || prev : async (lsn) => { + thumbnail: csettings4.hotlink ? prev || full : import_buffer7.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()), + data: csettings4.hotlink ? full || prev : async (lsn) => { if (!cachedFile) cachedFile = await (await ifetch(full || prev, void 0, lsn)).arrayBuffer(); return import_buffer7.Buffer.from(cachedFile); @@ -17127,7 +18786,7 @@ } return acc; }; - var has_embed4 = async (b, fn, prevlink) => { + var has_embed5 = async (b, fn, prevlink) => { if (import_buffer7.Buffer.from(fn, "hex").equals(b)) return false; let result = void 0; @@ -17159,8 +18818,8 @@ }; var thirdeye_default = { skip: true, - extract: extract4, - has_embed: has_embed4, + extract: extract5, + has_embed: has_embed5, match: (fn) => !!fn.match(/^[0-9a-f]{32}\.....?/) }; @@ -17173,9 +18832,9 @@ { host: "Litter", prefix: "litter.catbox.moe/" }, { host: "Zzzz", prefix: "z.zz.fo/" } ]; - var csettings4; + var csettings5; settings.subscribe((b) => { - csettings4 = b; + csettings5 = b; }); var getExt = (fn) => { const isB64 = fn.match(/^((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=))?\.(gif|jpe?g|png|webm)/); @@ -17200,7 +18859,7 @@ } return { ext, source }; }; - var extract5 = async (b, fn) => { + var extract6 = async (b, fn) => { const { ext, source } = getExt(fn); let rsource; for (const cs of sources) { @@ -17215,7 +18874,7 @@ } return [{ filename: ext, - data: csettings4.hotlink ? rsource : async (lsn) => { + data: csettings5.hotlink ? rsource : async (lsn) => { try { return import_buffer8.Buffer.from(await (await ifetch(rsource, void 0, lsn)).arrayBuffer()); } catch (e) { @@ -17224,7 +18883,7 @@ thumbnail: import_buffer8.Buffer.from(hasembed_default) }]; }; - var has_embed5 = async (b, fn) => { + var has_embed6 = async (b, fn) => { const { ext, source } = getExt(fn); if (!ext) return false; @@ -17241,8 +18900,8 @@ }; var pomf_default = { skip: true, - extract: extract5, - has_embed: has_embed5, + extract: extract6, + has_embed: has_embed6, match: (fn) => !!getExt(fn) }; @@ -18912,8 +20571,8 @@ const get_key = (ctx2) => ctx2[10][0]; for (let i = 0; i < each_value.length; i += 1) { let child_ctx = get_each_context(ctx, each_value, i); - let key = get_key(child_ctx); - each_1_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx)); + let key2 = get_key(child_ctx); + each_1_lookup.set(key2, each_blocks[i] = create_each_block(key2, child_ctx)); } return { c() { @@ -19237,34 +20896,34 @@ // src/Components/App.svelte function add_css8(target) { - append_styles(target, "svelte-98wprd", '.bepis.svelte-98wprd.svelte-98wprd{max-height:260px;overflow-y:auto}.tagcont.svelte-98wprd.svelte-98wprd{display:flex;gap:5px;margin-bottom:10px;flex-wrap:wrap}label.svelte-98wprd>input[type="text"].svelte-98wprd,label.svelte-98wprd>input[type="number"].svelte-98wprd{width:95%}.content.svelte-98wprd.svelte-98wprd{display:flex;flex-direction:column}.error.svelte-98wprd.svelte-98wprd{color:red}hr.svelte-98wprd.svelte-98wprd{width:100%}h1.svelte-98wprd.svelte-98wprd{text-align:center}.form.svelte-98wprd.svelte-98wprd{display:flex;flex-direction:column;gap:20px;position:absolute;padding:15px;border:1px solid white;background-color:inherit;border-radius:10px}.form.svelte-98wprd>label.svelte-98wprd{display:flex;flex-direction:column;gap:10px}.newsbox.svelte-98wprd.svelte-98wprd{max-height:300px;overflow-y:scroll}.backpanel.svelte-98wprd.svelte-98wprd{position:absolute;right:32px;padding:10px;width:15%;top:32px;border:1px solid;border-radius:5px;background-color:rgba(0, 0, 0, 0.8);pointer-events:all;backdrop-filter:blur(9px);max-height:80vh;min-width:321px}'); + append_styles(target, "svelte-2r0xqp", '.bepis.svelte-2r0xqp.svelte-2r0xqp{max-height:260px;overflow-y:auto}.tagcont.svelte-2r0xqp.svelte-2r0xqp{display:flex;gap:5px;margin-bottom:10px;flex-wrap:wrap}label.svelte-2r0xqp>input[type="text"].svelte-2r0xqp,label.svelte-2r0xqp>input[type="number"].svelte-2r0xqp{width:95%}.content.svelte-2r0xqp.svelte-2r0xqp{display:flex;flex-direction:column}.error.svelte-2r0xqp.svelte-2r0xqp{color:red}hr.svelte-2r0xqp.svelte-2r0xqp{width:100%}h1.svelte-2r0xqp.svelte-2r0xqp{text-align:center}.form.svelte-2r0xqp.svelte-2r0xqp{display:flex;flex-direction:column;gap:20px;position:absolute;padding:15px;border:1px solid white;background-color:black;border-radius:10px}.form.svelte-2r0xqp>label.svelte-2r0xqp{display:flex;flex-direction:column;gap:10px}.newsbox.svelte-2r0xqp.svelte-2r0xqp{max-height:300px;overflow-y:scroll}.backpanel.svelte-2r0xqp.svelte-2r0xqp{position:absolute;right:32px;padding:10px;width:15%;top:32px;border:1px solid;border-radius:5px;background-color:rgba(0, 0, 0, 0.8);pointer-events:all;backdrop-filter:blur(9px);max-height:80vh;min-width:321px}'); } function get_each_context2(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[57] = list[i]; + child_ctx[58] = list[i]; return child_ctx; } function get_each_context_12(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[60] = list[i]; + child_ctx[61] = list[i]; return child_ctx; } function get_each_context_2(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[63] = list[i]; - child_ctx[65] = i; + child_ctx[64] = list[i]; + child_ctx[66] = i; return child_ctx; } function get_each_context_3(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[66] = list[i]; - child_ctx[65] = i; + child_ctx[67] = list[i]; + child_ctx[66] = i; return child_ctx; } function get_each_context_4(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[68] = list[i]; - child_ctx[65] = i; + child_ctx[69] = list[i]; + child_ctx[66] = i; return child_ctx; } function create_if_block6(ctx) { @@ -19296,10 +20955,10 @@ hr = element("hr"); t3 = space(); create_component(tabs.$$.fragment); - attr(h1, "class", "svelte-98wprd"); - attr(hr, "class", "svelte-98wprd"); - attr(div0, "class", "content svelte-98wprd"); - attr(div1, "class", "backpanel svelte-98wprd"); + attr(h1, "class", "svelte-2r0xqp"); + attr(hr, "class", "svelte-2r0xqp"); + attr(div0, "class", "content svelte-2r0xqp"); + attr(div1, "class", "backpanel svelte-2r0xqp"); }, m(target, anchor) { insert(target, div1, anchor); @@ -19317,7 +20976,7 @@ if (!current || dirty[0] & 1) set_data(t1, ctx2[0]); const tabs_changes = {}; - if (dirty[0] & 1006 | dirty[2] & 256) { + if (dirty[0] & 1006 | dirty[2] & 512) { tabs_changes.$$scope = { dirty, ctx: ctx2 }; } tabs.$set(tabs_changes); @@ -19424,7 +21083,7 @@ } }; } - function create_if_block_10(ctx) { + function create_if_block_11(ctx) { let tab; let current; tab = new Tab_default({ @@ -19516,7 +21175,7 @@ } }); tab4.$on("select", ctx[19]); - let if_block = ctx[8].akValid && create_if_block_10(ctx); + let if_block = ctx[8].akValid && create_if_block_11(ctx); return { c() { create_component(tab0.$$.fragment); @@ -19551,27 +21210,27 @@ }, p(ctx2, dirty) { const tab0_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab0_changes.$$scope = { dirty, ctx: ctx2 }; } tab0.$set(tab0_changes); const tab1_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab1_changes.$$scope = { dirty, ctx: ctx2 }; } tab1.$set(tab1_changes); const tab2_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab2_changes.$$scope = { dirty, ctx: ctx2 }; } tab2.$set(tab2_changes); const tab3_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab3_changes.$$scope = { dirty, ctx: ctx2 }; } tab3.$set(tab3_changes); const tab4_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab4_changes.$$scope = { dirty, ctx: ctx2 }; } tab4.$set(tab4_changes); @@ -19581,7 +21240,7 @@ transition_in(if_block, 1); } } else { - if_block = create_if_block_10(ctx2); + if_block = create_if_block_11(ctx2); if_block.c(); transition_in(if_block, 1); if_block.m(if_block_anchor.parentNode, if_block_anchor); @@ -19637,7 +21296,7 @@ } }; } - function create_if_block_9(ctx) { + function create_if_block_10(ctx) { let label; let input; let t; @@ -19656,7 +21315,7 @@ input.checked = ctx[7].ho; append(label, t); if (!mounted) { - dispose = listen(input, "change", ctx[28]); + dispose = listen(input, "change", ctx[29]); mounted = true; } }, @@ -19673,7 +21332,7 @@ } }; } - function create_if_block_62(ctx) { + function create_if_block_72(ctx) { let t0; let label; let t1; @@ -19684,8 +21343,8 @@ let if_block1_anchor; let mounted; let dispose; - let if_block0 = ctx[8].herror && create_if_block_8(ctx); - let if_block1 = ctx[8].akValid && create_if_block_72(ctx); + let if_block0 = ctx[8].herror && create_if_block_9(ctx); + let if_block1 = ctx[8].akValid && create_if_block_8(ctx); return { c() { if (if_block0) @@ -19703,8 +21362,8 @@ if_block1_anchor = empty(); attr(a, "title", "Only requires Search Files permission. See Hydrus docs on where to set this up."); attr(input, "type", "text"); - attr(input, "class", "svelte-98wprd"); - attr(label, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { if (if_block0) @@ -19721,7 +21380,7 @@ if_block1.m(target, anchor); insert(target, if_block1_anchor, anchor); if (!mounted) { - dispose = listen(input, "input", ctx[36]); + dispose = listen(input, "input", ctx[37]); mounted = true; } }, @@ -19730,7 +21389,7 @@ if (if_block0) { if_block0.p(ctx2, dirty); } else { - if_block0 = create_if_block_8(ctx2); + if_block0 = create_if_block_9(ctx2); if_block0.c(); if_block0.m(t0.parentNode, t0); } @@ -19745,7 +21404,7 @@ if (if_block1) { if_block1.p(ctx2, dirty); } else { - if_block1 = create_if_block_72(ctx2); + if_block1 = create_if_block_8(ctx2); if_block1.c(); if_block1.m(if_block1_anchor.parentNode, if_block1_anchor); } @@ -19772,7 +21431,7 @@ } }; } - function create_if_block_8(ctx) { + function create_if_block_9(ctx) { let span; let t_value = ctx[8].herror + ""; let t; @@ -19780,7 +21439,7 @@ c() { span = element("span"); t = text(t_value); - attr(span, "class", "error svelte-98wprd"); + attr(span, "class", "error svelte-2r0xqp"); }, m(target, anchor) { insert(target, span, anchor); @@ -19796,7 +21455,7 @@ } }; } - function create_if_block_72(ctx) { + function create_if_block_8(ctx) { let label0; let t0; let input0; @@ -19817,12 +21476,12 @@ input1 = element("input"); set_style(input0, "width", "5ch"); attr(input0, "type", "number"); - attr(input0, "class", "svelte-98wprd"); - attr(label0, "class", "svelte-98wprd"); + attr(input0, "class", "svelte-2r0xqp"); + attr(label0, "class", "svelte-2r0xqp"); attr(input1, "placeholder", "Restrict to these tags (space to separate tags, _ to separate words)"); attr(input1, "type", "text"); - attr(input1, "class", "svelte-98wprd"); - attr(label1, "class", "svelte-98wprd"); + attr(input1, "class", "svelte-2r0xqp"); + attr(label1, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, label0, anchor); @@ -19836,8 +21495,8 @@ set_input_value(input1, ctx[7].auto_tags); if (!mounted) { dispose = [ - listen(input0, "input", ctx[37]), - listen(input1, "input", ctx[38]) + listen(input0, "input", ctx[38]), + listen(input1, "input", ctx[39]) ]; mounted = true; } @@ -19866,141 +21525,153 @@ let label0; let input0; let t0; - let t1; + let a0; + let t2; let label1; let input1; - let t2; let t3; + let t4; let label2; let input2; - let t4; let t5; + let t6; let label3; let input3; - let t6; let t7; + let t8; let label4; let input4; - let t8; let t9; + let t10; let label5; let input5; - let t10; let t11; + let t12; let label6; let input6; - let t12; let t13; + let t14; let label7; let input7; - let t14; let t15; let t16; let label8; let input8; let t17; let t18; + let t19; let label9; let input9; - let t19; let t20; + let t21; let label10; let input10; - let t21; let t22; + let t23; let label11; let input11; - let t23; let t24; + let t25; let label12; let input12; - let t25; let t26; + let t27; let label13; let input13; - let t27; - let a; + let t28; let t29; let label14; let input14; let t30; - let t31; + let a1; + let t32; + let label15; + let input15; + let t33; + let t34; let if_block1_anchor; let mounted; let dispose; - let if_block0 = ctx[7].eye && create_if_block_9(ctx); - let if_block1 = ctx[7].hyd && create_if_block_62(ctx); + let if_block0 = ctx[7].eye && create_if_block_10(ctx); + let if_block1 = ctx[7].hyd && create_if_block_72(ctx); return { c() { label0 = element("label"); input0 = element("input"); - t0 = text("\n Try to load embeds from server cache"); - t1 = space(); + t0 = text("\n Enable JPGs support (JPG embed and extract)\n "); + a0 = element("a"); + a0.textContent = "?"; + t2 = space(); label1 = element("label"); input1 = element("input"); - t2 = text("\n Display view counts"); - t3 = space(); + t3 = text("\n Try to load embeds from server cache"); + t4 = space(); label2 = element("label"); input2 = element("input"); - t4 = text("\n Check for new versions at startup."); - t5 = space(); + t5 = text("\n Display view counts"); + t6 = space(); label3 = element("label"); input3 = element("input"); - t6 = text("\n Autoexpand Images on opening."); - t7 = space(); + t7 = text("\n Check for new versions at startup."); + t8 = space(); label4 = element("label"); input4 = element("input"); - t8 = text("\n Autoexpand Videos on opening."); - t9 = space(); + t9 = text("\n Autoexpand Images on opening."); + t10 = space(); label5 = element("label"); input5 = element("input"); - t10 = text("\n Loop media content."); - t11 = space(); + t11 = text("\n Autoexpand Videos on opening."); + t12 = space(); label6 = element("label"); input6 = element("input"); - t12 = text("\n Disable hover preview."); - t13 = space(); + t13 = text("\n Loop media content."); + t14 = space(); label7 = element("label"); input7 = element("input"); - t14 = text("\n Hide embedded content behind an eye."); - t15 = space(); - if (if_block0) - if_block0.c(); + t15 = text("\n Disable hover preview."); t16 = space(); label8 = element("label"); input8 = element("input"); - t17 = text("\n Preload external files."); + t17 = text("\n Hide embedded content behind an eye."); t18 = space(); + if (if_block0) + if_block0.c(); + t19 = space(); label9 = element("label"); input9 = element("input"); - t19 = text("\n Preload external files when they are in view."); - t20 = space(); + t20 = text("\n Preload external files."); + t21 = space(); label10 = element("label"); input10 = element("input"); - t21 = text("\n Hotlink content."); - t22 = space(); + t22 = text("\n Preload external files when they are in view."); + t23 = space(); label11 = element("label"); input11 = element("input"); - t23 = text("\n Control audio on videos with mouse wheel."); - t24 = space(); + t24 = text("\n Hotlink content."); + t25 = space(); label12 = element("label"); input12 = element("input"); - t25 = text("\n Show Minimap"); - t26 = space(); + t26 = text("\n Control audio on videos with mouse wheel."); + t27 = space(); label13 = element("label"); input13 = element("input"); - t27 = text("\n \n Disable embedded file preloading"); - a = element("a"); - a.textContent = "?"; + t28 = text("\n Show Minimap"); t29 = space(); label14 = element("label"); input14 = element("input"); - t30 = text("\n \n Enable Hydrus Integration"); - t31 = space(); + t30 = text("\n \n Disable embedded file preloading"); + a1 = element("a"); + a1.textContent = "?"; + t32 = space(); + label15 = element("label"); + input15 = element("input"); + t33 = text("\n \n Enable Hydrus Integration"); + t34 = space(); if (if_block1) if_block1.c(); if_block1_anchor = empty(); attr(input0, "type", "checkbox"); + attr(a0, "title", "JPG embed detection is relatively slow, heavy, so you might want to also enable server cache loading"); attr(input1, "type", "checkbox"); attr(input2, "type", "checkbox"); attr(input3, "type", "checkbox"); @@ -20014,89 +21685,96 @@ attr(input11, "type", "checkbox"); attr(input12, "type", "checkbox"); attr(input13, "type", "checkbox"); - attr(a, "title", "You might still want to enable 'preload external files'"); attr(input14, "type", "checkbox"); + attr(a1, "title", "You might still want to enable 'preload external files'"); + attr(input15, "type", "checkbox"); }, m(target, anchor) { insert(target, label0, anchor); append(label0, input0); - input0.checked = ctx[9]; + input0.checked = ctx[7].jpeg; append(label0, t0); - insert(target, t1, anchor); + append(label0, a0); + insert(target, t2, anchor); insert(target, label1, anchor); append(label1, input1); - input1.checked = ctx[7].dvc; - append(label1, t2); - insert(target, t3, anchor); + input1.checked = ctx[9]; + append(label1, t3); + insert(target, t4, anchor); insert(target, label2, anchor); append(label2, input2); - input2.checked = ctx[7].vercheck; - append(label2, t4); - insert(target, t5, anchor); + input2.checked = ctx[7].dvc; + append(label2, t5); + insert(target, t6, anchor); insert(target, label3, anchor); append(label3, input3); - input3.checked = ctx[7].xpi; - append(label3, t6); - insert(target, t7, anchor); + input3.checked = ctx[7].vercheck; + append(label3, t7); + insert(target, t8, anchor); insert(target, label4, anchor); append(label4, input4); - input4.checked = ctx[7].xpv; - append(label4, t8); - insert(target, t9, anchor); + input4.checked = ctx[7].xpi; + append(label4, t9); + insert(target, t10, anchor); insert(target, label5, anchor); append(label5, input5); - input5.checked = ctx[7].loop; - append(label5, t10); - insert(target, t11, anchor); + input5.checked = ctx[7].xpv; + append(label5, t11); + insert(target, t12, anchor); insert(target, label6, anchor); append(label6, input6); - input6.checked = ctx[7].dh; - append(label6, t12); - insert(target, t13, anchor); + input6.checked = ctx[7].loop; + append(label6, t13); + insert(target, t14, anchor); insert(target, label7, anchor); append(label7, input7); - input7.checked = ctx[7].eye; - append(label7, t14); - insert(target, t15, anchor); - if (if_block0) - if_block0.m(target, anchor); + input7.checked = ctx[7].dh; + append(label7, t15); insert(target, t16, anchor); insert(target, label8, anchor); append(label8, input8); - input8.checked = ctx[7].pre; + input8.checked = ctx[7].eye; append(label8, t17); insert(target, t18, anchor); + if (if_block0) + if_block0.m(target, anchor); + insert(target, t19, anchor); insert(target, label9, anchor); append(label9, input9); - input9.checked = ctx[7].prev; - append(label9, t19); - insert(target, t20, anchor); + input9.checked = ctx[7].pre; + append(label9, t20); + insert(target, t21, anchor); insert(target, label10, anchor); append(label10, input10); - input10.checked = ctx[7].hotlink; - append(label10, t21); - insert(target, t22, anchor); + input10.checked = ctx[7].prev; + append(label10, t22); + insert(target, t23, anchor); insert(target, label11, anchor); append(label11, input11); - input11.checked = ctx[7].ca; - append(label11, t23); - insert(target, t24, anchor); + input11.checked = ctx[7].hotlink; + append(label11, t24); + insert(target, t25, anchor); insert(target, label12, anchor); append(label12, input12); - input12.checked = ctx[7].sh; - append(label12, t25); - insert(target, t26, anchor); + input12.checked = ctx[7].ca; + append(label12, t26); + insert(target, t27, anchor); insert(target, label13, anchor); append(label13, input13); - input13.checked = ctx[7].ep; - append(label13, t27); - append(label13, a); + input13.checked = ctx[7].sh; + append(label13, t28); insert(target, t29, anchor); insert(target, label14, anchor); append(label14, input14); - input14.checked = ctx[7].hyd; + input14.checked = ctx[7].ep; append(label14, t30); - insert(target, t31, anchor); + append(label14, a1); + insert(target, t32, anchor); + insert(target, label15, anchor); + append(label15, input15); + input15.checked = ctx[7].hyd; + append(label15, t33); + insert(target, t34, anchor); if (if_block1) if_block1.m(target, anchor); insert(target, if_block1_anchor, anchor); @@ -20110,80 +21788,84 @@ listen(input5, "change", ctx[25]), listen(input6, "change", ctx[26]), listen(input7, "change", ctx[27]), - listen(input8, "change", ctx[29]), + listen(input8, "change", ctx[28]), listen(input9, "change", ctx[30]), listen(input10, "change", ctx[31]), listen(input11, "change", ctx[32]), listen(input12, "change", ctx[33]), listen(input13, "change", ctx[34]), - listen(input14, "change", ctx[35]) + listen(input14, "change", ctx[35]), + listen(input15, "change", ctx[36]) ]; mounted = true; } }, p(ctx2, dirty) { + if (dirty[0] & 128) { + input0.checked = ctx2[7].jpeg; + } if (dirty[0] & 512) { - input0.checked = ctx2[9]; + input1.checked = ctx2[9]; } if (dirty[0] & 128) { - input1.checked = ctx2[7].dvc; + input2.checked = ctx2[7].dvc; } if (dirty[0] & 128) { - input2.checked = ctx2[7].vercheck; + input3.checked = ctx2[7].vercheck; } if (dirty[0] & 128) { - input3.checked = ctx2[7].xpi; + input4.checked = ctx2[7].xpi; } if (dirty[0] & 128) { - input4.checked = ctx2[7].xpv; + input5.checked = ctx2[7].xpv; } if (dirty[0] & 128) { - input5.checked = ctx2[7].loop; + input6.checked = ctx2[7].loop; } if (dirty[0] & 128) { - input6.checked = ctx2[7].dh; + input7.checked = ctx2[7].dh; } if (dirty[0] & 128) { - input7.checked = ctx2[7].eye; + input8.checked = ctx2[7].eye; } if (ctx2[7].eye) { if (if_block0) { if_block0.p(ctx2, dirty); } else { - if_block0 = create_if_block_9(ctx2); + if_block0 = create_if_block_10(ctx2); if_block0.c(); - if_block0.m(t16.parentNode, t16); + if_block0.m(t19.parentNode, t19); } } else if (if_block0) { if_block0.d(1); if_block0 = null; } if (dirty[0] & 128) { - input8.checked = ctx2[7].pre; + input9.checked = ctx2[7].pre; } if (dirty[0] & 128) { - input9.checked = ctx2[7].prev; + input10.checked = ctx2[7].prev; } if (dirty[0] & 128) { - input10.checked = ctx2[7].hotlink; + input11.checked = ctx2[7].hotlink; } if (dirty[0] & 128) { - input11.checked = ctx2[7].ca; + input12.checked = ctx2[7].ca; } if (dirty[0] & 128) { - input12.checked = ctx2[7].sh; + input13.checked = ctx2[7].sh; } if (dirty[0] & 128) { - input13.checked = ctx2[7].ep; + input14.checked = ctx2[7].ep; } if (dirty[0] & 128) { - input14.checked = ctx2[7].hyd; + input15.checked = ctx2[7].hyd; } if (ctx2[7].hyd) { if (if_block1) { if_block1.p(ctx2, dirty); } else { - if_block1 = create_if_block_62(ctx2); + if_block1 = create_if_block_72(ctx2); if_block1.c(); if_block1.m(if_block1_anchor.parentNode, if_block1_anchor); } @@ -20196,59 +21878,59 @@ if (detaching) detach(label0); if (detaching) - detach(t1); + detach(t2); if (detaching) detach(label1); if (detaching) - detach(t3); + detach(t4); if (detaching) detach(label2); if (detaching) - detach(t5); + detach(t6); if (detaching) detach(label3); if (detaching) - detach(t7); + detach(t8); if (detaching) detach(label4); if (detaching) - detach(t9); + detach(t10); if (detaching) detach(label5); if (detaching) - detach(t11); + detach(t12); if (detaching) detach(label6); if (detaching) - detach(t13); + detach(t14); if (detaching) detach(label7); - if (detaching) - detach(t15); - if (if_block0) - if_block0.d(detaching); if (detaching) detach(t16); if (detaching) detach(label8); if (detaching) detach(t18); + if (if_block0) + if_block0.d(detaching); + if (detaching) + detach(t19); if (detaching) detach(label9); if (detaching) - detach(t20); + detach(t21); if (detaching) detach(label10); if (detaching) - detach(t22); + detach(t23); if (detaching) detach(label11); if (detaching) - detach(t24); + detach(t25); if (detaching) detach(label12); if (detaching) - detach(t26); + detach(t27); if (detaching) detach(label13); if (detaching) @@ -20256,7 +21938,11 @@ if (detaching) detach(label14); if (detaching) - detach(t31); + detach(t32); + if (detaching) + detach(label15); + if (detaching) + detach(t34); if (if_block1) if_block1.d(detaching); if (detaching) @@ -20274,23 +21960,25 @@ let t2; let h30; let t4; - let div0; let t5; + let div0; + let t6; let button; - let t7; - let dialog; let t8; - let hr; + let dialog; let t9; + let hr; + let t10; let h31; - let t11; - let div1; let t12; + let div1; + let t13; let input1; let current; let mounted; let dispose; - let if_block = ctx[7].phash && create_if_block_52(ctx); + let if_block0 = ctx[7].phash && create_if_block_62(ctx); + let if_block1 = ctx[7].rsources.length == 0 && create_if_block_52(ctx); let each_value_4 = ctx[7].rsources; let each_blocks_1 = []; for (let i = 0; i < each_value_4.length; i += 1) { @@ -20304,7 +21992,7 @@ $$scope: { ctx } }; dialog = new Dialog_default({ props: dialog_props }); - ctx[50](dialog); + ctx[51](dialog); let each_value_3 = ctx[7].blacklist; let each_blocks = []; for (let i = 0; i < each_value_3.length; i += 1) { @@ -20319,37 +22007,40 @@ input0 = element("input"); t0 = text("\n Enable perceptual hash-based filtering"); t1 = space(); - if (if_block) - if_block.c(); + if (if_block0) + if_block0.c(); t2 = space(); h30 = element("h3"); h30.textContent = "Booru sources"; t4 = space(); + if (if_block1) + if_block1.c(); + t5 = space(); div0 = element("div"); for (let i = 0; i < each_blocks_1.length; i += 1) { each_blocks_1[i].c(); } - t5 = space(); + t6 = space(); button = element("button"); button.textContent = "Add a source"; - t7 = space(); - create_component(dialog.$$.fragment); t8 = space(); - hr = element("hr"); + create_component(dialog.$$.fragment); t9 = space(); + hr = element("hr"); + t10 = space(); h31 = element("h3"); h31.textContent = "Blacklisted tags"; - t11 = space(); + t12 = space(); div1 = element("div"); for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].c(); } - t12 = space(); + t13 = space(); input1 = element("input"); attr(input0, "type", "checkbox"); - attr(div0, "class", "tagcont svelte-98wprd"); - attr(hr, "class", "svelte-98wprd"); - attr(div1, "class", "tagcont svelte-98wprd"); + attr(div0, "class", "tagcont svelte-2r0xqp"); + attr(hr, "class", "svelte-2r0xqp"); + attr(div1, "class", "tagcont svelte-2r0xqp"); attr(input1, "placeholder", "Press enter after typing your tag"); }, m(target, anchor) { @@ -20358,36 +22049,39 @@ input0.checked = ctx[7].phash; append(label, t0); insert(target, t1, anchor); - if (if_block) - if_block.m(target, anchor); + if (if_block0) + if_block0.m(target, anchor); insert(target, t2, anchor); insert(target, h30, anchor); insert(target, t4, anchor); + if (if_block1) + if_block1.m(target, anchor); + insert(target, t5, anchor); insert(target, div0, anchor); for (let i = 0; i < each_blocks_1.length; i += 1) { each_blocks_1[i].m(div0, null); } - insert(target, t5, anchor); + insert(target, t6, anchor); insert(target, button, anchor); - insert(target, t7, anchor); - mount_component(dialog, target, anchor); insert(target, t8, anchor); - insert(target, hr, anchor); + mount_component(dialog, target, anchor); insert(target, t9, anchor); + insert(target, hr, anchor); + insert(target, t10, anchor); insert(target, h31, anchor); - insert(target, t11, anchor); + insert(target, t12, anchor); insert(target, div1, anchor); for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].m(div1, null); } - insert(target, t12, anchor); + insert(target, t13, anchor); insert(target, input1, anchor); current = true; if (!mounted) { dispose = [ - listen(input0, "change", ctx[40]), - listen(button, "click", ctx[45]), - listen(input1, "keydown", ctx[52]) + listen(input0, "change", ctx[41]), + listen(button, "click", ctx[46]), + listen(input1, "keydown", ctx[53]) ]; mounted = true; } @@ -20397,16 +22091,27 @@ input0.checked = ctx2[7].phash; } if (ctx2[7].phash) { - if (if_block) { - if_block.p(ctx2, dirty); + if (if_block0) { + if_block0.p(ctx2, dirty); } else { - if_block = create_if_block_52(ctx2); - if_block.c(); - if_block.m(t2.parentNode, t2); + if_block0 = create_if_block_62(ctx2); + if_block0.c(); + if_block0.m(t2.parentNode, t2); } - } else if (if_block) { - if_block.d(1); - if_block = null; + } else if (if_block0) { + if_block0.d(1); + if_block0 = null; + } + if (ctx2[7].rsources.length == 0) { + if (if_block1) { + } else { + if_block1 = create_if_block_52(ctx2); + if_block1.c(); + if_block1.m(t5.parentNode, t5); + } + } else if (if_block1) { + if_block1.d(1); + if_block1 = null; } if (dirty[0] & 73856) { each_value_4 = ctx2[7].rsources; @@ -20430,7 +22135,7 @@ check_outros(); } const dialog_changes = {}; - if (dirty[0] & 2 | dirty[2] & 256) { + if (dirty[0] & 2 | dirty[2] & 512) { dialog_changes.$$scope = { dirty, ctx: ctx2 }; } dialog.$set(dialog_changes); @@ -20485,40 +22190,44 @@ detach(label); if (detaching) detach(t1); - if (if_block) - if_block.d(detaching); + if (if_block0) + if_block0.d(detaching); if (detaching) detach(t2); if (detaching) detach(h30); if (detaching) detach(t4); + if (if_block1) + if_block1.d(detaching); + if (detaching) + detach(t5); if (detaching) detach(div0); destroy_each(each_blocks_1, detaching); if (detaching) - detach(t5); + detach(t6); if (detaching) detach(button); if (detaching) - detach(t7); - ctx[50](null); + detach(t8); + ctx[51](null); destroy_component(dialog, detaching); if (detaching) - detach(t8); + detach(t9); if (detaching) detach(hr); if (detaching) - detach(t9); + detach(t10); if (detaching) detach(h31); if (detaching) - detach(t11); + detach(t12); if (detaching) detach(div1); destroy_each(each_blocks, detaching); if (detaching) - detach(t12); + detach(t13); if (detaching) detach(input1); mounted = false; @@ -20526,7 +22235,7 @@ } }; } - function create_if_block_52(ctx) { + function create_if_block_62(ctx) { let label; let input; let t0; @@ -20541,9 +22250,9 @@ a = element("a"); a.textContent = "?"; attr(input, "type", "number"); - attr(input, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); attr(a, "title", "Higher will filter more potentially different images, lower will let more identical images through"); - attr(label, "class", "svelte-98wprd"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, label, anchor); @@ -20552,7 +22261,7 @@ append(label, t0); append(label, a); if (!mounted) { - dispose = listen(input, "input", ctx[41]); + dispose = listen(input, "input", ctx[42]); mounted = true; } }, @@ -20569,21 +22278,37 @@ } }; } + function create_if_block_52(ctx) { + let p; + return { + c() { + p = element("p"); + p.textContent = "Don't know what to put here? Ask some anons ;)"; + }, + m(target, anchor) { + insert(target, p, anchor); + }, + d(detaching) { + if (detaching) + detach(p); + } + }; + } function create_each_block_4(ctx) { let tag; let current; function func(...args) { - return ctx[42](ctx[68], ...args); + return ctx[43](ctx[69], ...args); } function remove_handler() { - return ctx[43](ctx[68]); + return ctx[44](ctx[69]); } function toggle_handler() { - return ctx[44](ctx[68]); + return ctx[45](ctx[69]); } tag = new Tag_default({ props: { - tag: ctx[68].name, + tag: ctx[69].name, toggleable: true, toggled: !ctx[7].rsources.find(func)?.disabled } @@ -20602,7 +22327,7 @@ ctx = new_ctx; const tag_changes = {}; if (dirty[0] & 128) - tag_changes.tag = ctx[68].name; + tag_changes.tag = ctx[69].name; if (dirty[0] & 128) tag_changes.toggled = !ctx[7].rsources.find(func)?.disabled; tag.$set(tag_changes); @@ -20665,22 +22390,22 @@ button = element("button"); button.textContent = "Add"; attr(input0, "type", "text"); - attr(input0, "placeholder", "Gelbooru"); - attr(input0, "class", "svelte-98wprd"); - attr(label0, "class", "svelte-98wprd"); + attr(input0, "placeholder", "Safebooru"); + attr(input0, "class", "svelte-2r0xqp"); + attr(label0, "class", "svelte-2r0xqp"); attr(input1, "type", "text"); - attr(input1, "placeholder", "gelbooru.com"); - attr(input1, "class", "svelte-98wprd"); - attr(label1, "class", "svelte-98wprd"); + attr(input1, "placeholder", "safebooru.com"); + attr(input1, "class", "svelte-2r0xqp"); + attr(label1, "class", "svelte-2r0xqp"); attr(input2, "type", "text"); attr(input2, "placeholder", "/post.json?tags=md5:"); - attr(input2, "class", "svelte-98wprd"); - attr(label2, "class", "svelte-98wprd"); + attr(input2, "class", "svelte-2r0xqp"); + attr(label2, "class", "svelte-2r0xqp"); attr(input3, "type", "text"); - attr(input3, "placeholder", "https://yande.re/post/show/"); - attr(input3, "class", "svelte-98wprd"); - attr(label3, "class", "svelte-98wprd"); - attr(div, "class", "form svelte-98wprd"); + attr(input3, "placeholder", "https://safebooru.com/post/show/"); + attr(input3, "class", "svelte-2r0xqp"); + attr(label3, "class", "svelte-2r0xqp"); + attr(div, "class", "form svelte-2r0xqp"); }, m(target, anchor) { insert(target, div, anchor); @@ -20707,10 +22432,10 @@ append(div, button); if (!mounted) { dispose = [ - listen(input0, "input", ctx[46]), - listen(input1, "input", ctx[47]), - listen(input2, "input", ctx[48]), - listen(input3, "input", ctx[49]), + listen(input0, "input", ctx[47]), + listen(input1, "input", ctx[48]), + listen(input2, "input", ctx[49]), + listen(input3, "input", ctx[50]), listen(button, "click", ctx[11]) ]; mounted = true; @@ -20742,9 +22467,9 @@ let tag; let current; function toggle_handler_1() { - return ctx[51](ctx[66]); + return ctx[52](ctx[67]); } - tag = new Tag_default({ props: { tag: ctx[66] } }); + tag = new Tag_default({ props: { tag: ctx[67] } }); tag.$on("toggle", toggle_handler_1); return { c() { @@ -20758,7 +22483,7 @@ ctx = new_ctx; const tag_changes = {}; if (dirty[0] & 128) - tag_changes.tag = ctx[66]; + tag_changes.tag = ctx[67]; tag.$set(tag_changes); }, i(local) { @@ -20808,7 +22533,7 @@ insert(target, if_block_anchor, anchor); current = true; if (!mounted) { - dispose = listen(input, "change", ctx[39]); + dispose = listen(input, "change", ctx[40]); mounted = true; } }, @@ -20862,14 +22587,14 @@ } function create_each_block_2(ctx) { let option; - let t_value = ctx[63].domain + ""; + let t_value = ctx[64].domain + ""; let t; let option_value_value; return { c() { option = element("option"); t = text(t_value); - option.__value = option_value_value = ctx[65]; + option.__value = option_value_value = ctx[66]; option.value = option.__value; }, m(target, anchor) { @@ -20912,10 +22637,10 @@ t3 = text("Maximum number of embedded links to display\n "); input = element("input"); if (ctx[7].fhost === void 0) - add_render_callback(() => ctx[53].call(select)); + add_render_callback(() => ctx[54].call(select)); attr(input, "type", "number"); - attr(input, "class", "svelte-98wprd"); - attr(label, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, p, anchor); @@ -20932,8 +22657,8 @@ set_input_value(input, ctx[7].maxe); if (!mounted) { dispose = [ - listen(select, "change", ctx[53]), - listen(input, "input", ctx[54]) + listen(select, "change", ctx[54]), + listen(input, "input", ctx[55]) ]; mounted = true; } @@ -21016,7 +22741,7 @@ for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].c(); } - attr(div, "class", "bepis svelte-98wprd"); + attr(div, "class", "bepis svelte-2r0xqp"); }, m(target, anchor) { insert(target, div, anchor); @@ -21057,14 +22782,14 @@ let div; let a; let t0; - let t1_value = ctx[60].id + ""; + let t1_value = ctx[61].id + ""; let t1; let a_href_value; let t2; - let t3_value = ctx[60].pees + ""; + let t3_value = ctx[61].pees + ""; let t3; let t4; - let t5_value = ctx[60].eyes + ctx[60].other + ""; + let t5_value = ctx[61].eyes + ctx[61].other + ""; let t5; let t6; return { @@ -21078,7 +22803,7 @@ t4 = text(" / "); t5 = text(t5_value); t6 = text(")\n "); - attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[14] + "/thread/" + ctx[60].id); + attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[14] + "/thread/" + ctx[61].id); attr(div, "class", "mbepis"); }, m(target, anchor) { @@ -21093,14 +22818,14 @@ append(div, t6); }, p(ctx2, dirty) { - if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[60].id + "")) + if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[61].id + "")) set_data(t1, t1_value); - if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[14] + "/thread/" + ctx2[60].id)) { + if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[14] + "/thread/" + ctx2[61].id)) { attr(a, "href", a_href_value); } - if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[60].pees + "")) + if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[61].pees + "")) set_data(t3, t3_value); - if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[60].eyes + ctx2[60].other + "")) + if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[61].eyes + ctx2[61].other + "")) set_data(t5, t5_value); }, d(detaching) { @@ -21151,7 +22876,7 @@ if_block.m(target, anchor); insert(target, if_block_anchor, anchor); if (!mounted) { - dispose = listen(input, "change", ctx[55]); + dispose = listen(input, "change", ctx[56]); mounted = true; } }, @@ -21249,11 +22974,11 @@ } function create_each_block2(ctx) { let h3; - let t0_value = ctx[57].title + ""; + let t0_value = ctx[58].title + ""; let t0; let t1; let p; - let t2_value = ctx[57].content + ""; + let t2_value = ctx[58].content + ""; let t2; return { c() { @@ -21271,9 +22996,9 @@ append(p, t2); }, p(ctx2, dirty) { - if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[57].title + "")) + if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[58].title + "")) set_data(t0, t0_value); - if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[57].content + "")) + if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[58].content + "")) set_data(t2, t2_value); }, d(detaching) { @@ -21304,7 +23029,7 @@ t2 = space(); div = element("div"); if_block.c(); - attr(div, "class", "newsbox svelte-98wprd"); + attr(div, "class", "newsbox svelte-2r0xqp"); }, m(target, anchor) { insert(target, p, anchor); @@ -21484,32 +23209,32 @@ }, p(ctx2, dirty) { const tablist_changes = {}; - if (dirty[0] & 256 | dirty[2] & 256) { + if (dirty[0] & 256 | dirty[2] & 512) { tablist_changes.$$scope = { dirty, ctx: ctx2 }; } tablist.$set(tablist_changes); const tabpanel0_changes = {}; - if (dirty[0] & 896 | dirty[2] & 256) { + if (dirty[0] & 896 | dirty[2] & 512) { tabpanel0_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel0.$set(tabpanel0_changes); const tabpanel1_changes = {}; - if (dirty[0] & 134 | dirty[2] & 256) { + if (dirty[0] & 134 | dirty[2] & 512) { tabpanel1_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel1.$set(tabpanel1_changes); const tabpanel2_changes = {}; - if (dirty[0] & 128 | dirty[2] & 256) { + if (dirty[0] & 128 | dirty[2] & 512) { tabpanel2_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel2.$set(tabpanel2_changes); const tabpanel3_changes = {}; - if (dirty[0] & 224 | dirty[2] & 256) { + if (dirty[0] & 224 | dirty[2] & 512) { tabpanel3_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel3.$set(tabpanel3_changes); const tabpanel4_changes = {}; - if (dirty[0] & 8 | dirty[2] & 256) { + if (dirty[0] & 8 | dirty[2] & 512) { tabpanel4_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel4.$set(tabpanel4_changes); @@ -21650,6 +23375,10 @@ $$invalidate(3, news = await res.json()); }; function appendBooru() { + if (false) { + request(newbooru.domain); + alert("Requested! Please click the PEE icon to validate"); + } set_store_value(settings, $settings.rsources = [...$settings.rsources, newbooru], $settings); dial.toggle(); $$invalidate(1, newbooru = {}); @@ -21705,34 +23434,38 @@ const select_handler = () => updateThreads(); const select_handler_1 = () => updateNews(); function input0_change_handler() { + $settings.jpeg = this.checked; + settings.set($settings); + } + function input1_change_handler() { $cached = this.checked; cached.set($cached); } - function input1_change_handler() { + function input2_change_handler() { $settings.dvc = this.checked; settings.set($settings); } - function input2_change_handler() { + function input3_change_handler() { $settings.vercheck = this.checked; settings.set($settings); } - function input3_change_handler() { + function input4_change_handler() { $settings.xpi = this.checked; settings.set($settings); } - function input4_change_handler() { + function input5_change_handler() { $settings.xpv = this.checked; settings.set($settings); } - function input5_change_handler() { + function input6_change_handler() { $settings.loop = this.checked; settings.set($settings); } - function input6_change_handler() { + function input7_change_handler() { $settings.dh = this.checked; settings.set($settings); } - function input7_change_handler() { + function input8_change_handler() { $settings.eye = this.checked; settings.set($settings); } @@ -21740,31 +23473,31 @@ $settings.ho = this.checked; settings.set($settings); } - function input8_change_handler() { + function input9_change_handler() { $settings.pre = this.checked; settings.set($settings); } - function input9_change_handler() { + function input10_change_handler() { $settings.prev = this.checked; settings.set($settings); } - function input10_change_handler() { + function input11_change_handler() { $settings.hotlink = this.checked; settings.set($settings); } - function input11_change_handler() { + function input12_change_handler() { $settings.ca = this.checked; settings.set($settings); } - function input12_change_handler() { + function input13_change_handler() { $settings.sh = this.checked; settings.set($settings); } - function input13_change_handler() { + function input14_change_handler() { $settings.ep = this.checked; settings.set($settings); } - function input14_change_handler() { + function input15_change_handler() { $settings.hyd = this.checked; settings.set($settings); } @@ -21873,14 +23606,15 @@ input5_change_handler, input6_change_handler, input7_change_handler, - input_change_handler, input8_change_handler, + input_change_handler, input9_change_handler, input10_change_handler, input11_change_handler, input12_change_handler, input13_change_handler, input14_change_handler, + input15_change_handler, input_input_handler, input0_input_handler, input1_input_handler, @@ -23223,8 +24957,8 @@ const get_key = (ctx2) => ctx2[4].id; for (let i = 0; i < each_value.length; i += 1) { let child_ctx = get_each_context6(ctx, each_value, i); - let key = get_key(child_ctx); - each_1_lookup.set(key, each_blocks[i] = create_each_block6(key, child_ctx)); + let key2 = get_key(child_ctx); + each_1_lookup.set(key2, each_blocks[i] = create_each_block6(key2, child_ctx)); } return { c() { @@ -23768,8 +25502,8 @@ check: function check(token) { return this.get("validate", token.toString(), token); }, - get: function get(key, operator, token) { - var option = this[key]; + get: function get(key2, operator, token) { + var option = this[key2]; if (!option) { return option; } @@ -23778,13 +25512,13 @@ case "function": return option(operator, token.t); case "object": - optionValue = token.t in option ? option[token.t] : defaults[key]; + optionValue = token.t in option ? option[token.t] : defaults[key2]; return typeof optionValue === "function" ? optionValue(operator, token.t) : optionValue; } return option; }, - getObject: function getObject(key, operator, token) { - var option = this[key]; + getObject: function getObject(key2, operator, token) { + var option = this[key2]; return typeof option === "function" ? option(operator, token.t) : option; } }; @@ -24578,8 +26312,10 @@ var ViewCount_default = ViewCount; // src/main.ts + if (!supportedMainDomain(location.host) && !supportedAltDomain(location.host)) + throw "PEE not supported here, skipping"; var qp; - var csettings5 = initial_settings; + var csettings6 = initial_settings; var processors = [thirdeye_default, pomf_default, pngv3_default, jpg_default, webm_default, gif_default]; var cappState; settings.subscribe(async (b) => { @@ -24599,9 +26335,9 @@ } } } - csettings5 = b; + csettings6 = b; processors = [ - ...!csettings5.te ? [thirdeye_default] : [], + ...!csettings6.te ? [thirdeye_default] : [], pngv3_default, pomf_default, jpg_default, @@ -24641,12 +26377,16 @@ } else { chunk = { done: false, value }; cumul = import_buffer11.Buffer.concat([cumul, value]); - found = await proc.has_embed(cumul); + const v = await proc.has_embed(cumul); + if (typeof v == "string") { + return [await proc.extract(cumul, v), false]; + } + found = v; } } while (found !== false && !chunk.done); succ = true; await iter.next(true); - if (found === false) { + if (found !== true) { return; } return [await proc.extract(cumul), false]; @@ -24659,7 +26399,7 @@ var textToElement = (s) => document.createRange().createContextualFragment(s).children[0]; var pendingPosts = []; var signalNewEmbeds = debounce(async () => { - if (!csettings5.tm) + if (!csettings6.tm) return; try { const boardname = location.pathname.match(/\/([^/]*)\//)[1]; @@ -24681,7 +26421,7 @@ var shouldUseCache = () => { if (cappState.isCatalog) return false; - return typeof csettings5.cache == "boolean" ? csettings5.cache : location.hostname.includes("b4k"); + return typeof csettings6.cache == "boolean" ? csettings6.cache : location.hostname.includes("b4k"); }; var processPost = async (post) => { const origlink = qp.getImageLink(post); @@ -24692,7 +26432,7 @@ return; let res2 = void 0; const reportEmbed = () => { - if (csettings5.tm) { + if (csettings6.tm) { if (["boards.4chan.org", "boards.4channel.org"].includes(location.host)) { if (!cappState.isCatalog) { const op = +location.pathname.match(/\/thread\/(.*)/)[1]; @@ -24739,7 +26479,7 @@ navigator.clipboard.writeText(text3); } var scrapeBoard = async (self) => { - if (csettings5.tm) { + if (csettings6.tm) { fireNotification("success", "Scrapping board with telemetry on! Thank you for your service, selfless stranger ;_;7"); } self.disabled = true; @@ -24779,7 +26519,11 @@ } else { chunk = { done: false, value }; cumul = import_buffer11.Buffer.concat([cumul, value]); - found = await proc.has_embed(cumul); + const v = await proc.has_embed(cumul); + if (typeof v == "string") { + return true; + } + found = v; } } while (found !== false && !chunk.done); await iter.next(true); @@ -24829,14 +26573,21 @@ var __DOMParser = true ? _DOMParser : DOMParser; var gmo; var earlystartup = async () => { - if (location.host == "arch.b4k.co" && true) { + if (["arch.b4k.co", "desuarchive.org"].includes(location.host) && true) { if (!GM_getValue("warning_seen2", false)) { - alert(`Due to b4k's policies being mean, PEE will get you banned, so the userscript version is disabled here`); - alert("Use the WebExtension version of PEE if you want to use b4k!"); + alert(`Due to b4k and desuarchive policies being mean, PEE will get you banned, so the userscript version is disabled here +Use the WebExtension version of PEE if you want to use b4k!`); GM_setValue("warning_seen2", true); return false; } } + if (["arch.b4k.co", "desuarchive.org"].includes(location.host) && false) { + if (!Platform5.getValue("warning_seen3", false)) { + alert('Due to b4k and desuarchive policies being mean, PEE cannot display content properly here. A "PEE companion" extension will be released as including that functionnallity in PEE lengthens ChromeWebStore review delays, please understando.'); + Platform5.setValue("warning_seen3", true); + return false; + } + } return true; }; var init4 = false; @@ -24856,7 +26607,7 @@ return; else qp = lqp; - if (csettings5.vercheck) + if (csettings6.vercheck) versionCheck(); const postQuote = ({ scanner, parser, utils }) => { const { CLOSEANGLEBRACKET: CLOSEANGLEBRACKET2, NUM: NUM2 } = scanner.tokens; diff --git a/firefox/dist/background.js b/firefox/dist/background.js index 52b366a..08a4375 100644 --- a/firefox/dist/background.js +++ b/firefox/dist/background.js @@ -1874,6 +1874,8 @@ // src/platform.ts var lqueue = {}; + var localLoad = (key, def) => "__pee__" + key in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key)) : def; + var localSet = (key, value) => localStorage.setItem("__pee__" + key, JSON.stringify(value)); var { port1, port2 } = new MessageChannel(); console.log("ff_api", true); if (false) { @@ -1917,6 +1919,15 @@ for (const k of keys) ctor[k] = bridge(k, ctor[k]); }; + if (false) { + popupport = chrome.runtime.connect({ name: "popup" }); + popupport.onMessage.addListener((msg) => { + if (msg.id in pendingcmds) { + pendingcmds[msg.id](msg); + delete pendingcmds[msg.id]; + } + }); + } var Platform = class { static async openInTab(src, opts) { if (false) { @@ -1928,7 +1939,14 @@ i = (await obj2.tabs.getCurrent()).index + 1; return obj2.tabs.create({ active: opts.active, url: src, index: i }); } + static getValue(name, def) { + return localLoad(name, def); + } + static setValue(name, val) { + localSet(name, val); + } }; + Platform.cmdid = 0; Platform = __decorateClass([ Bridged ], Platform); @@ -1953,8 +1971,9 @@ var bgCorsFetch = async (c, id, input, init) => { if (input.startsWith("//")) input = "https:" + input; - if (init?.body && false) - init.body = await deserialize(init.body); + if (init?.body && false) { + init.body = await bravedeserialize(init.body); + } try { const k = await fetch(input, init); let headersStr = ""; diff --git a/firefox/dist/main.js b/firefox/dist/main.js index 928e708..4f0e6b6 100644 --- a/firefox/dist/main.js +++ b/firefox/dist/main.js @@ -14,20 +14,20 @@ }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { - for (let key of __getOwnPropNames(from)) - if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + for (let key2 of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key2) && key2 !== except) + __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable }); } return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod)); - var __decorateClass = (decorators, target, key, kind) => { - var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; + var __decorateClass = (decorators, target, key2, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key2) : target; for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) - result = (kind ? decorator(target, key, result) : decorator(result)) || result; + result = (kind ? decorator(target, key2, result) : decorator(result)) || result; if (kind && result) - __defProp(target, key, result); + __defProp(target, key2, result); return result; }; var __toBinary = /* @__PURE__ */ (() => { @@ -51,7 +51,7 @@ var define_BUILD_VERSION_default; var init_define_BUILD_VERSION = __esm({ ""() { - define_BUILD_VERSION_default = [0, 254]; + define_BUILD_VERSION_default = [0, 261]; } }); @@ -2246,12 +2246,12 @@ } if (arguments.length === 0) { var keys = Object.keys(events); - var key; + var key2; for (i = 0; i < keys.length; ++i) { - key = keys[i]; - if (key === "removeListener") + key2 = keys[i]; + if (key2 === "removeListener") continue; - this.removeAllListeners(key); + this.removeAllListeners(key2); } this.removeAllListeners("removeListener"); this._events = /* @__PURE__ */ Object.create(null); @@ -2410,24 +2410,24 @@ for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { - ownKeys(Object(source), true).forEach(function(key) { - _defineProperty(target, key, source[key]); + ownKeys(Object(source), true).forEach(function(key2) { + _defineProperty(target, key2, source[key2]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { - ownKeys(Object(source)).forEach(function(key) { - Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + ownKeys(Object(source)).forEach(function(key2) { + Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2)); }); } } return target; } - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + function _defineProperty(obj, key2, value) { + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); } else { - obj[key] = value; + obj[key2] = value; } return obj; } @@ -3443,8 +3443,8 @@ init_esbuild_inject(); var objectKeys = Object.keys || function(obj) { var keys2 = []; - for (var key in obj) { - keys2.push(key); + for (var key2 in obj) { + keys2.push(key2); } return keys2; }; @@ -3533,8 +3533,8 @@ var buffer = require_buffer(); var Buffer18 = buffer.Buffer; function copyProps(src, dst) { - for (var key in src) { - dst[key] = src[key]; + for (var key2 in src) { + dst[key2] = src[key2]; } } if (Buffer18.from && Buffer18.alloc && Buffer18.allocUnsafe && Buffer18.allocUnsafeSlow) { @@ -3957,11 +3957,11 @@ init_define_BUILD_VERSION(); init_esbuild_inject(); var _Object$setPrototypeO; - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + function _defineProperty(obj, key2, value) { + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); } else { - obj[key] = value; + obj[key2] = value; } return obj; } @@ -10318,7 +10318,7 @@ return this; }; EventEmitter.prototype.removeAllListeners = function(type) { - var key, listeners; + var key2, listeners; if (!this._events) return this; if (!this._events.removeListener) { @@ -10329,10 +10329,10 @@ return this; } if (arguments.length === 0) { - for (key in this._events) { - if (key === "removeListener") + for (key2 in this._events) { + if (key2 === "removeListener") continue; - this.removeAllListeners(key); + this.removeAllListeners(key2); } this.removeAllListeners("removeListener"); this._events = {}; @@ -10772,6 +10772,1642 @@ } }); + // node_modules/f5stegojs/f5stego.js + var require_f5stego = __commonJS({ + "node_modules/f5stegojs/f5stego.js"(exports, module) { + init_define_BUILD_VERSION(); + init_esbuild_inject(); + (function(root, factory) { + "use strict"; + if (typeof define === "function" && define.amd) { + define([], factory); + } else if (typeof exports === "object") { + module.exports = factory(); + } else { + root.f5stego = factory(); + } + })(exports, function() { + "use strict"; + var f5stego = function(key2, maxPixels) { + this.maxPixels = maxPixels || 4096 * 4096; + this.shuffleInit(key2); + }; + f5stego.prototype.shuffleInit = function(key2) { + this.randPool = new ArrayBuffer(this.maxPixels * 4.125); + if (!key2.length) + throw "key needed"; + var i = 0, j = 0, t = 0, k = 0, S = new Uint8Array(256), rnd = new Uint8Array(this.randPool); + for (i = 0; i < 256; ++i) + S[i] = i; + for (i = 0; i < 256; ++i) { + j = j + S[i] + key2[i % key2.length] & 255; + t = S[i]; + S[i] = S[j]; + S[j] = t; + } + i = 0; + j = 0; + for (k = 0; k < this.maxPixels * 4.125; ++k) { + i = i + 1 & 255; + j = j + S[i] & 255; + t = S[i]; + S[i] = S[j]; + S[j] = t; + rnd[k] = S[t + S[i] & 255]; + } + }; + f5stego.prototype.stegShuffle = function(pm) { + var t, l, k, random_index, rand32Array = new Uint32Array(this.randPool); + if (typeof pm == "number") { + l = pm; + pm = new Uint32Array(l); + for (k = 1; k < l; k++) { + random_index = rand32Array[k] % (k + 1); + if (random_index != k) + pm[k] = pm[random_index]; + pm[random_index] = k; + } + } else { + l = pm.length; + for (k = 1; k < l; k++) { + random_index = rand32Array[k] % (k + 1); + t = pm[k]; + pm[k] = pm[random_index]; + pm[random_index] = t; + } + } + return { pm, gamma: new Uint8Array(this.randPool, l * 4) }; + }; + f5stego.prototype._analyze = function(coeff) { + var _one = 0, _zero = 0, _large, _ratio, usable, i, k, embedded, matched, changed; + for (i = 0; i < coeff.length; i++) { + if (i % 64 === 0) + continue; + if (coeff[i] === 0) + _zero++; + if (coeff[i] == 1 || coeff[i] == -1) + _one++; + } + _large = coeff.length - _zero - _one - coeff.length / 64; + _ratio = _one / (_large + _one); + var res = { + "capacity": [0, (_large + 0.49 * _one >> 3) - 1], + "coeff_total": coeff.length, + "coeff_large": _large, + "coeff_zero": _zero, + "coeff_one": _one, + "coeff_one_ratio": _one / (_large + _one) + }; + for (i = 2; i < 17; i++) { + k = (1 << i) - 1; + usable = _large + _one; + embedded = 0; + while (usable > k) { + matched = usable / k / (1 << i) / (1 << i) | 0; + usable -= matched * k; + changed = usable * (1 - _ratio) / k * 0.96 | 0; + usable -= changed * k; + embedded += changed + matched; + k++; + } + res.capacity[i] = (i * embedded >> 3) - 1; + } + return res; + }; + f5stego.prototype._f5write = function(coeff, data, k) { + var coeff_count = coeff.length; + var _changed = 0, _embedded = 0, _examined = 0, _thrown = 0, shuffled_index = 0, i, n, ii; + var pm = this.stegShuffle(coeff_count); + var gamma = pm.gamma, gammaI = 0; + pm = pm.pm; + var next_bit_to_embed = 0, byte_to_embed = data.length, data_idx = 0, available_bits_to_embed = 0; + n = (1 << k) - 1; + byte_to_embed = k - 1; + byte_to_embed ^= gamma[gammaI++]; + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed = 3; + for (ii = 0; ii < coeff_count; ii++) { + shuffled_index = pm[ii]; + if (shuffled_index % 64 === 0 || coeff[shuffled_index] === 0) + continue; + var cc = coeff[shuffled_index]; + _examined++; + if (cc > 0 && (cc & 1) != next_bit_to_embed) { + coeff[shuffled_index]--; + _changed++; + } else if (cc < 0 && (cc & 1) == next_bit_to_embed) { + coeff[shuffled_index]++; + _changed++; + } + if (coeff[shuffled_index] !== 0) { + _embedded++; + if (available_bits_to_embed === 0) { + if (k != 1 || data_idx >= data.length) + break; + byte_to_embed = data[data_idx++]; + byte_to_embed ^= gamma[gammaI++]; + available_bits_to_embed = 8; + } + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed--; + } else { + _thrown++; + } + } + if (k == 1 && _embedded < data.length * 8) + throw "capacity exceeded " + _embedded / 8 + " " + data.length; + if (k != 1) { + var is_last_byte = false, k_bits_to_embed = 0; + while (!is_last_byte || available_bits_to_embed !== 0 && is_last_byte) { + k_bits_to_embed = 0; + for (i = 0; i < k; i++) { + if (available_bits_to_embed === 0) { + if (data_idx >= data.length) { + is_last_byte = true; + break; + } + byte_to_embed = data[data_idx++]; + byte_to_embed ^= gamma[gammaI++]; + available_bits_to_embed = 8; + } + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed--; + k_bits_to_embed |= next_bit_to_embed << i; + } + var code_word = []; + var ci = null; + for (i = 0; i < n; i++) { + while (true) { + if (++ii >= coeff_count) { + throw "capacity exceeded " + _embedded / 8; + } + ci = pm[ii]; + if (ci % 64 !== 0 && coeff[ci] !== 0) + break; + } + code_word.push(ci); + } + _examined += n; + while (true) { + var vhash = 0, extracted_bit; + for (i = 0; i < code_word.length; i++) { + if (coeff[code_word[i]] > 0) { + extracted_bit = coeff[code_word[i]] & 1; + } else { + extracted_bit = 1 - (coeff[code_word[i]] & 1); + } + if (extracted_bit == 1) + vhash ^= i + 1; + } + i = vhash ^ k_bits_to_embed; + if (!i) { + _embedded += k; + break; + } + i--; + coeff[code_word[i]] += coeff[code_word[i]] < 0 ? 1 : -1; + _changed++; + if (coeff[code_word[i]] === 0) { + _thrown++; + code_word.splice(i, 1); + while (true) { + if (++ii >= coeff_count) { + throw "capacity exceeded " + _embedded / 8; + } + ci = pm[ii]; + if (ci % 64 !== 0 && coeff[ci] !== 0) + break; + } + _examined++; + code_word.push(ci); + } else { + _embedded += k; + break; + } + } + } + } + return { + "k": k, + "embedded": _embedded / 8, + "examined": _examined, + "changed": _changed, + "thrown": _thrown, + "efficiency": (_embedded / _changed).toFixed(2) + }; + }; + f5stego.prototype.analyze = function() { + var i, comp = this.frame.components[0]; + if (comp.componentId != 1) { + for (i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + return this._analyze(comp.blocks); + }; + f5stego.prototype.f5put = function(data, k) { + var t, i, comp = this.frame.components[0]; + if (data.length > 8388607) + throw "Data too big. Max 8388607 bytes allowed."; + if (data.length < 32768) { + t = new Uint8Array(2 + data.length); + t[0] = data.length & 255; + t[1] = data.length >>> 8; + t.set(data, 2); + } else { + t = new Uint8Array(3 + data.length); + t[0] = data.length & 255; + t[1] = (data.length >>> 8 & 127) + 128; + t[2] = data.length >>> 15; + t.set(data, 3); + } + if (comp.componentId != 1) { + for (i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + if (k) { + return this._f5write(comp.blocks, t, k); + } + var ret, prop = this._analyze(comp.blocks); + k = 0; + for (i = prop.capacity.length - 1; i >= 0; i--) { + if (prop.capacity[i] >= t.length) { + k = i; + break; + } + } + if (k === 0) + throw "capacity exceeded"; + try { + ret = this._f5write(comp.blocks, t, k); + } catch (e) { + k--; + if (k === 0) + throw "capacity exceeded"; + ret = this._f5write(comp.blocks, t, k); + } + ret["stats"] = prop; + return ret; + }; + f5stego.prototype.f5get = function() { + var comp = this.frame.components[0]; + if (comp.componentId != 1) { + for (var i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + var coeff = new Int16Array(comp.blocks.length); + coeff.set(comp.blocks); + var pos = -1, extrBit = 0, cCount = coeff.length - 1; + var pm = this.stegShuffle(coeff), gamma = pm.gamma, gammaI = 0; + var n, k = 0; + var out = new Uint8Array(coeff.length / 8 | 0), extrByte = 0, outPos = 0, bitsAvail = 0, code = 0, hash2 = 0; + while (bitsAvail < 4) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + k |= extrBit << bitsAvail; + bitsAvail++; + } + k = (k ^ gamma[gammaI++] & 15) + 1; + n = (1 << k) - 1; + bitsAvail = 0; + if (k == 1) { + while (pos < cCount) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + extrByte |= extrBit << bitsAvail; + bitsAvail++; + if (bitsAvail == 8) { + out[outPos++] = extrByte ^ gamma[gammaI++]; + extrByte = 0; + bitsAvail = 0; + } + } + } else { + while (pos < cCount) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + hash2 ^= extrBit * ++code; + if (code == n) { + extrByte |= hash2 << bitsAvail; + bitsAvail += k; + code = 0; + hash2 = 0; + while (bitsAvail >= 8) { + out[outPos++] = extrByte & 255 ^ gamma[gammaI++]; + bitsAvail -= 8; + extrByte = extrByte >> 8; + } + } + } + } + while (bitsAvail > 0) { + out[outPos++] = extrByte & 255 ^ gamma[gammaI++]; + bitsAvail -= 8; + extrByte = extrByte >> 8; + } + var s = 2, l = out[0]; + if (out[1] & 128) { + s++; + l += ((out[1] & 127) << 8) + (out[2] << 15); + } else { + l += out[1] << 8; + } + return out.subarray(s, s + l); + }; + f5stego.prototype.parse = function(data) { + var offset = 0; + function _buildHuffmanTable(nrcodes, values) { + var codevalue = 0, pos_in_table = 0, HT = new Uint16Array(65536); + for (var k = 0; k < 16; k++) { + for (var j2 = 0; j2 < nrcodes[k]; j2++) { + for (var i2 = codevalue << 15 - k, cntTo = codevalue + 1 << 15 - k; i2 < cntTo; i2++) { + HT[i2] = values[pos_in_table] + (k + 1 << 8); + } + pos_in_table++; + codevalue++; + } + codevalue *= 2; + } + return HT; + } + function decodeScan(data2, offset2, frame, components2, resetInterval2, spectralStart2, spectralEnd2, successivePrev, successive) { + var startOffset = offset2, bitsData = 0, bitsCount = 0, eobrun = 0, p1 = 1 << successive, m1 = -1 << successive; + function decodeBaseline(component2, pos) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + var t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535]; + if (!t) + throw "invalid huffman sequence"; + bitsCount -= t >>> 8; + t &= 255; + var diff = 0; + if (t !== 0) { + while (bitsCount < t) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + diff = bitsData >>> bitsCount - t & (1 << t) - 1; + bitsCount -= t; + if (diff < 1 << t - 1) + diff += (-1 << t) + 1; + } + component2.blocksDC[pos >> 6] = component2.pred += diff; + var k2 = 1, s, r; + while (k2 < 64) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s === 0) { + if (r < 15) { + break; + } + k2 += 16; + continue; + } + k2 += r; + while (bitsCount < s) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1; + bitsCount -= s; + if (component2.blocks[pos + k2] < 1 << s - 1) + component2.blocks[pos + k2] += (-1 << s) + 1; + k2++; + } + } + function decodeDCFirst(component2, pos) { + var diff = 0; + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + var t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535]; + if (!t) + throw "invalid huffman sequence"; + bitsCount -= t >>> 8; + t &= 255; + if (t !== 0) { + while (bitsCount < t) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + diff = bitsData >>> bitsCount - t & (1 << t) - 1; + bitsCount -= t; + if (diff < 1 << t - 1) + diff += (-1 << t) + 1; + } + component2.blocksDC[pos >> 6] = component2.pred += diff << successive; + } + function decodeDCSuccessive(component2, pos) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocksDC[pos >> 6] |= (bitsData >>> --bitsCount & 1) << successive; + } + function decodeACFirst(component2, pos) { + if (eobrun > 0) { + eobrun--; + return; + } + var k2 = spectralStart2, s, r; + while (k2 <= spectralEnd2) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s === 0) { + if (r != 15) { + eobrun = (1 << r) - 1; + if (r) { + while (bitsCount < r) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + eobrun += bitsData >>> bitsCount - r & (1 << r) - 1; + bitsCount -= r; + } + break; + } + k2 += 16; + continue; + } + k2 += r; + while (bitsCount < s) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1; + bitsCount -= s; + if (component2.blocks[pos + k2] < 1 << s - 1) + component2.blocks[pos + k2] += (-1 << s) + 1; + component2.blocks[pos + k2] *= p1; + k2++; + } + } + function decodeACSuccessive(component2, pos) { + var k2 = spectralStart2, r, s; + if (!eobrun) { + while (k2 <= spectralEnd2) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s) { + if (s != 1) + throw "bad jpeg"; + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + s = bitsData >>> --bitsCount & 1 ? p1 : m1; + } else { + if (r != 15) { + eobrun = 1 << r; + if (r) { + while (bitsCount < r) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + eobrun += bitsData >>> bitsCount - r & (1 << r) - 1; + bitsCount -= r; + } + break; + } + } + while (k2 <= spectralEnd2) { + if (component2.blocks[pos + k2]) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1); + } else { + if (--r < 0) + break; + } + k2++; + } + if (s) + component2.blocks[pos + k2] = s; + k2++; + } + } + if (eobrun) { + while (k2 <= spectralEnd2) { + if (component2.blocks[pos + k2]) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1); + } + k2++; + } + eobrun--; + } + } + var decodeFn; + if (frame.progressive) { + if (spectralStart2 === 0) + decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; + else + decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; + } else { + decodeFn = decodeBaseline; + } + var marker, mcuExpected, i2, j2, k, n, mcusPerLine2, mcusPerRow, x, y; + if (components2.length == 1) { + mcusPerLine2 = components2[0].blocksPerLine; + mcusPerRow = components2[0].blocksPerColumn; + mcuExpected = mcusPerRow * mcusPerLine2; + if (!resetInterval2) + resetInterval2 = mcuExpected; + n = resetInterval2; + components2[0].pred = 0; + eobrun = 0; + for (y = 0; y < mcusPerRow; y++) { + for (x = 0; x < mcusPerLine2; x++) { + if (!n) { + n = resetInterval2; + components2[0].pred = 0; + eobrun = 0; + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + bitsCount = 0; + marker = data2[offset2] << 8 | data2[offset2 + 1]; + if (marker >= 65488 && marker <= 65495) { + offset2 += 2; + } else { + if (marker <= 65280) { + throw "bad jpeg"; + } + break; + } + } + n--; + for (i2 = 0; i2 < components2.length; i2++) { + decodeFn(components2[i2], (y * components2[i2].blocksPerLineForMcu + x) * 64); + } + } + } + } else { + mcusPerLine2 = frame.mcusPerLine; + mcusPerRow = frame.mcusPerColumn; + mcuExpected = mcusPerRow * mcusPerLine2; + if (!resetInterval2) + resetInterval2 = mcuExpected; + n = resetInterval2; + for (i2 = 0; i2 < components2.length; i2++) + components2[i2].pred = 0; + eobrun = 0; + for (y = 0; y < mcusPerRow; y++) { + for (x = 0; x < mcusPerLine2; x++) { + if (!n) { + n = resetInterval2; + for (i2 = 0; i2 < components2.length; i2++) + components2[i2].pred = 0; + eobrun = 0; + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + bitsCount = 0; + marker = data2[offset2] << 8 | data2[offset2 + 1]; + if (marker >= 65488 && marker <= 65495) { + offset2 += 2; + } else { + if (marker <= 65280) { + throw "bad jpeg"; + } + break; + } + } + n--; + for (i2 = 0; i2 < components2.length; i2++) { + for (j2 = 0; j2 < components2[i2].v; j2++) { + for (k = 0; k < components2[i2].h; k++) { + decodeFn(components2[i2], ((y * components2[i2].v + j2) * components2[i2].blocksPerLineForMcu + x * components2[i2].h + k) * 64); + } + } + } + } + } + } + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + return offset2 - startOffset; + } + function readUint16() { + var value = data[offset] << 8 | data[offset + 1]; + offset += 2; + return value; + } + function readDataBlock() { + var length = readUint16(); + var array = data.subarray(offset, offset + length - 2); + offset += array.length; + return array; + } + this["_raw"] = data; + this["jfif"] = null; + this["APPn"] = []; + this["qts"] = []; + this["frame"] = null; + this["tail"] = null; + var markerHi, markerLo, i, j, resetInterval, component; + var huffmanTablesAC = [], huffmanTablesDC = []; + while (1) { + if (offset >= data.length) + throw "unexpected EOF"; + markerHi = data[offset++]; + markerLo = data[offset++]; + if (markerHi == 255) { + if (markerLo == 224) { + this.jfif = readDataBlock(); + } + if (markerLo > 224 && markerLo < 240 || markerLo == 254) { + this.APPn.push({ + "app": markerLo, + "data": readDataBlock() + }); + } + if (markerLo == 219) { + this.qts.push(readDataBlock()); + } + if (markerLo >= 192 && markerLo <= 194) { + if (this.frame) + throw "Only single frame JPEGs supported"; + readUint16(); + this.frame = { + "extended": markerLo === 193, + "progressive": markerLo === 194, + "precision": data[offset++], + "scanLines": readUint16(), + "samplesPerLine": readUint16(), + "components": [], + "componentIds": {}, + "maxH": 1, + "maxV": 1 + }; + if (this.frame.scanLines * this.frame.samplesPerLine > this.maxPixels) + throw "Image is too big."; + var componentsCount = data[offset++], componentId; + var maxH = 0, maxV = 0; + for (i = 0; i < componentsCount; i++) { + componentId = data[offset]; + var h = data[offset + 1] >> 4; + var v = data[offset + 1] & 15; + if (maxH < h) + maxH = h; + if (maxV < v) + maxV = v; + var qId = data[offset + 2]; + var l = this.frame.components.push({ + "componentId": componentId, + "h": h, + "v": v, + "quantizationTable": qId + }); + this.frame.componentIds[componentId] = l - 1; + offset += 3; + } + this.frame.maxH = maxH; + this.frame.maxV = maxV; + var mcusPerLine = Math.ceil(this.frame.samplesPerLine / 8 / maxH); + var mcusPerColumn = Math.ceil(this.frame.scanLines / 8 / maxV); + for (i = 0; i < this.frame.components.length; i++) { + component = this.frame.components[i]; + var blocksPerLine = Math.ceil(Math.ceil(this.frame.samplesPerLine / 8) * component.h / maxH); + var blocksPerColumn = Math.ceil(Math.ceil(this.frame.scanLines / 8) * component.v / maxV); + var blocksPerLineForMcu = mcusPerLine * component.h; + var blocksPerColumnForMcu = mcusPerColumn * component.v; + component["blocks"] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu * 64); + component["blocksDC"] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu); + component["blocksPerLine"] = blocksPerLine; + component["blocksPerColumn"] = blocksPerColumn; + component["blocksPerLineForMcu"] = blocksPerLineForMcu; + component["blocksPerColumnForMcu"] = blocksPerColumnForMcu; + } + this.frame["mcusPerLine"] = mcusPerLine; + this.frame["mcusPerColumn"] = mcusPerColumn; + } + if (markerLo == 196) { + var huffmanLength = readUint16(); + for (i = 2; i < huffmanLength; ) { + var huffmanTableSpec = data[offset++]; + var codeLengths = new Uint8Array(16); + var codeLengthSum = 0; + for (j = 0; j < 16; j++, offset++) + codeLengthSum += codeLengths[j] = data[offset]; + var huffmanValues = new Uint8Array(codeLengthSum); + for (j = 0; j < codeLengthSum; j++, offset++) + huffmanValues[j] = data[offset]; + i += 17 + codeLengthSum; + (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = _buildHuffmanTable(codeLengths, huffmanValues); + } + } + if (markerLo == 221) { + resetInterval = readUint16(); + } + if (markerLo == 218) { + readUint16(); + var selectorsCount = data[offset++]; + var components = []; + for (i = 0; i < selectorsCount; i++) { + var componentIndex = this.frame.componentIds[data[offset++]]; + component = this.frame.components[componentIndex]; + var tableSpec = data[offset++]; + component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]; + component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]; + components.push(component); + } + var spectralStart = data[offset++]; + var spectralEnd = data[offset++]; + var successiveApproximation = data[offset++]; + var processed = decodeScan(data, offset, this.frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15); + offset += processed; + } + if (markerLo == 217) { + break; + } + } else { + if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) { + offset -= 3; + } + while (data[offset] != 255 && offset < data.length) { + offset++; + } + if (data[offset] != 255) { + throw "bad jpeg "; + } + } + } + if (!this.frame) + throw "bad jpeg"; + if (offset < data.length) + this.tail = data.subarray(offset); + return this; + }; + var bitcode = new Array(65535), category = new Array(65535), std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125], std_ac_luminance_values = [ + 1, + 2, + 3, + 0, + 4, + 17, + 5, + 18, + 33, + 49, + 65, + 6, + 19, + 81, + 97, + 7, + 34, + 113, + 20, + 50, + 129, + 145, + 161, + 8, + 35, + 66, + 177, + 193, + 21, + 82, + 209, + 240, + 36, + 51, + 98, + 114, + 130, + 9, + 10, + 22, + 23, + 24, + 25, + 26, + 37, + 38, + 39, + 40, + 41, + 42, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250 + ], std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119], std_ac_chrominance_values = [ + 0, + 1, + 2, + 3, + 17, + 4, + 5, + 33, + 49, + 6, + 18, + 65, + 81, + 7, + 97, + 113, + 19, + 34, + 50, + 129, + 8, + 20, + 66, + 145, + 161, + 177, + 193, + 9, + 35, + 51, + 82, + 240, + 21, + 98, + 114, + 209, + 10, + 22, + 36, + 52, + 225, + 37, + 241, + 23, + 24, + 25, + 26, + 38, + 39, + 40, + 41, + 42, + 53, + 54, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250 + ]; + function _initCategoryNumber() { + var nrlower = 1; + var nrupper = 2; + for (var cat = 1; cat <= 15; cat++) { + for (var nr = nrlower; nr < nrupper; nr++) { + category[32767 + nr] = cat; + bitcode[32767 + nr] = []; + bitcode[32767 + nr][1] = cat; + bitcode[32767 + nr][0] = nr; + } + for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) { + category[32767 + nrneg] = cat; + bitcode[32767 + nrneg] = []; + bitcode[32767 + nrneg][1] = cat; + bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg; + } + nrlower <<= 1; + nrupper <<= 1; + } + } + _initCategoryNumber(); + function _computeHuffmanTbl(nrcodes, std_table) { + var codevalue = 0; + var pos_in_table = 0; + var HT = []; + for (var k = 1; k <= 16; k++) { + for (var j = 1; j <= nrcodes[k]; j++) { + HT[std_table[pos_in_table]] = []; + HT[std_table[pos_in_table]][0] = codevalue; + HT[std_table[pos_in_table]][1] = k; + pos_in_table++; + codevalue++; + } + codevalue *= 2; + } + return HT; + } + var YDC_HT = _computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values), UVDC_HT = _computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values), YAC_HT = _computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values), UVAC_HT = _computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values); + f5stego.prototype.pack = function() { + var byteout, bytenew, bytepos, poslast, outpos, byte; + function writeByte(value) { + var t; + byteout[outpos++] = value; + if (outpos > poslast) { + t = new Uint8Array(byteout.length * 2); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + } + function writeWord(value) { + writeByte(value >> 8 & 255); + writeByte(value & 255); + } + function writeBlock(block) { + var t; + if (outpos + block.length > poslast) { + t = new Uint8Array(byteout.length * 2 + block.length); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + byteout.set(block, outpos); + outpos += block.length; + } + function writeAPP0(self) { + writeWord(65504); + if (!self.jfif) { + writeWord(16); + writeByte(74); + writeByte(70); + writeByte(73); + writeByte(70); + writeByte(0); + writeByte(1); + writeByte(1); + writeByte(0); + writeWord(1); + writeWord(1); + writeByte(0); + writeByte(0); + } else { + writeWord(self.jfif.length + 2); + writeBlock(self.jfif); + } + } + function writeDQT(self) { + for (var i2 = 0; i2 < self.qts.length; i2++) { + writeWord(65499); + writeWord(self.qts[i2].length + 2); + writeBlock(self.qts[i2]); + } + } + function writeAPPn(self) { + for (var i2 = 0; i2 < self.APPn.length; i2++) { + writeWord(65280 | self.APPn[i2].app); + writeWord(self.APPn[i2].data.length + 2); + writeBlock(self.APPn[i2].data); + } + } + function writeSOF0(self) { + writeWord(65472); + writeWord(8 + self.frame.components.length * 3); + writeByte(self.frame.precision); + writeWord(self.frame.scanLines); + writeWord(self.frame.samplesPerLine); + writeByte(self.frame.components.length); + for (var i2 = 0; i2 < self.frame.components.length; i2++) { + var c2 = self.frame.components[i2]; + writeByte(c2.componentId); + writeByte(c2.h << 4 | c2.v); + writeByte(c2.quantizationTable); + } + } + function writeDHT(self) { + writeWord(65476); + writeWord(31); + writeByte(0); + for (var i2 = 0; i2 < 16; i2++) { + writeByte(std_dc_luminance_nrcodes[i2 + 1]); + } + for (var j = 0; j <= 11; j++) { + writeByte(std_dc_luminance_values[j]); + } + writeWord(65476); + writeWord(181); + writeByte(16); + for (var k = 0; k < 16; k++) { + writeByte(std_ac_luminance_nrcodes[k + 1]); + } + for (var l = 0; l <= 161; l++) { + writeByte(std_ac_luminance_values[l]); + } + if (self.frame.components.length != 1) { + writeWord(65476); + writeWord(31); + writeByte(1); + for (var m = 0; m < 16; m++) { + writeByte(std_dc_chrominance_nrcodes[m + 1]); + } + for (var n = 0; n <= 11; n++) { + writeByte(std_dc_chrominance_values[n]); + } + writeWord(65476); + writeWord(181); + writeByte(17); + for (var o = 0; o < 16; o++) { + writeByte(std_ac_chrominance_nrcodes[o + 1]); + } + for (var p = 0; p <= 161; p++) { + writeByte(std_ac_chrominance_values[p]); + } + } + } + function writeSOS(self) { + writeWord(65498); + writeWord(6 + self.frame.components.length * 2); + writeByte(self.frame.components.length); + for (var i2 = 0; i2 < self.frame.components.length; i2++) { + var c2 = self.frame.components[i2]; + writeByte(c2.componentId); + if (i2 === 0) { + writeByte(0); + } else { + writeByte(17); + } + } + writeByte(0); + writeByte(63); + writeByte(0); + } + function processDU(comp, POS, DC, HTDC, HTAC) { + var pos, posval, t; + if (bytepos === 0) + bytenew = 0; + var Diff = comp.blocksDC[POS >> 6] - DC; + DC = comp.blocksDC[POS >> 6]; + if (Diff === 0) { + posval = HTDC[0][1]; + bytenew <<= posval; + bytenew += HTDC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } else { + pos = 32767 + Diff; + posval = HTDC[category[pos]][1]; + bytenew <<= posval; + bytenew += HTDC[category[pos]][0]; + bytepos += posval; + posval = bitcode[pos][1]; + bytenew <<= posval; + bytenew += bitcode[pos][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + var end0pos = 63; + for (; end0pos > 0 && comp.blocks[POS + end0pos] === 0; end0pos--) { + } + if (end0pos === 0) { + posval = HTAC[0][1]; + bytenew <<= posval; + bytenew += HTAC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + return DC; + } + var i2 = 1; + var lng; + while (i2 <= end0pos) { + var startpos = i2; + for (; comp.blocks[POS + i2] === 0 && i2 <= end0pos; ++i2) { + } + var nrzeroes = i2 - startpos; + if (nrzeroes >= 16) { + lng = nrzeroes >> 4; + for (var nrmarker = 1; nrmarker <= lng; ++nrmarker) { + posval = HTAC[240][1]; + bytenew <<= posval; + bytenew += HTAC[240][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + nrzeroes = nrzeroes & 15; + } + pos = 32767 + comp.blocks[POS + i2]; + posval = HTAC[(nrzeroes << 4) + category[pos]][1]; + bytenew <<= posval; + bytenew += HTAC[(nrzeroes << 4) + category[pos]][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + posval = bitcode[pos][1]; + bytenew <<= posval; + bytenew += bitcode[pos][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + i2++; + } + if (end0pos != 63) { + posval = HTAC[0][1]; + bytenew <<= posval; + bytenew += HTAC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + if (outpos > poslast) { + t = new Uint8Array(byteout.length * 2); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + return DC; + } + byteout = new Uint8Array(65536); + poslast = 65536 - 128; + outpos = 0; + bytenew = 0; + bytepos = 0; + writeWord(65496); + writeAPP0(this); + writeAPPn(this); + writeDQT(this); + writeSOF0(this); + writeDHT(this); + writeSOS(this); + bytenew = 0; + bytepos = 0; + var c, mcuRow, mcuCol, blockRow, blockCol, mcu, i, v, h; + var DCdiff = []; + for (i = 0; i < this.frame.components.length; i++) { + DCdiff.push(0); + } + for (mcu = 0; mcu < this.frame.mcusPerLine * this.frame.mcusPerColumn; mcu++) { + mcuRow = mcu / this.frame.mcusPerLine | 0; + mcuCol = mcu % this.frame.mcusPerLine; + for (i = 0; i < this.frame.components.length; i++) { + c = this.frame.components[i]; + for (v = 0; v < c.v; v++) { + blockRow = mcuRow * c.v + v; + for (h = 0; h < c.h; h++) { + blockCol = mcuCol * c.h + h; + if (i === 0) { + DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], YDC_HT, YAC_HT); + } else { + DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], UVDC_HT, UVAC_HT); + } + } + } + } + } + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + } + if (bytepos > 0) { + bytenew <<= 8 - bytepos; + bytenew += (1 << 8 - bytepos) - 1; + byteout[outpos++] = 255 & bytenew; + } + writeWord(65497); + if (this.tail) + writeBlock(this.tail); + return byteout.slice(0, outpos); + }; + f5stego.prototype.clearTail = function() { + if (!this.tail) + return null; + var t = this.tail; + this.tail = null; + return t; + }; + f5stego.prototype.setTail = function(data) { + this.tail = data; + }; + f5stego.prototype.getTail = function() { + return this.tail; + }; + f5stego.prototype.clearAPPs = function() { + var t = this.APPn; + this.APPn = []; + return t; + }; + f5stego.prototype.getAPPn = function(id, remove) { + var i, t, ret = new Uint8Array(0), n = []; + id &= 255; + if (id < 16) + id += 224; + if (id === 224) + return this.jfif; + for (i = 0; i < this.APPn.length; i++) { + if (this.APPn[i].app == id) { + t = new Uint8Array(ret.length + this.APPn[i].data.length); + t.set(ret); + t.set(this.APPn[i].data, ret.length); + ret = t; + } else if (remove) + n.push(this.APPn[i]); + } + if (remove) + this.APPn = n; + if (ret.length === 0) + return null; + return ret; + }; + f5stego.prototype.setAPPn = function(id, data) { + var i, t, ret; + id &= 255; + if (id < 16) + id += 224; + if (id === 224) { + t = this.jfif; + this.jfif = data; + return t; + } + ret = this.getAPPn(id, true); + if (data.length < 65534) { + this.APPn.push({ "app": id, "data": data }); + return ret; + } + i = 0; + while (i < data.length) { + this.APPn.push({ "app": id, "data": data.subarray(i, i + 65533) }); + i += 65533; + } + return ret; + }; + f5stego.prototype.strip = function() { + this.clearTail(); + this.clearAPPs(); + return true; + }; + f5stego.prototype.embed = function(image, data) { + this.parse(image).f5put(data); + return this.pack(); + }; + f5stego.prototype.extract = function(image) { + return this.parse(image).f5get(); + }; + return f5stego; + }); + } + }); + // node_modules/jpeg-js/lib/encoder.js var require_encoder = __commonJS({ "node_modules/jpeg-js/lib/encoder.js"(exports, module) { @@ -13134,11 +14770,11 @@ function set_input_value(input, value) { input.value = value == null ? "" : value; } - function set_style(node, key, value, important) { + function set_style(node, key2, value, important) { if (value === null) { - node.style.removeProperty(key); + node.style.removeProperty(key2); } else { - node.style.setProperty(key, value, important ? "important" : ""); + node.style.setProperty(key2, value, important ? "important" : ""); } } function select_option(select, value) { @@ -13294,12 +14930,12 @@ return true; }; } - function setContext(key, context) { - get_current_component().$$.context.set(key, context); + function setContext(key2, context) { + get_current_component().$$.context.set(key2, context); return context; } - function getContext(key) { - return get_current_component().$$.context.get(key); + function getContext(key2) { + return get_current_component().$$.context.get(key2); } function bubble(component, event) { const callbacks = component.$$.callbacks[event.type]; @@ -13533,17 +15169,17 @@ i = n; while (i--) { const child_ctx = get_context(ctx, list, i); - const key = get_key(child_ctx); - let block = lookup.get(key); + const key2 = get_key(child_ctx); + let block = lookup.get(key2); if (!block) { - block = create_each_block8(key, child_ctx); + block = create_each_block8(key2, child_ctx); block.c(); } else if (dynamic) { block.p(child_ctx, dirty); } - new_lookup.set(key, new_blocks[i] = block); - if (key in old_indexes) - deltas.set(key, Math.abs(i - old_indexes[key])); + new_lookup.set(key2, new_blocks[i] = block); + if (key2 in old_indexes) + deltas.set(key2, Math.abs(i - old_indexes[key2])); } const will_move = /* @__PURE__ */ new Set(); const did_move = /* @__PURE__ */ new Set(); @@ -13687,8 +15323,8 @@ connectedCallback() { const { on_mount } = this.$$; this.$$.on_disconnect = on_mount.map(run).filter(is_function); - for (const key in this.$$.slotted) { - this.appendChild(this.$$.slotted[key]); + for (const key2 in this.$$.slotted) { + this.appendChild(this.$$.slotted[key2]); } } attributeChangedCallback(attr2, _oldValue, newValue) { @@ -13787,8 +15423,8 @@ } // src/stores.ts - var localLoad = (key, def) => "__pee__" + key in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key)) : def; - var localSet = (key, value) => localStorage.setItem("__pee__" + key, JSON.stringify(value)); + var localLoad = (key2, def) => "__pee__" + key2 in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key2)) : def; + var localSet = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value)); var initial_settings = localLoad("settingsv2", { ...localLoad("settings", {}), loop: true, @@ -13812,6 +15448,7 @@ mdist: -1, phash: false, hotlink: false, + jpeg: false, vercheck: false, cache: void 0, fhost: 0, @@ -13819,50 +15456,7 @@ conc: 8, ho: false, blacklist: ["guro", "scat", "ryona", "gore"], - rsources: [ - { - name: "Gelbooru", - domain: "gelbooru.com", - endpoint: "/index.php?page=dapi&s=post&q=index&json=1&tags=md5:", - view: "https://gelbooru.com/index.php?page=post&s=view&id=" - }, - { - name: "Yandere", - domain: "yande.re", - endpoint: "/post.json?tags=md5:", - view: `https://yande.re/post/show/` - }, - { - name: "Sankaku", - domain: "capi-v2.sankakucomplex.com", - endpoint: "/posts/keyset?tags=md5:", - view: `https://chan.sankakucomplex.com/post/show/` - }, - { - name: "Rule34", - domain: "api.rule34.xxx", - endpoint: "/index.php?page=dapi&s=post&q=index&json=1&tags=md5:", - view: "https://rule34.xxx/index.php?page=post&s=view&id=" - }, - { - name: "Danbooru", - domain: "danbooru.donmai.us", - endpoint: "/posts.json?tags=md5:", - view: "https://danbooru.donmai.us/posts/" - }, - { - name: "Lolibooru", - domain: "lolibooru.moe", - endpoint: "/post.json?tags=md5:", - view: "https://lolibooru.moe/post/show/" - }, - { - name: "ATFbooru", - domain: "booru.allthefallen.moe", - endpoint: "/posts.json?tags=md5:", - view: "https://booru.allthefallen.moe/posts/" - } - ], + rsources: [], ...localLoad("settingsv2", {}) }); var settings = writable(initial_settings); @@ -14136,6 +15730,8 @@ // src/platform.ts var lqueue = {}; + var localLoad2 = (key2, def) => "__pee__" + key2 in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key2)) : def; + var localSet2 = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value)); var { port1, port2 } = new MessageChannel(); console.log("ff_api", false); if (true) { @@ -14179,10 +15775,33 @@ for (const k of keys) ctor[k] = bridge(k, ctor[k]); }; + var altdomains = [ + "desuarchive.org", + "archived.moe", + "archive.nyafuu.org", + "arch.b4k.co", + "archive.wakarimasen.moe", + "b4k.co", + "fireden.net", + "thebarchive.com", + "archiveofsins.com" + ]; function supportedAltDomain(s) { - if (false) - return GM.info.script.matches.slice(2).some((m) => m.includes(s)); - return !location.host.includes("boards.4chan"); + return altdomains.includes(s); + } + function supportedMainDomain(s) { + return ["boards.4channel.org", "boards.4chan.org"].includes(s); + } + var popupport; + var pendingcmds = {}; + if (false) { + popupport = chrome.runtime.connect({ name: "popup" }); + popupport.onMessage.addListener((msg) => { + if (msg.id in pendingcmds) { + pendingcmds[msg.id](msg); + delete pendingcmds[msg.id]; + } + }); } var Platform = class { static async openInTab(src, opts) { @@ -14195,15 +15814,42 @@ i = (await obj.tabs.getCurrent()).index + 1; return obj.tabs.create({ active: opts.active, url: src, index: i }); } + static getValue(name, def) { + return localLoad2(name, def); + } + static setValue(name, val) { + localSet2(name, val); + } }; + Platform.cmdid = 0; Platform = __decorateClass([ Bridged ], Platform); + var cmdid = 0; + function request(domain) { + try { + popupport.postMessage({ id: cmdid, type: "grant", domain }); + cmdid++; + } catch (e) { + if (e.message.includes("disconnected")) { + popupport = chrome.runtime.connect({ name: "popup" }); + popupport.onMessage.addListener((msg) => { + if (msg.id in pendingcmds) { + pendingcmds[msg.id](msg); + delete pendingcmds[msg.id]; + } + }); + return request(domain); + } + } + } var corsFetch = async (input, init5, lsn) => { const id = gid++; + let transfer = []; if (init5?.body) { - if (false) - init5.body = await serialize(init5.body); + if (false) { + [init5.body, transfer] = await braveserialize(init5.body); + } } const prom = new Promise((_, rej) => { let gcontroller; @@ -14222,12 +15868,7 @@ let s; s = 0; const cmdbuff = []; - let cleaned = false; lqueue[id] = async (e) => { - if (!cleaned && false) { - cleanupSerialized(init5.body); - cleaned = true; - } if (e.progress) { if (lsn) lsn.dispatchEvent(new CustomEvent("progress", { detail: e.progress })); @@ -14319,7 +15960,7 @@ id, name: "corsFetch", args: [input, init5] - }); + }, transfer); }); return prom; }; @@ -14370,7 +16011,7 @@ // src/filehosts.ts function parseForm(data) { const form = new FormData(); - Object.entries(data).filter(([key, value]) => value !== null).map(([key, value]) => form.append(key, value)); + Object.entries(data).filter(([key2, value]) => value !== null).map(([key2, value]) => form.append(key2, value)); return form; } var lolisafe = (domain, serving = domain) => ({ @@ -16635,11 +18276,18 @@ } if (buff.slice(4, 4 + CUM6.length).equals(CUM6)) { const passed = buff.slice(4 + CUM6.length); - const decoded = import_buffer3.Buffer.from(passed.toString(), "base64").toString().split(" ").map((e) => { - return `https://${rprefs[e[0]]}/${e.slice(1)}`; - }).join(" "); - const k = await decodeCoom3Payload(import_buffer3.Buffer.from(decoded)); - ret.push(...k.filter((e) => e).map((e) => e)); + if (!passed.toString().match(/^[0-9a-zA-Z+/=]+$/g)) + continue; + try { + const decoded = import_buffer3.Buffer.from(passed.toString(), "base64").toString().split(" ").map((e) => { + if (!(e[0] in rprefs)) + throw "Uhh"; + return `https://${rprefs[e[0]]}/${e.slice(1)}`; + }).join(" "); + const k = await decodeCoom3Payload(import_buffer3.Buffer.from(decoded)); + ret.push(...k.filter((e) => e).map((e) => e)); + } finally { + } } break; case "IDAT": @@ -16672,7 +18320,7 @@ }; var inject_data = async (container, injb) => { let magic3 = false; - const [writestream, extract6] = BufferWriteStream2(); + const [writestream, extract7] = BufferWriteStream2(); const encoder = new PNGEncoder(writestream); const decoder = new PNGDecoder(container.stream().getReader()); for await (const [name, chunk, crc, offset] of decoder.chunks()) { @@ -16691,7 +18339,7 @@ async () => Promise.resolve(0), 0 ]); - return extract6(); + return extract7(); }; var inject = async (container, links) => { links = links.map((link) => { @@ -16723,7 +18371,10 @@ return true; if (buff.slice(4, 4 + CUM6.length).equals(CUM6)) { const passed = buff.slice(4 + CUM6.length).toString(); - return !!passed.match(/^[0-9a-zA-Z+/=]+$/g); + if (passed.match(/^[0-9a-zA-Z+/=]+$/g)) { + if (import_buffer3.Buffer.from(passed, "base64").toString().split(" ").every((l) => l[0] in rprefs)) + return true; + } } break; case "IDAT": @@ -16973,7 +18624,7 @@ } }; var inject3 = async (container, links) => { - const [writestream, extract6] = BufferWriteStream(); + const [writestream, extract7] = BufferWriteStream(); const writer = writestream.getWriter(); const inj = import_buffer5.Buffer.from(links.join(" ")); xor3(inj, password3); @@ -16988,7 +18639,7 @@ await writer.write(contbuff.slice(0, endo)); await write_embedding(writer, import_buffer5.Buffer.from(inj)); await writer.write(contbuff.slice(endo)); - return extract6(); + return extract7(); }; var has_embed3 = (gif) => { const field = gif.readUInt8(10); @@ -17025,6 +18676,11 @@ init_define_BUILD_VERSION(); init_esbuild_inject(); var import_buffer6 = __toESM(require_buffer(), 1); + var import_f5stegojs = __toESM(require_f5stego(), 1); + var csettings3; + settings.subscribe((b) => { + csettings3 = b; + }); var convertToPng = async (f) => { const can = document.createElement("canvas"); const url = URL.createObjectURL(f); @@ -17064,18 +18720,48 @@ URL.revokeObjectURL(url); } }; + var key = import_buffer6.Buffer.from("CUNNYCUNNYCUNNY"); + var f5inst = new import_f5stegojs.default(key); + var injectTrue = async (b, links) => { + if (b.size / 20 < links.join(" ").length) + throw "Image too small to embed."; + const arr = new Uint8Array(await b.arrayBuffer()); + const buff = f5inst.embed(arr, import_buffer6.Buffer.from(links.join(" "))); + return import_buffer6.Buffer.from(buff); + }; var inject4 = async (b, links) => { + if (csettings3.jpeg) + return injectTrue(b, links); const pngfile = await convertToPng(b); if (!pngfile || pngfile.size > 3e3 * 1024) { throw new Error("Couldn't convert file to PNG: resulting filesize too big."); } - return pngv3_default.inject(new File([pngfile], b.name), links); + return pngv3_default.inject(new File([pngfile], b.name), links); + }; + var has_embed4 = (b) => { + if (!csettings3.jpeg) + return false; + try { + const res = f5inst.extract(b); + if (!res) + return; + if (res.length > 1024) + return; + const str = import_buffer6.Buffer.from(res).toString(); + if (!str.match(/^[a-zA-Z0-9:/.\-_ ]+$/)) + return; + return str; + } catch { + return; + } + }; + var extract4 = (b, ex) => { + return decodeCoom3Payload(import_buffer6.Buffer.from(ex)); }; var jpg_default = { - skip: true, match: (fn) => !!fn.match(/\.jpe?g$/), - has_embed: () => false, - extract: () => [], + has_embed: has_embed4, + extract: extract4, inject: inject4 }; @@ -17142,9 +18828,9 @@ }; // src/thirdeye.ts - var csettings3; + var csettings4; settings.subscribe((b) => { - csettings3 = b; + csettings4 = b; }); var gelquirk = (prefix) => (a) => { let base = a.post || a.data || a; @@ -17199,7 +18885,7 @@ return []; } }; - var extract4 = async (b, fn) => { + var extract5 = async (b, fn) => { let result; let booru; for (const e of Object.values(boorus)) { @@ -17221,8 +18907,8 @@ url: result[0].page }, filename: fn.substring(0, 33) + result[0].ext, - thumbnail: csettings3.hotlink ? prev || full : import_buffer7.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()), - data: csettings3.hotlink ? full || prev : async (lsn) => { + thumbnail: csettings4.hotlink ? prev || full : import_buffer7.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()), + data: csettings4.hotlink ? full || prev : async (lsn) => { if (!cachedFile) cachedFile = await (await ifetch(full || prev, void 0, lsn)).arrayBuffer(); return import_buffer7.Buffer.from(cachedFile); @@ -17242,7 +18928,7 @@ } return acc; }; - var has_embed4 = async (b, fn, prevlink) => { + var has_embed5 = async (b, fn, prevlink) => { if (import_buffer7.Buffer.from(fn, "hex").equals(b)) return false; let result = void 0; @@ -17274,8 +18960,8 @@ }; var thirdeye_default = { skip: true, - extract: extract4, - has_embed: has_embed4, + extract: extract5, + has_embed: has_embed5, match: (fn) => !!fn.match(/^[0-9a-f]{32}\.....?/) }; @@ -17288,9 +18974,9 @@ { host: "Litter", prefix: "litter.catbox.moe/" }, { host: "Zzzz", prefix: "z.zz.fo/" } ]; - var csettings4; + var csettings5; settings.subscribe((b) => { - csettings4 = b; + csettings5 = b; }); var getExt = (fn) => { const isB64 = fn.match(/^((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=))?\.(gif|jpe?g|png|webm)/); @@ -17315,7 +19001,7 @@ } return { ext, source }; }; - var extract5 = async (b, fn) => { + var extract6 = async (b, fn) => { const { ext, source } = getExt(fn); let rsource; for (const cs of sources) { @@ -17330,7 +19016,7 @@ } return [{ filename: ext, - data: csettings4.hotlink ? rsource : async (lsn) => { + data: csettings5.hotlink ? rsource : async (lsn) => { try { return import_buffer8.Buffer.from(await (await ifetch(rsource, void 0, lsn)).arrayBuffer()); } catch (e) { @@ -17339,7 +19025,7 @@ thumbnail: import_buffer8.Buffer.from(hasembed_default) }]; }; - var has_embed5 = async (b, fn) => { + var has_embed6 = async (b, fn) => { const { ext, source } = getExt(fn); if (!ext) return false; @@ -17356,8 +19042,8 @@ }; var pomf_default = { skip: true, - extract: extract5, - has_embed: has_embed5, + extract: extract6, + has_embed: has_embed6, match: (fn) => !!getExt(fn) }; @@ -19027,8 +20713,8 @@ const get_key = (ctx2) => ctx2[10][0]; for (let i = 0; i < each_value.length; i += 1) { let child_ctx = get_each_context(ctx, each_value, i); - let key = get_key(child_ctx); - each_1_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx)); + let key2 = get_key(child_ctx); + each_1_lookup.set(key2, each_blocks[i] = create_each_block(key2, child_ctx)); } return { c() { @@ -19352,34 +21038,34 @@ // src/Components/App.svelte function add_css8(target) { - append_styles(target, "svelte-98wprd", '.bepis.svelte-98wprd.svelte-98wprd{max-height:260px;overflow-y:auto}.tagcont.svelte-98wprd.svelte-98wprd{display:flex;gap:5px;margin-bottom:10px;flex-wrap:wrap}label.svelte-98wprd>input[type="text"].svelte-98wprd,label.svelte-98wprd>input[type="number"].svelte-98wprd{width:95%}.content.svelte-98wprd.svelte-98wprd{display:flex;flex-direction:column}.error.svelte-98wprd.svelte-98wprd{color:red}hr.svelte-98wprd.svelte-98wprd{width:100%}h1.svelte-98wprd.svelte-98wprd{text-align:center}.form.svelte-98wprd.svelte-98wprd{display:flex;flex-direction:column;gap:20px;position:absolute;padding:15px;border:1px solid white;background-color:inherit;border-radius:10px}.form.svelte-98wprd>label.svelte-98wprd{display:flex;flex-direction:column;gap:10px}.newsbox.svelte-98wprd.svelte-98wprd{max-height:300px;overflow-y:scroll}.backpanel.svelte-98wprd.svelte-98wprd{position:absolute;right:32px;padding:10px;width:15%;top:32px;border:1px solid;border-radius:5px;background-color:rgba(0, 0, 0, 0.8);pointer-events:all;backdrop-filter:blur(9px);max-height:80vh;min-width:321px}'); + append_styles(target, "svelte-2r0xqp", '.bepis.svelte-2r0xqp.svelte-2r0xqp{max-height:260px;overflow-y:auto}.tagcont.svelte-2r0xqp.svelte-2r0xqp{display:flex;gap:5px;margin-bottom:10px;flex-wrap:wrap}label.svelte-2r0xqp>input[type="text"].svelte-2r0xqp,label.svelte-2r0xqp>input[type="number"].svelte-2r0xqp{width:95%}.content.svelte-2r0xqp.svelte-2r0xqp{display:flex;flex-direction:column}.error.svelte-2r0xqp.svelte-2r0xqp{color:red}hr.svelte-2r0xqp.svelte-2r0xqp{width:100%}h1.svelte-2r0xqp.svelte-2r0xqp{text-align:center}.form.svelte-2r0xqp.svelte-2r0xqp{display:flex;flex-direction:column;gap:20px;position:absolute;padding:15px;border:1px solid white;background-color:black;border-radius:10px}.form.svelte-2r0xqp>label.svelte-2r0xqp{display:flex;flex-direction:column;gap:10px}.newsbox.svelte-2r0xqp.svelte-2r0xqp{max-height:300px;overflow-y:scroll}.backpanel.svelte-2r0xqp.svelte-2r0xqp{position:absolute;right:32px;padding:10px;width:15%;top:32px;border:1px solid;border-radius:5px;background-color:rgba(0, 0, 0, 0.8);pointer-events:all;backdrop-filter:blur(9px);max-height:80vh;min-width:321px}'); } function get_each_context2(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[57] = list[i]; + child_ctx[58] = list[i]; return child_ctx; } function get_each_context_12(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[60] = list[i]; + child_ctx[61] = list[i]; return child_ctx; } function get_each_context_2(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[63] = list[i]; - child_ctx[65] = i; + child_ctx[64] = list[i]; + child_ctx[66] = i; return child_ctx; } function get_each_context_3(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[66] = list[i]; - child_ctx[65] = i; + child_ctx[67] = list[i]; + child_ctx[66] = i; return child_ctx; } function get_each_context_4(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[68] = list[i]; - child_ctx[65] = i; + child_ctx[69] = list[i]; + child_ctx[66] = i; return child_ctx; } function create_if_block6(ctx) { @@ -19411,10 +21097,10 @@ hr = element("hr"); t3 = space(); create_component(tabs.$$.fragment); - attr(h1, "class", "svelte-98wprd"); - attr(hr, "class", "svelte-98wprd"); - attr(div0, "class", "content svelte-98wprd"); - attr(div1, "class", "backpanel svelte-98wprd"); + attr(h1, "class", "svelte-2r0xqp"); + attr(hr, "class", "svelte-2r0xqp"); + attr(div0, "class", "content svelte-2r0xqp"); + attr(div1, "class", "backpanel svelte-2r0xqp"); }, m(target, anchor) { insert(target, div1, anchor); @@ -19432,7 +21118,7 @@ if (!current || dirty[0] & 1) set_data(t1, ctx2[0]); const tabs_changes = {}; - if (dirty[0] & 1006 | dirty[2] & 256) { + if (dirty[0] & 1006 | dirty[2] & 512) { tabs_changes.$$scope = { dirty, ctx: ctx2 }; } tabs.$set(tabs_changes); @@ -19539,7 +21225,7 @@ } }; } - function create_if_block_10(ctx) { + function create_if_block_11(ctx) { let tab; let current; tab = new Tab_default({ @@ -19631,7 +21317,7 @@ } }); tab4.$on("select", ctx[19]); - let if_block = ctx[8].akValid && create_if_block_10(ctx); + let if_block = ctx[8].akValid && create_if_block_11(ctx); return { c() { create_component(tab0.$$.fragment); @@ -19666,27 +21352,27 @@ }, p(ctx2, dirty) { const tab0_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab0_changes.$$scope = { dirty, ctx: ctx2 }; } tab0.$set(tab0_changes); const tab1_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab1_changes.$$scope = { dirty, ctx: ctx2 }; } tab1.$set(tab1_changes); const tab2_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab2_changes.$$scope = { dirty, ctx: ctx2 }; } tab2.$set(tab2_changes); const tab3_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab3_changes.$$scope = { dirty, ctx: ctx2 }; } tab3.$set(tab3_changes); const tab4_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab4_changes.$$scope = { dirty, ctx: ctx2 }; } tab4.$set(tab4_changes); @@ -19696,7 +21382,7 @@ transition_in(if_block, 1); } } else { - if_block = create_if_block_10(ctx2); + if_block = create_if_block_11(ctx2); if_block.c(); transition_in(if_block, 1); if_block.m(if_block_anchor.parentNode, if_block_anchor); @@ -19752,7 +21438,7 @@ } }; } - function create_if_block_9(ctx) { + function create_if_block_10(ctx) { let label; let input; let t; @@ -19771,7 +21457,7 @@ input.checked = ctx[7].ho; append(label, t); if (!mounted) { - dispose = listen(input, "change", ctx[28]); + dispose = listen(input, "change", ctx[29]); mounted = true; } }, @@ -19788,7 +21474,7 @@ } }; } - function create_if_block_62(ctx) { + function create_if_block_72(ctx) { let t0; let label; let t1; @@ -19799,8 +21485,8 @@ let if_block1_anchor; let mounted; let dispose; - let if_block0 = ctx[8].herror && create_if_block_8(ctx); - let if_block1 = ctx[8].akValid && create_if_block_72(ctx); + let if_block0 = ctx[8].herror && create_if_block_9(ctx); + let if_block1 = ctx[8].akValid && create_if_block_8(ctx); return { c() { if (if_block0) @@ -19818,8 +21504,8 @@ if_block1_anchor = empty(); attr(a, "title", "Only requires Search Files permission. See Hydrus docs on where to set this up."); attr(input, "type", "text"); - attr(input, "class", "svelte-98wprd"); - attr(label, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { if (if_block0) @@ -19836,7 +21522,7 @@ if_block1.m(target, anchor); insert(target, if_block1_anchor, anchor); if (!mounted) { - dispose = listen(input, "input", ctx[36]); + dispose = listen(input, "input", ctx[37]); mounted = true; } }, @@ -19845,7 +21531,7 @@ if (if_block0) { if_block0.p(ctx2, dirty); } else { - if_block0 = create_if_block_8(ctx2); + if_block0 = create_if_block_9(ctx2); if_block0.c(); if_block0.m(t0.parentNode, t0); } @@ -19860,7 +21546,7 @@ if (if_block1) { if_block1.p(ctx2, dirty); } else { - if_block1 = create_if_block_72(ctx2); + if_block1 = create_if_block_8(ctx2); if_block1.c(); if_block1.m(if_block1_anchor.parentNode, if_block1_anchor); } @@ -19887,7 +21573,7 @@ } }; } - function create_if_block_8(ctx) { + function create_if_block_9(ctx) { let span; let t_value = ctx[8].herror + ""; let t; @@ -19895,7 +21581,7 @@ c() { span = element("span"); t = text(t_value); - attr(span, "class", "error svelte-98wprd"); + attr(span, "class", "error svelte-2r0xqp"); }, m(target, anchor) { insert(target, span, anchor); @@ -19911,7 +21597,7 @@ } }; } - function create_if_block_72(ctx) { + function create_if_block_8(ctx) { let label0; let t0; let input0; @@ -19932,12 +21618,12 @@ input1 = element("input"); set_style(input0, "width", "5ch"); attr(input0, "type", "number"); - attr(input0, "class", "svelte-98wprd"); - attr(label0, "class", "svelte-98wprd"); + attr(input0, "class", "svelte-2r0xqp"); + attr(label0, "class", "svelte-2r0xqp"); attr(input1, "placeholder", "Restrict to these tags (space to separate tags, _ to separate words)"); attr(input1, "type", "text"); - attr(input1, "class", "svelte-98wprd"); - attr(label1, "class", "svelte-98wprd"); + attr(input1, "class", "svelte-2r0xqp"); + attr(label1, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, label0, anchor); @@ -19951,8 +21637,8 @@ set_input_value(input1, ctx[7].auto_tags); if (!mounted) { dispose = [ - listen(input0, "input", ctx[37]), - listen(input1, "input", ctx[38]) + listen(input0, "input", ctx[38]), + listen(input1, "input", ctx[39]) ]; mounted = true; } @@ -19981,141 +21667,153 @@ let label0; let input0; let t0; - let t1; + let a0; + let t2; let label1; let input1; - let t2; let t3; + let t4; let label2; let input2; - let t4; let t5; + let t6; let label3; let input3; - let t6; let t7; + let t8; let label4; let input4; - let t8; let t9; + let t10; let label5; let input5; - let t10; let t11; + let t12; let label6; let input6; - let t12; let t13; + let t14; let label7; let input7; - let t14; let t15; let t16; let label8; let input8; let t17; let t18; + let t19; let label9; let input9; - let t19; let t20; + let t21; let label10; let input10; - let t21; let t22; + let t23; let label11; let input11; - let t23; let t24; + let t25; let label12; let input12; - let t25; let t26; + let t27; let label13; let input13; - let t27; - let a; + let t28; let t29; let label14; let input14; let t30; - let t31; + let a1; + let t32; + let label15; + let input15; + let t33; + let t34; let if_block1_anchor; let mounted; let dispose; - let if_block0 = ctx[7].eye && create_if_block_9(ctx); - let if_block1 = ctx[7].hyd && create_if_block_62(ctx); + let if_block0 = ctx[7].eye && create_if_block_10(ctx); + let if_block1 = ctx[7].hyd && create_if_block_72(ctx); return { c() { label0 = element("label"); input0 = element("input"); - t0 = text("\n Try to load embeds from server cache"); - t1 = space(); + t0 = text("\n Enable JPGs support (JPG embed and extract)\n "); + a0 = element("a"); + a0.textContent = "?"; + t2 = space(); label1 = element("label"); input1 = element("input"); - t2 = text("\n Display view counts"); - t3 = space(); + t3 = text("\n Try to load embeds from server cache"); + t4 = space(); label2 = element("label"); input2 = element("input"); - t4 = text("\n Check for new versions at startup."); - t5 = space(); + t5 = text("\n Display view counts"); + t6 = space(); label3 = element("label"); input3 = element("input"); - t6 = text("\n Autoexpand Images on opening."); - t7 = space(); + t7 = text("\n Check for new versions at startup."); + t8 = space(); label4 = element("label"); input4 = element("input"); - t8 = text("\n Autoexpand Videos on opening."); - t9 = space(); + t9 = text("\n Autoexpand Images on opening."); + t10 = space(); label5 = element("label"); input5 = element("input"); - t10 = text("\n Loop media content."); - t11 = space(); + t11 = text("\n Autoexpand Videos on opening."); + t12 = space(); label6 = element("label"); input6 = element("input"); - t12 = text("\n Disable hover preview."); - t13 = space(); + t13 = text("\n Loop media content."); + t14 = space(); label7 = element("label"); input7 = element("input"); - t14 = text("\n Hide embedded content behind an eye."); - t15 = space(); - if (if_block0) - if_block0.c(); + t15 = text("\n Disable hover preview."); t16 = space(); label8 = element("label"); input8 = element("input"); - t17 = text("\n Preload external files."); + t17 = text("\n Hide embedded content behind an eye."); t18 = space(); + if (if_block0) + if_block0.c(); + t19 = space(); label9 = element("label"); input9 = element("input"); - t19 = text("\n Preload external files when they are in view."); - t20 = space(); + t20 = text("\n Preload external files."); + t21 = space(); label10 = element("label"); input10 = element("input"); - t21 = text("\n Hotlink content."); - t22 = space(); + t22 = text("\n Preload external files when they are in view."); + t23 = space(); label11 = element("label"); input11 = element("input"); - t23 = text("\n Control audio on videos with mouse wheel."); - t24 = space(); + t24 = text("\n Hotlink content."); + t25 = space(); label12 = element("label"); input12 = element("input"); - t25 = text("\n Show Minimap"); - t26 = space(); + t26 = text("\n Control audio on videos with mouse wheel."); + t27 = space(); label13 = element("label"); input13 = element("input"); - t27 = text("\n \n Disable embedded file preloading"); - a = element("a"); - a.textContent = "?"; + t28 = text("\n Show Minimap"); t29 = space(); label14 = element("label"); input14 = element("input"); - t30 = text("\n \n Enable Hydrus Integration"); - t31 = space(); + t30 = text("\n \n Disable embedded file preloading"); + a1 = element("a"); + a1.textContent = "?"; + t32 = space(); + label15 = element("label"); + input15 = element("input"); + t33 = text("\n \n Enable Hydrus Integration"); + t34 = space(); if (if_block1) if_block1.c(); if_block1_anchor = empty(); attr(input0, "type", "checkbox"); + attr(a0, "title", "JPG embed detection is relatively slow, heavy, so you might want to also enable server cache loading"); attr(input1, "type", "checkbox"); attr(input2, "type", "checkbox"); attr(input3, "type", "checkbox"); @@ -20129,89 +21827,96 @@ attr(input11, "type", "checkbox"); attr(input12, "type", "checkbox"); attr(input13, "type", "checkbox"); - attr(a, "title", "You might still want to enable 'preload external files'"); attr(input14, "type", "checkbox"); + attr(a1, "title", "You might still want to enable 'preload external files'"); + attr(input15, "type", "checkbox"); }, m(target, anchor) { insert(target, label0, anchor); append(label0, input0); - input0.checked = ctx[9]; + input0.checked = ctx[7].jpeg; append(label0, t0); - insert(target, t1, anchor); + append(label0, a0); + insert(target, t2, anchor); insert(target, label1, anchor); append(label1, input1); - input1.checked = ctx[7].dvc; - append(label1, t2); - insert(target, t3, anchor); + input1.checked = ctx[9]; + append(label1, t3); + insert(target, t4, anchor); insert(target, label2, anchor); append(label2, input2); - input2.checked = ctx[7].vercheck; - append(label2, t4); - insert(target, t5, anchor); + input2.checked = ctx[7].dvc; + append(label2, t5); + insert(target, t6, anchor); insert(target, label3, anchor); append(label3, input3); - input3.checked = ctx[7].xpi; - append(label3, t6); - insert(target, t7, anchor); + input3.checked = ctx[7].vercheck; + append(label3, t7); + insert(target, t8, anchor); insert(target, label4, anchor); append(label4, input4); - input4.checked = ctx[7].xpv; - append(label4, t8); - insert(target, t9, anchor); + input4.checked = ctx[7].xpi; + append(label4, t9); + insert(target, t10, anchor); insert(target, label5, anchor); append(label5, input5); - input5.checked = ctx[7].loop; - append(label5, t10); - insert(target, t11, anchor); + input5.checked = ctx[7].xpv; + append(label5, t11); + insert(target, t12, anchor); insert(target, label6, anchor); append(label6, input6); - input6.checked = ctx[7].dh; - append(label6, t12); - insert(target, t13, anchor); + input6.checked = ctx[7].loop; + append(label6, t13); + insert(target, t14, anchor); insert(target, label7, anchor); append(label7, input7); - input7.checked = ctx[7].eye; - append(label7, t14); - insert(target, t15, anchor); - if (if_block0) - if_block0.m(target, anchor); + input7.checked = ctx[7].dh; + append(label7, t15); insert(target, t16, anchor); insert(target, label8, anchor); append(label8, input8); - input8.checked = ctx[7].pre; + input8.checked = ctx[7].eye; append(label8, t17); insert(target, t18, anchor); + if (if_block0) + if_block0.m(target, anchor); + insert(target, t19, anchor); insert(target, label9, anchor); append(label9, input9); - input9.checked = ctx[7].prev; - append(label9, t19); - insert(target, t20, anchor); + input9.checked = ctx[7].pre; + append(label9, t20); + insert(target, t21, anchor); insert(target, label10, anchor); append(label10, input10); - input10.checked = ctx[7].hotlink; - append(label10, t21); - insert(target, t22, anchor); + input10.checked = ctx[7].prev; + append(label10, t22); + insert(target, t23, anchor); insert(target, label11, anchor); append(label11, input11); - input11.checked = ctx[7].ca; - append(label11, t23); - insert(target, t24, anchor); + input11.checked = ctx[7].hotlink; + append(label11, t24); + insert(target, t25, anchor); insert(target, label12, anchor); append(label12, input12); - input12.checked = ctx[7].sh; - append(label12, t25); - insert(target, t26, anchor); + input12.checked = ctx[7].ca; + append(label12, t26); + insert(target, t27, anchor); insert(target, label13, anchor); append(label13, input13); - input13.checked = ctx[7].ep; - append(label13, t27); - append(label13, a); + input13.checked = ctx[7].sh; + append(label13, t28); insert(target, t29, anchor); insert(target, label14, anchor); append(label14, input14); - input14.checked = ctx[7].hyd; + input14.checked = ctx[7].ep; append(label14, t30); - insert(target, t31, anchor); + append(label14, a1); + insert(target, t32, anchor); + insert(target, label15, anchor); + append(label15, input15); + input15.checked = ctx[7].hyd; + append(label15, t33); + insert(target, t34, anchor); if (if_block1) if_block1.m(target, anchor); insert(target, if_block1_anchor, anchor); @@ -20225,80 +21930,84 @@ listen(input5, "change", ctx[25]), listen(input6, "change", ctx[26]), listen(input7, "change", ctx[27]), - listen(input8, "change", ctx[29]), + listen(input8, "change", ctx[28]), listen(input9, "change", ctx[30]), listen(input10, "change", ctx[31]), listen(input11, "change", ctx[32]), listen(input12, "change", ctx[33]), listen(input13, "change", ctx[34]), - listen(input14, "change", ctx[35]) + listen(input14, "change", ctx[35]), + listen(input15, "change", ctx[36]) ]; mounted = true; } }, p(ctx2, dirty) { + if (dirty[0] & 128) { + input0.checked = ctx2[7].jpeg; + } if (dirty[0] & 512) { - input0.checked = ctx2[9]; + input1.checked = ctx2[9]; } if (dirty[0] & 128) { - input1.checked = ctx2[7].dvc; + input2.checked = ctx2[7].dvc; } if (dirty[0] & 128) { - input2.checked = ctx2[7].vercheck; + input3.checked = ctx2[7].vercheck; } if (dirty[0] & 128) { - input3.checked = ctx2[7].xpi; + input4.checked = ctx2[7].xpi; } if (dirty[0] & 128) { - input4.checked = ctx2[7].xpv; + input5.checked = ctx2[7].xpv; } if (dirty[0] & 128) { - input5.checked = ctx2[7].loop; + input6.checked = ctx2[7].loop; } if (dirty[0] & 128) { - input6.checked = ctx2[7].dh; + input7.checked = ctx2[7].dh; } if (dirty[0] & 128) { - input7.checked = ctx2[7].eye; + input8.checked = ctx2[7].eye; } if (ctx2[7].eye) { if (if_block0) { if_block0.p(ctx2, dirty); } else { - if_block0 = create_if_block_9(ctx2); + if_block0 = create_if_block_10(ctx2); if_block0.c(); - if_block0.m(t16.parentNode, t16); + if_block0.m(t19.parentNode, t19); } } else if (if_block0) { if_block0.d(1); if_block0 = null; } if (dirty[0] & 128) { - input8.checked = ctx2[7].pre; + input9.checked = ctx2[7].pre; } if (dirty[0] & 128) { - input9.checked = ctx2[7].prev; + input10.checked = ctx2[7].prev; } if (dirty[0] & 128) { - input10.checked = ctx2[7].hotlink; + input11.checked = ctx2[7].hotlink; } if (dirty[0] & 128) { - input11.checked = ctx2[7].ca; + input12.checked = ctx2[7].ca; } if (dirty[0] & 128) { - input12.checked = ctx2[7].sh; + input13.checked = ctx2[7].sh; } if (dirty[0] & 128) { - input13.checked = ctx2[7].ep; + input14.checked = ctx2[7].ep; } if (dirty[0] & 128) { - input14.checked = ctx2[7].hyd; + input15.checked = ctx2[7].hyd; } if (ctx2[7].hyd) { if (if_block1) { if_block1.p(ctx2, dirty); } else { - if_block1 = create_if_block_62(ctx2); + if_block1 = create_if_block_72(ctx2); if_block1.c(); if_block1.m(if_block1_anchor.parentNode, if_block1_anchor); } @@ -20311,59 +22020,59 @@ if (detaching) detach(label0); if (detaching) - detach(t1); + detach(t2); if (detaching) detach(label1); if (detaching) - detach(t3); + detach(t4); if (detaching) detach(label2); if (detaching) - detach(t5); + detach(t6); if (detaching) detach(label3); if (detaching) - detach(t7); + detach(t8); if (detaching) detach(label4); if (detaching) - detach(t9); + detach(t10); if (detaching) detach(label5); if (detaching) - detach(t11); + detach(t12); if (detaching) detach(label6); if (detaching) - detach(t13); + detach(t14); if (detaching) detach(label7); - if (detaching) - detach(t15); - if (if_block0) - if_block0.d(detaching); if (detaching) detach(t16); if (detaching) detach(label8); if (detaching) detach(t18); + if (if_block0) + if_block0.d(detaching); + if (detaching) + detach(t19); if (detaching) detach(label9); if (detaching) - detach(t20); + detach(t21); if (detaching) detach(label10); if (detaching) - detach(t22); + detach(t23); if (detaching) detach(label11); if (detaching) - detach(t24); + detach(t25); if (detaching) detach(label12); if (detaching) - detach(t26); + detach(t27); if (detaching) detach(label13); if (detaching) @@ -20371,7 +22080,11 @@ if (detaching) detach(label14); if (detaching) - detach(t31); + detach(t32); + if (detaching) + detach(label15); + if (detaching) + detach(t34); if (if_block1) if_block1.d(detaching); if (detaching) @@ -20389,23 +22102,25 @@ let t2; let h30; let t4; - let div0; let t5; + let div0; + let t6; let button; - let t7; - let dialog; let t8; - let hr; + let dialog; let t9; + let hr; + let t10; let h31; - let t11; - let div1; let t12; + let div1; + let t13; let input1; let current; let mounted; let dispose; - let if_block = ctx[7].phash && create_if_block_52(ctx); + let if_block0 = ctx[7].phash && create_if_block_62(ctx); + let if_block1 = ctx[7].rsources.length == 0 && create_if_block_52(ctx); let each_value_4 = ctx[7].rsources; let each_blocks_1 = []; for (let i = 0; i < each_value_4.length; i += 1) { @@ -20419,7 +22134,7 @@ $$scope: { ctx } }; dialog = new Dialog_default({ props: dialog_props }); - ctx[50](dialog); + ctx[51](dialog); let each_value_3 = ctx[7].blacklist; let each_blocks = []; for (let i = 0; i < each_value_3.length; i += 1) { @@ -20434,37 +22149,40 @@ input0 = element("input"); t0 = text("\n Enable perceptual hash-based filtering"); t1 = space(); - if (if_block) - if_block.c(); + if (if_block0) + if_block0.c(); t2 = space(); h30 = element("h3"); h30.textContent = "Booru sources"; t4 = space(); + if (if_block1) + if_block1.c(); + t5 = space(); div0 = element("div"); for (let i = 0; i < each_blocks_1.length; i += 1) { each_blocks_1[i].c(); } - t5 = space(); + t6 = space(); button = element("button"); button.textContent = "Add a source"; - t7 = space(); - create_component(dialog.$$.fragment); t8 = space(); - hr = element("hr"); + create_component(dialog.$$.fragment); t9 = space(); + hr = element("hr"); + t10 = space(); h31 = element("h3"); h31.textContent = "Blacklisted tags"; - t11 = space(); + t12 = space(); div1 = element("div"); for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].c(); } - t12 = space(); + t13 = space(); input1 = element("input"); attr(input0, "type", "checkbox"); - attr(div0, "class", "tagcont svelte-98wprd"); - attr(hr, "class", "svelte-98wprd"); - attr(div1, "class", "tagcont svelte-98wprd"); + attr(div0, "class", "tagcont svelte-2r0xqp"); + attr(hr, "class", "svelte-2r0xqp"); + attr(div1, "class", "tagcont svelte-2r0xqp"); attr(input1, "placeholder", "Press enter after typing your tag"); }, m(target, anchor) { @@ -20473,36 +22191,39 @@ input0.checked = ctx[7].phash; append(label, t0); insert(target, t1, anchor); - if (if_block) - if_block.m(target, anchor); + if (if_block0) + if_block0.m(target, anchor); insert(target, t2, anchor); insert(target, h30, anchor); insert(target, t4, anchor); + if (if_block1) + if_block1.m(target, anchor); + insert(target, t5, anchor); insert(target, div0, anchor); for (let i = 0; i < each_blocks_1.length; i += 1) { each_blocks_1[i].m(div0, null); } - insert(target, t5, anchor); + insert(target, t6, anchor); insert(target, button, anchor); - insert(target, t7, anchor); - mount_component(dialog, target, anchor); insert(target, t8, anchor); - insert(target, hr, anchor); + mount_component(dialog, target, anchor); insert(target, t9, anchor); + insert(target, hr, anchor); + insert(target, t10, anchor); insert(target, h31, anchor); - insert(target, t11, anchor); + insert(target, t12, anchor); insert(target, div1, anchor); for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].m(div1, null); } - insert(target, t12, anchor); + insert(target, t13, anchor); insert(target, input1, anchor); current = true; if (!mounted) { dispose = [ - listen(input0, "change", ctx[40]), - listen(button, "click", ctx[45]), - listen(input1, "keydown", ctx[52]) + listen(input0, "change", ctx[41]), + listen(button, "click", ctx[46]), + listen(input1, "keydown", ctx[53]) ]; mounted = true; } @@ -20512,16 +22233,27 @@ input0.checked = ctx2[7].phash; } if (ctx2[7].phash) { - if (if_block) { - if_block.p(ctx2, dirty); + if (if_block0) { + if_block0.p(ctx2, dirty); } else { - if_block = create_if_block_52(ctx2); - if_block.c(); - if_block.m(t2.parentNode, t2); + if_block0 = create_if_block_62(ctx2); + if_block0.c(); + if_block0.m(t2.parentNode, t2); } - } else if (if_block) { - if_block.d(1); - if_block = null; + } else if (if_block0) { + if_block0.d(1); + if_block0 = null; + } + if (ctx2[7].rsources.length == 0) { + if (if_block1) { + } else { + if_block1 = create_if_block_52(ctx2); + if_block1.c(); + if_block1.m(t5.parentNode, t5); + } + } else if (if_block1) { + if_block1.d(1); + if_block1 = null; } if (dirty[0] & 73856) { each_value_4 = ctx2[7].rsources; @@ -20545,7 +22277,7 @@ check_outros(); } const dialog_changes = {}; - if (dirty[0] & 2 | dirty[2] & 256) { + if (dirty[0] & 2 | dirty[2] & 512) { dialog_changes.$$scope = { dirty, ctx: ctx2 }; } dialog.$set(dialog_changes); @@ -20600,40 +22332,44 @@ detach(label); if (detaching) detach(t1); - if (if_block) - if_block.d(detaching); + if (if_block0) + if_block0.d(detaching); if (detaching) detach(t2); if (detaching) detach(h30); if (detaching) detach(t4); + if (if_block1) + if_block1.d(detaching); + if (detaching) + detach(t5); if (detaching) detach(div0); destroy_each(each_blocks_1, detaching); if (detaching) - detach(t5); + detach(t6); if (detaching) detach(button); if (detaching) - detach(t7); - ctx[50](null); + detach(t8); + ctx[51](null); destroy_component(dialog, detaching); if (detaching) - detach(t8); + detach(t9); if (detaching) detach(hr); if (detaching) - detach(t9); + detach(t10); if (detaching) detach(h31); if (detaching) - detach(t11); + detach(t12); if (detaching) detach(div1); destroy_each(each_blocks, detaching); if (detaching) - detach(t12); + detach(t13); if (detaching) detach(input1); mounted = false; @@ -20641,7 +22377,7 @@ } }; } - function create_if_block_52(ctx) { + function create_if_block_62(ctx) { let label; let input; let t0; @@ -20656,9 +22392,9 @@ a = element("a"); a.textContent = "?"; attr(input, "type", "number"); - attr(input, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); attr(a, "title", "Higher will filter more potentially different images, lower will let more identical images through"); - attr(label, "class", "svelte-98wprd"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, label, anchor); @@ -20667,7 +22403,7 @@ append(label, t0); append(label, a); if (!mounted) { - dispose = listen(input, "input", ctx[41]); + dispose = listen(input, "input", ctx[42]); mounted = true; } }, @@ -20684,21 +22420,37 @@ } }; } + function create_if_block_52(ctx) { + let p; + return { + c() { + p = element("p"); + p.textContent = "Don't know what to put here? Ask some anons ;)"; + }, + m(target, anchor) { + insert(target, p, anchor); + }, + d(detaching) { + if (detaching) + detach(p); + } + }; + } function create_each_block_4(ctx) { let tag; let current; function func(...args) { - return ctx[42](ctx[68], ...args); + return ctx[43](ctx[69], ...args); } function remove_handler() { - return ctx[43](ctx[68]); + return ctx[44](ctx[69]); } function toggle_handler() { - return ctx[44](ctx[68]); + return ctx[45](ctx[69]); } tag = new Tag_default({ props: { - tag: ctx[68].name, + tag: ctx[69].name, toggleable: true, toggled: !ctx[7].rsources.find(func)?.disabled } @@ -20717,7 +22469,7 @@ ctx = new_ctx; const tag_changes = {}; if (dirty[0] & 128) - tag_changes.tag = ctx[68].name; + tag_changes.tag = ctx[69].name; if (dirty[0] & 128) tag_changes.toggled = !ctx[7].rsources.find(func)?.disabled; tag.$set(tag_changes); @@ -20780,22 +22532,22 @@ button = element("button"); button.textContent = "Add"; attr(input0, "type", "text"); - attr(input0, "placeholder", "Gelbooru"); - attr(input0, "class", "svelte-98wprd"); - attr(label0, "class", "svelte-98wprd"); + attr(input0, "placeholder", "Safebooru"); + attr(input0, "class", "svelte-2r0xqp"); + attr(label0, "class", "svelte-2r0xqp"); attr(input1, "type", "text"); - attr(input1, "placeholder", "gelbooru.com"); - attr(input1, "class", "svelte-98wprd"); - attr(label1, "class", "svelte-98wprd"); + attr(input1, "placeholder", "safebooru.com"); + attr(input1, "class", "svelte-2r0xqp"); + attr(label1, "class", "svelte-2r0xqp"); attr(input2, "type", "text"); attr(input2, "placeholder", "/post.json?tags=md5:"); - attr(input2, "class", "svelte-98wprd"); - attr(label2, "class", "svelte-98wprd"); + attr(input2, "class", "svelte-2r0xqp"); + attr(label2, "class", "svelte-2r0xqp"); attr(input3, "type", "text"); - attr(input3, "placeholder", "https://yande.re/post/show/"); - attr(input3, "class", "svelte-98wprd"); - attr(label3, "class", "svelte-98wprd"); - attr(div, "class", "form svelte-98wprd"); + attr(input3, "placeholder", "https://safebooru.com/post/show/"); + attr(input3, "class", "svelte-2r0xqp"); + attr(label3, "class", "svelte-2r0xqp"); + attr(div, "class", "form svelte-2r0xqp"); }, m(target, anchor) { insert(target, div, anchor); @@ -20822,10 +22574,10 @@ append(div, button); if (!mounted) { dispose = [ - listen(input0, "input", ctx[46]), - listen(input1, "input", ctx[47]), - listen(input2, "input", ctx[48]), - listen(input3, "input", ctx[49]), + listen(input0, "input", ctx[47]), + listen(input1, "input", ctx[48]), + listen(input2, "input", ctx[49]), + listen(input3, "input", ctx[50]), listen(button, "click", ctx[11]) ]; mounted = true; @@ -20857,9 +22609,9 @@ let tag; let current; function toggle_handler_1() { - return ctx[51](ctx[66]); + return ctx[52](ctx[67]); } - tag = new Tag_default({ props: { tag: ctx[66] } }); + tag = new Tag_default({ props: { tag: ctx[67] } }); tag.$on("toggle", toggle_handler_1); return { c() { @@ -20873,7 +22625,7 @@ ctx = new_ctx; const tag_changes = {}; if (dirty[0] & 128) - tag_changes.tag = ctx[66]; + tag_changes.tag = ctx[67]; tag.$set(tag_changes); }, i(local) { @@ -20923,7 +22675,7 @@ insert(target, if_block_anchor, anchor); current = true; if (!mounted) { - dispose = listen(input, "change", ctx[39]); + dispose = listen(input, "change", ctx[40]); mounted = true; } }, @@ -20977,14 +22729,14 @@ } function create_each_block_2(ctx) { let option; - let t_value = ctx[63].domain + ""; + let t_value = ctx[64].domain + ""; let t; let option_value_value; return { c() { option = element("option"); t = text(t_value); - option.__value = option_value_value = ctx[65]; + option.__value = option_value_value = ctx[66]; option.value = option.__value; }, m(target, anchor) { @@ -21027,10 +22779,10 @@ t3 = text("Maximum number of embedded links to display\n "); input = element("input"); if (ctx[7].fhost === void 0) - add_render_callback(() => ctx[53].call(select)); + add_render_callback(() => ctx[54].call(select)); attr(input, "type", "number"); - attr(input, "class", "svelte-98wprd"); - attr(label, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, p, anchor); @@ -21047,8 +22799,8 @@ set_input_value(input, ctx[7].maxe); if (!mounted) { dispose = [ - listen(select, "change", ctx[53]), - listen(input, "input", ctx[54]) + listen(select, "change", ctx[54]), + listen(input, "input", ctx[55]) ]; mounted = true; } @@ -21131,7 +22883,7 @@ for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].c(); } - attr(div, "class", "bepis svelte-98wprd"); + attr(div, "class", "bepis svelte-2r0xqp"); }, m(target, anchor) { insert(target, div, anchor); @@ -21172,14 +22924,14 @@ let div; let a; let t0; - let t1_value = ctx[60].id + ""; + let t1_value = ctx[61].id + ""; let t1; let a_href_value; let t2; - let t3_value = ctx[60].pees + ""; + let t3_value = ctx[61].pees + ""; let t3; let t4; - let t5_value = ctx[60].eyes + ctx[60].other + ""; + let t5_value = ctx[61].eyes + ctx[61].other + ""; let t5; let t6; return { @@ -21193,7 +22945,7 @@ t4 = text(" / "); t5 = text(t5_value); t6 = text(")\n "); - attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[14] + "/thread/" + ctx[60].id); + attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[14] + "/thread/" + ctx[61].id); attr(div, "class", "mbepis"); }, m(target, anchor) { @@ -21208,14 +22960,14 @@ append(div, t6); }, p(ctx2, dirty) { - if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[60].id + "")) + if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[61].id + "")) set_data(t1, t1_value); - if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[14] + "/thread/" + ctx2[60].id)) { + if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[14] + "/thread/" + ctx2[61].id)) { attr(a, "href", a_href_value); } - if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[60].pees + "")) + if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[61].pees + "")) set_data(t3, t3_value); - if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[60].eyes + ctx2[60].other + "")) + if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[61].eyes + ctx2[61].other + "")) set_data(t5, t5_value); }, d(detaching) { @@ -21266,7 +23018,7 @@ if_block.m(target, anchor); insert(target, if_block_anchor, anchor); if (!mounted) { - dispose = listen(input, "change", ctx[55]); + dispose = listen(input, "change", ctx[56]); mounted = true; } }, @@ -21364,11 +23116,11 @@ } function create_each_block2(ctx) { let h3; - let t0_value = ctx[57].title + ""; + let t0_value = ctx[58].title + ""; let t0; let t1; let p; - let t2_value = ctx[57].content + ""; + let t2_value = ctx[58].content + ""; let t2; return { c() { @@ -21386,9 +23138,9 @@ append(p, t2); }, p(ctx2, dirty) { - if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[57].title + "")) + if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[58].title + "")) set_data(t0, t0_value); - if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[57].content + "")) + if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[58].content + "")) set_data(t2, t2_value); }, d(detaching) { @@ -21419,7 +23171,7 @@ t2 = space(); div = element("div"); if_block.c(); - attr(div, "class", "newsbox svelte-98wprd"); + attr(div, "class", "newsbox svelte-2r0xqp"); }, m(target, anchor) { insert(target, p, anchor); @@ -21599,32 +23351,32 @@ }, p(ctx2, dirty) { const tablist_changes = {}; - if (dirty[0] & 256 | dirty[2] & 256) { + if (dirty[0] & 256 | dirty[2] & 512) { tablist_changes.$$scope = { dirty, ctx: ctx2 }; } tablist.$set(tablist_changes); const tabpanel0_changes = {}; - if (dirty[0] & 896 | dirty[2] & 256) { + if (dirty[0] & 896 | dirty[2] & 512) { tabpanel0_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel0.$set(tabpanel0_changes); const tabpanel1_changes = {}; - if (dirty[0] & 134 | dirty[2] & 256) { + if (dirty[0] & 134 | dirty[2] & 512) { tabpanel1_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel1.$set(tabpanel1_changes); const tabpanel2_changes = {}; - if (dirty[0] & 128 | dirty[2] & 256) { + if (dirty[0] & 128 | dirty[2] & 512) { tabpanel2_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel2.$set(tabpanel2_changes); const tabpanel3_changes = {}; - if (dirty[0] & 224 | dirty[2] & 256) { + if (dirty[0] & 224 | dirty[2] & 512) { tabpanel3_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel3.$set(tabpanel3_changes); const tabpanel4_changes = {}; - if (dirty[0] & 8 | dirty[2] & 256) { + if (dirty[0] & 8 | dirty[2] & 512) { tabpanel4_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel4.$set(tabpanel4_changes); @@ -21765,6 +23517,10 @@ $$invalidate(3, news = await res.json()); }; function appendBooru() { + if (true) { + request(newbooru.domain); + alert("Requested! Please click the PEE icon to validate"); + } set_store_value(settings, $settings.rsources = [...$settings.rsources, newbooru], $settings); dial.toggle(); $$invalidate(1, newbooru = {}); @@ -21820,34 +23576,38 @@ const select_handler = () => updateThreads(); const select_handler_1 = () => updateNews(); function input0_change_handler() { + $settings.jpeg = this.checked; + settings.set($settings); + } + function input1_change_handler() { $cached = this.checked; cached.set($cached); } - function input1_change_handler() { + function input2_change_handler() { $settings.dvc = this.checked; settings.set($settings); } - function input2_change_handler() { + function input3_change_handler() { $settings.vercheck = this.checked; settings.set($settings); } - function input3_change_handler() { + function input4_change_handler() { $settings.xpi = this.checked; settings.set($settings); } - function input4_change_handler() { + function input5_change_handler() { $settings.xpv = this.checked; settings.set($settings); } - function input5_change_handler() { + function input6_change_handler() { $settings.loop = this.checked; settings.set($settings); } - function input6_change_handler() { + function input7_change_handler() { $settings.dh = this.checked; settings.set($settings); } - function input7_change_handler() { + function input8_change_handler() { $settings.eye = this.checked; settings.set($settings); } @@ -21855,31 +23615,31 @@ $settings.ho = this.checked; settings.set($settings); } - function input8_change_handler() { + function input9_change_handler() { $settings.pre = this.checked; settings.set($settings); } - function input9_change_handler() { + function input10_change_handler() { $settings.prev = this.checked; settings.set($settings); } - function input10_change_handler() { + function input11_change_handler() { $settings.hotlink = this.checked; settings.set($settings); } - function input11_change_handler() { + function input12_change_handler() { $settings.ca = this.checked; settings.set($settings); } - function input12_change_handler() { + function input13_change_handler() { $settings.sh = this.checked; settings.set($settings); } - function input13_change_handler() { + function input14_change_handler() { $settings.ep = this.checked; settings.set($settings); } - function input14_change_handler() { + function input15_change_handler() { $settings.hyd = this.checked; settings.set($settings); } @@ -21988,14 +23748,15 @@ input5_change_handler, input6_change_handler, input7_change_handler, - input_change_handler, input8_change_handler, + input_change_handler, input9_change_handler, input10_change_handler, input11_change_handler, input12_change_handler, input13_change_handler, input14_change_handler, + input15_change_handler, input_input_handler, input0_input_handler, input1_input_handler, @@ -23338,8 +25099,8 @@ const get_key = (ctx2) => ctx2[4].id; for (let i = 0; i < each_value.length; i += 1) { let child_ctx = get_each_context6(ctx, each_value, i); - let key = get_key(child_ctx); - each_1_lookup.set(key, each_blocks[i] = create_each_block6(key, child_ctx)); + let key2 = get_key(child_ctx); + each_1_lookup.set(key2, each_blocks[i] = create_each_block6(key2, child_ctx)); } return { c() { @@ -23883,8 +25644,8 @@ check: function check(token) { return this.get("validate", token.toString(), token); }, - get: function get(key, operator, token) { - var option = this[key]; + get: function get(key2, operator, token) { + var option = this[key2]; if (!option) { return option; } @@ -23893,13 +25654,13 @@ case "function": return option(operator, token.t); case "object": - optionValue = token.t in option ? option[token.t] : defaults[key]; + optionValue = token.t in option ? option[token.t] : defaults[key2]; return typeof optionValue === "function" ? optionValue(operator, token.t) : optionValue; } return option; }, - getObject: function getObject(key, operator, token) { - var option = this[key]; + getObject: function getObject(key2, operator, token) { + var option = this[key2]; return typeof option === "function" ? option(operator, token.t) : option; } }; @@ -24693,8 +26454,10 @@ var ViewCount_default = ViewCount; // src/main.ts + if (!supportedMainDomain(location.host) && !supportedAltDomain(location.host)) + throw "PEE not supported here, skipping"; var qp; - var csettings5 = initial_settings; + var csettings6 = initial_settings; var processors = [thirdeye_default, pomf_default, pngv3_default, jpg_default, webm_default, gif_default]; var cappState; settings.subscribe(async (b) => { @@ -24714,9 +26477,9 @@ } } } - csettings5 = b; + csettings6 = b; processors = [ - ...!csettings5.te ? [thirdeye_default] : [], + ...!csettings6.te ? [thirdeye_default] : [], pngv3_default, pomf_default, jpg_default, @@ -24756,12 +26519,16 @@ } else { chunk = { done: false, value }; cumul = import_buffer11.Buffer.concat([cumul, value]); - found = await proc.has_embed(cumul); + const v = await proc.has_embed(cumul); + if (typeof v == "string") { + return [await proc.extract(cumul, v), false]; + } + found = v; } } while (found !== false && !chunk.done); succ = true; await iter.next(true); - if (found === false) { + if (found !== true) { return; } return [await proc.extract(cumul), false]; @@ -24774,7 +26541,7 @@ var textToElement = (s) => document.createRange().createContextualFragment(s).children[0]; var pendingPosts = []; var signalNewEmbeds = debounce(async () => { - if (!csettings5.tm) + if (!csettings6.tm) return; try { const boardname = location.pathname.match(/\/([^/]*)\//)[1]; @@ -24796,7 +26563,7 @@ var shouldUseCache = () => { if (cappState.isCatalog) return false; - return typeof csettings5.cache == "boolean" ? csettings5.cache : location.hostname.includes("b4k"); + return typeof csettings6.cache == "boolean" ? csettings6.cache : location.hostname.includes("b4k"); }; var processPost = async (post) => { const origlink = qp.getImageLink(post); @@ -24807,7 +26574,7 @@ return; let res2 = void 0; const reportEmbed = () => { - if (csettings5.tm) { + if (csettings6.tm) { if (["boards.4chan.org", "boards.4channel.org"].includes(location.host)) { if (!cappState.isCatalog) { const op = +location.pathname.match(/\/thread\/(.*)/)[1]; @@ -24854,7 +26621,7 @@ navigator.clipboard.writeText(text3); } var scrapeBoard = async (self) => { - if (csettings5.tm) { + if (csettings6.tm) { fireNotification("success", "Scrapping board with telemetry on! Thank you for your service, selfless stranger ;_;7"); } self.disabled = true; @@ -24894,7 +26661,11 @@ } else { chunk = { done: false, value }; cumul = import_buffer11.Buffer.concat([cumul, value]); - found = await proc.has_embed(cumul); + const v = await proc.has_embed(cumul); + if (typeof v == "string") { + return true; + } + found = v; } } while (found !== false && !chunk.done); await iter.next(true); @@ -24944,14 +26715,21 @@ var __DOMParser = false ? _DOMParser : DOMParser; var gmo; var earlystartup = async () => { - if (location.host == "arch.b4k.co" && false) { + if (["arch.b4k.co", "desuarchive.org"].includes(location.host) && false) { if (!GM_getValue("warning_seen2", false)) { - alert(`Due to b4k's policies being mean, PEE will get you banned, so the userscript version is disabled here`); - alert("Use the WebExtension version of PEE if you want to use b4k!"); + alert(`Due to b4k and desuarchive policies being mean, PEE will get you banned, so the userscript version is disabled here +Use the WebExtension version of PEE if you want to use b4k!`); GM_setValue("warning_seen2", true); return false; } } + if (["arch.b4k.co", "desuarchive.org"].includes(location.host) && false) { + if (!Platform5.getValue("warning_seen3", false)) { + alert('Due to b4k and desuarchive policies being mean, PEE cannot display content properly here. A "PEE companion" extension will be released as including that functionnallity in PEE lengthens ChromeWebStore review delays, please understando.'); + Platform5.setValue("warning_seen3", true); + return false; + } + } return true; }; var init4 = false; @@ -24971,7 +26749,7 @@ return; else qp = lqp; - if (csettings5.vercheck) + if (csettings6.vercheck) versionCheck(); const postQuote = ({ scanner, parser, utils }) => { const { CLOSEANGLEBRACKET: CLOSEANGLEBRACKET2, NUM: NUM2 } = scanner.tokens; diff --git a/firefox/manifest.json b/firefox/manifest.json index 38459c5..73d50a6 100644 --- a/firefox/manifest.json +++ b/firefox/manifest.json @@ -7,7 +7,7 @@ }, "name": "PngExtraEmbedder", "description": "Discover embedded files on 4chan and archives!", - "version": "0.254", + "version": "0.261", "icons": { "64": "1449696017588.png" }, diff --git a/firefox_update.json b/firefox_update.json index ff9c671..3b857b3 100644 --- a/firefox_update.json +++ b/firefox_update.json @@ -1 +1 @@ -{"addons":{"{34ac4994-07f2-44d2-8599-682516a6c6a6}":{"updates":[{"version":"0.254","update_link":"https://git.coom.tech/fuckjannies/lolipiss/raw/branch/%E4%B8%AD%E5%87%BA%E3%81%97/pngextraembedder-0.254.xpi"}]}}} \ No newline at end of file +{"addons":{"{34ac4994-07f2-44d2-8599-682516a6c6a6}":{"updates":[{"version":"0.261","update_link":"https://git.coom.tech/fuckjannies/lolipiss/raw/branch/%E4%B8%AD%E5%87%BA%E3%81%97/pngextraembedder-0.261.xpi"}]}}} \ No newline at end of file diff --git a/main.d.ts b/main.d.ts index 6a79be4..481250e 100644 --- a/main.d.ts +++ b/main.d.ts @@ -6,6 +6,16 @@ declare module '*.png' { export default new Uint8Array; } +declare module 'f5stegojs' { + export default class f5 { + constructor(private seed: ArrayLike); + + embed(jpegdata: Uint8Array, data: Uint8Array): Uint8Array; + + extract(jpegdata: Uint8Array): Uint8Array | null; + } +} + declare module 'mp4box' { type BaseTrackInfo = { id: number, diff --git a/main.meta.js b/main.meta.js index ca678c4..e31d84d 100644 --- a/main.meta.js +++ b/main.meta.js @@ -1,7 +1,7 @@ // ==UserScript== // @name PNGExtraEmbed // @namespace https://coom.tech/ -// @version 0.255 +// @version 0.261 // @description uhh // @author You // @match https://boards.4channel.org/* diff --git a/main.user.js b/main.user.js index 30de638..e234ca7 100644 --- a/main.user.js +++ b/main.user.js @@ -1,7 +1,7 @@ // ==UserScript== // @name PNGExtraEmbed // @namespace https://coom.tech/ -// @version 0.255 +// @version 0.261 // @description uhh // @author You // @match https://boards.4channel.org/* @@ -50,20 +50,20 @@ const _DOMParser = DOMParser; }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { - for (let key of __getOwnPropNames(from)) - if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + for (let key2 of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key2) && key2 !== except) + __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable }); } return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod)); - var __decorateClass = (decorators, target, key, kind) => { - var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target; + var __decorateClass = (decorators, target, key2, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key2) : target; for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) - result = (kind ? decorator(target, key, result) : decorator(result)) || result; + result = (kind ? decorator(target, key2, result) : decorator(result)) || result; if (kind && result) - __defProp(target, key, result); + __defProp(target, key2, result); return result; }; var __toBinary = /* @__PURE__ */ (() => { @@ -87,7 +87,7 @@ const _DOMParser = DOMParser; var define_BUILD_VERSION_default; var init_define_BUILD_VERSION = __esm({ ""() { - define_BUILD_VERSION_default = [0, 255]; + define_BUILD_VERSION_default = [0, 261]; } }); @@ -2282,12 +2282,12 @@ const _DOMParser = DOMParser; } if (arguments.length === 0) { var keys = Object.keys(events); - var key; + var key2; for (i = 0; i < keys.length; ++i) { - key = keys[i]; - if (key === "removeListener") + key2 = keys[i]; + if (key2 === "removeListener") continue; - this.removeAllListeners(key); + this.removeAllListeners(key2); } this.removeAllListeners("removeListener"); this._events = /* @__PURE__ */ Object.create(null); @@ -2446,24 +2446,24 @@ const _DOMParser = DOMParser; for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { - ownKeys(Object(source), true).forEach(function(key) { - _defineProperty(target, key, source[key]); + ownKeys(Object(source), true).forEach(function(key2) { + _defineProperty(target, key2, source[key2]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { - ownKeys(Object(source)).forEach(function(key) { - Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + ownKeys(Object(source)).forEach(function(key2) { + Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2)); }); } } return target; } - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + function _defineProperty(obj, key2, value) { + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); } else { - obj[key] = value; + obj[key2] = value; } return obj; } @@ -3479,8 +3479,8 @@ const _DOMParser = DOMParser; init_esbuild_inject(); var objectKeys = Object.keys || function(obj) { var keys2 = []; - for (var key in obj) { - keys2.push(key); + for (var key2 in obj) { + keys2.push(key2); } return keys2; }; @@ -3569,8 +3569,8 @@ const _DOMParser = DOMParser; var buffer = require_buffer(); var Buffer18 = buffer.Buffer; function copyProps(src, dst) { - for (var key in src) { - dst[key] = src[key]; + for (var key2 in src) { + dst[key2] = src[key2]; } } if (Buffer18.from && Buffer18.alloc && Buffer18.allocUnsafe && Buffer18.allocUnsafeSlow) { @@ -3993,11 +3993,11 @@ const _DOMParser = DOMParser; init_define_BUILD_VERSION(); init_esbuild_inject(); var _Object$setPrototypeO; - function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true }); + function _defineProperty(obj, key2, value) { + if (key2 in obj) { + Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true }); } else { - obj[key] = value; + obj[key2] = value; } return obj; } @@ -10354,7 +10354,7 @@ const _DOMParser = DOMParser; return this; }; EventEmitter.prototype.removeAllListeners = function(type) { - var key, listeners; + var key2, listeners; if (!this._events) return this; if (!this._events.removeListener) { @@ -10365,10 +10365,10 @@ const _DOMParser = DOMParser; return this; } if (arguments.length === 0) { - for (key in this._events) { - if (key === "removeListener") + for (key2 in this._events) { + if (key2 === "removeListener") continue; - this.removeAllListeners(key); + this.removeAllListeners(key2); } this.removeAllListeners("removeListener"); this._events = {}; @@ -10808,6 +10808,1642 @@ const _DOMParser = DOMParser; } }); + // node_modules/f5stegojs/f5stego.js + var require_f5stego = __commonJS({ + "node_modules/f5stegojs/f5stego.js"(exports, module) { + init_define_BUILD_VERSION(); + init_esbuild_inject(); + (function(root, factory) { + "use strict"; + if (typeof define === "function" && define.amd) { + define([], factory); + } else if (typeof exports === "object") { + module.exports = factory(); + } else { + root.f5stego = factory(); + } + })(exports, function() { + "use strict"; + var f5stego = function(key2, maxPixels) { + this.maxPixels = maxPixels || 4096 * 4096; + this.shuffleInit(key2); + }; + f5stego.prototype.shuffleInit = function(key2) { + this.randPool = new ArrayBuffer(this.maxPixels * 4.125); + if (!key2.length) + throw "key needed"; + var i = 0, j = 0, t = 0, k = 0, S = new Uint8Array(256), rnd = new Uint8Array(this.randPool); + for (i = 0; i < 256; ++i) + S[i] = i; + for (i = 0; i < 256; ++i) { + j = j + S[i] + key2[i % key2.length] & 255; + t = S[i]; + S[i] = S[j]; + S[j] = t; + } + i = 0; + j = 0; + for (k = 0; k < this.maxPixels * 4.125; ++k) { + i = i + 1 & 255; + j = j + S[i] & 255; + t = S[i]; + S[i] = S[j]; + S[j] = t; + rnd[k] = S[t + S[i] & 255]; + } + }; + f5stego.prototype.stegShuffle = function(pm) { + var t, l, k, random_index, rand32Array = new Uint32Array(this.randPool); + if (typeof pm == "number") { + l = pm; + pm = new Uint32Array(l); + for (k = 1; k < l; k++) { + random_index = rand32Array[k] % (k + 1); + if (random_index != k) + pm[k] = pm[random_index]; + pm[random_index] = k; + } + } else { + l = pm.length; + for (k = 1; k < l; k++) { + random_index = rand32Array[k] % (k + 1); + t = pm[k]; + pm[k] = pm[random_index]; + pm[random_index] = t; + } + } + return { pm, gamma: new Uint8Array(this.randPool, l * 4) }; + }; + f5stego.prototype._analyze = function(coeff) { + var _one = 0, _zero = 0, _large, _ratio, usable, i, k, embedded, matched, changed; + for (i = 0; i < coeff.length; i++) { + if (i % 64 === 0) + continue; + if (coeff[i] === 0) + _zero++; + if (coeff[i] == 1 || coeff[i] == -1) + _one++; + } + _large = coeff.length - _zero - _one - coeff.length / 64; + _ratio = _one / (_large + _one); + var res = { + "capacity": [0, (_large + 0.49 * _one >> 3) - 1], + "coeff_total": coeff.length, + "coeff_large": _large, + "coeff_zero": _zero, + "coeff_one": _one, + "coeff_one_ratio": _one / (_large + _one) + }; + for (i = 2; i < 17; i++) { + k = (1 << i) - 1; + usable = _large + _one; + embedded = 0; + while (usable > k) { + matched = usable / k / (1 << i) / (1 << i) | 0; + usable -= matched * k; + changed = usable * (1 - _ratio) / k * 0.96 | 0; + usable -= changed * k; + embedded += changed + matched; + k++; + } + res.capacity[i] = (i * embedded >> 3) - 1; + } + return res; + }; + f5stego.prototype._f5write = function(coeff, data, k) { + var coeff_count = coeff.length; + var _changed = 0, _embedded = 0, _examined = 0, _thrown = 0, shuffled_index = 0, i, n, ii; + var pm = this.stegShuffle(coeff_count); + var gamma = pm.gamma, gammaI = 0; + pm = pm.pm; + var next_bit_to_embed = 0, byte_to_embed = data.length, data_idx = 0, available_bits_to_embed = 0; + n = (1 << k) - 1; + byte_to_embed = k - 1; + byte_to_embed ^= gamma[gammaI++]; + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed = 3; + for (ii = 0; ii < coeff_count; ii++) { + shuffled_index = pm[ii]; + if (shuffled_index % 64 === 0 || coeff[shuffled_index] === 0) + continue; + var cc = coeff[shuffled_index]; + _examined++; + if (cc > 0 && (cc & 1) != next_bit_to_embed) { + coeff[shuffled_index]--; + _changed++; + } else if (cc < 0 && (cc & 1) == next_bit_to_embed) { + coeff[shuffled_index]++; + _changed++; + } + if (coeff[shuffled_index] !== 0) { + _embedded++; + if (available_bits_to_embed === 0) { + if (k != 1 || data_idx >= data.length) + break; + byte_to_embed = data[data_idx++]; + byte_to_embed ^= gamma[gammaI++]; + available_bits_to_embed = 8; + } + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed--; + } else { + _thrown++; + } + } + if (k == 1 && _embedded < data.length * 8) + throw "capacity exceeded " + _embedded / 8 + " " + data.length; + if (k != 1) { + var is_last_byte = false, k_bits_to_embed = 0; + while (!is_last_byte || available_bits_to_embed !== 0 && is_last_byte) { + k_bits_to_embed = 0; + for (i = 0; i < k; i++) { + if (available_bits_to_embed === 0) { + if (data_idx >= data.length) { + is_last_byte = true; + break; + } + byte_to_embed = data[data_idx++]; + byte_to_embed ^= gamma[gammaI++]; + available_bits_to_embed = 8; + } + next_bit_to_embed = byte_to_embed & 1; + byte_to_embed >>= 1; + available_bits_to_embed--; + k_bits_to_embed |= next_bit_to_embed << i; + } + var code_word = []; + var ci = null; + for (i = 0; i < n; i++) { + while (true) { + if (++ii >= coeff_count) { + throw "capacity exceeded " + _embedded / 8; + } + ci = pm[ii]; + if (ci % 64 !== 0 && coeff[ci] !== 0) + break; + } + code_word.push(ci); + } + _examined += n; + while (true) { + var vhash = 0, extracted_bit; + for (i = 0; i < code_word.length; i++) { + if (coeff[code_word[i]] > 0) { + extracted_bit = coeff[code_word[i]] & 1; + } else { + extracted_bit = 1 - (coeff[code_word[i]] & 1); + } + if (extracted_bit == 1) + vhash ^= i + 1; + } + i = vhash ^ k_bits_to_embed; + if (!i) { + _embedded += k; + break; + } + i--; + coeff[code_word[i]] += coeff[code_word[i]] < 0 ? 1 : -1; + _changed++; + if (coeff[code_word[i]] === 0) { + _thrown++; + code_word.splice(i, 1); + while (true) { + if (++ii >= coeff_count) { + throw "capacity exceeded " + _embedded / 8; + } + ci = pm[ii]; + if (ci % 64 !== 0 && coeff[ci] !== 0) + break; + } + _examined++; + code_word.push(ci); + } else { + _embedded += k; + break; + } + } + } + } + return { + "k": k, + "embedded": _embedded / 8, + "examined": _examined, + "changed": _changed, + "thrown": _thrown, + "efficiency": (_embedded / _changed).toFixed(2) + }; + }; + f5stego.prototype.analyze = function() { + var i, comp = this.frame.components[0]; + if (comp.componentId != 1) { + for (i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + return this._analyze(comp.blocks); + }; + f5stego.prototype.f5put = function(data, k) { + var t, i, comp = this.frame.components[0]; + if (data.length > 8388607) + throw "Data too big. Max 8388607 bytes allowed."; + if (data.length < 32768) { + t = new Uint8Array(2 + data.length); + t[0] = data.length & 255; + t[1] = data.length >>> 8; + t.set(data, 2); + } else { + t = new Uint8Array(3 + data.length); + t[0] = data.length & 255; + t[1] = (data.length >>> 8 & 127) + 128; + t[2] = data.length >>> 15; + t.set(data, 3); + } + if (comp.componentId != 1) { + for (i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + if (k) { + return this._f5write(comp.blocks, t, k); + } + var ret, prop = this._analyze(comp.blocks); + k = 0; + for (i = prop.capacity.length - 1; i >= 0; i--) { + if (prop.capacity[i] >= t.length) { + k = i; + break; + } + } + if (k === 0) + throw "capacity exceeded"; + try { + ret = this._f5write(comp.blocks, t, k); + } catch (e) { + k--; + if (k === 0) + throw "capacity exceeded"; + ret = this._f5write(comp.blocks, t, k); + } + ret["stats"] = prop; + return ret; + }; + f5stego.prototype.f5get = function() { + var comp = this.frame.components[0]; + if (comp.componentId != 1) { + for (var i = 0; i < this.frame.components.length; i++) { + if (this.frame.components[i].componentId == 1) { + comp = this.frame.components[i]; + break; + } + } + } + var coeff = new Int16Array(comp.blocks.length); + coeff.set(comp.blocks); + var pos = -1, extrBit = 0, cCount = coeff.length - 1; + var pm = this.stegShuffle(coeff), gamma = pm.gamma, gammaI = 0; + var n, k = 0; + var out = new Uint8Array(coeff.length / 8 | 0), extrByte = 0, outPos = 0, bitsAvail = 0, code = 0, hash2 = 0; + while (bitsAvail < 4) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + k |= extrBit << bitsAvail; + bitsAvail++; + } + k = (k ^ gamma[gammaI++] & 15) + 1; + n = (1 << k) - 1; + bitsAvail = 0; + if (k == 1) { + while (pos < cCount) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + extrByte |= extrBit << bitsAvail; + bitsAvail++; + if (bitsAvail == 8) { + out[outPos++] = extrByte ^ gamma[gammaI++]; + extrByte = 0; + bitsAvail = 0; + } + } + } else { + while (pos < cCount) { + pos++; + if (coeff[pos] === 0) { + continue; + } + extrBit = coeff[pos] & 1; + if (coeff[pos] < 0) { + extrBit = 1 - extrBit; + } + hash2 ^= extrBit * ++code; + if (code == n) { + extrByte |= hash2 << bitsAvail; + bitsAvail += k; + code = 0; + hash2 = 0; + while (bitsAvail >= 8) { + out[outPos++] = extrByte & 255 ^ gamma[gammaI++]; + bitsAvail -= 8; + extrByte = extrByte >> 8; + } + } + } + } + while (bitsAvail > 0) { + out[outPos++] = extrByte & 255 ^ gamma[gammaI++]; + bitsAvail -= 8; + extrByte = extrByte >> 8; + } + var s = 2, l = out[0]; + if (out[1] & 128) { + s++; + l += ((out[1] & 127) << 8) + (out[2] << 15); + } else { + l += out[1] << 8; + } + return out.subarray(s, s + l); + }; + f5stego.prototype.parse = function(data) { + var offset = 0; + function _buildHuffmanTable(nrcodes, values) { + var codevalue = 0, pos_in_table = 0, HT = new Uint16Array(65536); + for (var k = 0; k < 16; k++) { + for (var j2 = 0; j2 < nrcodes[k]; j2++) { + for (var i2 = codevalue << 15 - k, cntTo = codevalue + 1 << 15 - k; i2 < cntTo; i2++) { + HT[i2] = values[pos_in_table] + (k + 1 << 8); + } + pos_in_table++; + codevalue++; + } + codevalue *= 2; + } + return HT; + } + function decodeScan(data2, offset2, frame, components2, resetInterval2, spectralStart2, spectralEnd2, successivePrev, successive) { + var startOffset = offset2, bitsData = 0, bitsCount = 0, eobrun = 0, p1 = 1 << successive, m1 = -1 << successive; + function decodeBaseline(component2, pos) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + var t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535]; + if (!t) + throw "invalid huffman sequence"; + bitsCount -= t >>> 8; + t &= 255; + var diff = 0; + if (t !== 0) { + while (bitsCount < t) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + diff = bitsData >>> bitsCount - t & (1 << t) - 1; + bitsCount -= t; + if (diff < 1 << t - 1) + diff += (-1 << t) + 1; + } + component2.blocksDC[pos >> 6] = component2.pred += diff; + var k2 = 1, s, r; + while (k2 < 64) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s === 0) { + if (r < 15) { + break; + } + k2 += 16; + continue; + } + k2 += r; + while (bitsCount < s) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1; + bitsCount -= s; + if (component2.blocks[pos + k2] < 1 << s - 1) + component2.blocks[pos + k2] += (-1 << s) + 1; + k2++; + } + } + function decodeDCFirst(component2, pos) { + var diff = 0; + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + var t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535]; + if (!t) + throw "invalid huffman sequence"; + bitsCount -= t >>> 8; + t &= 255; + if (t !== 0) { + while (bitsCount < t) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + diff = bitsData >>> bitsCount - t & (1 << t) - 1; + bitsCount -= t; + if (diff < 1 << t - 1) + diff += (-1 << t) + 1; + } + component2.blocksDC[pos >> 6] = component2.pred += diff << successive; + } + function decodeDCSuccessive(component2, pos) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocksDC[pos >> 6] |= (bitsData >>> --bitsCount & 1) << successive; + } + function decodeACFirst(component2, pos) { + if (eobrun > 0) { + eobrun--; + return; + } + var k2 = spectralStart2, s, r; + while (k2 <= spectralEnd2) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s === 0) { + if (r != 15) { + eobrun = (1 << r) - 1; + if (r) { + while (bitsCount < r) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + eobrun += bitsData >>> bitsCount - r & (1 << r) - 1; + bitsCount -= r; + } + break; + } + k2 += 16; + continue; + } + k2 += r; + while (bitsCount < s) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1; + bitsCount -= s; + if (component2.blocks[pos + k2] < 1 << s - 1) + component2.blocks[pos + k2] += (-1 << s) + 1; + component2.blocks[pos + k2] *= p1; + k2++; + } + } + function decodeACSuccessive(component2, pos) { + var k2 = spectralStart2, r, s; + if (!eobrun) { + while (k2 <= spectralEnd2) { + while (bitsCount < 16) { + bitsData = (bitsData << 8) + (data2[offset2] | 0); + bitsCount += 8; + if (data2[offset2] == 255) + offset2++; + offset2++; + } + s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535]; + if (!s) + throw "invalid huffman sequence"; + bitsCount -= s >>> 8; + r = s >> 4 & 15; + s &= 15; + if (s) { + if (s != 1) + throw "bad jpeg"; + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + s = bitsData >>> --bitsCount & 1 ? p1 : m1; + } else { + if (r != 15) { + eobrun = 1 << r; + if (r) { + while (bitsCount < r) { + bitsData = (bitsData << 8) + data2[offset2++]; + if ((bitsData & 255) == 255) + offset2++; + bitsCount += 8; + } + eobrun += bitsData >>> bitsCount - r & (1 << r) - 1; + bitsCount -= r; + } + break; + } + } + while (k2 <= spectralEnd2) { + if (component2.blocks[pos + k2]) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1); + } else { + if (--r < 0) + break; + } + k2++; + } + if (s) + component2.blocks[pos + k2] = s; + k2++; + } + } + if (eobrun) { + while (k2 <= spectralEnd2) { + if (component2.blocks[pos + k2]) { + if (!bitsCount) { + bitsData = data2[offset2++]; + if (bitsData == 255) + offset2++; + bitsCount = 8; + } + component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1); + } + k2++; + } + eobrun--; + } + } + var decodeFn; + if (frame.progressive) { + if (spectralStart2 === 0) + decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; + else + decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; + } else { + decodeFn = decodeBaseline; + } + var marker, mcuExpected, i2, j2, k, n, mcusPerLine2, mcusPerRow, x, y; + if (components2.length == 1) { + mcusPerLine2 = components2[0].blocksPerLine; + mcusPerRow = components2[0].blocksPerColumn; + mcuExpected = mcusPerRow * mcusPerLine2; + if (!resetInterval2) + resetInterval2 = mcuExpected; + n = resetInterval2; + components2[0].pred = 0; + eobrun = 0; + for (y = 0; y < mcusPerRow; y++) { + for (x = 0; x < mcusPerLine2; x++) { + if (!n) { + n = resetInterval2; + components2[0].pred = 0; + eobrun = 0; + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + bitsCount = 0; + marker = data2[offset2] << 8 | data2[offset2 + 1]; + if (marker >= 65488 && marker <= 65495) { + offset2 += 2; + } else { + if (marker <= 65280) { + throw "bad jpeg"; + } + break; + } + } + n--; + for (i2 = 0; i2 < components2.length; i2++) { + decodeFn(components2[i2], (y * components2[i2].blocksPerLineForMcu + x) * 64); + } + } + } + } else { + mcusPerLine2 = frame.mcusPerLine; + mcusPerRow = frame.mcusPerColumn; + mcuExpected = mcusPerRow * mcusPerLine2; + if (!resetInterval2) + resetInterval2 = mcuExpected; + n = resetInterval2; + for (i2 = 0; i2 < components2.length; i2++) + components2[i2].pred = 0; + eobrun = 0; + for (y = 0; y < mcusPerRow; y++) { + for (x = 0; x < mcusPerLine2; x++) { + if (!n) { + n = resetInterval2; + for (i2 = 0; i2 < components2.length; i2++) + components2[i2].pred = 0; + eobrun = 0; + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + bitsCount = 0; + marker = data2[offset2] << 8 | data2[offset2 + 1]; + if (marker >= 65488 && marker <= 65495) { + offset2 += 2; + } else { + if (marker <= 65280) { + throw "bad jpeg"; + } + break; + } + } + n--; + for (i2 = 0; i2 < components2.length; i2++) { + for (j2 = 0; j2 < components2[i2].v; j2++) { + for (k = 0; k < components2[i2].h; k++) { + decodeFn(components2[i2], ((y * components2[i2].v + j2) * components2[i2].blocksPerLineForMcu + x * components2[i2].h + k) * 64); + } + } + } + } + } + } + offset2 -= bitsCount / 8 | 0; + if (data2[offset2 - 1] == 255) + offset2--; + return offset2 - startOffset; + } + function readUint16() { + var value = data[offset] << 8 | data[offset + 1]; + offset += 2; + return value; + } + function readDataBlock() { + var length = readUint16(); + var array = data.subarray(offset, offset + length - 2); + offset += array.length; + return array; + } + this["_raw"] = data; + this["jfif"] = null; + this["APPn"] = []; + this["qts"] = []; + this["frame"] = null; + this["tail"] = null; + var markerHi, markerLo, i, j, resetInterval, component; + var huffmanTablesAC = [], huffmanTablesDC = []; + while (1) { + if (offset >= data.length) + throw "unexpected EOF"; + markerHi = data[offset++]; + markerLo = data[offset++]; + if (markerHi == 255) { + if (markerLo == 224) { + this.jfif = readDataBlock(); + } + if (markerLo > 224 && markerLo < 240 || markerLo == 254) { + this.APPn.push({ + "app": markerLo, + "data": readDataBlock() + }); + } + if (markerLo == 219) { + this.qts.push(readDataBlock()); + } + if (markerLo >= 192 && markerLo <= 194) { + if (this.frame) + throw "Only single frame JPEGs supported"; + readUint16(); + this.frame = { + "extended": markerLo === 193, + "progressive": markerLo === 194, + "precision": data[offset++], + "scanLines": readUint16(), + "samplesPerLine": readUint16(), + "components": [], + "componentIds": {}, + "maxH": 1, + "maxV": 1 + }; + if (this.frame.scanLines * this.frame.samplesPerLine > this.maxPixels) + throw "Image is too big."; + var componentsCount = data[offset++], componentId; + var maxH = 0, maxV = 0; + for (i = 0; i < componentsCount; i++) { + componentId = data[offset]; + var h = data[offset + 1] >> 4; + var v = data[offset + 1] & 15; + if (maxH < h) + maxH = h; + if (maxV < v) + maxV = v; + var qId = data[offset + 2]; + var l = this.frame.components.push({ + "componentId": componentId, + "h": h, + "v": v, + "quantizationTable": qId + }); + this.frame.componentIds[componentId] = l - 1; + offset += 3; + } + this.frame.maxH = maxH; + this.frame.maxV = maxV; + var mcusPerLine = Math.ceil(this.frame.samplesPerLine / 8 / maxH); + var mcusPerColumn = Math.ceil(this.frame.scanLines / 8 / maxV); + for (i = 0; i < this.frame.components.length; i++) { + component = this.frame.components[i]; + var blocksPerLine = Math.ceil(Math.ceil(this.frame.samplesPerLine / 8) * component.h / maxH); + var blocksPerColumn = Math.ceil(Math.ceil(this.frame.scanLines / 8) * component.v / maxV); + var blocksPerLineForMcu = mcusPerLine * component.h; + var blocksPerColumnForMcu = mcusPerColumn * component.v; + component["blocks"] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu * 64); + component["blocksDC"] = new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu); + component["blocksPerLine"] = blocksPerLine; + component["blocksPerColumn"] = blocksPerColumn; + component["blocksPerLineForMcu"] = blocksPerLineForMcu; + component["blocksPerColumnForMcu"] = blocksPerColumnForMcu; + } + this.frame["mcusPerLine"] = mcusPerLine; + this.frame["mcusPerColumn"] = mcusPerColumn; + } + if (markerLo == 196) { + var huffmanLength = readUint16(); + for (i = 2; i < huffmanLength; ) { + var huffmanTableSpec = data[offset++]; + var codeLengths = new Uint8Array(16); + var codeLengthSum = 0; + for (j = 0; j < 16; j++, offset++) + codeLengthSum += codeLengths[j] = data[offset]; + var huffmanValues = new Uint8Array(codeLengthSum); + for (j = 0; j < codeLengthSum; j++, offset++) + huffmanValues[j] = data[offset]; + i += 17 + codeLengthSum; + (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = _buildHuffmanTable(codeLengths, huffmanValues); + } + } + if (markerLo == 221) { + resetInterval = readUint16(); + } + if (markerLo == 218) { + readUint16(); + var selectorsCount = data[offset++]; + var components = []; + for (i = 0; i < selectorsCount; i++) { + var componentIndex = this.frame.componentIds[data[offset++]]; + component = this.frame.components[componentIndex]; + var tableSpec = data[offset++]; + component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]; + component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]; + components.push(component); + } + var spectralStart = data[offset++]; + var spectralEnd = data[offset++]; + var successiveApproximation = data[offset++]; + var processed = decodeScan(data, offset, this.frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15); + offset += processed; + } + if (markerLo == 217) { + break; + } + } else { + if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) { + offset -= 3; + } + while (data[offset] != 255 && offset < data.length) { + offset++; + } + if (data[offset] != 255) { + throw "bad jpeg "; + } + } + } + if (!this.frame) + throw "bad jpeg"; + if (offset < data.length) + this.tail = data.subarray(offset); + return this; + }; + var bitcode = new Array(65535), category = new Array(65535), std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125], std_ac_luminance_values = [ + 1, + 2, + 3, + 0, + 4, + 17, + 5, + 18, + 33, + 49, + 65, + 6, + 19, + 81, + 97, + 7, + 34, + 113, + 20, + 50, + 129, + 145, + 161, + 8, + 35, + 66, + 177, + 193, + 21, + 82, + 209, + 240, + 36, + 51, + 98, + 114, + 130, + 9, + 10, + 22, + 23, + 24, + 25, + 26, + 37, + 38, + 39, + 40, + 41, + 42, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250 + ], std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119], std_ac_chrominance_values = [ + 0, + 1, + 2, + 3, + 17, + 4, + 5, + 33, + 49, + 6, + 18, + 65, + 81, + 7, + 97, + 113, + 19, + 34, + 50, + 129, + 8, + 20, + 66, + 145, + 161, + 177, + 193, + 9, + 35, + 51, + 82, + 240, + 21, + 98, + 114, + 209, + 10, + 22, + 36, + 52, + 225, + 37, + 241, + 23, + 24, + 25, + 26, + 38, + 39, + 40, + 41, + 42, + 53, + 54, + 55, + 56, + 57, + 58, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250 + ]; + function _initCategoryNumber() { + var nrlower = 1; + var nrupper = 2; + for (var cat = 1; cat <= 15; cat++) { + for (var nr = nrlower; nr < nrupper; nr++) { + category[32767 + nr] = cat; + bitcode[32767 + nr] = []; + bitcode[32767 + nr][1] = cat; + bitcode[32767 + nr][0] = nr; + } + for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) { + category[32767 + nrneg] = cat; + bitcode[32767 + nrneg] = []; + bitcode[32767 + nrneg][1] = cat; + bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg; + } + nrlower <<= 1; + nrupper <<= 1; + } + } + _initCategoryNumber(); + function _computeHuffmanTbl(nrcodes, std_table) { + var codevalue = 0; + var pos_in_table = 0; + var HT = []; + for (var k = 1; k <= 16; k++) { + for (var j = 1; j <= nrcodes[k]; j++) { + HT[std_table[pos_in_table]] = []; + HT[std_table[pos_in_table]][0] = codevalue; + HT[std_table[pos_in_table]][1] = k; + pos_in_table++; + codevalue++; + } + codevalue *= 2; + } + return HT; + } + var YDC_HT = _computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values), UVDC_HT = _computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values), YAC_HT = _computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values), UVAC_HT = _computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values); + f5stego.prototype.pack = function() { + var byteout, bytenew, bytepos, poslast, outpos, byte; + function writeByte(value) { + var t; + byteout[outpos++] = value; + if (outpos > poslast) { + t = new Uint8Array(byteout.length * 2); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + } + function writeWord(value) { + writeByte(value >> 8 & 255); + writeByte(value & 255); + } + function writeBlock(block) { + var t; + if (outpos + block.length > poslast) { + t = new Uint8Array(byteout.length * 2 + block.length); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + byteout.set(block, outpos); + outpos += block.length; + } + function writeAPP0(self) { + writeWord(65504); + if (!self.jfif) { + writeWord(16); + writeByte(74); + writeByte(70); + writeByte(73); + writeByte(70); + writeByte(0); + writeByte(1); + writeByte(1); + writeByte(0); + writeWord(1); + writeWord(1); + writeByte(0); + writeByte(0); + } else { + writeWord(self.jfif.length + 2); + writeBlock(self.jfif); + } + } + function writeDQT(self) { + for (var i2 = 0; i2 < self.qts.length; i2++) { + writeWord(65499); + writeWord(self.qts[i2].length + 2); + writeBlock(self.qts[i2]); + } + } + function writeAPPn(self) { + for (var i2 = 0; i2 < self.APPn.length; i2++) { + writeWord(65280 | self.APPn[i2].app); + writeWord(self.APPn[i2].data.length + 2); + writeBlock(self.APPn[i2].data); + } + } + function writeSOF0(self) { + writeWord(65472); + writeWord(8 + self.frame.components.length * 3); + writeByte(self.frame.precision); + writeWord(self.frame.scanLines); + writeWord(self.frame.samplesPerLine); + writeByte(self.frame.components.length); + for (var i2 = 0; i2 < self.frame.components.length; i2++) { + var c2 = self.frame.components[i2]; + writeByte(c2.componentId); + writeByte(c2.h << 4 | c2.v); + writeByte(c2.quantizationTable); + } + } + function writeDHT(self) { + writeWord(65476); + writeWord(31); + writeByte(0); + for (var i2 = 0; i2 < 16; i2++) { + writeByte(std_dc_luminance_nrcodes[i2 + 1]); + } + for (var j = 0; j <= 11; j++) { + writeByte(std_dc_luminance_values[j]); + } + writeWord(65476); + writeWord(181); + writeByte(16); + for (var k = 0; k < 16; k++) { + writeByte(std_ac_luminance_nrcodes[k + 1]); + } + for (var l = 0; l <= 161; l++) { + writeByte(std_ac_luminance_values[l]); + } + if (self.frame.components.length != 1) { + writeWord(65476); + writeWord(31); + writeByte(1); + for (var m = 0; m < 16; m++) { + writeByte(std_dc_chrominance_nrcodes[m + 1]); + } + for (var n = 0; n <= 11; n++) { + writeByte(std_dc_chrominance_values[n]); + } + writeWord(65476); + writeWord(181); + writeByte(17); + for (var o = 0; o < 16; o++) { + writeByte(std_ac_chrominance_nrcodes[o + 1]); + } + for (var p = 0; p <= 161; p++) { + writeByte(std_ac_chrominance_values[p]); + } + } + } + function writeSOS(self) { + writeWord(65498); + writeWord(6 + self.frame.components.length * 2); + writeByte(self.frame.components.length); + for (var i2 = 0; i2 < self.frame.components.length; i2++) { + var c2 = self.frame.components[i2]; + writeByte(c2.componentId); + if (i2 === 0) { + writeByte(0); + } else { + writeByte(17); + } + } + writeByte(0); + writeByte(63); + writeByte(0); + } + function processDU(comp, POS, DC, HTDC, HTAC) { + var pos, posval, t; + if (bytepos === 0) + bytenew = 0; + var Diff = comp.blocksDC[POS >> 6] - DC; + DC = comp.blocksDC[POS >> 6]; + if (Diff === 0) { + posval = HTDC[0][1]; + bytenew <<= posval; + bytenew += HTDC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } else { + pos = 32767 + Diff; + posval = HTDC[category[pos]][1]; + bytenew <<= posval; + bytenew += HTDC[category[pos]][0]; + bytepos += posval; + posval = bitcode[pos][1]; + bytenew <<= posval; + bytenew += bitcode[pos][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + var end0pos = 63; + for (; end0pos > 0 && comp.blocks[POS + end0pos] === 0; end0pos--) { + } + if (end0pos === 0) { + posval = HTAC[0][1]; + bytenew <<= posval; + bytenew += HTAC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + return DC; + } + var i2 = 1; + var lng; + while (i2 <= end0pos) { + var startpos = i2; + for (; comp.blocks[POS + i2] === 0 && i2 <= end0pos; ++i2) { + } + var nrzeroes = i2 - startpos; + if (nrzeroes >= 16) { + lng = nrzeroes >> 4; + for (var nrmarker = 1; nrmarker <= lng; ++nrmarker) { + posval = HTAC[240][1]; + bytenew <<= posval; + bytenew += HTAC[240][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + nrzeroes = nrzeroes & 15; + } + pos = 32767 + comp.blocks[POS + i2]; + posval = HTAC[(nrzeroes << 4) + category[pos]][1]; + bytenew <<= posval; + bytenew += HTAC[(nrzeroes << 4) + category[pos]][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + posval = bitcode[pos][1]; + bytenew <<= posval; + bytenew += bitcode[pos][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + i2++; + } + if (end0pos != 63) { + posval = HTAC[0][1]; + bytenew <<= posval; + bytenew += HTAC[0][0]; + bytepos += posval; + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + bytenew &= (1 << bytepos) - 1; + } + } + if (outpos > poslast) { + t = new Uint8Array(byteout.length * 2); + t.set(byteout); + byteout = t; + poslast = t.length - 128; + } + return DC; + } + byteout = new Uint8Array(65536); + poslast = 65536 - 128; + outpos = 0; + bytenew = 0; + bytepos = 0; + writeWord(65496); + writeAPP0(this); + writeAPPn(this); + writeDQT(this); + writeSOF0(this); + writeDHT(this); + writeSOS(this); + bytenew = 0; + bytepos = 0; + var c, mcuRow, mcuCol, blockRow, blockCol, mcu, i, v, h; + var DCdiff = []; + for (i = 0; i < this.frame.components.length; i++) { + DCdiff.push(0); + } + for (mcu = 0; mcu < this.frame.mcusPerLine * this.frame.mcusPerColumn; mcu++) { + mcuRow = mcu / this.frame.mcusPerLine | 0; + mcuCol = mcu % this.frame.mcusPerLine; + for (i = 0; i < this.frame.components.length; i++) { + c = this.frame.components[i]; + for (v = 0; v < c.v; v++) { + blockRow = mcuRow * c.v + v; + for (h = 0; h < c.h; h++) { + blockCol = mcuCol * c.h + h; + if (i === 0) { + DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], YDC_HT, YAC_HT); + } else { + DCdiff[i] = processDU(c, (blockRow * this.frame.mcusPerLine * c.h + blockCol) * 64, DCdiff[i], UVDC_HT, UVAC_HT); + } + } + } + } + } + while (bytepos > 7) { + byte = 255 & bytenew >>> bytepos - 8; + byteout[outpos++] = byte; + if (byte == 255) { + outpos++; + } + bytepos -= 8; + } + if (bytepos > 0) { + bytenew <<= 8 - bytepos; + bytenew += (1 << 8 - bytepos) - 1; + byteout[outpos++] = 255 & bytenew; + } + writeWord(65497); + if (this.tail) + writeBlock(this.tail); + return byteout.slice(0, outpos); + }; + f5stego.prototype.clearTail = function() { + if (!this.tail) + return null; + var t = this.tail; + this.tail = null; + return t; + }; + f5stego.prototype.setTail = function(data) { + this.tail = data; + }; + f5stego.prototype.getTail = function() { + return this.tail; + }; + f5stego.prototype.clearAPPs = function() { + var t = this.APPn; + this.APPn = []; + return t; + }; + f5stego.prototype.getAPPn = function(id, remove) { + var i, t, ret = new Uint8Array(0), n = []; + id &= 255; + if (id < 16) + id += 224; + if (id === 224) + return this.jfif; + for (i = 0; i < this.APPn.length; i++) { + if (this.APPn[i].app == id) { + t = new Uint8Array(ret.length + this.APPn[i].data.length); + t.set(ret); + t.set(this.APPn[i].data, ret.length); + ret = t; + } else if (remove) + n.push(this.APPn[i]); + } + if (remove) + this.APPn = n; + if (ret.length === 0) + return null; + return ret; + }; + f5stego.prototype.setAPPn = function(id, data) { + var i, t, ret; + id &= 255; + if (id < 16) + id += 224; + if (id === 224) { + t = this.jfif; + this.jfif = data; + return t; + } + ret = this.getAPPn(id, true); + if (data.length < 65534) { + this.APPn.push({ "app": id, "data": data }); + return ret; + } + i = 0; + while (i < data.length) { + this.APPn.push({ "app": id, "data": data.subarray(i, i + 65533) }); + i += 65533; + } + return ret; + }; + f5stego.prototype.strip = function() { + this.clearTail(); + this.clearAPPs(); + return true; + }; + f5stego.prototype.embed = function(image, data) { + this.parse(image).f5put(data); + return this.pack(); + }; + f5stego.prototype.extract = function(image) { + return this.parse(image).f5get(); + }; + return f5stego; + }); + } + }); + // node_modules/jpeg-js/lib/encoder.js var require_encoder = __commonJS({ "node_modules/jpeg-js/lib/encoder.js"(exports, module) { @@ -13170,11 +14806,11 @@ const _DOMParser = DOMParser; function set_input_value(input, value) { input.value = value == null ? "" : value; } - function set_style(node, key, value, important) { + function set_style(node, key2, value, important) { if (value === null) { - node.style.removeProperty(key); + node.style.removeProperty(key2); } else { - node.style.setProperty(key, value, important ? "important" : ""); + node.style.setProperty(key2, value, important ? "important" : ""); } } function select_option(select, value) { @@ -13330,12 +14966,12 @@ const _DOMParser = DOMParser; return true; }; } - function setContext(key, context) { - get_current_component().$$.context.set(key, context); + function setContext(key2, context) { + get_current_component().$$.context.set(key2, context); return context; } - function getContext(key) { - return get_current_component().$$.context.get(key); + function getContext(key2) { + return get_current_component().$$.context.get(key2); } function bubble(component, event) { const callbacks = component.$$.callbacks[event.type]; @@ -13569,17 +15205,17 @@ const _DOMParser = DOMParser; i = n; while (i--) { const child_ctx = get_context(ctx, list, i); - const key = get_key(child_ctx); - let block = lookup.get(key); + const key2 = get_key(child_ctx); + let block = lookup.get(key2); if (!block) { - block = create_each_block8(key, child_ctx); + block = create_each_block8(key2, child_ctx); block.c(); } else if (dynamic) { block.p(child_ctx, dirty); } - new_lookup.set(key, new_blocks[i] = block); - if (key in old_indexes) - deltas.set(key, Math.abs(i - old_indexes[key])); + new_lookup.set(key2, new_blocks[i] = block); + if (key2 in old_indexes) + deltas.set(key2, Math.abs(i - old_indexes[key2])); } const will_move = /* @__PURE__ */ new Set(); const did_move = /* @__PURE__ */ new Set(); @@ -13723,8 +15359,8 @@ const _DOMParser = DOMParser; connectedCallback() { const { on_mount } = this.$$; this.$$.on_disconnect = on_mount.map(run).filter(is_function); - for (const key in this.$$.slotted) { - this.appendChild(this.$$.slotted[key]); + for (const key2 in this.$$.slotted) { + this.appendChild(this.$$.slotted[key2]); } } attributeChangedCallback(attr2, _oldValue, newValue) { @@ -13823,8 +15459,8 @@ const _DOMParser = DOMParser; } // src/stores.ts - var localLoad = (key, def) => "__pee__" + key in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key)) : def; - var localSet = (key, value) => localStorage.setItem("__pee__" + key, JSON.stringify(value)); + var localLoad = (key2, def) => "__pee__" + key2 in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key2)) : def; + var localSet = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value)); var initial_settings = localLoad("settingsv2", { ...localLoad("settings", {}), loop: true, @@ -13848,6 +15484,7 @@ const _DOMParser = DOMParser; mdist: -1, phash: false, hotlink: false, + jpeg: false, vercheck: false, cache: void 0, fhost: 0, @@ -13855,50 +15492,7 @@ const _DOMParser = DOMParser; conc: 8, ho: false, blacklist: ["guro", "scat", "ryona", "gore"], - rsources: [ - { - name: "Gelbooru", - domain: "gelbooru.com", - endpoint: "/index.php?page=dapi&s=post&q=index&json=1&tags=md5:", - view: "https://gelbooru.com/index.php?page=post&s=view&id=" - }, - { - name: "Yandere", - domain: "yande.re", - endpoint: "/post.json?tags=md5:", - view: `https://yande.re/post/show/` - }, - { - name: "Sankaku", - domain: "capi-v2.sankakucomplex.com", - endpoint: "/posts/keyset?tags=md5:", - view: `https://chan.sankakucomplex.com/post/show/` - }, - { - name: "Rule34", - domain: "api.rule34.xxx", - endpoint: "/index.php?page=dapi&s=post&q=index&json=1&tags=md5:", - view: "https://rule34.xxx/index.php?page=post&s=view&id=" - }, - { - name: "Danbooru", - domain: "danbooru.donmai.us", - endpoint: "/posts.json?tags=md5:", - view: "https://danbooru.donmai.us/posts/" - }, - { - name: "Lolibooru", - domain: "lolibooru.moe", - endpoint: "/post.json?tags=md5:", - view: "https://lolibooru.moe/post/show/" - }, - { - name: "ATFbooru", - domain: "booru.allthefallen.moe", - endpoint: "/posts.json?tags=md5:", - view: "https://booru.allthefallen.moe/posts/" - } - ], + rsources: [], ...localLoad("settingsv2", {}) }); var settings = writable(initial_settings); @@ -14195,6 +15789,8 @@ const _DOMParser = DOMParser; // src/platform.ts var lqueue = {}; + var localLoad2 = (key2, def) => "__pee__" + key2 in localStorage ? JSON.parse(localStorage.getItem("__pee__" + key2)) : def; + var localSet2 = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value)); var { port1, port2 } = new MessageChannel(); console.log("userscript", "false"); if (false) { @@ -14238,10 +15834,31 @@ const _DOMParser = DOMParser; for (const k of keys) ctor[k] = bridge(k, ctor[k]); }; + var altdomains = [ + "desuarchive.org", + "archived.moe", + "archive.nyafuu.org", + "arch.b4k.co", + "archive.wakarimasen.moe", + "b4k.co", + "fireden.net", + "thebarchive.com", + "archiveofsins.com" + ]; function supportedAltDomain(s) { - if (true) - return GM.info.script.matches.slice(2).some((m) => m.includes(s)); - return !location.host.includes("boards.4chan"); + return altdomains.includes(s); + } + function supportedMainDomain(s) { + return ["boards.4channel.org", "boards.4chan.org"].includes(s); + } + if (false) { + popupport = chrome.runtime.connect({ name: "popup" }); + popupport.onMessage.addListener((msg) => { + if (msg.id in pendingcmds) { + pendingcmds[msg.id](msg); + delete pendingcmds[msg.id]; + } + }); } var Platform = class { static async openInTab(src, opts) { @@ -14254,7 +15871,14 @@ const _DOMParser = DOMParser; i = (await obj.tabs.getCurrent()).index + 1; return obj.tabs.create({ active: opts.active, url: src, index: i }); } + static getValue(name, def) { + return localLoad2(name, def); + } + static setValue(name, val) { + localSet2(name, val); + } }; + Platform.cmdid = 0; Platform = __decorateClass([ Bridged ], Platform); @@ -14305,7 +15929,7 @@ const _DOMParser = DOMParser; // src/filehosts.ts function parseForm(data) { const form = new FormData(); - Object.entries(data).filter(([key, value]) => value !== null).map(([key, value]) => form.append(key, value)); + Object.entries(data).filter(([key2, value]) => value !== null).map(([key2, value]) => form.append(key2, value)); return form; } var lolisafe = (domain, serving = domain) => ({ @@ -16590,7 +18214,7 @@ const _DOMParser = DOMParser; }; var inject_data = async (container, injb) => { let magic3 = false; - const [writestream, extract6] = BufferWriteStream2(); + const [writestream, extract7] = BufferWriteStream2(); const encoder = new PNGEncoder(writestream); const decoder = new PNGDecoder(container.stream().getReader()); for await (const [name, chunk, crc, offset] of decoder.chunks()) { @@ -16609,7 +18233,7 @@ const _DOMParser = DOMParser; async () => Promise.resolve(0), 0 ]); - return extract6(); + return extract7(); }; var inject = async (container, links) => { links = links.map((link) => { @@ -16894,7 +18518,7 @@ const _DOMParser = DOMParser; } }; var inject3 = async (container, links) => { - const [writestream, extract6] = BufferWriteStream(); + const [writestream, extract7] = BufferWriteStream(); const writer = writestream.getWriter(); const inj = import_buffer5.Buffer.from(links.join(" ")); xor3(inj, password3); @@ -16909,7 +18533,7 @@ const _DOMParser = DOMParser; await writer.write(contbuff.slice(0, endo)); await write_embedding(writer, import_buffer5.Buffer.from(inj)); await writer.write(contbuff.slice(endo)); - return extract6(); + return extract7(); }; var has_embed3 = (gif) => { const field = gif.readUInt8(10); @@ -16946,6 +18570,11 @@ const _DOMParser = DOMParser; init_define_BUILD_VERSION(); init_esbuild_inject(); var import_buffer6 = __toESM(require_buffer(), 1); + var import_f5stegojs = __toESM(require_f5stego(), 1); + var csettings3; + settings.subscribe((b) => { + csettings3 = b; + }); var convertToPng = async (f) => { const can = document.createElement("canvas"); const url = URL.createObjectURL(f); @@ -16985,18 +18614,48 @@ const _DOMParser = DOMParser; URL.revokeObjectURL(url); } }; + var key = import_buffer6.Buffer.from("CUNNYCUNNYCUNNY"); + var f5inst = new import_f5stegojs.default(key); + var injectTrue = async (b, links) => { + if (b.size / 20 < links.join(" ").length) + throw "Image too small to embed."; + const arr = new Uint8Array(await b.arrayBuffer()); + const buff = f5inst.embed(arr, import_buffer6.Buffer.from(links.join(" "))); + return import_buffer6.Buffer.from(buff); + }; var inject4 = async (b, links) => { + if (csettings3.jpeg) + return injectTrue(b, links); const pngfile = await convertToPng(b); if (!pngfile || pngfile.size > 3e3 * 1024) { throw new Error("Couldn't convert file to PNG: resulting filesize too big."); } - return pngv3_default.inject(new File([pngfile], b.name), links); + return pngv3_default.inject(new File([pngfile], b.name), links); + }; + var has_embed4 = (b) => { + if (!csettings3.jpeg) + return false; + try { + const res = f5inst.extract(b); + if (!res) + return; + if (res.length > 1024) + return; + const str = import_buffer6.Buffer.from(res).toString(); + if (!str.match(/^[a-zA-Z0-9:/.\-_ ]+$/)) + return; + return str; + } catch { + return; + } + }; + var extract4 = (b, ex) => { + return decodeCoom3Payload(import_buffer6.Buffer.from(ex)); }; var jpg_default = { - skip: true, match: (fn) => !!fn.match(/\.jpe?g$/), - has_embed: () => false, - extract: () => [], + has_embed: has_embed4, + extract: extract4, inject: inject4 }; @@ -17063,9 +18722,9 @@ const _DOMParser = DOMParser; }; // src/thirdeye.ts - var csettings3; + var csettings4; settings.subscribe((b) => { - csettings3 = b; + csettings4 = b; }); var gelquirk = (prefix) => (a) => { let base = a.post || a.data || a; @@ -17120,7 +18779,7 @@ const _DOMParser = DOMParser; return []; } }; - var extract4 = async (b, fn) => { + var extract5 = async (b, fn) => { let result; let booru; for (const e of Object.values(boorus)) { @@ -17142,8 +18801,8 @@ const _DOMParser = DOMParser; url: result[0].page }, filename: fn.substring(0, 33) + result[0].ext, - thumbnail: csettings3.hotlink ? prev || full : import_buffer7.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()), - data: csettings3.hotlink ? full || prev : async (lsn) => { + thumbnail: csettings4.hotlink ? prev || full : import_buffer7.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()), + data: csettings4.hotlink ? full || prev : async (lsn) => { if (!cachedFile) cachedFile = await (await ifetch(full || prev, void 0, lsn)).arrayBuffer(); return import_buffer7.Buffer.from(cachedFile); @@ -17163,7 +18822,7 @@ const _DOMParser = DOMParser; } return acc; }; - var has_embed4 = async (b, fn, prevlink) => { + var has_embed5 = async (b, fn, prevlink) => { if (import_buffer7.Buffer.from(fn, "hex").equals(b)) return false; let result = void 0; @@ -17195,8 +18854,8 @@ const _DOMParser = DOMParser; }; var thirdeye_default = { skip: true, - extract: extract4, - has_embed: has_embed4, + extract: extract5, + has_embed: has_embed5, match: (fn) => !!fn.match(/^[0-9a-f]{32}\.....?/) }; @@ -17209,9 +18868,9 @@ const _DOMParser = DOMParser; { host: "Litter", prefix: "litter.catbox.moe/" }, { host: "Zzzz", prefix: "z.zz.fo/" } ]; - var csettings4; + var csettings5; settings.subscribe((b) => { - csettings4 = b; + csettings5 = b; }); var getExt = (fn) => { const isB64 = fn.match(/^((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=))?\.(gif|jpe?g|png|webm)/); @@ -17236,7 +18895,7 @@ const _DOMParser = DOMParser; } return { ext, source }; }; - var extract5 = async (b, fn) => { + var extract6 = async (b, fn) => { const { ext, source } = getExt(fn); let rsource; for (const cs of sources) { @@ -17251,7 +18910,7 @@ const _DOMParser = DOMParser; } return [{ filename: ext, - data: csettings4.hotlink ? rsource : async (lsn) => { + data: csettings5.hotlink ? rsource : async (lsn) => { try { return import_buffer8.Buffer.from(await (await ifetch(rsource, void 0, lsn)).arrayBuffer()); } catch (e) { @@ -17260,7 +18919,7 @@ const _DOMParser = DOMParser; thumbnail: import_buffer8.Buffer.from(hasembed_default) }]; }; - var has_embed5 = async (b, fn) => { + var has_embed6 = async (b, fn) => { const { ext, source } = getExt(fn); if (!ext) return false; @@ -17277,8 +18936,8 @@ const _DOMParser = DOMParser; }; var pomf_default = { skip: true, - extract: extract5, - has_embed: has_embed5, + extract: extract6, + has_embed: has_embed6, match: (fn) => !!getExt(fn) }; @@ -18948,8 +20607,8 @@ const _DOMParser = DOMParser; const get_key = (ctx2) => ctx2[10][0]; for (let i = 0; i < each_value.length; i += 1) { let child_ctx = get_each_context(ctx, each_value, i); - let key = get_key(child_ctx); - each_1_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx)); + let key2 = get_key(child_ctx); + each_1_lookup.set(key2, each_blocks[i] = create_each_block(key2, child_ctx)); } return { c() { @@ -19273,34 +20932,34 @@ const _DOMParser = DOMParser; // src/Components/App.svelte function add_css8(target) { - append_styles(target, "svelte-98wprd", '.bepis.svelte-98wprd.svelte-98wprd{max-height:260px;overflow-y:auto}.tagcont.svelte-98wprd.svelte-98wprd{display:flex;gap:5px;margin-bottom:10px;flex-wrap:wrap}label.svelte-98wprd>input[type="text"].svelte-98wprd,label.svelte-98wprd>input[type="number"].svelte-98wprd{width:95%}.content.svelte-98wprd.svelte-98wprd{display:flex;flex-direction:column}.error.svelte-98wprd.svelte-98wprd{color:red}hr.svelte-98wprd.svelte-98wprd{width:100%}h1.svelte-98wprd.svelte-98wprd{text-align:center}.form.svelte-98wprd.svelte-98wprd{display:flex;flex-direction:column;gap:20px;position:absolute;padding:15px;border:1px solid white;background-color:inherit;border-radius:10px}.form.svelte-98wprd>label.svelte-98wprd{display:flex;flex-direction:column;gap:10px}.newsbox.svelte-98wprd.svelte-98wprd{max-height:300px;overflow-y:scroll}.backpanel.svelte-98wprd.svelte-98wprd{position:absolute;right:32px;padding:10px;width:15%;top:32px;border:1px solid;border-radius:5px;background-color:rgba(0, 0, 0, 0.8);pointer-events:all;backdrop-filter:blur(9px);max-height:80vh;min-width:321px}'); + append_styles(target, "svelte-2r0xqp", '.bepis.svelte-2r0xqp.svelte-2r0xqp{max-height:260px;overflow-y:auto}.tagcont.svelte-2r0xqp.svelte-2r0xqp{display:flex;gap:5px;margin-bottom:10px;flex-wrap:wrap}label.svelte-2r0xqp>input[type="text"].svelte-2r0xqp,label.svelte-2r0xqp>input[type="number"].svelte-2r0xqp{width:95%}.content.svelte-2r0xqp.svelte-2r0xqp{display:flex;flex-direction:column}.error.svelte-2r0xqp.svelte-2r0xqp{color:red}hr.svelte-2r0xqp.svelte-2r0xqp{width:100%}h1.svelte-2r0xqp.svelte-2r0xqp{text-align:center}.form.svelte-2r0xqp.svelte-2r0xqp{display:flex;flex-direction:column;gap:20px;position:absolute;padding:15px;border:1px solid white;background-color:black;border-radius:10px}.form.svelte-2r0xqp>label.svelte-2r0xqp{display:flex;flex-direction:column;gap:10px}.newsbox.svelte-2r0xqp.svelte-2r0xqp{max-height:300px;overflow-y:scroll}.backpanel.svelte-2r0xqp.svelte-2r0xqp{position:absolute;right:32px;padding:10px;width:15%;top:32px;border:1px solid;border-radius:5px;background-color:rgba(0, 0, 0, 0.8);pointer-events:all;backdrop-filter:blur(9px);max-height:80vh;min-width:321px}'); } function get_each_context2(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[57] = list[i]; + child_ctx[58] = list[i]; return child_ctx; } function get_each_context_12(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[60] = list[i]; + child_ctx[61] = list[i]; return child_ctx; } function get_each_context_2(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[63] = list[i]; - child_ctx[65] = i; + child_ctx[64] = list[i]; + child_ctx[66] = i; return child_ctx; } function get_each_context_3(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[66] = list[i]; - child_ctx[65] = i; + child_ctx[67] = list[i]; + child_ctx[66] = i; return child_ctx; } function get_each_context_4(ctx, list, i) { const child_ctx = ctx.slice(); - child_ctx[68] = list[i]; - child_ctx[65] = i; + child_ctx[69] = list[i]; + child_ctx[66] = i; return child_ctx; } function create_if_block6(ctx) { @@ -19332,10 +20991,10 @@ const _DOMParser = DOMParser; hr = element("hr"); t3 = space(); create_component(tabs.$$.fragment); - attr(h1, "class", "svelte-98wprd"); - attr(hr, "class", "svelte-98wprd"); - attr(div0, "class", "content svelte-98wprd"); - attr(div1, "class", "backpanel svelte-98wprd"); + attr(h1, "class", "svelte-2r0xqp"); + attr(hr, "class", "svelte-2r0xqp"); + attr(div0, "class", "content svelte-2r0xqp"); + attr(div1, "class", "backpanel svelte-2r0xqp"); }, m(target, anchor) { insert(target, div1, anchor); @@ -19353,7 +21012,7 @@ const _DOMParser = DOMParser; if (!current || dirty[0] & 1) set_data(t1, ctx2[0]); const tabs_changes = {}; - if (dirty[0] & 1006 | dirty[2] & 256) { + if (dirty[0] & 1006 | dirty[2] & 512) { tabs_changes.$$scope = { dirty, ctx: ctx2 }; } tabs.$set(tabs_changes); @@ -19460,7 +21119,7 @@ const _DOMParser = DOMParser; } }; } - function create_if_block_10(ctx) { + function create_if_block_11(ctx) { let tab; let current; tab = new Tab_default({ @@ -19552,7 +21211,7 @@ const _DOMParser = DOMParser; } }); tab4.$on("select", ctx[19]); - let if_block = ctx[8].akValid && create_if_block_10(ctx); + let if_block = ctx[8].akValid && create_if_block_11(ctx); return { c() { create_component(tab0.$$.fragment); @@ -19587,27 +21246,27 @@ const _DOMParser = DOMParser; }, p(ctx2, dirty) { const tab0_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab0_changes.$$scope = { dirty, ctx: ctx2 }; } tab0.$set(tab0_changes); const tab1_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab1_changes.$$scope = { dirty, ctx: ctx2 }; } tab1.$set(tab1_changes); const tab2_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab2_changes.$$scope = { dirty, ctx: ctx2 }; } tab2.$set(tab2_changes); const tab3_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab3_changes.$$scope = { dirty, ctx: ctx2 }; } tab3.$set(tab3_changes); const tab4_changes = {}; - if (dirty[2] & 256) { + if (dirty[2] & 512) { tab4_changes.$$scope = { dirty, ctx: ctx2 }; } tab4.$set(tab4_changes); @@ -19617,7 +21276,7 @@ const _DOMParser = DOMParser; transition_in(if_block, 1); } } else { - if_block = create_if_block_10(ctx2); + if_block = create_if_block_11(ctx2); if_block.c(); transition_in(if_block, 1); if_block.m(if_block_anchor.parentNode, if_block_anchor); @@ -19673,7 +21332,7 @@ const _DOMParser = DOMParser; } }; } - function create_if_block_9(ctx) { + function create_if_block_10(ctx) { let label; let input; let t; @@ -19692,7 +21351,7 @@ const _DOMParser = DOMParser; input.checked = ctx[7].ho; append(label, t); if (!mounted) { - dispose = listen(input, "change", ctx[28]); + dispose = listen(input, "change", ctx[29]); mounted = true; } }, @@ -19709,7 +21368,7 @@ const _DOMParser = DOMParser; } }; } - function create_if_block_62(ctx) { + function create_if_block_72(ctx) { let t0; let label; let t1; @@ -19720,8 +21379,8 @@ const _DOMParser = DOMParser; let if_block1_anchor; let mounted; let dispose; - let if_block0 = ctx[8].herror && create_if_block_8(ctx); - let if_block1 = ctx[8].akValid && create_if_block_72(ctx); + let if_block0 = ctx[8].herror && create_if_block_9(ctx); + let if_block1 = ctx[8].akValid && create_if_block_8(ctx); return { c() { if (if_block0) @@ -19739,8 +21398,8 @@ const _DOMParser = DOMParser; if_block1_anchor = empty(); attr(a, "title", "Only requires Search Files permission. See Hydrus docs on where to set this up."); attr(input, "type", "text"); - attr(input, "class", "svelte-98wprd"); - attr(label, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { if (if_block0) @@ -19757,7 +21416,7 @@ const _DOMParser = DOMParser; if_block1.m(target, anchor); insert(target, if_block1_anchor, anchor); if (!mounted) { - dispose = listen(input, "input", ctx[36]); + dispose = listen(input, "input", ctx[37]); mounted = true; } }, @@ -19766,7 +21425,7 @@ const _DOMParser = DOMParser; if (if_block0) { if_block0.p(ctx2, dirty); } else { - if_block0 = create_if_block_8(ctx2); + if_block0 = create_if_block_9(ctx2); if_block0.c(); if_block0.m(t0.parentNode, t0); } @@ -19781,7 +21440,7 @@ const _DOMParser = DOMParser; if (if_block1) { if_block1.p(ctx2, dirty); } else { - if_block1 = create_if_block_72(ctx2); + if_block1 = create_if_block_8(ctx2); if_block1.c(); if_block1.m(if_block1_anchor.parentNode, if_block1_anchor); } @@ -19808,7 +21467,7 @@ const _DOMParser = DOMParser; } }; } - function create_if_block_8(ctx) { + function create_if_block_9(ctx) { let span; let t_value = ctx[8].herror + ""; let t; @@ -19816,7 +21475,7 @@ const _DOMParser = DOMParser; c() { span = element("span"); t = text(t_value); - attr(span, "class", "error svelte-98wprd"); + attr(span, "class", "error svelte-2r0xqp"); }, m(target, anchor) { insert(target, span, anchor); @@ -19832,7 +21491,7 @@ const _DOMParser = DOMParser; } }; } - function create_if_block_72(ctx) { + function create_if_block_8(ctx) { let label0; let t0; let input0; @@ -19853,12 +21512,12 @@ const _DOMParser = DOMParser; input1 = element("input"); set_style(input0, "width", "5ch"); attr(input0, "type", "number"); - attr(input0, "class", "svelte-98wprd"); - attr(label0, "class", "svelte-98wprd"); + attr(input0, "class", "svelte-2r0xqp"); + attr(label0, "class", "svelte-2r0xqp"); attr(input1, "placeholder", "Restrict to these tags (space to separate tags, _ to separate words)"); attr(input1, "type", "text"); - attr(input1, "class", "svelte-98wprd"); - attr(label1, "class", "svelte-98wprd"); + attr(input1, "class", "svelte-2r0xqp"); + attr(label1, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, label0, anchor); @@ -19872,8 +21531,8 @@ const _DOMParser = DOMParser; set_input_value(input1, ctx[7].auto_tags); if (!mounted) { dispose = [ - listen(input0, "input", ctx[37]), - listen(input1, "input", ctx[38]) + listen(input0, "input", ctx[38]), + listen(input1, "input", ctx[39]) ]; mounted = true; } @@ -19902,141 +21561,153 @@ const _DOMParser = DOMParser; let label0; let input0; let t0; - let t1; + let a0; + let t2; let label1; let input1; - let t2; let t3; + let t4; let label2; let input2; - let t4; let t5; + let t6; let label3; let input3; - let t6; let t7; + let t8; let label4; let input4; - let t8; let t9; + let t10; let label5; let input5; - let t10; let t11; + let t12; let label6; let input6; - let t12; let t13; + let t14; let label7; let input7; - let t14; let t15; let t16; let label8; let input8; let t17; let t18; + let t19; let label9; let input9; - let t19; let t20; + let t21; let label10; let input10; - let t21; let t22; + let t23; let label11; let input11; - let t23; let t24; + let t25; let label12; let input12; - let t25; let t26; + let t27; let label13; let input13; - let t27; - let a; + let t28; let t29; let label14; let input14; let t30; - let t31; + let a1; + let t32; + let label15; + let input15; + let t33; + let t34; let if_block1_anchor; let mounted; let dispose; - let if_block0 = ctx[7].eye && create_if_block_9(ctx); - let if_block1 = ctx[7].hyd && create_if_block_62(ctx); + let if_block0 = ctx[7].eye && create_if_block_10(ctx); + let if_block1 = ctx[7].hyd && create_if_block_72(ctx); return { c() { label0 = element("label"); input0 = element("input"); - t0 = text("\n Try to load embeds from server cache"); - t1 = space(); + t0 = text("\n Enable JPGs support (JPG embed and extract)\n "); + a0 = element("a"); + a0.textContent = "?"; + t2 = space(); label1 = element("label"); input1 = element("input"); - t2 = text("\n Display view counts"); - t3 = space(); + t3 = text("\n Try to load embeds from server cache"); + t4 = space(); label2 = element("label"); input2 = element("input"); - t4 = text("\n Check for new versions at startup."); - t5 = space(); + t5 = text("\n Display view counts"); + t6 = space(); label3 = element("label"); input3 = element("input"); - t6 = text("\n Autoexpand Images on opening."); - t7 = space(); + t7 = text("\n Check for new versions at startup."); + t8 = space(); label4 = element("label"); input4 = element("input"); - t8 = text("\n Autoexpand Videos on opening."); - t9 = space(); + t9 = text("\n Autoexpand Images on opening."); + t10 = space(); label5 = element("label"); input5 = element("input"); - t10 = text("\n Loop media content."); - t11 = space(); + t11 = text("\n Autoexpand Videos on opening."); + t12 = space(); label6 = element("label"); input6 = element("input"); - t12 = text("\n Disable hover preview."); - t13 = space(); + t13 = text("\n Loop media content."); + t14 = space(); label7 = element("label"); input7 = element("input"); - t14 = text("\n Hide embedded content behind an eye."); - t15 = space(); - if (if_block0) - if_block0.c(); + t15 = text("\n Disable hover preview."); t16 = space(); label8 = element("label"); input8 = element("input"); - t17 = text("\n Preload external files."); + t17 = text("\n Hide embedded content behind an eye."); t18 = space(); + if (if_block0) + if_block0.c(); + t19 = space(); label9 = element("label"); input9 = element("input"); - t19 = text("\n Preload external files when they are in view."); - t20 = space(); + t20 = text("\n Preload external files."); + t21 = space(); label10 = element("label"); input10 = element("input"); - t21 = text("\n Hotlink content."); - t22 = space(); + t22 = text("\n Preload external files when they are in view."); + t23 = space(); label11 = element("label"); input11 = element("input"); - t23 = text("\n Control audio on videos with mouse wheel."); - t24 = space(); + t24 = text("\n Hotlink content."); + t25 = space(); label12 = element("label"); input12 = element("input"); - t25 = text("\n Show Minimap"); - t26 = space(); + t26 = text("\n Control audio on videos with mouse wheel."); + t27 = space(); label13 = element("label"); input13 = element("input"); - t27 = text("\n \n Disable embedded file preloading"); - a = element("a"); - a.textContent = "?"; + t28 = text("\n Show Minimap"); t29 = space(); label14 = element("label"); input14 = element("input"); - t30 = text("\n \n Enable Hydrus Integration"); - t31 = space(); + t30 = text("\n \n Disable embedded file preloading"); + a1 = element("a"); + a1.textContent = "?"; + t32 = space(); + label15 = element("label"); + input15 = element("input"); + t33 = text("\n \n Enable Hydrus Integration"); + t34 = space(); if (if_block1) if_block1.c(); if_block1_anchor = empty(); attr(input0, "type", "checkbox"); + attr(a0, "title", "JPG embed detection is relatively slow, heavy, so you might want to also enable server cache loading"); attr(input1, "type", "checkbox"); attr(input2, "type", "checkbox"); attr(input3, "type", "checkbox"); @@ -20050,89 +21721,96 @@ const _DOMParser = DOMParser; attr(input11, "type", "checkbox"); attr(input12, "type", "checkbox"); attr(input13, "type", "checkbox"); - attr(a, "title", "You might still want to enable 'preload external files'"); attr(input14, "type", "checkbox"); + attr(a1, "title", "You might still want to enable 'preload external files'"); + attr(input15, "type", "checkbox"); }, m(target, anchor) { insert(target, label0, anchor); append(label0, input0); - input0.checked = ctx[9]; + input0.checked = ctx[7].jpeg; append(label0, t0); - insert(target, t1, anchor); + append(label0, a0); + insert(target, t2, anchor); insert(target, label1, anchor); append(label1, input1); - input1.checked = ctx[7].dvc; - append(label1, t2); - insert(target, t3, anchor); + input1.checked = ctx[9]; + append(label1, t3); + insert(target, t4, anchor); insert(target, label2, anchor); append(label2, input2); - input2.checked = ctx[7].vercheck; - append(label2, t4); - insert(target, t5, anchor); + input2.checked = ctx[7].dvc; + append(label2, t5); + insert(target, t6, anchor); insert(target, label3, anchor); append(label3, input3); - input3.checked = ctx[7].xpi; - append(label3, t6); - insert(target, t7, anchor); + input3.checked = ctx[7].vercheck; + append(label3, t7); + insert(target, t8, anchor); insert(target, label4, anchor); append(label4, input4); - input4.checked = ctx[7].xpv; - append(label4, t8); - insert(target, t9, anchor); + input4.checked = ctx[7].xpi; + append(label4, t9); + insert(target, t10, anchor); insert(target, label5, anchor); append(label5, input5); - input5.checked = ctx[7].loop; - append(label5, t10); - insert(target, t11, anchor); + input5.checked = ctx[7].xpv; + append(label5, t11); + insert(target, t12, anchor); insert(target, label6, anchor); append(label6, input6); - input6.checked = ctx[7].dh; - append(label6, t12); - insert(target, t13, anchor); + input6.checked = ctx[7].loop; + append(label6, t13); + insert(target, t14, anchor); insert(target, label7, anchor); append(label7, input7); - input7.checked = ctx[7].eye; - append(label7, t14); - insert(target, t15, anchor); - if (if_block0) - if_block0.m(target, anchor); + input7.checked = ctx[7].dh; + append(label7, t15); insert(target, t16, anchor); insert(target, label8, anchor); append(label8, input8); - input8.checked = ctx[7].pre; + input8.checked = ctx[7].eye; append(label8, t17); insert(target, t18, anchor); + if (if_block0) + if_block0.m(target, anchor); + insert(target, t19, anchor); insert(target, label9, anchor); append(label9, input9); - input9.checked = ctx[7].prev; - append(label9, t19); - insert(target, t20, anchor); + input9.checked = ctx[7].pre; + append(label9, t20); + insert(target, t21, anchor); insert(target, label10, anchor); append(label10, input10); - input10.checked = ctx[7].hotlink; - append(label10, t21); - insert(target, t22, anchor); + input10.checked = ctx[7].prev; + append(label10, t22); + insert(target, t23, anchor); insert(target, label11, anchor); append(label11, input11); - input11.checked = ctx[7].ca; - append(label11, t23); - insert(target, t24, anchor); + input11.checked = ctx[7].hotlink; + append(label11, t24); + insert(target, t25, anchor); insert(target, label12, anchor); append(label12, input12); - input12.checked = ctx[7].sh; - append(label12, t25); - insert(target, t26, anchor); + input12.checked = ctx[7].ca; + append(label12, t26); + insert(target, t27, anchor); insert(target, label13, anchor); append(label13, input13); - input13.checked = ctx[7].ep; - append(label13, t27); - append(label13, a); + input13.checked = ctx[7].sh; + append(label13, t28); insert(target, t29, anchor); insert(target, label14, anchor); append(label14, input14); - input14.checked = ctx[7].hyd; + input14.checked = ctx[7].ep; append(label14, t30); - insert(target, t31, anchor); + append(label14, a1); + insert(target, t32, anchor); + insert(target, label15, anchor); + append(label15, input15); + input15.checked = ctx[7].hyd; + append(label15, t33); + insert(target, t34, anchor); if (if_block1) if_block1.m(target, anchor); insert(target, if_block1_anchor, anchor); @@ -20146,80 +21824,84 @@ const _DOMParser = DOMParser; listen(input5, "change", ctx[25]), listen(input6, "change", ctx[26]), listen(input7, "change", ctx[27]), - listen(input8, "change", ctx[29]), + listen(input8, "change", ctx[28]), listen(input9, "change", ctx[30]), listen(input10, "change", ctx[31]), listen(input11, "change", ctx[32]), listen(input12, "change", ctx[33]), listen(input13, "change", ctx[34]), - listen(input14, "change", ctx[35]) + listen(input14, "change", ctx[35]), + listen(input15, "change", ctx[36]) ]; mounted = true; } }, p(ctx2, dirty) { + if (dirty[0] & 128) { + input0.checked = ctx2[7].jpeg; + } if (dirty[0] & 512) { - input0.checked = ctx2[9]; + input1.checked = ctx2[9]; } if (dirty[0] & 128) { - input1.checked = ctx2[7].dvc; + input2.checked = ctx2[7].dvc; } if (dirty[0] & 128) { - input2.checked = ctx2[7].vercheck; + input3.checked = ctx2[7].vercheck; } if (dirty[0] & 128) { - input3.checked = ctx2[7].xpi; + input4.checked = ctx2[7].xpi; } if (dirty[0] & 128) { - input4.checked = ctx2[7].xpv; + input5.checked = ctx2[7].xpv; } if (dirty[0] & 128) { - input5.checked = ctx2[7].loop; + input6.checked = ctx2[7].loop; } if (dirty[0] & 128) { - input6.checked = ctx2[7].dh; + input7.checked = ctx2[7].dh; } if (dirty[0] & 128) { - input7.checked = ctx2[7].eye; + input8.checked = ctx2[7].eye; } if (ctx2[7].eye) { if (if_block0) { if_block0.p(ctx2, dirty); } else { - if_block0 = create_if_block_9(ctx2); + if_block0 = create_if_block_10(ctx2); if_block0.c(); - if_block0.m(t16.parentNode, t16); + if_block0.m(t19.parentNode, t19); } } else if (if_block0) { if_block0.d(1); if_block0 = null; } if (dirty[0] & 128) { - input8.checked = ctx2[7].pre; + input9.checked = ctx2[7].pre; } if (dirty[0] & 128) { - input9.checked = ctx2[7].prev; + input10.checked = ctx2[7].prev; } if (dirty[0] & 128) { - input10.checked = ctx2[7].hotlink; + input11.checked = ctx2[7].hotlink; } if (dirty[0] & 128) { - input11.checked = ctx2[7].ca; + input12.checked = ctx2[7].ca; } if (dirty[0] & 128) { - input12.checked = ctx2[7].sh; + input13.checked = ctx2[7].sh; } if (dirty[0] & 128) { - input13.checked = ctx2[7].ep; + input14.checked = ctx2[7].ep; } if (dirty[0] & 128) { - input14.checked = ctx2[7].hyd; + input15.checked = ctx2[7].hyd; } if (ctx2[7].hyd) { if (if_block1) { if_block1.p(ctx2, dirty); } else { - if_block1 = create_if_block_62(ctx2); + if_block1 = create_if_block_72(ctx2); if_block1.c(); if_block1.m(if_block1_anchor.parentNode, if_block1_anchor); } @@ -20232,59 +21914,59 @@ const _DOMParser = DOMParser; if (detaching) detach(label0); if (detaching) - detach(t1); + detach(t2); if (detaching) detach(label1); if (detaching) - detach(t3); + detach(t4); if (detaching) detach(label2); if (detaching) - detach(t5); + detach(t6); if (detaching) detach(label3); if (detaching) - detach(t7); + detach(t8); if (detaching) detach(label4); if (detaching) - detach(t9); + detach(t10); if (detaching) detach(label5); if (detaching) - detach(t11); + detach(t12); if (detaching) detach(label6); if (detaching) - detach(t13); + detach(t14); if (detaching) detach(label7); - if (detaching) - detach(t15); - if (if_block0) - if_block0.d(detaching); if (detaching) detach(t16); if (detaching) detach(label8); if (detaching) detach(t18); + if (if_block0) + if_block0.d(detaching); + if (detaching) + detach(t19); if (detaching) detach(label9); if (detaching) - detach(t20); + detach(t21); if (detaching) detach(label10); if (detaching) - detach(t22); + detach(t23); if (detaching) detach(label11); if (detaching) - detach(t24); + detach(t25); if (detaching) detach(label12); if (detaching) - detach(t26); + detach(t27); if (detaching) detach(label13); if (detaching) @@ -20292,7 +21974,11 @@ const _DOMParser = DOMParser; if (detaching) detach(label14); if (detaching) - detach(t31); + detach(t32); + if (detaching) + detach(label15); + if (detaching) + detach(t34); if (if_block1) if_block1.d(detaching); if (detaching) @@ -20310,23 +21996,25 @@ const _DOMParser = DOMParser; let t2; let h30; let t4; - let div0; let t5; + let div0; + let t6; let button; - let t7; - let dialog; let t8; - let hr; + let dialog; let t9; + let hr; + let t10; let h31; - let t11; - let div1; let t12; + let div1; + let t13; let input1; let current; let mounted; let dispose; - let if_block = ctx[7].phash && create_if_block_52(ctx); + let if_block0 = ctx[7].phash && create_if_block_62(ctx); + let if_block1 = ctx[7].rsources.length == 0 && create_if_block_52(ctx); let each_value_4 = ctx[7].rsources; let each_blocks_1 = []; for (let i = 0; i < each_value_4.length; i += 1) { @@ -20340,7 +22028,7 @@ const _DOMParser = DOMParser; $$scope: { ctx } }; dialog = new Dialog_default({ props: dialog_props }); - ctx[50](dialog); + ctx[51](dialog); let each_value_3 = ctx[7].blacklist; let each_blocks = []; for (let i = 0; i < each_value_3.length; i += 1) { @@ -20355,37 +22043,40 @@ const _DOMParser = DOMParser; input0 = element("input"); t0 = text("\n Enable perceptual hash-based filtering"); t1 = space(); - if (if_block) - if_block.c(); + if (if_block0) + if_block0.c(); t2 = space(); h30 = element("h3"); h30.textContent = "Booru sources"; t4 = space(); + if (if_block1) + if_block1.c(); + t5 = space(); div0 = element("div"); for (let i = 0; i < each_blocks_1.length; i += 1) { each_blocks_1[i].c(); } - t5 = space(); + t6 = space(); button = element("button"); button.textContent = "Add a source"; - t7 = space(); - create_component(dialog.$$.fragment); t8 = space(); - hr = element("hr"); + create_component(dialog.$$.fragment); t9 = space(); + hr = element("hr"); + t10 = space(); h31 = element("h3"); h31.textContent = "Blacklisted tags"; - t11 = space(); + t12 = space(); div1 = element("div"); for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].c(); } - t12 = space(); + t13 = space(); input1 = element("input"); attr(input0, "type", "checkbox"); - attr(div0, "class", "tagcont svelte-98wprd"); - attr(hr, "class", "svelte-98wprd"); - attr(div1, "class", "tagcont svelte-98wprd"); + attr(div0, "class", "tagcont svelte-2r0xqp"); + attr(hr, "class", "svelte-2r0xqp"); + attr(div1, "class", "tagcont svelte-2r0xqp"); attr(input1, "placeholder", "Press enter after typing your tag"); }, m(target, anchor) { @@ -20394,36 +22085,39 @@ const _DOMParser = DOMParser; input0.checked = ctx[7].phash; append(label, t0); insert(target, t1, anchor); - if (if_block) - if_block.m(target, anchor); + if (if_block0) + if_block0.m(target, anchor); insert(target, t2, anchor); insert(target, h30, anchor); insert(target, t4, anchor); + if (if_block1) + if_block1.m(target, anchor); + insert(target, t5, anchor); insert(target, div0, anchor); for (let i = 0; i < each_blocks_1.length; i += 1) { each_blocks_1[i].m(div0, null); } - insert(target, t5, anchor); + insert(target, t6, anchor); insert(target, button, anchor); - insert(target, t7, anchor); - mount_component(dialog, target, anchor); insert(target, t8, anchor); - insert(target, hr, anchor); + mount_component(dialog, target, anchor); insert(target, t9, anchor); + insert(target, hr, anchor); + insert(target, t10, anchor); insert(target, h31, anchor); - insert(target, t11, anchor); + insert(target, t12, anchor); insert(target, div1, anchor); for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].m(div1, null); } - insert(target, t12, anchor); + insert(target, t13, anchor); insert(target, input1, anchor); current = true; if (!mounted) { dispose = [ - listen(input0, "change", ctx[40]), - listen(button, "click", ctx[45]), - listen(input1, "keydown", ctx[52]) + listen(input0, "change", ctx[41]), + listen(button, "click", ctx[46]), + listen(input1, "keydown", ctx[53]) ]; mounted = true; } @@ -20433,16 +22127,27 @@ const _DOMParser = DOMParser; input0.checked = ctx2[7].phash; } if (ctx2[7].phash) { - if (if_block) { - if_block.p(ctx2, dirty); + if (if_block0) { + if_block0.p(ctx2, dirty); } else { - if_block = create_if_block_52(ctx2); - if_block.c(); - if_block.m(t2.parentNode, t2); + if_block0 = create_if_block_62(ctx2); + if_block0.c(); + if_block0.m(t2.parentNode, t2); } - } else if (if_block) { - if_block.d(1); - if_block = null; + } else if (if_block0) { + if_block0.d(1); + if_block0 = null; + } + if (ctx2[7].rsources.length == 0) { + if (if_block1) { + } else { + if_block1 = create_if_block_52(ctx2); + if_block1.c(); + if_block1.m(t5.parentNode, t5); + } + } else if (if_block1) { + if_block1.d(1); + if_block1 = null; } if (dirty[0] & 73856) { each_value_4 = ctx2[7].rsources; @@ -20466,7 +22171,7 @@ const _DOMParser = DOMParser; check_outros(); } const dialog_changes = {}; - if (dirty[0] & 2 | dirty[2] & 256) { + if (dirty[0] & 2 | dirty[2] & 512) { dialog_changes.$$scope = { dirty, ctx: ctx2 }; } dialog.$set(dialog_changes); @@ -20521,40 +22226,44 @@ const _DOMParser = DOMParser; detach(label); if (detaching) detach(t1); - if (if_block) - if_block.d(detaching); + if (if_block0) + if_block0.d(detaching); if (detaching) detach(t2); if (detaching) detach(h30); if (detaching) detach(t4); + if (if_block1) + if_block1.d(detaching); + if (detaching) + detach(t5); if (detaching) detach(div0); destroy_each(each_blocks_1, detaching); if (detaching) - detach(t5); + detach(t6); if (detaching) detach(button); if (detaching) - detach(t7); - ctx[50](null); + detach(t8); + ctx[51](null); destroy_component(dialog, detaching); if (detaching) - detach(t8); + detach(t9); if (detaching) detach(hr); if (detaching) - detach(t9); + detach(t10); if (detaching) detach(h31); if (detaching) - detach(t11); + detach(t12); if (detaching) detach(div1); destroy_each(each_blocks, detaching); if (detaching) - detach(t12); + detach(t13); if (detaching) detach(input1); mounted = false; @@ -20562,7 +22271,7 @@ const _DOMParser = DOMParser; } }; } - function create_if_block_52(ctx) { + function create_if_block_62(ctx) { let label; let input; let t0; @@ -20577,9 +22286,9 @@ const _DOMParser = DOMParser; a = element("a"); a.textContent = "?"; attr(input, "type", "number"); - attr(input, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); attr(a, "title", "Higher will filter more potentially different images, lower will let more identical images through"); - attr(label, "class", "svelte-98wprd"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, label, anchor); @@ -20588,7 +22297,7 @@ const _DOMParser = DOMParser; append(label, t0); append(label, a); if (!mounted) { - dispose = listen(input, "input", ctx[41]); + dispose = listen(input, "input", ctx[42]); mounted = true; } }, @@ -20605,21 +22314,37 @@ const _DOMParser = DOMParser; } }; } + function create_if_block_52(ctx) { + let p; + return { + c() { + p = element("p"); + p.textContent = "Don't know what to put here? Ask some anons ;)"; + }, + m(target, anchor) { + insert(target, p, anchor); + }, + d(detaching) { + if (detaching) + detach(p); + } + }; + } function create_each_block_4(ctx) { let tag; let current; function func(...args) { - return ctx[42](ctx[68], ...args); + return ctx[43](ctx[69], ...args); } function remove_handler() { - return ctx[43](ctx[68]); + return ctx[44](ctx[69]); } function toggle_handler() { - return ctx[44](ctx[68]); + return ctx[45](ctx[69]); } tag = new Tag_default({ props: { - tag: ctx[68].name, + tag: ctx[69].name, toggleable: true, toggled: !ctx[7].rsources.find(func)?.disabled } @@ -20638,7 +22363,7 @@ const _DOMParser = DOMParser; ctx = new_ctx; const tag_changes = {}; if (dirty[0] & 128) - tag_changes.tag = ctx[68].name; + tag_changes.tag = ctx[69].name; if (dirty[0] & 128) tag_changes.toggled = !ctx[7].rsources.find(func)?.disabled; tag.$set(tag_changes); @@ -20701,22 +22426,22 @@ const _DOMParser = DOMParser; button = element("button"); button.textContent = "Add"; attr(input0, "type", "text"); - attr(input0, "placeholder", "Gelbooru"); - attr(input0, "class", "svelte-98wprd"); - attr(label0, "class", "svelte-98wprd"); + attr(input0, "placeholder", "Safebooru"); + attr(input0, "class", "svelte-2r0xqp"); + attr(label0, "class", "svelte-2r0xqp"); attr(input1, "type", "text"); - attr(input1, "placeholder", "gelbooru.com"); - attr(input1, "class", "svelte-98wprd"); - attr(label1, "class", "svelte-98wprd"); + attr(input1, "placeholder", "safebooru.com"); + attr(input1, "class", "svelte-2r0xqp"); + attr(label1, "class", "svelte-2r0xqp"); attr(input2, "type", "text"); attr(input2, "placeholder", "/post.json?tags=md5:"); - attr(input2, "class", "svelte-98wprd"); - attr(label2, "class", "svelte-98wprd"); + attr(input2, "class", "svelte-2r0xqp"); + attr(label2, "class", "svelte-2r0xqp"); attr(input3, "type", "text"); - attr(input3, "placeholder", "https://yande.re/post/show/"); - attr(input3, "class", "svelte-98wprd"); - attr(label3, "class", "svelte-98wprd"); - attr(div, "class", "form svelte-98wprd"); + attr(input3, "placeholder", "https://safebooru.com/post/show/"); + attr(input3, "class", "svelte-2r0xqp"); + attr(label3, "class", "svelte-2r0xqp"); + attr(div, "class", "form svelte-2r0xqp"); }, m(target, anchor) { insert(target, div, anchor); @@ -20743,10 +22468,10 @@ const _DOMParser = DOMParser; append(div, button); if (!mounted) { dispose = [ - listen(input0, "input", ctx[46]), - listen(input1, "input", ctx[47]), - listen(input2, "input", ctx[48]), - listen(input3, "input", ctx[49]), + listen(input0, "input", ctx[47]), + listen(input1, "input", ctx[48]), + listen(input2, "input", ctx[49]), + listen(input3, "input", ctx[50]), listen(button, "click", ctx[11]) ]; mounted = true; @@ -20778,9 +22503,9 @@ const _DOMParser = DOMParser; let tag; let current; function toggle_handler_1() { - return ctx[51](ctx[66]); + return ctx[52](ctx[67]); } - tag = new Tag_default({ props: { tag: ctx[66] } }); + tag = new Tag_default({ props: { tag: ctx[67] } }); tag.$on("toggle", toggle_handler_1); return { c() { @@ -20794,7 +22519,7 @@ const _DOMParser = DOMParser; ctx = new_ctx; const tag_changes = {}; if (dirty[0] & 128) - tag_changes.tag = ctx[66]; + tag_changes.tag = ctx[67]; tag.$set(tag_changes); }, i(local) { @@ -20844,7 +22569,7 @@ const _DOMParser = DOMParser; insert(target, if_block_anchor, anchor); current = true; if (!mounted) { - dispose = listen(input, "change", ctx[39]); + dispose = listen(input, "change", ctx[40]); mounted = true; } }, @@ -20898,14 +22623,14 @@ const _DOMParser = DOMParser; } function create_each_block_2(ctx) { let option; - let t_value = ctx[63].domain + ""; + let t_value = ctx[64].domain + ""; let t; let option_value_value; return { c() { option = element("option"); t = text(t_value); - option.__value = option_value_value = ctx[65]; + option.__value = option_value_value = ctx[66]; option.value = option.__value; }, m(target, anchor) { @@ -20948,10 +22673,10 @@ const _DOMParser = DOMParser; t3 = text("Maximum number of embedded links to display\n "); input = element("input"); if (ctx[7].fhost === void 0) - add_render_callback(() => ctx[53].call(select)); + add_render_callback(() => ctx[54].call(select)); attr(input, "type", "number"); - attr(input, "class", "svelte-98wprd"); - attr(label, "class", "svelte-98wprd"); + attr(input, "class", "svelte-2r0xqp"); + attr(label, "class", "svelte-2r0xqp"); }, m(target, anchor) { insert(target, p, anchor); @@ -20968,8 +22693,8 @@ const _DOMParser = DOMParser; set_input_value(input, ctx[7].maxe); if (!mounted) { dispose = [ - listen(select, "change", ctx[53]), - listen(input, "input", ctx[54]) + listen(select, "change", ctx[54]), + listen(input, "input", ctx[55]) ]; mounted = true; } @@ -21052,7 +22777,7 @@ const _DOMParser = DOMParser; for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].c(); } - attr(div, "class", "bepis svelte-98wprd"); + attr(div, "class", "bepis svelte-2r0xqp"); }, m(target, anchor) { insert(target, div, anchor); @@ -21093,14 +22818,14 @@ const _DOMParser = DOMParser; let div; let a; let t0; - let t1_value = ctx[60].id + ""; + let t1_value = ctx[61].id + ""; let t1; let a_href_value; let t2; - let t3_value = ctx[60].pees + ""; + let t3_value = ctx[61].pees + ""; let t3; let t4; - let t5_value = ctx[60].eyes + ctx[60].other + ""; + let t5_value = ctx[61].eyes + ctx[61].other + ""; let t5; let t6; return { @@ -21114,7 +22839,7 @@ const _DOMParser = DOMParser; t4 = text(" / "); t5 = text(t5_value); t6 = text(")\n "); - attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[14] + "/thread/" + ctx[60].id); + attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[14] + "/thread/" + ctx[61].id); attr(div, "class", "mbepis"); }, m(target, anchor) { @@ -21129,14 +22854,14 @@ const _DOMParser = DOMParser; append(div, t6); }, p(ctx2, dirty) { - if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[60].id + "")) + if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[61].id + "")) set_data(t1, t1_value); - if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[14] + "/thread/" + ctx2[60].id)) { + if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[14] + "/thread/" + ctx2[61].id)) { attr(a, "href", a_href_value); } - if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[60].pees + "")) + if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[61].pees + "")) set_data(t3, t3_value); - if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[60].eyes + ctx2[60].other + "")) + if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[61].eyes + ctx2[61].other + "")) set_data(t5, t5_value); }, d(detaching) { @@ -21187,7 +22912,7 @@ const _DOMParser = DOMParser; if_block.m(target, anchor); insert(target, if_block_anchor, anchor); if (!mounted) { - dispose = listen(input, "change", ctx[55]); + dispose = listen(input, "change", ctx[56]); mounted = true; } }, @@ -21285,11 +23010,11 @@ const _DOMParser = DOMParser; } function create_each_block2(ctx) { let h3; - let t0_value = ctx[57].title + ""; + let t0_value = ctx[58].title + ""; let t0; let t1; let p; - let t2_value = ctx[57].content + ""; + let t2_value = ctx[58].content + ""; let t2; return { c() { @@ -21307,9 +23032,9 @@ const _DOMParser = DOMParser; append(p, t2); }, p(ctx2, dirty) { - if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[57].title + "")) + if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[58].title + "")) set_data(t0, t0_value); - if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[57].content + "")) + if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[58].content + "")) set_data(t2, t2_value); }, d(detaching) { @@ -21340,7 +23065,7 @@ const _DOMParser = DOMParser; t2 = space(); div = element("div"); if_block.c(); - attr(div, "class", "newsbox svelte-98wprd"); + attr(div, "class", "newsbox svelte-2r0xqp"); }, m(target, anchor) { insert(target, p, anchor); @@ -21520,32 +23245,32 @@ const _DOMParser = DOMParser; }, p(ctx2, dirty) { const tablist_changes = {}; - if (dirty[0] & 256 | dirty[2] & 256) { + if (dirty[0] & 256 | dirty[2] & 512) { tablist_changes.$$scope = { dirty, ctx: ctx2 }; } tablist.$set(tablist_changes); const tabpanel0_changes = {}; - if (dirty[0] & 896 | dirty[2] & 256) { + if (dirty[0] & 896 | dirty[2] & 512) { tabpanel0_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel0.$set(tabpanel0_changes); const tabpanel1_changes = {}; - if (dirty[0] & 134 | dirty[2] & 256) { + if (dirty[0] & 134 | dirty[2] & 512) { tabpanel1_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel1.$set(tabpanel1_changes); const tabpanel2_changes = {}; - if (dirty[0] & 128 | dirty[2] & 256) { + if (dirty[0] & 128 | dirty[2] & 512) { tabpanel2_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel2.$set(tabpanel2_changes); const tabpanel3_changes = {}; - if (dirty[0] & 224 | dirty[2] & 256) { + if (dirty[0] & 224 | dirty[2] & 512) { tabpanel3_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel3.$set(tabpanel3_changes); const tabpanel4_changes = {}; - if (dirty[0] & 8 | dirty[2] & 256) { + if (dirty[0] & 8 | dirty[2] & 512) { tabpanel4_changes.$$scope = { dirty, ctx: ctx2 }; } tabpanel4.$set(tabpanel4_changes); @@ -21686,6 +23411,10 @@ const _DOMParser = DOMParser; $$invalidate(3, news = await res.json()); }; function appendBooru() { + if (false) { + request(newbooru.domain); + alert("Requested! Please click the PEE icon to validate"); + } set_store_value(settings, $settings.rsources = [...$settings.rsources, newbooru], $settings); dial.toggle(); $$invalidate(1, newbooru = {}); @@ -21741,34 +23470,38 @@ const _DOMParser = DOMParser; const select_handler = () => updateThreads(); const select_handler_1 = () => updateNews(); function input0_change_handler() { + $settings.jpeg = this.checked; + settings.set($settings); + } + function input1_change_handler() { $cached = this.checked; cached.set($cached); } - function input1_change_handler() { + function input2_change_handler() { $settings.dvc = this.checked; settings.set($settings); } - function input2_change_handler() { + function input3_change_handler() { $settings.vercheck = this.checked; settings.set($settings); } - function input3_change_handler() { + function input4_change_handler() { $settings.xpi = this.checked; settings.set($settings); } - function input4_change_handler() { + function input5_change_handler() { $settings.xpv = this.checked; settings.set($settings); } - function input5_change_handler() { + function input6_change_handler() { $settings.loop = this.checked; settings.set($settings); } - function input6_change_handler() { + function input7_change_handler() { $settings.dh = this.checked; settings.set($settings); } - function input7_change_handler() { + function input8_change_handler() { $settings.eye = this.checked; settings.set($settings); } @@ -21776,31 +23509,31 @@ const _DOMParser = DOMParser; $settings.ho = this.checked; settings.set($settings); } - function input8_change_handler() { + function input9_change_handler() { $settings.pre = this.checked; settings.set($settings); } - function input9_change_handler() { + function input10_change_handler() { $settings.prev = this.checked; settings.set($settings); } - function input10_change_handler() { + function input11_change_handler() { $settings.hotlink = this.checked; settings.set($settings); } - function input11_change_handler() { + function input12_change_handler() { $settings.ca = this.checked; settings.set($settings); } - function input12_change_handler() { + function input13_change_handler() { $settings.sh = this.checked; settings.set($settings); } - function input13_change_handler() { + function input14_change_handler() { $settings.ep = this.checked; settings.set($settings); } - function input14_change_handler() { + function input15_change_handler() { $settings.hyd = this.checked; settings.set($settings); } @@ -21909,14 +23642,15 @@ const _DOMParser = DOMParser; input5_change_handler, input6_change_handler, input7_change_handler, - input_change_handler, input8_change_handler, + input_change_handler, input9_change_handler, input10_change_handler, input11_change_handler, input12_change_handler, input13_change_handler, input14_change_handler, + input15_change_handler, input_input_handler, input0_input_handler, input1_input_handler, @@ -23259,8 +24993,8 @@ const _DOMParser = DOMParser; const get_key = (ctx2) => ctx2[4].id; for (let i = 0; i < each_value.length; i += 1) { let child_ctx = get_each_context6(ctx, each_value, i); - let key = get_key(child_ctx); - each_1_lookup.set(key, each_blocks[i] = create_each_block6(key, child_ctx)); + let key2 = get_key(child_ctx); + each_1_lookup.set(key2, each_blocks[i] = create_each_block6(key2, child_ctx)); } return { c() { @@ -23804,8 +25538,8 @@ const _DOMParser = DOMParser; check: function check(token) { return this.get("validate", token.toString(), token); }, - get: function get(key, operator, token) { - var option = this[key]; + get: function get(key2, operator, token) { + var option = this[key2]; if (!option) { return option; } @@ -23814,13 +25548,13 @@ const _DOMParser = DOMParser; case "function": return option(operator, token.t); case "object": - optionValue = token.t in option ? option[token.t] : defaults[key]; + optionValue = token.t in option ? option[token.t] : defaults[key2]; return typeof optionValue === "function" ? optionValue(operator, token.t) : optionValue; } return option; }, - getObject: function getObject(key, operator, token) { - var option = this[key]; + getObject: function getObject(key2, operator, token) { + var option = this[key2]; return typeof option === "function" ? option(operator, token.t) : option; } }; @@ -24614,8 +26348,10 @@ const _DOMParser = DOMParser; var ViewCount_default = ViewCount; // src/main.ts + if (!supportedMainDomain(location.host) && !supportedAltDomain(location.host)) + throw "PEE not supported here, skipping"; var qp; - var csettings5 = initial_settings; + var csettings6 = initial_settings; var processors = [thirdeye_default, pomf_default, pngv3_default, jpg_default, webm_default, gif_default]; var cappState; settings.subscribe(async (b) => { @@ -24635,9 +26371,9 @@ const _DOMParser = DOMParser; } } } - csettings5 = b; + csettings6 = b; processors = [ - ...!csettings5.te ? [thirdeye_default] : [], + ...!csettings6.te ? [thirdeye_default] : [], pngv3_default, pomf_default, jpg_default, @@ -24677,12 +26413,16 @@ const _DOMParser = DOMParser; } else { chunk = { done: false, value }; cumul = import_buffer11.Buffer.concat([cumul, value]); - found = await proc.has_embed(cumul); + const v = await proc.has_embed(cumul); + if (typeof v == "string") { + return [await proc.extract(cumul, v), false]; + } + found = v; } } while (found !== false && !chunk.done); succ = true; await iter.next(true); - if (found === false) { + if (found !== true) { return; } return [await proc.extract(cumul), false]; @@ -24695,7 +26435,7 @@ const _DOMParser = DOMParser; var textToElement = (s) => document.createRange().createContextualFragment(s).children[0]; var pendingPosts = []; var signalNewEmbeds = debounce(async () => { - if (!csettings5.tm) + if (!csettings6.tm) return; try { const boardname = location.pathname.match(/\/([^/]*)\//)[1]; @@ -24717,7 +26457,7 @@ const _DOMParser = DOMParser; var shouldUseCache = () => { if (cappState.isCatalog) return false; - return typeof csettings5.cache == "boolean" ? csettings5.cache : location.hostname.includes("b4k"); + return typeof csettings6.cache == "boolean" ? csettings6.cache : location.hostname.includes("b4k"); }; var processPost = async (post) => { const origlink = qp.getImageLink(post); @@ -24728,7 +26468,7 @@ const _DOMParser = DOMParser; return; let res2 = void 0; const reportEmbed = () => { - if (csettings5.tm) { + if (csettings6.tm) { if (["boards.4chan.org", "boards.4channel.org"].includes(location.host)) { if (!cappState.isCatalog) { const op = +location.pathname.match(/\/thread\/(.*)/)[1]; @@ -24775,7 +26515,7 @@ const _DOMParser = DOMParser; navigator.clipboard.writeText(text3); } var scrapeBoard = async (self) => { - if (csettings5.tm) { + if (csettings6.tm) { fireNotification("success", "Scrapping board with telemetry on! Thank you for your service, selfless stranger ;_;7"); } self.disabled = true; @@ -24815,7 +26555,11 @@ const _DOMParser = DOMParser; } else { chunk = { done: false, value }; cumul = import_buffer11.Buffer.concat([cumul, value]); - found = await proc.has_embed(cumul); + const v = await proc.has_embed(cumul); + if (typeof v == "string") { + return true; + } + found = v; } } while (found !== false && !chunk.done); await iter.next(true); @@ -24865,14 +26609,21 @@ const _DOMParser = DOMParser; var __DOMParser = true ? _DOMParser : DOMParser; var gmo; var earlystartup = async () => { - if (location.host == "arch.b4k.co" && true) { + if (["arch.b4k.co", "desuarchive.org"].includes(location.host) && true) { if (!GM_getValue("warning_seen2", false)) { - alert(`Due to b4k's policies being mean, PEE will get you banned, so the userscript version is disabled here`); - alert("Use the WebExtension version of PEE if you want to use b4k!"); + alert(`Due to b4k and desuarchive policies being mean, PEE will get you banned, so the userscript version is disabled here +Use the WebExtension version of PEE if you want to use b4k!`); GM_setValue("warning_seen2", true); return false; } } + if (["arch.b4k.co", "desuarchive.org"].includes(location.host) && false) { + if (!Platform5.getValue("warning_seen3", false)) { + alert('Due to b4k and desuarchive policies being mean, PEE cannot display content properly here. A "PEE companion" extension will be released as including that functionnallity in PEE lengthens ChromeWebStore review delays, please understando.'); + Platform5.setValue("warning_seen3", true); + return false; + } + } return true; }; var init4 = false; @@ -24892,7 +26643,7 @@ const _DOMParser = DOMParser; return; else qp = lqp; - if (csettings5.vercheck) + if (csettings6.vercheck) versionCheck(); const postQuote = ({ scanner, parser, utils }) => { const { CLOSEANGLEBRACKET: CLOSEANGLEBRACKET2, NUM: NUM2 } = scanner.tokens; diff --git a/package-lock.json b/package-lock.json index 89456cf..6973013 100644 --- a/package-lock.json +++ b/package-lock.json @@ -13,6 +13,7 @@ "buffer": "^6.0.3", "crc-32": "^1.2.0", "events": "^3.3.0", + "f5stegojs": "^0.1.2", "file-type": "^17.0.2", "hls.js": "^1.1.5", "image-hash": "^5.0.1", @@ -4144,6 +4145,19 @@ "node >=0.6.0" ] }, + "node_modules/f5stegojs": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/f5stegojs/-/f5stegojs-0.1.2.tgz", + "integrity": "sha512-aOLoD2U9yENaq7ripE0PTrAcyYml5IYr1Kuf5k5rW33xhVKAFbQiFx3kRID7Te05vZoWYNbnjPuP8YrG01Fhug==", + "dependencies": { + "minimist": "^1.2.0" + }, + "bin": { + "f5stego": "bin/f5stego", + "stegodctdump": "bin/stegodctdump", + "stegodcthist": "bin/stegodcthist" + } + }, "node_modules/fast-deep-equal": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", @@ -6239,8 +6253,7 @@ "node_modules/minimist": { "version": "1.2.6", "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", - "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==", - "dev": true + "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==" }, "node_modules/minimist-options": { "version": "4.1.0", @@ -12262,6 +12275,14 @@ "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" }, + "f5stegojs": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/f5stegojs/-/f5stegojs-0.1.2.tgz", + "integrity": "sha512-aOLoD2U9yENaq7ripE0PTrAcyYml5IYr1Kuf5k5rW33xhVKAFbQiFx3kRID7Te05vZoWYNbnjPuP8YrG01Fhug==", + "requires": { + "minimist": "^1.2.0" + } + }, "fast-deep-equal": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", @@ -13879,8 +13900,7 @@ "minimist": { "version": "1.2.6", "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", - "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==", - "dev": true + "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==" }, "minimist-options": { "version": "4.1.0", diff --git a/package.json b/package.json index 6f8000d..7155168 100644 --- a/package.json +++ b/package.json @@ -19,6 +19,7 @@ "buffer": "^6.0.3", "crc-32": "^1.2.0", "events": "^3.3.0", + "f5stegojs": "^0.1.2", "file-type": "^17.0.2", "hls.js": "^1.1.5", "image-hash": "^5.0.1", diff --git a/src/Components/App.svelte b/src/Components/App.svelte index b615225..17a3ef9 100644 --- a/src/Components/App.svelte +++ b/src/Components/App.svelte @@ -123,6 +123,14 @@ {/if} +