You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
22600 lines
1.1 MiB
22600 lines
1.1 MiB
// ==UserScript==
|
|
// @name PNGExtraEmbed
|
|
// @namespace https://coom.tech/
|
|
// @version 0.361
|
|
// @description uhh
|
|
// @author You
|
|
// @match https://boards.4channel.org/*
|
|
// @match https://boards.4chan.org/*
|
|
// @match https://desuarchive.org/*
|
|
// @match https://archived.moe/*
|
|
// @match https://archive.nyafuu.org/*
|
|
// @match https://arch.b4k.co/*
|
|
// @match https://archive.wakarimasen.moe/*
|
|
// @match https://fireden.net/*
|
|
// @match https://thebarchive.com/*
|
|
// @match https://archiveofsins.com/*
|
|
// @require https://unpkg.com/web-streams-polyfill/dist/polyfill.min.js
|
|
// @grant GM_xmlhttpRequest
|
|
// @grant GM.xmlHttpRequest
|
|
// @grant GM_getValue
|
|
// @grant GM.getValue
|
|
// @grant GM_setValue
|
|
// @grant GM.setValue
|
|
// @grant GM_openInTab
|
|
// @grant GM.openInTab
|
|
// @grant GM_addElement
|
|
// @grant unsafeWindow
|
|
// @run-at document-start
|
|
// @connect 4chan.org
|
|
// @connect 4channel.org
|
|
// @connect i.4cdn.org
|
|
// @connect *
|
|
// @icon https://coom.tech/resources/assets/1449696017588.png
|
|
// ==/UserScript==
|
|
const _DOMParser = DOMParser;
|
|
|
|
"use strict";
|
|
(() => {
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
|
|
var __esm = (fn, res) => function __init() {
|
|
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
|
|
};
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
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, 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, key2, result) : decorator(result)) || result;
|
|
if (kind && result)
|
|
__defProp(target, key2, result);
|
|
return result;
|
|
};
|
|
var __publicField = (obj, key2, value) => {
|
|
__defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
|
|
return value;
|
|
};
|
|
var __toBinary = /* @__PURE__ */ (() => {
|
|
var table = new Uint8Array(128);
|
|
for (var i = 0; i < 64; i++)
|
|
table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;
|
|
return (base64) => {
|
|
var n = base64.length, bytes = new Uint8Array((n - (base64[n - 1] == "=") - (base64[n - 2] == "=")) * 3 / 4 | 0);
|
|
for (var i2 = 0, j = 0; i2 < n; ) {
|
|
var c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)];
|
|
var c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)];
|
|
bytes[j++] = c0 << 2 | c1 >> 4;
|
|
bytes[j++] = c1 << 4 | c2 >> 2;
|
|
bytes[j++] = c2 << 6 | c3;
|
|
}
|
|
return bytes;
|
|
};
|
|
})();
|
|
|
|
// <define:BUILD_VERSION>
|
|
var define_BUILD_VERSION_default;
|
|
var init_define_BUILD_VERSION = __esm({
|
|
"<define:BUILD_VERSION>"() {
|
|
define_BUILD_VERSION_default = [0, 361];
|
|
}
|
|
});
|
|
|
|
// node_modules/base64-js/index.js
|
|
var require_base64_js = __commonJS({
|
|
"node_modules/base64-js/index.js"(exports) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
exports.byteLength = byteLength;
|
|
exports.toByteArray = toByteArray;
|
|
exports.fromByteArray = fromByteArray;
|
|
var lookup = [];
|
|
var revLookup = [];
|
|
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
|
|
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
for (i = 0, len = code.length; i < len; ++i) {
|
|
lookup[i] = code[i];
|
|
revLookup[code.charCodeAt(i)] = i;
|
|
}
|
|
var i;
|
|
var len;
|
|
revLookup["-".charCodeAt(0)] = 62;
|
|
revLookup["_".charCodeAt(0)] = 63;
|
|
function getLens(b64) {
|
|
var len2 = b64.length;
|
|
if (len2 % 4 > 0) {
|
|
throw new Error("Invalid string. Length must be a multiple of 4");
|
|
}
|
|
var validLen = b64.indexOf("=");
|
|
if (validLen === -1)
|
|
validLen = len2;
|
|
var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
|
|
return [validLen, placeHoldersLen];
|
|
}
|
|
function byteLength(b64) {
|
|
var lens = getLens(b64);
|
|
var validLen = lens[0];
|
|
var placeHoldersLen = lens[1];
|
|
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
|
|
}
|
|
function _byteLength(b64, validLen, placeHoldersLen) {
|
|
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
|
|
}
|
|
function toByteArray(b64) {
|
|
var tmp;
|
|
var lens = getLens(b64);
|
|
var validLen = lens[0];
|
|
var placeHoldersLen = lens[1];
|
|
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
|
|
var curByte = 0;
|
|
var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
|
|
var i2;
|
|
for (i2 = 0; i2 < len2; i2 += 4) {
|
|
tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
|
|
arr[curByte++] = tmp >> 16 & 255;
|
|
arr[curByte++] = tmp >> 8 & 255;
|
|
arr[curByte++] = tmp & 255;
|
|
}
|
|
if (placeHoldersLen === 2) {
|
|
tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
|
|
arr[curByte++] = tmp & 255;
|
|
}
|
|
if (placeHoldersLen === 1) {
|
|
tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
|
|
arr[curByte++] = tmp >> 8 & 255;
|
|
arr[curByte++] = tmp & 255;
|
|
}
|
|
return arr;
|
|
}
|
|
function tripletToBase64(num) {
|
|
return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
|
|
}
|
|
function encodeChunk(uint8, start, end) {
|
|
var tmp;
|
|
var output = [];
|
|
for (var i2 = start; i2 < end; i2 += 3) {
|
|
tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
|
|
output.push(tripletToBase64(tmp));
|
|
}
|
|
return output.join("");
|
|
}
|
|
function fromByteArray(uint8) {
|
|
var tmp;
|
|
var len2 = uint8.length;
|
|
var extraBytes = len2 % 3;
|
|
var parts = [];
|
|
var maxChunkLength = 16383;
|
|
for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
|
|
parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
|
|
}
|
|
if (extraBytes === 1) {
|
|
tmp = uint8[len2 - 1];
|
|
parts.push(
|
|
lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
|
|
);
|
|
} else if (extraBytes === 2) {
|
|
tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
|
|
parts.push(
|
|
lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
|
|
);
|
|
}
|
|
return parts.join("");
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/ieee754/index.js
|
|
var require_ieee754 = __commonJS({
|
|
"node_modules/ieee754/index.js"(exports) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
exports.read = function(buffer, offset, isLE, mLen, nBytes) {
|
|
var e, m;
|
|
var eLen = nBytes * 8 - mLen - 1;
|
|
var eMax = (1 << eLen) - 1;
|
|
var eBias = eMax >> 1;
|
|
var nBits = -7;
|
|
var i = isLE ? nBytes - 1 : 0;
|
|
var d = isLE ? -1 : 1;
|
|
var s = buffer[offset + i];
|
|
i += d;
|
|
e = s & (1 << -nBits) - 1;
|
|
s >>= -nBits;
|
|
nBits += eLen;
|
|
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
|
|
}
|
|
m = e & (1 << -nBits) - 1;
|
|
e >>= -nBits;
|
|
nBits += mLen;
|
|
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
|
|
}
|
|
if (e === 0) {
|
|
e = 1 - eBias;
|
|
} else if (e === eMax) {
|
|
return m ? NaN : (s ? -1 : 1) * Infinity;
|
|
} else {
|
|
m = m + Math.pow(2, mLen);
|
|
e = e - eBias;
|
|
}
|
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
|
|
};
|
|
exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
|
|
var e, m, c;
|
|
var eLen = nBytes * 8 - mLen - 1;
|
|
var eMax = (1 << eLen) - 1;
|
|
var eBias = eMax >> 1;
|
|
var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
|
|
var i = isLE ? 0 : nBytes - 1;
|
|
var d = isLE ? 1 : -1;
|
|
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
|
|
value = Math.abs(value);
|
|
if (isNaN(value) || value === Infinity) {
|
|
m = isNaN(value) ? 1 : 0;
|
|
e = eMax;
|
|
} else {
|
|
e = Math.floor(Math.log(value) / Math.LN2);
|
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
|
e--;
|
|
c *= 2;
|
|
}
|
|
if (e + eBias >= 1) {
|
|
value += rt / c;
|
|
} else {
|
|
value += rt * Math.pow(2, 1 - eBias);
|
|
}
|
|
if (value * c >= 2) {
|
|
e++;
|
|
c /= 2;
|
|
}
|
|
if (e + eBias >= eMax) {
|
|
m = 0;
|
|
e = eMax;
|
|
} else if (e + eBias >= 1) {
|
|
m = (value * c - 1) * Math.pow(2, mLen);
|
|
e = e + eBias;
|
|
} else {
|
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
|
e = 0;
|
|
}
|
|
}
|
|
for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
|
|
}
|
|
e = e << mLen | m;
|
|
eLen += mLen;
|
|
for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
|
|
}
|
|
buffer[offset + i - d] |= s * 128;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/buffer/index.js
|
|
var require_buffer = __commonJS({
|
|
"node_modules/buffer/index.js"(exports) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var base64 = require_base64_js();
|
|
var ieee7542 = require_ieee754();
|
|
var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
|
|
exports.Buffer = Buffer14;
|
|
exports.SlowBuffer = SlowBuffer;
|
|
exports.INSPECT_MAX_BYTES = 50;
|
|
var K_MAX_LENGTH = 2147483647;
|
|
exports.kMaxLength = K_MAX_LENGTH;
|
|
Buffer14.TYPED_ARRAY_SUPPORT = typedArraySupport();
|
|
if (!Buffer14.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
|
|
console.error(
|
|
"This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
|
|
);
|
|
}
|
|
function typedArraySupport() {
|
|
try {
|
|
const arr = new Uint8Array(1);
|
|
const proto = { foo: function() {
|
|
return 42;
|
|
} };
|
|
Object.setPrototypeOf(proto, Uint8Array.prototype);
|
|
Object.setPrototypeOf(arr, proto);
|
|
return arr.foo() === 42;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
Object.defineProperty(Buffer14.prototype, "parent", {
|
|
enumerable: true,
|
|
get: function() {
|
|
if (!Buffer14.isBuffer(this))
|
|
return void 0;
|
|
return this.buffer;
|
|
}
|
|
});
|
|
Object.defineProperty(Buffer14.prototype, "offset", {
|
|
enumerable: true,
|
|
get: function() {
|
|
if (!Buffer14.isBuffer(this))
|
|
return void 0;
|
|
return this.byteOffset;
|
|
}
|
|
});
|
|
function createBuffer(length) {
|
|
if (length > K_MAX_LENGTH) {
|
|
throw new RangeError('The value "' + length + '" is invalid for option "size"');
|
|
}
|
|
const buf2 = new Uint8Array(length);
|
|
Object.setPrototypeOf(buf2, Buffer14.prototype);
|
|
return buf2;
|
|
}
|
|
function Buffer14(arg, encodingOrOffset, length) {
|
|
if (typeof arg === "number") {
|
|
if (typeof encodingOrOffset === "string") {
|
|
throw new TypeError(
|
|
'The "string" argument must be of type string. Received type number'
|
|
);
|
|
}
|
|
return allocUnsafe(arg);
|
|
}
|
|
return from(arg, encodingOrOffset, length);
|
|
}
|
|
Buffer14.poolSize = 8192;
|
|
function from(value, encodingOrOffset, length) {
|
|
if (typeof value === "string") {
|
|
return fromString(value, encodingOrOffset);
|
|
}
|
|
if (ArrayBuffer.isView(value)) {
|
|
return fromArrayView(value);
|
|
}
|
|
if (value == null) {
|
|
throw new TypeError(
|
|
"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
|
|
);
|
|
}
|
|
if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
|
|
return fromArrayBuffer(value, encodingOrOffset, length);
|
|
}
|
|
if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
|
|
return fromArrayBuffer(value, encodingOrOffset, length);
|
|
}
|
|
if (typeof value === "number") {
|
|
throw new TypeError(
|
|
'The "value" argument must not be of type number. Received type number'
|
|
);
|
|
}
|
|
const valueOf = value.valueOf && value.valueOf();
|
|
if (valueOf != null && valueOf !== value) {
|
|
return Buffer14.from(valueOf, encodingOrOffset, length);
|
|
}
|
|
const b = fromObject(value);
|
|
if (b)
|
|
return b;
|
|
if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
|
|
return Buffer14.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
|
|
}
|
|
throw new TypeError(
|
|
"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
|
|
);
|
|
}
|
|
Buffer14.from = function(value, encodingOrOffset, length) {
|
|
return from(value, encodingOrOffset, length);
|
|
};
|
|
Object.setPrototypeOf(Buffer14.prototype, Uint8Array.prototype);
|
|
Object.setPrototypeOf(Buffer14, Uint8Array);
|
|
function assertSize(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError('"size" argument must be of type number');
|
|
} else if (size < 0) {
|
|
throw new RangeError('The value "' + size + '" is invalid for option "size"');
|
|
}
|
|
}
|
|
function alloc(size, fill, encoding) {
|
|
assertSize(size);
|
|
if (size <= 0) {
|
|
return createBuffer(size);
|
|
}
|
|
if (fill !== void 0) {
|
|
return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
|
|
}
|
|
return createBuffer(size);
|
|
}
|
|
Buffer14.alloc = function(size, fill, encoding) {
|
|
return alloc(size, fill, encoding);
|
|
};
|
|
function allocUnsafe(size) {
|
|
assertSize(size);
|
|
return createBuffer(size < 0 ? 0 : checked(size) | 0);
|
|
}
|
|
Buffer14.allocUnsafe = function(size) {
|
|
return allocUnsafe(size);
|
|
};
|
|
Buffer14.allocUnsafeSlow = function(size) {
|
|
return allocUnsafe(size);
|
|
};
|
|
function fromString(string, encoding) {
|
|
if (typeof encoding !== "string" || encoding === "") {
|
|
encoding = "utf8";
|
|
}
|
|
if (!Buffer14.isEncoding(encoding)) {
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
}
|
|
const length = byteLength(string, encoding) | 0;
|
|
let buf2 = createBuffer(length);
|
|
const actual = buf2.write(string, encoding);
|
|
if (actual !== length) {
|
|
buf2 = buf2.slice(0, actual);
|
|
}
|
|
return buf2;
|
|
}
|
|
function fromArrayLike(array) {
|
|
const length = array.length < 0 ? 0 : checked(array.length) | 0;
|
|
const buf2 = createBuffer(length);
|
|
for (let i = 0; i < length; i += 1) {
|
|
buf2[i] = array[i] & 255;
|
|
}
|
|
return buf2;
|
|
}
|
|
function fromArrayView(arrayView) {
|
|
if (isInstance(arrayView, Uint8Array)) {
|
|
const copy = new Uint8Array(arrayView);
|
|
return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
|
|
}
|
|
return fromArrayLike(arrayView);
|
|
}
|
|
function fromArrayBuffer(array, byteOffset, length) {
|
|
if (byteOffset < 0 || array.byteLength < byteOffset) {
|
|
throw new RangeError('"offset" is outside of buffer bounds');
|
|
}
|
|
if (array.byteLength < byteOffset + (length || 0)) {
|
|
throw new RangeError('"length" is outside of buffer bounds');
|
|
}
|
|
let buf2;
|
|
if (byteOffset === void 0 && length === void 0) {
|
|
buf2 = new Uint8Array(array);
|
|
} else if (length === void 0) {
|
|
buf2 = new Uint8Array(array, byteOffset);
|
|
} else {
|
|
buf2 = new Uint8Array(array, byteOffset, length);
|
|
}
|
|
Object.setPrototypeOf(buf2, Buffer14.prototype);
|
|
return buf2;
|
|
}
|
|
function fromObject(obj) {
|
|
if (Buffer14.isBuffer(obj)) {
|
|
const len = checked(obj.length) | 0;
|
|
const buf2 = createBuffer(len);
|
|
if (buf2.length === 0) {
|
|
return buf2;
|
|
}
|
|
obj.copy(buf2, 0, 0, len);
|
|
return buf2;
|
|
}
|
|
if (obj.length !== void 0) {
|
|
if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
|
|
return createBuffer(0);
|
|
}
|
|
return fromArrayLike(obj);
|
|
}
|
|
if (obj.type === "Buffer" && Array.isArray(obj.data)) {
|
|
return fromArrayLike(obj.data);
|
|
}
|
|
}
|
|
function checked(length) {
|
|
if (length >= K_MAX_LENGTH) {
|
|
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
|
|
}
|
|
return length | 0;
|
|
}
|
|
function SlowBuffer(length) {
|
|
if (+length != length) {
|
|
length = 0;
|
|
}
|
|
return Buffer14.alloc(+length);
|
|
}
|
|
Buffer14.isBuffer = function isBuffer(b) {
|
|
return b != null && b._isBuffer === true && b !== Buffer14.prototype;
|
|
};
|
|
Buffer14.compare = function compare(a, b) {
|
|
if (isInstance(a, Uint8Array))
|
|
a = Buffer14.from(a, a.offset, a.byteLength);
|
|
if (isInstance(b, Uint8Array))
|
|
b = Buffer14.from(b, b.offset, b.byteLength);
|
|
if (!Buffer14.isBuffer(a) || !Buffer14.isBuffer(b)) {
|
|
throw new TypeError(
|
|
'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
|
|
);
|
|
}
|
|
if (a === b)
|
|
return 0;
|
|
let x = a.length;
|
|
let y = b.length;
|
|
for (let i = 0, len = Math.min(x, y); i < len; ++i) {
|
|
if (a[i] !== b[i]) {
|
|
x = a[i];
|
|
y = b[i];
|
|
break;
|
|
}
|
|
}
|
|
if (x < y)
|
|
return -1;
|
|
if (y < x)
|
|
return 1;
|
|
return 0;
|
|
};
|
|
Buffer14.isEncoding = function isEncoding(encoding) {
|
|
switch (String(encoding).toLowerCase()) {
|
|
case "hex":
|
|
case "utf8":
|
|
case "utf-8":
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
case "base64":
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
Buffer14.concat = function concat(list, length) {
|
|
if (!Array.isArray(list)) {
|
|
throw new TypeError('"list" argument must be an Array of Buffers');
|
|
}
|
|
if (list.length === 0) {
|
|
return Buffer14.alloc(0);
|
|
}
|
|
let i;
|
|
if (length === void 0) {
|
|
length = 0;
|
|
for (i = 0; i < list.length; ++i) {
|
|
length += list[i].length;
|
|
}
|
|
}
|
|
const buffer = Buffer14.allocUnsafe(length);
|
|
let pos = 0;
|
|
for (i = 0; i < list.length; ++i) {
|
|
let buf2 = list[i];
|
|
if (isInstance(buf2, Uint8Array)) {
|
|
if (pos + buf2.length > buffer.length) {
|
|
if (!Buffer14.isBuffer(buf2))
|
|
buf2 = Buffer14.from(buf2);
|
|
buf2.copy(buffer, pos);
|
|
} else {
|
|
Uint8Array.prototype.set.call(
|
|
buffer,
|
|
buf2,
|
|
pos
|
|
);
|
|
}
|
|
} else if (!Buffer14.isBuffer(buf2)) {
|
|
throw new TypeError('"list" argument must be an Array of Buffers');
|
|
} else {
|
|
buf2.copy(buffer, pos);
|
|
}
|
|
pos += buf2.length;
|
|
}
|
|
return buffer;
|
|
};
|
|
function byteLength(string, encoding) {
|
|
if (Buffer14.isBuffer(string)) {
|
|
return string.length;
|
|
}
|
|
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
|
|
return string.byteLength;
|
|
}
|
|
if (typeof string !== "string") {
|
|
throw new TypeError(
|
|
'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
|
|
);
|
|
}
|
|
const len = string.length;
|
|
const mustMatch = arguments.length > 2 && arguments[2] === true;
|
|
if (!mustMatch && len === 0)
|
|
return 0;
|
|
let loweredCase = false;
|
|
for (; ; ) {
|
|
switch (encoding) {
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
return len;
|
|
case "utf8":
|
|
case "utf-8":
|
|
return utf8ToBytes(string).length;
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return len * 2;
|
|
case "hex":
|
|
return len >>> 1;
|
|
case "base64":
|
|
return base64ToBytes(string).length;
|
|
default:
|
|
if (loweredCase) {
|
|
return mustMatch ? -1 : utf8ToBytes(string).length;
|
|
}
|
|
encoding = ("" + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
}
|
|
Buffer14.byteLength = byteLength;
|
|
function slowToString(encoding, start, end) {
|
|
let loweredCase = false;
|
|
if (start === void 0 || start < 0) {
|
|
start = 0;
|
|
}
|
|
if (start > this.length) {
|
|
return "";
|
|
}
|
|
if (end === void 0 || end > this.length) {
|
|
end = this.length;
|
|
}
|
|
if (end <= 0) {
|
|
return "";
|
|
}
|
|
end >>>= 0;
|
|
start >>>= 0;
|
|
if (end <= start) {
|
|
return "";
|
|
}
|
|
if (!encoding)
|
|
encoding = "utf8";
|
|
while (true) {
|
|
switch (encoding) {
|
|
case "hex":
|
|
return hexSlice(this, start, end);
|
|
case "utf8":
|
|
case "utf-8":
|
|
return utf8Slice(this, start, end);
|
|
case "ascii":
|
|
return asciiSlice(this, start, end);
|
|
case "latin1":
|
|
case "binary":
|
|
return latin1Slice(this, start, end);
|
|
case "base64":
|
|
return base64Slice(this, start, end);
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return utf16leSlice(this, start, end);
|
|
default:
|
|
if (loweredCase)
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
encoding = (encoding + "").toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
}
|
|
Buffer14.prototype._isBuffer = true;
|
|
function swap(b, n, m) {
|
|
const i = b[n];
|
|
b[n] = b[m];
|
|
b[m] = i;
|
|
}
|
|
Buffer14.prototype.swap16 = function swap16() {
|
|
const len = this.length;
|
|
if (len % 2 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 16-bits");
|
|
}
|
|
for (let i = 0; i < len; i += 2) {
|
|
swap(this, i, i + 1);
|
|
}
|
|
return this;
|
|
};
|
|
Buffer14.prototype.swap32 = function swap32() {
|
|
const len = this.length;
|
|
if (len % 4 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 32-bits");
|
|
}
|
|
for (let i = 0; i < len; i += 4) {
|
|
swap(this, i, i + 3);
|
|
swap(this, i + 1, i + 2);
|
|
}
|
|
return this;
|
|
};
|
|
Buffer14.prototype.swap64 = function swap64() {
|
|
const len = this.length;
|
|
if (len % 8 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 64-bits");
|
|
}
|
|
for (let i = 0; i < len; i += 8) {
|
|
swap(this, i, i + 7);
|
|
swap(this, i + 1, i + 6);
|
|
swap(this, i + 2, i + 5);
|
|
swap(this, i + 3, i + 4);
|
|
}
|
|
return this;
|
|
};
|
|
Buffer14.prototype.toString = function toString2() {
|
|
const length = this.length;
|
|
if (length === 0)
|
|
return "";
|
|
if (arguments.length === 0)
|
|
return utf8Slice(this, 0, length);
|
|
return slowToString.apply(this, arguments);
|
|
};
|
|
Buffer14.prototype.toLocaleString = Buffer14.prototype.toString;
|
|
Buffer14.prototype.equals = function equals(b) {
|
|
if (!Buffer14.isBuffer(b))
|
|
throw new TypeError("Argument must be a Buffer");
|
|
if (this === b)
|
|
return true;
|
|
return Buffer14.compare(this, b) === 0;
|
|
};
|
|
Buffer14.prototype.inspect = function inspect() {
|
|
let str = "";
|
|
const max = exports.INSPECT_MAX_BYTES;
|
|
str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
|
|
if (this.length > max)
|
|
str += " ... ";
|
|
return "<Buffer " + str + ">";
|
|
};
|
|
if (customInspectSymbol) {
|
|
Buffer14.prototype[customInspectSymbol] = Buffer14.prototype.inspect;
|
|
}
|
|
Buffer14.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
|
|
if (isInstance(target, Uint8Array)) {
|
|
target = Buffer14.from(target, target.offset, target.byteLength);
|
|
}
|
|
if (!Buffer14.isBuffer(target)) {
|
|
throw new TypeError(
|
|
'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
|
|
);
|
|
}
|
|
if (start === void 0) {
|
|
start = 0;
|
|
}
|
|
if (end === void 0) {
|
|
end = target ? target.length : 0;
|
|
}
|
|
if (thisStart === void 0) {
|
|
thisStart = 0;
|
|
}
|
|
if (thisEnd === void 0) {
|
|
thisEnd = this.length;
|
|
}
|
|
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
|
|
throw new RangeError("out of range index");
|
|
}
|
|
if (thisStart >= thisEnd && start >= end) {
|
|
return 0;
|
|
}
|
|
if (thisStart >= thisEnd) {
|
|
return -1;
|
|
}
|
|
if (start >= end) {
|
|
return 1;
|
|
}
|
|
start >>>= 0;
|
|
end >>>= 0;
|
|
thisStart >>>= 0;
|
|
thisEnd >>>= 0;
|
|
if (this === target)
|
|
return 0;
|
|
let x = thisEnd - thisStart;
|
|
let y = end - start;
|
|
const len = Math.min(x, y);
|
|
const thisCopy = this.slice(thisStart, thisEnd);
|
|
const targetCopy = target.slice(start, end);
|
|
for (let i = 0; i < len; ++i) {
|
|
if (thisCopy[i] !== targetCopy[i]) {
|
|
x = thisCopy[i];
|
|
y = targetCopy[i];
|
|
break;
|
|
}
|
|
}
|
|
if (x < y)
|
|
return -1;
|
|
if (y < x)
|
|
return 1;
|
|
return 0;
|
|
};
|
|
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
|
|
if (buffer.length === 0)
|
|
return -1;
|
|
if (typeof byteOffset === "string") {
|
|
encoding = byteOffset;
|
|
byteOffset = 0;
|
|
} else if (byteOffset > 2147483647) {
|
|
byteOffset = 2147483647;
|
|
} else if (byteOffset < -2147483648) {
|
|
byteOffset = -2147483648;
|
|
}
|
|
byteOffset = +byteOffset;
|
|
if (numberIsNaN(byteOffset)) {
|
|
byteOffset = dir ? 0 : buffer.length - 1;
|
|
}
|
|
if (byteOffset < 0)
|
|
byteOffset = buffer.length + byteOffset;
|
|
if (byteOffset >= buffer.length) {
|
|
if (dir)
|
|
return -1;
|
|
else
|
|
byteOffset = buffer.length - 1;
|
|
} else if (byteOffset < 0) {
|
|
if (dir)
|
|
byteOffset = 0;
|
|
else
|
|
return -1;
|
|
}
|
|
if (typeof val === "string") {
|
|
val = Buffer14.from(val, encoding);
|
|
}
|
|
if (Buffer14.isBuffer(val)) {
|
|
if (val.length === 0) {
|
|
return -1;
|
|
}
|
|
return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
|
|
} else if (typeof val === "number") {
|
|
val = val & 255;
|
|
if (typeof Uint8Array.prototype.indexOf === "function") {
|
|
if (dir) {
|
|
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
|
|
} else {
|
|
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
|
|
}
|
|
}
|
|
return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
|
|
}
|
|
throw new TypeError("val must be string, number or Buffer");
|
|
}
|
|
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
|
|
let indexSize = 1;
|
|
let arrLength = arr.length;
|
|
let valLength = val.length;
|
|
if (encoding !== void 0) {
|
|
encoding = String(encoding).toLowerCase();
|
|
if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
|
|
if (arr.length < 2 || val.length < 2) {
|
|
return -1;
|
|
}
|
|
indexSize = 2;
|
|
arrLength /= 2;
|
|
valLength /= 2;
|
|
byteOffset /= 2;
|
|
}
|
|
}
|
|
function read2(buf2, i2) {
|
|
if (indexSize === 1) {
|
|
return buf2[i2];
|
|
} else {
|
|
return buf2.readUInt16BE(i2 * indexSize);
|
|
}
|
|
}
|
|
let i;
|
|
if (dir) {
|
|
let foundIndex = -1;
|
|
for (i = byteOffset; i < arrLength; i++) {
|
|
if (read2(arr, i) === read2(val, foundIndex === -1 ? 0 : i - foundIndex)) {
|
|
if (foundIndex === -1)
|
|
foundIndex = i;
|
|
if (i - foundIndex + 1 === valLength)
|
|
return foundIndex * indexSize;
|
|
} else {
|
|
if (foundIndex !== -1)
|
|
i -= i - foundIndex;
|
|
foundIndex = -1;
|
|
}
|
|
}
|
|
} else {
|
|
if (byteOffset + valLength > arrLength)
|
|
byteOffset = arrLength - valLength;
|
|
for (i = byteOffset; i >= 0; i--) {
|
|
let found = true;
|
|
for (let j = 0; j < valLength; j++) {
|
|
if (read2(arr, i + j) !== read2(val, j)) {
|
|
found = false;
|
|
break;
|
|
}
|
|
}
|
|
if (found)
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
Buffer14.prototype.includes = function includes(val, byteOffset, encoding) {
|
|
return this.indexOf(val, byteOffset, encoding) !== -1;
|
|
};
|
|
Buffer14.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
|
|
};
|
|
Buffer14.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
|
|
};
|
|
function hexWrite(buf2, string, offset, length) {
|
|
offset = Number(offset) || 0;
|
|
const remaining = buf2.length - offset;
|
|
if (!length) {
|
|
length = remaining;
|
|
} else {
|
|
length = Number(length);
|
|
if (length > remaining) {
|
|
length = remaining;
|
|
}
|
|
}
|
|
const strLen = string.length;
|
|
if (length > strLen / 2) {
|
|
length = strLen / 2;
|
|
}
|
|
let i;
|
|
for (i = 0; i < length; ++i) {
|
|
const parsed = parseInt(string.substr(i * 2, 2), 16);
|
|
if (numberIsNaN(parsed))
|
|
return i;
|
|
buf2[offset + i] = parsed;
|
|
}
|
|
return i;
|
|
}
|
|
function utf8Write(buf2, string, offset, length) {
|
|
return blitBuffer(utf8ToBytes(string, buf2.length - offset), buf2, offset, length);
|
|
}
|
|
function asciiWrite(buf2, string, offset, length) {
|
|
return blitBuffer(asciiToBytes(string), buf2, offset, length);
|
|
}
|
|
function base64Write(buf2, string, offset, length) {
|
|
return blitBuffer(base64ToBytes(string), buf2, offset, length);
|
|
}
|
|
function ucs2Write(buf2, string, offset, length) {
|
|
return blitBuffer(utf16leToBytes(string, buf2.length - offset), buf2, offset, length);
|
|
}
|
|
Buffer14.prototype.write = function write2(string, offset, length, encoding) {
|
|
if (offset === void 0) {
|
|
encoding = "utf8";
|
|
length = this.length;
|
|
offset = 0;
|
|
} else if (length === void 0 && typeof offset === "string") {
|
|
encoding = offset;
|
|
length = this.length;
|
|
offset = 0;
|
|
} else if (isFinite(offset)) {
|
|
offset = offset >>> 0;
|
|
if (isFinite(length)) {
|
|
length = length >>> 0;
|
|
if (encoding === void 0)
|
|
encoding = "utf8";
|
|
} else {
|
|
encoding = length;
|
|
length = void 0;
|
|
}
|
|
} else {
|
|
throw new Error(
|
|
"Buffer.write(string, encoding, offset[, length]) is no longer supported"
|
|
);
|
|
}
|
|
const remaining = this.length - offset;
|
|
if (length === void 0 || length > remaining)
|
|
length = remaining;
|
|
if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
|
|
throw new RangeError("Attempt to write outside buffer bounds");
|
|
}
|
|
if (!encoding)
|
|
encoding = "utf8";
|
|
let loweredCase = false;
|
|
for (; ; ) {
|
|
switch (encoding) {
|
|
case "hex":
|
|
return hexWrite(this, string, offset, length);
|
|
case "utf8":
|
|
case "utf-8":
|
|
return utf8Write(this, string, offset, length);
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
return asciiWrite(this, string, offset, length);
|
|
case "base64":
|
|
return base64Write(this, string, offset, length);
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return ucs2Write(this, string, offset, length);
|
|
default:
|
|
if (loweredCase)
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
encoding = ("" + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
};
|
|
Buffer14.prototype.toJSON = function toJSON() {
|
|
return {
|
|
type: "Buffer",
|
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
|
};
|
|
};
|
|
function base64Slice(buf2, start, end) {
|
|
if (start === 0 && end === buf2.length) {
|
|
return base64.fromByteArray(buf2);
|
|
} else {
|
|
return base64.fromByteArray(buf2.slice(start, end));
|
|
}
|
|
}
|
|
function utf8Slice(buf2, start, end) {
|
|
end = Math.min(buf2.length, end);
|
|
const res = [];
|
|
let i = start;
|
|
while (i < end) {
|
|
const firstByte = buf2[i];
|
|
let codePoint = null;
|
|
let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
|
|
if (i + bytesPerSequence <= end) {
|
|
let secondByte, thirdByte, fourthByte, tempCodePoint;
|
|
switch (bytesPerSequence) {
|
|
case 1:
|
|
if (firstByte < 128) {
|
|
codePoint = firstByte;
|
|
}
|
|
break;
|
|
case 2:
|
|
secondByte = buf2[i + 1];
|
|
if ((secondByte & 192) === 128) {
|
|
tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
|
|
if (tempCodePoint > 127) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
secondByte = buf2[i + 1];
|
|
thirdByte = buf2[i + 2];
|
|
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
|
|
tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
|
|
if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
secondByte = buf2[i + 1];
|
|
thirdByte = buf2[i + 2];
|
|
fourthByte = buf2[i + 3];
|
|
if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
|
|
tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
|
|
if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (codePoint === null) {
|
|
codePoint = 65533;
|
|
bytesPerSequence = 1;
|
|
} else if (codePoint > 65535) {
|
|
codePoint -= 65536;
|
|
res.push(codePoint >>> 10 & 1023 | 55296);
|
|
codePoint = 56320 | codePoint & 1023;
|
|
}
|
|
res.push(codePoint);
|
|
i += bytesPerSequence;
|
|
}
|
|
return decodeCodePointsArray(res);
|
|
}
|
|
var MAX_ARGUMENTS_LENGTH = 4096;
|
|
function decodeCodePointsArray(codePoints) {
|
|
const len = codePoints.length;
|
|
if (len <= MAX_ARGUMENTS_LENGTH) {
|
|
return String.fromCharCode.apply(String, codePoints);
|
|
}
|
|
let res = "";
|
|
let i = 0;
|
|
while (i < len) {
|
|
res += String.fromCharCode.apply(
|
|
String,
|
|
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
|
|
);
|
|
}
|
|
return res;
|
|
}
|
|
function asciiSlice(buf2, start, end) {
|
|
let ret = "";
|
|
end = Math.min(buf2.length, end);
|
|
for (let i = start; i < end; ++i) {
|
|
ret += String.fromCharCode(buf2[i] & 127);
|
|
}
|
|
return ret;
|
|
}
|
|
function latin1Slice(buf2, start, end) {
|
|
let ret = "";
|
|
end = Math.min(buf2.length, end);
|
|
for (let i = start; i < end; ++i) {
|
|
ret += String.fromCharCode(buf2[i]);
|
|
}
|
|
return ret;
|
|
}
|
|
function hexSlice(buf2, start, end) {
|
|
const len = buf2.length;
|
|
if (!start || start < 0)
|
|
start = 0;
|
|
if (!end || end < 0 || end > len)
|
|
end = len;
|
|
let out = "";
|
|
for (let i = start; i < end; ++i) {
|
|
out += hexSliceLookupTable[buf2[i]];
|
|
}
|
|
return out;
|
|
}
|
|
function utf16leSlice(buf2, start, end) {
|
|
const bytes = buf2.slice(start, end);
|
|
let res = "";
|
|
for (let i = 0; i < bytes.length - 1; i += 2) {
|
|
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
|
|
}
|
|
return res;
|
|
}
|
|
Buffer14.prototype.slice = function slice(start, end) {
|
|
const len = this.length;
|
|
start = ~~start;
|
|
end = end === void 0 ? len : ~~end;
|
|
if (start < 0) {
|
|
start += len;
|
|
if (start < 0)
|
|
start = 0;
|
|
} else if (start > len) {
|
|
start = len;
|
|
}
|
|
if (end < 0) {
|
|
end += len;
|
|
if (end < 0)
|
|
end = 0;
|
|
} else if (end > len) {
|
|
end = len;
|
|
}
|
|
if (end < start)
|
|
end = start;
|
|
const newBuf = this.subarray(start, end);
|
|
Object.setPrototypeOf(newBuf, Buffer14.prototype);
|
|
return newBuf;
|
|
};
|
|
function checkOffset(offset, ext, length) {
|
|
if (offset % 1 !== 0 || offset < 0)
|
|
throw new RangeError("offset is not uint");
|
|
if (offset + ext > length)
|
|
throw new RangeError("Trying to access beyond buffer length");
|
|
}
|
|
Buffer14.prototype.readUintLE = Buffer14.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength2, this.length);
|
|
let val = this[offset];
|
|
let mul = 1;
|
|
let i = 0;
|
|
while (++i < byteLength2 && (mul *= 256)) {
|
|
val += this[offset + i] * mul;
|
|
}
|
|
return val;
|
|
};
|
|
Buffer14.prototype.readUintBE = Buffer14.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert) {
|
|
checkOffset(offset, byteLength2, this.length);
|
|
}
|
|
let val = this[offset + --byteLength2];
|
|
let mul = 1;
|
|
while (byteLength2 > 0 && (mul *= 256)) {
|
|
val += this[offset + --byteLength2] * mul;
|
|
}
|
|
return val;
|
|
};
|
|
Buffer14.prototype.readUint8 = Buffer14.prototype.readUInt8 = function readUInt8(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 1, this.length);
|
|
return this[offset];
|
|
};
|
|
Buffer14.prototype.readUint16LE = Buffer14.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
return this[offset] | this[offset + 1] << 8;
|
|
};
|
|
Buffer14.prototype.readUint16BE = Buffer14.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
return this[offset] << 8 | this[offset + 1];
|
|
};
|
|
Buffer14.prototype.readUint32LE = Buffer14.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
|
|
};
|
|
Buffer14.prototype.readUint32BE = Buffer14.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
|
|
};
|
|
Buffer14.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
|
|
offset = offset >>> 0;
|
|
validateNumber(offset, "offset");
|
|
const first = this[offset];
|
|
const last = this[offset + 7];
|
|
if (first === void 0 || last === void 0) {
|
|
boundsError(offset, this.length - 8);
|
|
}
|
|
const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
|
|
const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
|
|
return BigInt(lo) + (BigInt(hi) << BigInt(32));
|
|
});
|
|
Buffer14.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
|
|
offset = offset >>> 0;
|
|
validateNumber(offset, "offset");
|
|
const first = this[offset];
|
|
const last = this[offset + 7];
|
|
if (first === void 0 || last === void 0) {
|
|
boundsError(offset, this.length - 8);
|
|
}
|
|
const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
|
|
const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
|
|
return (BigInt(hi) << BigInt(32)) + BigInt(lo);
|
|
});
|
|
Buffer14.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength2, this.length);
|
|
let val = this[offset];
|
|
let mul = 1;
|
|
let i = 0;
|
|
while (++i < byteLength2 && (mul *= 256)) {
|
|
val += this[offset + i] * mul;
|
|
}
|
|
mul *= 128;
|
|
if (val >= mul)
|
|
val -= Math.pow(2, 8 * byteLength2);
|
|
return val;
|
|
};
|
|
Buffer14.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength2, this.length);
|
|
let i = byteLength2;
|
|
let mul = 1;
|
|
let val = this[offset + --i];
|
|
while (i > 0 && (mul *= 256)) {
|
|
val += this[offset + --i] * mul;
|
|
}
|
|
mul *= 128;
|
|
if (val >= mul)
|
|
val -= Math.pow(2, 8 * byteLength2);
|
|
return val;
|
|
};
|
|
Buffer14.prototype.readInt8 = function readInt8(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 1, this.length);
|
|
if (!(this[offset] & 128))
|
|
return this[offset];
|
|
return (255 - this[offset] + 1) * -1;
|
|
};
|
|
Buffer14.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
const val = this[offset] | this[offset + 1] << 8;
|
|
return val & 32768 ? val | 4294901760 : val;
|
|
};
|
|
Buffer14.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
const val = this[offset + 1] | this[offset] << 8;
|
|
return val & 32768 ? val | 4294901760 : val;
|
|
};
|
|
Buffer14.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
|
|
};
|
|
Buffer14.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
|
|
};
|
|
Buffer14.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
|
|
offset = offset >>> 0;
|
|
validateNumber(offset, "offset");
|
|
const first = this[offset];
|
|
const last = this[offset + 7];
|
|
if (first === void 0 || last === void 0) {
|
|
boundsError(offset, this.length - 8);
|
|
}
|
|
const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
|
|
return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
|
|
});
|
|
Buffer14.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
|
|
offset = offset >>> 0;
|
|
validateNumber(offset, "offset");
|
|
const first = this[offset];
|
|
const last = this[offset + 7];
|
|
if (first === void 0 || last === void 0) {
|
|
boundsError(offset, this.length - 8);
|
|
}
|
|
const val = (first << 24) + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
|
|
return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
|
|
});
|
|
Buffer14.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return ieee7542.read(this, offset, true, 23, 4);
|
|
};
|
|
Buffer14.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return ieee7542.read(this, offset, false, 23, 4);
|
|
};
|
|
Buffer14.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 8, this.length);
|
|
return ieee7542.read(this, offset, true, 52, 8);
|
|
};
|
|
Buffer14.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 8, this.length);
|
|
return ieee7542.read(this, offset, false, 52, 8);
|
|
};
|
|
function checkInt(buf2, value, offset, ext, max, min) {
|
|
if (!Buffer14.isBuffer(buf2))
|
|
throw new TypeError('"buffer" argument must be a Buffer instance');
|
|
if (value > max || value < min)
|
|
throw new RangeError('"value" argument is out of bounds');
|
|
if (offset + ext > buf2.length)
|
|
throw new RangeError("Index out of range");
|
|
}
|
|
Buffer14.prototype.writeUintLE = Buffer14.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert) {
|
|
const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
|
|
checkInt(this, value, offset, byteLength2, maxBytes, 0);
|
|
}
|
|
let mul = 1;
|
|
let i = 0;
|
|
this[offset] = value & 255;
|
|
while (++i < byteLength2 && (mul *= 256)) {
|
|
this[offset + i] = value / mul & 255;
|
|
}
|
|
return offset + byteLength2;
|
|
};
|
|
Buffer14.prototype.writeUintBE = Buffer14.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
byteLength2 = byteLength2 >>> 0;
|
|
if (!noAssert) {
|
|
const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
|
|
checkInt(this, value, offset, byteLength2, maxBytes, 0);
|
|
}
|
|
let i = byteLength2 - 1;
|
|
let mul = 1;
|
|
this[offset + i] = value & 255;
|
|
while (--i >= 0 && (mul *= 256)) {
|
|
this[offset + i] = value / mul & 255;
|
|
}
|
|
return offset + byteLength2;
|
|
};
|
|
Buffer14.prototype.writeUint8 = Buffer14.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 1, 255, 0);
|
|
this[offset] = value & 255;
|
|
return offset + 1;
|
|
};
|
|
Buffer14.prototype.writeUint16LE = Buffer14.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 65535, 0);
|
|
this[offset] = value & 255;
|
|
this[offset + 1] = value >>> 8;
|
|
return offset + 2;
|
|
};
|
|
Buffer14.prototype.writeUint16BE = Buffer14.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 65535, 0);
|
|
this[offset] = value >>> 8;
|
|
this[offset + 1] = value & 255;
|
|
return offset + 2;
|
|
};
|
|
Buffer14.prototype.writeUint32LE = Buffer14.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 4294967295, 0);
|
|
this[offset + 3] = value >>> 24;
|
|
this[offset + 2] = value >>> 16;
|
|
this[offset + 1] = value >>> 8;
|
|
this[offset] = value & 255;
|
|
return offset + 4;
|
|
};
|
|
Buffer14.prototype.writeUint32BE = Buffer14.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 4294967295, 0);
|
|
this[offset] = value >>> 24;
|
|
this[offset + 1] = value >>> 16;
|
|
this[offset + 2] = value >>> 8;
|
|
this[offset + 3] = value & 255;
|
|
return offset + 4;
|
|
};
|
|
function wrtBigUInt64LE(buf2, value, offset, min, max) {
|
|
checkIntBI(value, min, max, buf2, offset, 7);
|
|
let lo = Number(value & BigInt(4294967295));
|
|
buf2[offset++] = lo;
|
|
lo = lo >> 8;
|
|
buf2[offset++] = lo;
|
|
lo = lo >> 8;
|
|
buf2[offset++] = lo;
|
|
lo = lo >> 8;
|
|
buf2[offset++] = lo;
|
|
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
|
|
buf2[offset++] = hi;
|
|
hi = hi >> 8;
|
|
buf2[offset++] = hi;
|
|
hi = hi >> 8;
|
|
buf2[offset++] = hi;
|
|
hi = hi >> 8;
|
|
buf2[offset++] = hi;
|
|
return offset;
|
|
}
|
|
function wrtBigUInt64BE(buf2, value, offset, min, max) {
|
|
checkIntBI(value, min, max, buf2, offset, 7);
|
|
let lo = Number(value & BigInt(4294967295));
|
|
buf2[offset + 7] = lo;
|
|
lo = lo >> 8;
|
|
buf2[offset + 6] = lo;
|
|
lo = lo >> 8;
|
|
buf2[offset + 5] = lo;
|
|
lo = lo >> 8;
|
|
buf2[offset + 4] = lo;
|
|
let hi = Number(value >> BigInt(32) & BigInt(4294967295));
|
|
buf2[offset + 3] = hi;
|
|
hi = hi >> 8;
|
|
buf2[offset + 2] = hi;
|
|
hi = hi >> 8;
|
|
buf2[offset + 1] = hi;
|
|
hi = hi >> 8;
|
|
buf2[offset] = hi;
|
|
return offset + 8;
|
|
}
|
|
Buffer14.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
|
|
return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
|
|
});
|
|
Buffer14.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
|
|
return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
|
|
});
|
|
Buffer14.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
const limit = Math.pow(2, 8 * byteLength2 - 1);
|
|
checkInt(this, value, offset, byteLength2, limit - 1, -limit);
|
|
}
|
|
let i = 0;
|
|
let mul = 1;
|
|
let sub = 0;
|
|
this[offset] = value & 255;
|
|
while (++i < byteLength2 && (mul *= 256)) {
|
|
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
|
|
sub = 1;
|
|
}
|
|
this[offset + i] = (value / mul >> 0) - sub & 255;
|
|
}
|
|
return offset + byteLength2;
|
|
};
|
|
Buffer14.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
const limit = Math.pow(2, 8 * byteLength2 - 1);
|
|
checkInt(this, value, offset, byteLength2, limit - 1, -limit);
|
|
}
|
|
let i = byteLength2 - 1;
|
|
let mul = 1;
|
|
let sub = 0;
|
|
this[offset + i] = value & 255;
|
|
while (--i >= 0 && (mul *= 256)) {
|
|
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
|
|
sub = 1;
|
|
}
|
|
this[offset + i] = (value / mul >> 0) - sub & 255;
|
|
}
|
|
return offset + byteLength2;
|
|
};
|
|
Buffer14.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 1, 127, -128);
|
|
if (value < 0)
|
|
value = 255 + value + 1;
|
|
this[offset] = value & 255;
|
|
return offset + 1;
|
|
};
|
|
Buffer14.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 32767, -32768);
|
|
this[offset] = value & 255;
|
|
this[offset + 1] = value >>> 8;
|
|
return offset + 2;
|
|
};
|
|
Buffer14.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 32767, -32768);
|
|
this[offset] = value >>> 8;
|
|
this[offset + 1] = value & 255;
|
|
return offset + 2;
|
|
};
|
|
Buffer14.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 2147483647, -2147483648);
|
|
this[offset] = value & 255;
|
|
this[offset + 1] = value >>> 8;
|
|
this[offset + 2] = value >>> 16;
|
|
this[offset + 3] = value >>> 24;
|
|
return offset + 4;
|
|
};
|
|
Buffer14.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 2147483647, -2147483648);
|
|
if (value < 0)
|
|
value = 4294967295 + value + 1;
|
|
this[offset] = value >>> 24;
|
|
this[offset + 1] = value >>> 16;
|
|
this[offset + 2] = value >>> 8;
|
|
this[offset + 3] = value & 255;
|
|
return offset + 4;
|
|
};
|
|
Buffer14.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
|
|
return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
|
|
});
|
|
Buffer14.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
|
|
return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
|
|
});
|
|
function checkIEEE754(buf2, value, offset, ext, max, min) {
|
|
if (offset + ext > buf2.length)
|
|
throw new RangeError("Index out of range");
|
|
if (offset < 0)
|
|
throw new RangeError("Index out of range");
|
|
}
|
|
function writeFloat(buf2, value, offset, littleEndian, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
checkIEEE754(buf2, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
|
|
}
|
|
ieee7542.write(buf2, value, offset, littleEndian, 23, 4);
|
|
return offset + 4;
|
|
}
|
|
Buffer14.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, true, noAssert);
|
|
};
|
|
Buffer14.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, false, noAssert);
|
|
};
|
|
function writeDouble(buf2, value, offset, littleEndian, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
checkIEEE754(buf2, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
|
|
}
|
|
ieee7542.write(buf2, value, offset, littleEndian, 52, 8);
|
|
return offset + 8;
|
|
}
|
|
Buffer14.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, true, noAssert);
|
|
};
|
|
Buffer14.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, false, noAssert);
|
|
};
|
|
Buffer14.prototype.copy = function copy(target, targetStart, start, end) {
|
|
if (!Buffer14.isBuffer(target))
|
|
throw new TypeError("argument should be a Buffer");
|
|
if (!start)
|
|
start = 0;
|
|
if (!end && end !== 0)
|
|
end = this.length;
|
|
if (targetStart >= target.length)
|
|
targetStart = target.length;
|
|
if (!targetStart)
|
|
targetStart = 0;
|
|
if (end > 0 && end < start)
|
|
end = start;
|
|
if (end === start)
|
|
return 0;
|
|
if (target.length === 0 || this.length === 0)
|
|
return 0;
|
|
if (targetStart < 0) {
|
|
throw new RangeError("targetStart out of bounds");
|
|
}
|
|
if (start < 0 || start >= this.length)
|
|
throw new RangeError("Index out of range");
|
|
if (end < 0)
|
|
throw new RangeError("sourceEnd out of bounds");
|
|
if (end > this.length)
|
|
end = this.length;
|
|
if (target.length - targetStart < end - start) {
|
|
end = target.length - targetStart + start;
|
|
}
|
|
const len = end - start;
|
|
if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
|
|
this.copyWithin(targetStart, start, end);
|
|
} else {
|
|
Uint8Array.prototype.set.call(
|
|
target,
|
|
this.subarray(start, end),
|
|
targetStart
|
|
);
|
|
}
|
|
return len;
|
|
};
|
|
Buffer14.prototype.fill = function fill(val, start, end, encoding) {
|
|
if (typeof val === "string") {
|
|
if (typeof start === "string") {
|
|
encoding = start;
|
|
start = 0;
|
|
end = this.length;
|
|
} else if (typeof end === "string") {
|
|
encoding = end;
|
|
end = this.length;
|
|
}
|
|
if (encoding !== void 0 && typeof encoding !== "string") {
|
|
throw new TypeError("encoding must be a string");
|
|
}
|
|
if (typeof encoding === "string" && !Buffer14.isEncoding(encoding)) {
|
|
throw new TypeError("Unknown encoding: " + encoding);
|
|
}
|
|
if (val.length === 1) {
|
|
const code = val.charCodeAt(0);
|
|
if (encoding === "utf8" && code < 128 || encoding === "latin1") {
|
|
val = code;
|
|
}
|
|
}
|
|
} else if (typeof val === "number") {
|
|
val = val & 255;
|
|
} else if (typeof val === "boolean") {
|
|
val = Number(val);
|
|
}
|
|
if (start < 0 || this.length < start || this.length < end) {
|
|
throw new RangeError("Out of range index");
|
|
}
|
|
if (end <= start) {
|
|
return this;
|
|
}
|
|
start = start >>> 0;
|
|
end = end === void 0 ? this.length : end >>> 0;
|
|
if (!val)
|
|
val = 0;
|
|
let i;
|
|
if (typeof val === "number") {
|
|
for (i = start; i < end; ++i) {
|
|
this[i] = val;
|
|
}
|
|
} else {
|
|
const bytes = Buffer14.isBuffer(val) ? val : Buffer14.from(val, encoding);
|
|
const len = bytes.length;
|
|
if (len === 0) {
|
|
throw new TypeError('The value "' + val + '" is invalid for argument "value"');
|
|
}
|
|
for (i = 0; i < end - start; ++i) {
|
|
this[i + start] = bytes[i % len];
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
var errors = {};
|
|
function E(sym, getMessage, Base) {
|
|
errors[sym] = class NodeError extends Base {
|
|
constructor() {
|
|
super();
|
|
Object.defineProperty(this, "message", {
|
|
value: getMessage.apply(this, arguments),
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
this.name = `${this.name} [${sym}]`;
|
|
this.stack;
|
|
delete this.name;
|
|
}
|
|
get code() {
|
|
return sym;
|
|
}
|
|
set code(value) {
|
|
Object.defineProperty(this, "code", {
|
|
configurable: true,
|
|
enumerable: true,
|
|
value,
|
|
writable: true
|
|
});
|
|
}
|
|
toString() {
|
|
return `${this.name} [${sym}]: ${this.message}`;
|
|
}
|
|
};
|
|
}
|
|
E(
|
|
"ERR_BUFFER_OUT_OF_BOUNDS",
|
|
function(name) {
|
|
if (name) {
|
|
return `${name} is outside of buffer bounds`;
|
|
}
|
|
return "Attempt to access memory outside buffer bounds";
|
|
},
|
|
RangeError
|
|
);
|
|
E(
|
|
"ERR_INVALID_ARG_TYPE",
|
|
function(name, actual) {
|
|
return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
|
|
},
|
|
TypeError
|
|
);
|
|
E(
|
|
"ERR_OUT_OF_RANGE",
|
|
function(str, range, input) {
|
|
let msg = `The value of "${str}" is out of range.`;
|
|
let received = input;
|
|
if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
|
|
received = addNumericalSeparator(String(input));
|
|
} else if (typeof input === "bigint") {
|
|
received = String(input);
|
|
if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
|
|
received = addNumericalSeparator(received);
|
|
}
|
|
received += "n";
|
|
}
|
|
msg += ` It must be ${range}. Received ${received}`;
|
|
return msg;
|
|
},
|
|
RangeError
|
|
);
|
|
function addNumericalSeparator(val) {
|
|
let res = "";
|
|
let i = val.length;
|
|
const start = val[0] === "-" ? 1 : 0;
|
|
for (; i >= start + 4; i -= 3) {
|
|
res = `_${val.slice(i - 3, i)}${res}`;
|
|
}
|
|
return `${val.slice(0, i)}${res}`;
|
|
}
|
|
function checkBounds(buf2, offset, byteLength2) {
|
|
validateNumber(offset, "offset");
|
|
if (buf2[offset] === void 0 || buf2[offset + byteLength2] === void 0) {
|
|
boundsError(offset, buf2.length - (byteLength2 + 1));
|
|
}
|
|
}
|
|
function checkIntBI(value, min, max, buf2, offset, byteLength2) {
|
|
if (value > max || value < min) {
|
|
const n = typeof min === "bigint" ? "n" : "";
|
|
let range;
|
|
if (byteLength2 > 3) {
|
|
if (min === 0 || min === BigInt(0)) {
|
|
range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
|
|
} else {
|
|
range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
|
|
}
|
|
} else {
|
|
range = `>= ${min}${n} and <= ${max}${n}`;
|
|
}
|
|
throw new errors.ERR_OUT_OF_RANGE("value", range, value);
|
|
}
|
|
checkBounds(buf2, offset, byteLength2);
|
|
}
|
|
function validateNumber(value, name) {
|
|
if (typeof value !== "number") {
|
|
throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
|
|
}
|
|
}
|
|
function boundsError(value, length, type) {
|
|
if (Math.floor(value) !== value) {
|
|
validateNumber(value, type);
|
|
throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
|
|
}
|
|
if (length < 0) {
|
|
throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
|
|
}
|
|
throw new errors.ERR_OUT_OF_RANGE(
|
|
type || "offset",
|
|
`>= ${type ? 1 : 0} and <= ${length}`,
|
|
value
|
|
);
|
|
}
|
|
var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
|
|
function base64clean(str) {
|
|
str = str.split("=")[0];
|
|
str = str.trim().replace(INVALID_BASE64_RE, "");
|
|
if (str.length < 2)
|
|
return "";
|
|
while (str.length % 4 !== 0) {
|
|
str = str + "=";
|
|
}
|
|
return str;
|
|
}
|
|
function utf8ToBytes(string, units) {
|
|
units = units || Infinity;
|
|
let codePoint;
|
|
const length = string.length;
|
|
let leadSurrogate = null;
|
|
const bytes = [];
|
|
for (let i = 0; i < length; ++i) {
|
|
codePoint = string.charCodeAt(i);
|
|
if (codePoint > 55295 && codePoint < 57344) {
|
|
if (!leadSurrogate) {
|
|
if (codePoint > 56319) {
|
|
if ((units -= 3) > -1)
|
|
bytes.push(239, 191, 189);
|
|
continue;
|
|
} else if (i + 1 === length) {
|
|
if ((units -= 3) > -1)
|
|
bytes.push(239, 191, 189);
|
|
continue;
|
|
}
|
|
leadSurrogate = codePoint;
|
|
continue;
|
|
}
|
|
if (codePoint < 56320) {
|
|
if ((units -= 3) > -1)
|
|
bytes.push(239, 191, 189);
|
|
leadSurrogate = codePoint;
|
|
continue;
|
|
}
|
|
codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
|
|
} else if (leadSurrogate) {
|
|
if ((units -= 3) > -1)
|
|
bytes.push(239, 191, 189);
|
|
}
|
|
leadSurrogate = null;
|
|
if (codePoint < 128) {
|
|
if ((units -= 1) < 0)
|
|
break;
|
|
bytes.push(codePoint);
|
|
} else if (codePoint < 2048) {
|
|
if ((units -= 2) < 0)
|
|
break;
|
|
bytes.push(
|
|
codePoint >> 6 | 192,
|
|
codePoint & 63 | 128
|
|
);
|
|
} else if (codePoint < 65536) {
|
|
if ((units -= 3) < 0)
|
|
break;
|
|
bytes.push(
|
|
codePoint >> 12 | 224,
|
|
codePoint >> 6 & 63 | 128,
|
|
codePoint & 63 | 128
|
|
);
|
|
} else if (codePoint < 1114112) {
|
|
if ((units -= 4) < 0)
|
|
break;
|
|
bytes.push(
|
|
codePoint >> 18 | 240,
|
|
codePoint >> 12 & 63 | 128,
|
|
codePoint >> 6 & 63 | 128,
|
|
codePoint & 63 | 128
|
|
);
|
|
} else {
|
|
throw new Error("Invalid code point");
|
|
}
|
|
}
|
|
return bytes;
|
|
}
|
|
function asciiToBytes(str) {
|
|
const byteArray = [];
|
|
for (let i = 0; i < str.length; ++i) {
|
|
byteArray.push(str.charCodeAt(i) & 255);
|
|
}
|
|
return byteArray;
|
|
}
|
|
function utf16leToBytes(str, units) {
|
|
let c, hi, lo;
|
|
const byteArray = [];
|
|
for (let i = 0; i < str.length; ++i) {
|
|
if ((units -= 2) < 0)
|
|
break;
|
|
c = str.charCodeAt(i);
|
|
hi = c >> 8;
|
|
lo = c % 256;
|
|
byteArray.push(lo);
|
|
byteArray.push(hi);
|
|
}
|
|
return byteArray;
|
|
}
|
|
function base64ToBytes(str) {
|
|
return base64.toByteArray(base64clean(str));
|
|
}
|
|
function blitBuffer(src, dst, offset, length) {
|
|
let i;
|
|
for (i = 0; i < length; ++i) {
|
|
if (i + offset >= dst.length || i >= src.length)
|
|
break;
|
|
dst[i + offset] = src[i];
|
|
}
|
|
return i;
|
|
}
|
|
function isInstance(obj, type) {
|
|
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
|
|
}
|
|
function numberIsNaN(obj) {
|
|
return obj !== obj;
|
|
}
|
|
var hexSliceLookupTable = function() {
|
|
const alphabet = "0123456789abcdef";
|
|
const table = new Array(256);
|
|
for (let i = 0; i < 16; ++i) {
|
|
const i16 = i * 16;
|
|
for (let j = 0; j < 16; ++j) {
|
|
table[i16 + j] = alphabet[i] + alphabet[j];
|
|
}
|
|
}
|
|
return table;
|
|
}();
|
|
function defineBigIntMethod(fn) {
|
|
return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
|
|
}
|
|
function BufferBigIntNotDefined() {
|
|
throw new Error("BigInt not supported");
|
|
}
|
|
}
|
|
});
|
|
|
|
// esbuild.inject.js
|
|
var Buffer2;
|
|
var init_esbuild_inject = __esm({
|
|
"esbuild.inject.js"() {
|
|
"use strict";
|
|
Buffer2 = require_buffer().Buffer;
|
|
if (true) {
|
|
if (true) {
|
|
const ocreate = unsafeWindow.document.createElement.bind(document);
|
|
unsafeWindow.document.createElement = (tag) => {
|
|
if (tag != "meta")
|
|
return ocreate(tag);
|
|
unsafeWindow.document.createElement = ocreate;
|
|
return unsafeWindow.document.createElement("link");
|
|
};
|
|
}
|
|
if (false) {
|
|
if (typeof cloneInto != "undefined")
|
|
console.log("CLONE INTO DEFINED");
|
|
else
|
|
console.log("CLONE INTO NOT DEFINED");
|
|
let a = 1;
|
|
console.log(a++);
|
|
const unsafeWindow2 = window;
|
|
console.log(a++);
|
|
const ocreate = unsafeWindow2.document.createElement.bind(document);
|
|
console.log(a++);
|
|
exportFunction((tag) => {
|
|
if (tag != "meta")
|
|
return ocreate(tag);
|
|
unsafeWindow2.document.createElement = ocreate;
|
|
return unsafeWindow2.document.createElement("link");
|
|
}, window.document, { defineAs: "createElement" });
|
|
console.log(a++);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/crc-32/crc32.js
|
|
var require_crc32 = __commonJS({
|
|
"node_modules/crc-32/crc32.js"(exports) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var CRC32;
|
|
(function(factory) {
|
|
if (typeof DO_NOT_EXPORT_CRC === "undefined") {
|
|
if ("object" === typeof exports) {
|
|
factory(exports);
|
|
} else if ("function" === typeof define && define.amd) {
|
|
define(function() {
|
|
var module2 = {};
|
|
factory(module2);
|
|
return module2;
|
|
});
|
|
} else {
|
|
factory(CRC32 = {});
|
|
}
|
|
} else {
|
|
factory(CRC32 = {});
|
|
}
|
|
})(function(CRC322) {
|
|
CRC322.version = "1.2.2";
|
|
function signed_crc_table() {
|
|
var c = 0, table = new Array(256);
|
|
for (var n = 0; n != 256; ++n) {
|
|
c = n;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;
|
|
table[n] = c;
|
|
}
|
|
return typeof Int32Array !== "undefined" ? new Int32Array(table) : table;
|
|
}
|
|
var T0 = signed_crc_table();
|
|
function slice_by_16_tables(T) {
|
|
var c = 0, v = 0, n = 0, table = typeof Int32Array !== "undefined" ? new Int32Array(4096) : new Array(4096);
|
|
for (n = 0; n != 256; ++n)
|
|
table[n] = T[n];
|
|
for (n = 0; n != 256; ++n) {
|
|
v = T[n];
|
|
for (c = 256 + n; c < 4096; c += 256)
|
|
v = table[c] = v >>> 8 ^ T[v & 255];
|
|
}
|
|
var out = [];
|
|
for (n = 1; n != 16; ++n)
|
|
out[n - 1] = typeof Int32Array !== "undefined" ? table.subarray(n * 256, n * 256 + 256) : table.slice(n * 256, n * 256 + 256);
|
|
return out;
|
|
}
|
|
var TT = slice_by_16_tables(T0);
|
|
var T1 = TT[0], T2 = TT[1], T3 = TT[2], T4 = TT[3], T5 = TT[4];
|
|
var T6 = TT[5], T7 = TT[6], T8 = TT[7], T9 = TT[8], Ta = TT[9];
|
|
var Tb = TT[10], Tc = TT[11], Td = TT[12], Te = TT[13], Tf = TT[14];
|
|
function crc32_bstr(bstr, seed) {
|
|
var C = seed ^ -1;
|
|
for (var i = 0, L = bstr.length; i < L; )
|
|
C = C >>> 8 ^ T0[(C ^ bstr.charCodeAt(i++)) & 255];
|
|
return ~C;
|
|
}
|
|
function crc32_buf(B, seed) {
|
|
var C = seed ^ -1, L = B.length - 15, i = 0;
|
|
for (; i < L; )
|
|
C = Tf[B[i++] ^ C & 255] ^ Te[B[i++] ^ C >> 8 & 255] ^ Td[B[i++] ^ C >> 16 & 255] ^ Tc[B[i++] ^ C >>> 24] ^ Tb[B[i++]] ^ Ta[B[i++]] ^ T9[B[i++]] ^ T8[B[i++]] ^ T7[B[i++]] ^ T6[B[i++]] ^ T5[B[i++]] ^ T4[B[i++]] ^ T3[B[i++]] ^ T2[B[i++]] ^ T1[B[i++]] ^ T0[B[i++]];
|
|
L += 15;
|
|
while (i < L)
|
|
C = C >>> 8 ^ T0[(C ^ B[i++]) & 255];
|
|
return ~C;
|
|
}
|
|
function crc32_str(str, seed) {
|
|
var C = seed ^ -1;
|
|
for (var i = 0, L = str.length, c = 0, d = 0; i < L; ) {
|
|
c = str.charCodeAt(i++);
|
|
if (c < 128) {
|
|
C = C >>> 8 ^ T0[(C ^ c) & 255];
|
|
} else if (c < 2048) {
|
|
C = C >>> 8 ^ T0[(C ^ (192 | c >> 6 & 31)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
|
|
} else if (c >= 55296 && c < 57344) {
|
|
c = (c & 1023) + 64;
|
|
d = str.charCodeAt(i++) & 1023;
|
|
C = C >>> 8 ^ T0[(C ^ (240 | c >> 8 & 7)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | c >> 2 & 63)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | d & 63)) & 255];
|
|
} else {
|
|
C = C >>> 8 ^ T0[(C ^ (224 | c >> 12 & 15)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | c >> 6 & 63)) & 255];
|
|
C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
|
|
}
|
|
}
|
|
return ~C;
|
|
}
|
|
CRC322.table = T0;
|
|
CRC322.bstr = crc32_bstr;
|
|
CRC322.buf = crc32_buf;
|
|
CRC322.str = crc32_str;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/events/events.js
|
|
var require_events = __commonJS({
|
|
"node_modules/events/events.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var R = typeof Reflect === "object" ? Reflect : null;
|
|
var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
|
|
return Function.prototype.apply.call(target, receiver, args);
|
|
};
|
|
var ReflectOwnKeys;
|
|
if (R && typeof R.ownKeys === "function") {
|
|
ReflectOwnKeys = R.ownKeys;
|
|
} else if (Object.getOwnPropertySymbols) {
|
|
ReflectOwnKeys = function ReflectOwnKeys2(target) {
|
|
return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
|
|
};
|
|
} else {
|
|
ReflectOwnKeys = function ReflectOwnKeys2(target) {
|
|
return Object.getOwnPropertyNames(target);
|
|
};
|
|
}
|
|
function ProcessEmitWarning(warning) {
|
|
if (console && console.warn)
|
|
console.warn(warning);
|
|
}
|
|
var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
|
|
return value !== value;
|
|
};
|
|
function EventEmitter() {
|
|
EventEmitter.init.call(this);
|
|
}
|
|
module.exports = EventEmitter;
|
|
module.exports.once = once;
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|
EventEmitter.prototype._events = void 0;
|
|
EventEmitter.prototype._eventsCount = 0;
|
|
EventEmitter.prototype._maxListeners = void 0;
|
|
var defaultMaxListeners = 10;
|
|
function checkListener(listener) {
|
|
if (typeof listener !== "function") {
|
|
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
|
|
}
|
|
}
|
|
Object.defineProperty(EventEmitter, "defaultMaxListeners", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return defaultMaxListeners;
|
|
},
|
|
set: function(arg) {
|
|
if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
|
|
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
|
|
}
|
|
defaultMaxListeners = arg;
|
|
}
|
|
});
|
|
EventEmitter.init = function() {
|
|
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
this._eventsCount = 0;
|
|
}
|
|
this._maxListeners = this._maxListeners || void 0;
|
|
};
|
|
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
|
|
if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
|
|
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
|
|
}
|
|
this._maxListeners = n;
|
|
return this;
|
|
};
|
|
function _getMaxListeners(that) {
|
|
if (that._maxListeners === void 0)
|
|
return EventEmitter.defaultMaxListeners;
|
|
return that._maxListeners;
|
|
}
|
|
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
|
|
return _getMaxListeners(this);
|
|
};
|
|
EventEmitter.prototype.emit = function emit(type) {
|
|
var args = [];
|
|
for (var i = 1; i < arguments.length; i++)
|
|
args.push(arguments[i]);
|
|
var doError = type === "error";
|
|
var events = this._events;
|
|
if (events !== void 0)
|
|
doError = doError && events.error === void 0;
|
|
else if (!doError)
|
|
return false;
|
|
if (doError) {
|
|
var er;
|
|
if (args.length > 0)
|
|
er = args[0];
|
|
if (er instanceof Error) {
|
|
throw er;
|
|
}
|
|
var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
|
|
err.context = er;
|
|
throw err;
|
|
}
|
|
var handler = events[type];
|
|
if (handler === void 0)
|
|
return false;
|
|
if (typeof handler === "function") {
|
|
ReflectApply(handler, this, args);
|
|
} else {
|
|
var len = handler.length;
|
|
var listeners = arrayClone(handler, len);
|
|
for (var i = 0; i < len; ++i)
|
|
ReflectApply(listeners[i], this, args);
|
|
}
|
|
return true;
|
|
};
|
|
function _addListener(target, type, listener, prepend) {
|
|
var m;
|
|
var events;
|
|
var existing;
|
|
checkListener(listener);
|
|
events = target._events;
|
|
if (events === void 0) {
|
|
events = target._events = /* @__PURE__ */ Object.create(null);
|
|
target._eventsCount = 0;
|
|
} else {
|
|
if (events.newListener !== void 0) {
|
|
target.emit(
|
|
"newListener",
|
|
type,
|
|
listener.listener ? listener.listener : listener
|
|
);
|
|
events = target._events;
|
|
}
|
|
existing = events[type];
|
|
}
|
|
if (existing === void 0) {
|
|
existing = events[type] = listener;
|
|
++target._eventsCount;
|
|
} else {
|
|
if (typeof existing === "function") {
|
|
existing = events[type] = prepend ? [listener, existing] : [existing, listener];
|
|
} else if (prepend) {
|
|
existing.unshift(listener);
|
|
} else {
|
|
existing.push(listener);
|
|
}
|
|
m = _getMaxListeners(target);
|
|
if (m > 0 && existing.length > m && !existing.warned) {
|
|
existing.warned = true;
|
|
var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
|
|
w.name = "MaxListenersExceededWarning";
|
|
w.emitter = target;
|
|
w.type = type;
|
|
w.count = existing.length;
|
|
ProcessEmitWarning(w);
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
EventEmitter.prototype.addListener = function addListener(type, listener) {
|
|
return _addListener(this, type, listener, false);
|
|
};
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
EventEmitter.prototype.prependListener = function prependListener(type, listener) {
|
|
return _addListener(this, type, listener, true);
|
|
};
|
|
function onceWrapper() {
|
|
if (!this.fired) {
|
|
this.target.removeListener(this.type, this.wrapFn);
|
|
this.fired = true;
|
|
if (arguments.length === 0)
|
|
return this.listener.call(this.target);
|
|
return this.listener.apply(this.target, arguments);
|
|
}
|
|
}
|
|
function _onceWrap(target, type, listener) {
|
|
var state = { fired: false, wrapFn: void 0, target, type, listener };
|
|
var wrapped = onceWrapper.bind(state);
|
|
wrapped.listener = listener;
|
|
state.wrapFn = wrapped;
|
|
return wrapped;
|
|
}
|
|
EventEmitter.prototype.once = function once2(type, listener) {
|
|
checkListener(listener);
|
|
this.on(type, _onceWrap(this, type, listener));
|
|
return this;
|
|
};
|
|
EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
|
|
checkListener(listener);
|
|
this.prependListener(type, _onceWrap(this, type, listener));
|
|
return this;
|
|
};
|
|
EventEmitter.prototype.removeListener = function removeListener(type, listener) {
|
|
var list, events, position, i, originalListener;
|
|
checkListener(listener);
|
|
events = this._events;
|
|
if (events === void 0)
|
|
return this;
|
|
list = events[type];
|
|
if (list === void 0)
|
|
return this;
|
|
if (list === listener || list.listener === listener) {
|
|
if (--this._eventsCount === 0)
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
else {
|
|
delete events[type];
|
|
if (events.removeListener)
|
|
this.emit("removeListener", type, list.listener || listener);
|
|
}
|
|
} else if (typeof list !== "function") {
|
|
position = -1;
|
|
for (i = list.length - 1; i >= 0; i--) {
|
|
if (list[i] === listener || list[i].listener === listener) {
|
|
originalListener = list[i].listener;
|
|
position = i;
|
|
break;
|
|
}
|
|
}
|
|
if (position < 0)
|
|
return this;
|
|
if (position === 0)
|
|
list.shift();
|
|
else {
|
|
spliceOne(list, position);
|
|
}
|
|
if (list.length === 1)
|
|
events[type] = list[0];
|
|
if (events.removeListener !== void 0)
|
|
this.emit("removeListener", type, originalListener || listener);
|
|
}
|
|
return this;
|
|
};
|
|
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
|
|
EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
|
|
var listeners, events, i;
|
|
events = this._events;
|
|
if (events === void 0)
|
|
return this;
|
|
if (events.removeListener === void 0) {
|
|
if (arguments.length === 0) {
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
this._eventsCount = 0;
|
|
} else if (events[type] !== void 0) {
|
|
if (--this._eventsCount === 0)
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
else
|
|
delete events[type];
|
|
}
|
|
return this;
|
|
}
|
|
if (arguments.length === 0) {
|
|
var keys = Object.keys(events);
|
|
var key2;
|
|
for (i = 0; i < keys.length; ++i) {
|
|
key2 = keys[i];
|
|
if (key2 === "removeListener")
|
|
continue;
|
|
this.removeAllListeners(key2);
|
|
}
|
|
this.removeAllListeners("removeListener");
|
|
this._events = /* @__PURE__ */ Object.create(null);
|
|
this._eventsCount = 0;
|
|
return this;
|
|
}
|
|
listeners = events[type];
|
|
if (typeof listeners === "function") {
|
|
this.removeListener(type, listeners);
|
|
} else if (listeners !== void 0) {
|
|
for (i = listeners.length - 1; i >= 0; i--) {
|
|
this.removeListener(type, listeners[i]);
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
function _listeners(target, type, unwrap) {
|
|
var events = target._events;
|
|
if (events === void 0)
|
|
return [];
|
|
var evlistener = events[type];
|
|
if (evlistener === void 0)
|
|
return [];
|
|
if (typeof evlistener === "function")
|
|
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
|
|
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
|
|
}
|
|
EventEmitter.prototype.listeners = function listeners(type) {
|
|
return _listeners(this, type, true);
|
|
};
|
|
EventEmitter.prototype.rawListeners = function rawListeners(type) {
|
|
return _listeners(this, type, false);
|
|
};
|
|
EventEmitter.listenerCount = function(emitter, type) {
|
|
if (typeof emitter.listenerCount === "function") {
|
|
return emitter.listenerCount(type);
|
|
} else {
|
|
return listenerCount.call(emitter, type);
|
|
}
|
|
};
|
|
EventEmitter.prototype.listenerCount = listenerCount;
|
|
function listenerCount(type) {
|
|
var events = this._events;
|
|
if (events !== void 0) {
|
|
var evlistener = events[type];
|
|
if (typeof evlistener === "function") {
|
|
return 1;
|
|
} else if (evlistener !== void 0) {
|
|
return evlistener.length;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
EventEmitter.prototype.eventNames = function eventNames() {
|
|
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
|
|
};
|
|
function arrayClone(arr, n) {
|
|
var copy = new Array(n);
|
|
for (var i = 0; i < n; ++i)
|
|
copy[i] = arr[i];
|
|
return copy;
|
|
}
|
|
function spliceOne(list, index) {
|
|
for (; index + 1 < list.length; index++)
|
|
list[index] = list[index + 1];
|
|
list.pop();
|
|
}
|
|
function unwrapListeners(arr) {
|
|
var ret = new Array(arr.length);
|
|
for (var i = 0; i < ret.length; ++i) {
|
|
ret[i] = arr[i].listener || arr[i];
|
|
}
|
|
return ret;
|
|
}
|
|
function once(emitter, name) {
|
|
return new Promise(function(resolve, reject) {
|
|
function errorListener(err) {
|
|
emitter.removeListener(name, resolver);
|
|
reject(err);
|
|
}
|
|
function resolver() {
|
|
if (typeof emitter.removeListener === "function") {
|
|
emitter.removeListener("error", errorListener);
|
|
}
|
|
resolve([].slice.call(arguments));
|
|
}
|
|
;
|
|
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
|
|
if (name !== "error") {
|
|
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
|
|
}
|
|
});
|
|
}
|
|
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
|
|
if (typeof emitter.on === "function") {
|
|
eventTargetAgnosticAddListener(emitter, "error", handler, flags);
|
|
}
|
|
}
|
|
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
|
|
if (typeof emitter.on === "function") {
|
|
if (flags.once) {
|
|
emitter.once(name, listener);
|
|
} else {
|
|
emitter.on(name, listener);
|
|
}
|
|
} else if (typeof emitter.addEventListener === "function") {
|
|
emitter.addEventListener(name, function wrapListener(arg) {
|
|
if (flags.once) {
|
|
emitter.removeEventListener(name, wrapListener);
|
|
}
|
|
listener(arg);
|
|
});
|
|
} else {
|
|
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/stream-browser.js
|
|
var require_stream_browser = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/stream-browser.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
module.exports = require_events().EventEmitter;
|
|
}
|
|
});
|
|
|
|
// (disabled):node_modules/util/util.js
|
|
var require_util = __commonJS({
|
|
"(disabled):node_modules/util/util.js"() {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/buffer_list.js
|
|
var require_buffer_list = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function ownKeys(object, enumerableOnly) {
|
|
var keys = Object.keys(object);
|
|
if (Object.getOwnPropertySymbols) {
|
|
var symbols = Object.getOwnPropertySymbols(object);
|
|
if (enumerableOnly)
|
|
symbols = symbols.filter(function(sym) {
|
|
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
|
|
});
|
|
keys.push.apply(keys, symbols);
|
|
}
|
|
return keys;
|
|
}
|
|
function _objectSpread(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i] != null ? arguments[i] : {};
|
|
if (i % 2) {
|
|
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(key2) {
|
|
Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2));
|
|
});
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
function _defineProperty(obj, key2, value) {
|
|
if (key2 in obj) {
|
|
Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });
|
|
} else {
|
|
obj[key2] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
function _classCallCheck(instance18, Constructor) {
|
|
if (!(instance18 instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
}
|
|
function _defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor)
|
|
descriptor.writable = true;
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
|
}
|
|
}
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
|
if (protoProps)
|
|
_defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps)
|
|
_defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
}
|
|
var _require = require_buffer();
|
|
var Buffer14 = _require.Buffer;
|
|
var _require2 = require_util();
|
|
var inspect = _require2.inspect;
|
|
var custom = inspect && inspect.custom || "inspect";
|
|
function copyBuffer(src, target, offset) {
|
|
Buffer14.prototype.copy.call(src, target, offset);
|
|
}
|
|
module.exports = /* @__PURE__ */ function() {
|
|
function BufferList() {
|
|
_classCallCheck(this, BufferList);
|
|
this.head = null;
|
|
this.tail = null;
|
|
this.length = 0;
|
|
}
|
|
_createClass(BufferList, [{
|
|
key: "push",
|
|
value: function push(v) {
|
|
var entry = {
|
|
data: v,
|
|
next: null
|
|
};
|
|
if (this.length > 0)
|
|
this.tail.next = entry;
|
|
else
|
|
this.head = entry;
|
|
this.tail = entry;
|
|
++this.length;
|
|
}
|
|
}, {
|
|
key: "unshift",
|
|
value: function unshift(v) {
|
|
var entry = {
|
|
data: v,
|
|
next: this.head
|
|
};
|
|
if (this.length === 0)
|
|
this.tail = entry;
|
|
this.head = entry;
|
|
++this.length;
|
|
}
|
|
}, {
|
|
key: "shift",
|
|
value: function shift() {
|
|
if (this.length === 0)
|
|
return;
|
|
var ret = this.head.data;
|
|
if (this.length === 1)
|
|
this.head = this.tail = null;
|
|
else
|
|
this.head = this.head.next;
|
|
--this.length;
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear() {
|
|
this.head = this.tail = null;
|
|
this.length = 0;
|
|
}
|
|
}, {
|
|
key: "join",
|
|
value: function join(s) {
|
|
if (this.length === 0)
|
|
return "";
|
|
var p = this.head;
|
|
var ret = "" + p.data;
|
|
while (p = p.next) {
|
|
ret += s + p.data;
|
|
}
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: "concat",
|
|
value: function concat(n) {
|
|
if (this.length === 0)
|
|
return Buffer14.alloc(0);
|
|
var ret = Buffer14.allocUnsafe(n >>> 0);
|
|
var p = this.head;
|
|
var i = 0;
|
|
while (p) {
|
|
copyBuffer(p.data, ret, i);
|
|
i += p.data.length;
|
|
p = p.next;
|
|
}
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: "consume",
|
|
value: function consume(n, hasStrings) {
|
|
var ret;
|
|
if (n < this.head.data.length) {
|
|
ret = this.head.data.slice(0, n);
|
|
this.head.data = this.head.data.slice(n);
|
|
} else if (n === this.head.data.length) {
|
|
ret = this.shift();
|
|
} else {
|
|
ret = hasStrings ? this._getString(n) : this._getBuffer(n);
|
|
}
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: "first",
|
|
value: function first() {
|
|
return this.head.data;
|
|
}
|
|
}, {
|
|
key: "_getString",
|
|
value: function _getString(n) {
|
|
var p = this.head;
|
|
var c = 1;
|
|
var ret = p.data;
|
|
n -= ret.length;
|
|
while (p = p.next) {
|
|
var str = p.data;
|
|
var nb = n > str.length ? str.length : n;
|
|
if (nb === str.length)
|
|
ret += str;
|
|
else
|
|
ret += str.slice(0, n);
|
|
n -= nb;
|
|
if (n === 0) {
|
|
if (nb === str.length) {
|
|
++c;
|
|
if (p.next)
|
|
this.head = p.next;
|
|
else
|
|
this.head = this.tail = null;
|
|
} else {
|
|
this.head = p;
|
|
p.data = str.slice(nb);
|
|
}
|
|
break;
|
|
}
|
|
++c;
|
|
}
|
|
this.length -= c;
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: "_getBuffer",
|
|
value: function _getBuffer(n) {
|
|
var ret = Buffer14.allocUnsafe(n);
|
|
var p = this.head;
|
|
var c = 1;
|
|
p.data.copy(ret);
|
|
n -= p.data.length;
|
|
while (p = p.next) {
|
|
var buf2 = p.data;
|
|
var nb = n > buf2.length ? buf2.length : n;
|
|
buf2.copy(ret, ret.length - n, 0, nb);
|
|
n -= nb;
|
|
if (n === 0) {
|
|
if (nb === buf2.length) {
|
|
++c;
|
|
if (p.next)
|
|
this.head = p.next;
|
|
else
|
|
this.head = this.tail = null;
|
|
} else {
|
|
this.head = p;
|
|
p.data = buf2.slice(nb);
|
|
}
|
|
break;
|
|
}
|
|
++c;
|
|
}
|
|
this.length -= c;
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: custom,
|
|
value: function value(_, options) {
|
|
return inspect(this, _objectSpread({}, options, {
|
|
depth: 0,
|
|
customInspect: false
|
|
}));
|
|
}
|
|
}]);
|
|
return BufferList;
|
|
}();
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/destroy.js
|
|
var require_destroy = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function destroy(err, cb) {
|
|
var _this = this;
|
|
var readableDestroyed = this._readableState && this._readableState.destroyed;
|
|
var writableDestroyed = this._writableState && this._writableState.destroyed;
|
|
if (readableDestroyed || writableDestroyed) {
|
|
if (cb) {
|
|
cb(err);
|
|
} else if (err) {
|
|
if (!this._writableState) {
|
|
process.nextTick(emitErrorNT, this, err);
|
|
} else if (!this._writableState.errorEmitted) {
|
|
this._writableState.errorEmitted = true;
|
|
process.nextTick(emitErrorNT, this, err);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
if (this._readableState) {
|
|
this._readableState.destroyed = true;
|
|
}
|
|
if (this._writableState) {
|
|
this._writableState.destroyed = true;
|
|
}
|
|
this._destroy(err || null, function(err2) {
|
|
if (!cb && err2) {
|
|
if (!_this._writableState) {
|
|
process.nextTick(emitErrorAndCloseNT, _this, err2);
|
|
} else if (!_this._writableState.errorEmitted) {
|
|
_this._writableState.errorEmitted = true;
|
|
process.nextTick(emitErrorAndCloseNT, _this, err2);
|
|
} else {
|
|
process.nextTick(emitCloseNT, _this);
|
|
}
|
|
} else if (cb) {
|
|
process.nextTick(emitCloseNT, _this);
|
|
cb(err2);
|
|
} else {
|
|
process.nextTick(emitCloseNT, _this);
|
|
}
|
|
});
|
|
return this;
|
|
}
|
|
function emitErrorAndCloseNT(self, err) {
|
|
emitErrorNT(self, err);
|
|
emitCloseNT(self);
|
|
}
|
|
function emitCloseNT(self) {
|
|
if (self._writableState && !self._writableState.emitClose)
|
|
return;
|
|
if (self._readableState && !self._readableState.emitClose)
|
|
return;
|
|
self.emit("close");
|
|
}
|
|
function undestroy() {
|
|
if (this._readableState) {
|
|
this._readableState.destroyed = false;
|
|
this._readableState.reading = false;
|
|
this._readableState.ended = false;
|
|
this._readableState.endEmitted = false;
|
|
}
|
|
if (this._writableState) {
|
|
this._writableState.destroyed = false;
|
|
this._writableState.ended = false;
|
|
this._writableState.ending = false;
|
|
this._writableState.finalCalled = false;
|
|
this._writableState.prefinished = false;
|
|
this._writableState.finished = false;
|
|
this._writableState.errorEmitted = false;
|
|
}
|
|
}
|
|
function emitErrorNT(self, err) {
|
|
self.emit("error", err);
|
|
}
|
|
function errorOrDestroy(stream, err) {
|
|
var rState = stream._readableState;
|
|
var wState = stream._writableState;
|
|
if (rState && rState.autoDestroy || wState && wState.autoDestroy)
|
|
stream.destroy(err);
|
|
else
|
|
stream.emit("error", err);
|
|
}
|
|
module.exports = {
|
|
destroy,
|
|
undestroy,
|
|
errorOrDestroy
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/errors-browser.js
|
|
var require_errors_browser = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/errors-browser.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function _inheritsLoose2(subClass, superClass) {
|
|
subClass.prototype = Object.create(superClass.prototype);
|
|
subClass.prototype.constructor = subClass;
|
|
subClass.__proto__ = superClass;
|
|
}
|
|
var codes = {};
|
|
function createErrorType(code, message, Base) {
|
|
if (!Base) {
|
|
Base = Error;
|
|
}
|
|
function getMessage(arg1, arg2, arg3) {
|
|
if (typeof message === "string") {
|
|
return message;
|
|
} else {
|
|
return message(arg1, arg2, arg3);
|
|
}
|
|
}
|
|
var NodeError = /* @__PURE__ */ function(_Base) {
|
|
_inheritsLoose2(NodeError2, _Base);
|
|
function NodeError2(arg1, arg2, arg3) {
|
|
return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
|
|
}
|
|
return NodeError2;
|
|
}(Base);
|
|
NodeError.prototype.name = Base.name;
|
|
NodeError.prototype.code = code;
|
|
codes[code] = NodeError;
|
|
}
|
|
function oneOf(expected, thing) {
|
|
if (Array.isArray(expected)) {
|
|
var len = expected.length;
|
|
expected = expected.map(function(i) {
|
|
return String(i);
|
|
});
|
|
if (len > 2) {
|
|
return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];
|
|
} else if (len === 2) {
|
|
return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
|
|
} else {
|
|
return "of ".concat(thing, " ").concat(expected[0]);
|
|
}
|
|
} else {
|
|
return "of ".concat(thing, " ").concat(String(expected));
|
|
}
|
|
}
|
|
function startsWith(str, search, pos) {
|
|
return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
|
|
}
|
|
function endsWith(str, search, this_len) {
|
|
if (this_len === void 0 || this_len > str.length) {
|
|
this_len = str.length;
|
|
}
|
|
return str.substring(this_len - search.length, this_len) === search;
|
|
}
|
|
function includes(str, search, start) {
|
|
if (typeof start !== "number") {
|
|
start = 0;
|
|
}
|
|
if (start + search.length > str.length) {
|
|
return false;
|
|
} else {
|
|
return str.indexOf(search, start) !== -1;
|
|
}
|
|
}
|
|
createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {
|
|
return 'The value "' + value + '" is invalid for option "' + name + '"';
|
|
}, TypeError);
|
|
createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
|
|
var determiner;
|
|
if (typeof expected === "string" && startsWith(expected, "not ")) {
|
|
determiner = "must not be";
|
|
expected = expected.replace(/^not /, "");
|
|
} else {
|
|
determiner = "must be";
|
|
}
|
|
var msg;
|
|
if (endsWith(name, " argument")) {
|
|
msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
|
|
} else {
|
|
var type = includes(name, ".") ? "property" : "argument";
|
|
msg = 'The "'.concat(name, '" ').concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
|
|
}
|
|
msg += ". Received type ".concat(typeof actual);
|
|
return msg;
|
|
}, TypeError);
|
|
createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
|
|
createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) {
|
|
return "The " + name + " method is not implemented";
|
|
});
|
|
createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
|
|
createErrorType("ERR_STREAM_DESTROYED", function(name) {
|
|
return "Cannot call " + name + " after a stream was destroyed";
|
|
});
|
|
createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
|
|
createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
|
|
createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
|
|
createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
|
|
createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
|
|
return "Unknown encoding: " + arg;
|
|
}, TypeError);
|
|
createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
|
|
module.exports.codes = codes;
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/state.js
|
|
var require_state = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/state.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var ERR_INVALID_OPT_VALUE = require_errors_browser().codes.ERR_INVALID_OPT_VALUE;
|
|
function highWaterMarkFrom(options, isDuplex, duplexKey) {
|
|
return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
|
|
}
|
|
function getHighWaterMark(state, options, duplexKey, isDuplex) {
|
|
var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
|
|
if (hwm != null) {
|
|
if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
|
|
var name = isDuplex ? duplexKey : "highWaterMark";
|
|
throw new ERR_INVALID_OPT_VALUE(name, hwm);
|
|
}
|
|
return Math.floor(hwm);
|
|
}
|
|
return state.objectMode ? 16 : 16 * 1024;
|
|
}
|
|
module.exports = {
|
|
getHighWaterMark
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/inherits/inherits_browser.js
|
|
var require_inherits_browser = __commonJS({
|
|
"node_modules/inherits/inherits_browser.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
if (typeof Object.create === "function") {
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor;
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
}
|
|
};
|
|
} else {
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor;
|
|
var TempCtor = function() {
|
|
};
|
|
TempCtor.prototype = superCtor.prototype;
|
|
ctor.prototype = new TempCtor();
|
|
ctor.prototype.constructor = ctor;
|
|
}
|
|
};
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/util-deprecate/browser.js
|
|
var require_browser = __commonJS({
|
|
"node_modules/util-deprecate/browser.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
module.exports = deprecate;
|
|
function deprecate(fn, msg) {
|
|
if (config("noDeprecation")) {
|
|
return fn;
|
|
}
|
|
var warned = false;
|
|
function deprecated() {
|
|
if (!warned) {
|
|
if (config("throwDeprecation")) {
|
|
throw new Error(msg);
|
|
} else if (config("traceDeprecation")) {
|
|
console.trace(msg);
|
|
} else {
|
|
console.warn(msg);
|
|
}
|
|
warned = true;
|
|
}
|
|
return fn.apply(this, arguments);
|
|
}
|
|
return deprecated;
|
|
}
|
|
function config(name) {
|
|
try {
|
|
if (!window.localStorage)
|
|
return false;
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
var val = window.localStorage[name];
|
|
if (null == val)
|
|
return false;
|
|
return String(val).toLowerCase() === "true";
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_writable.js
|
|
var require_stream_writable = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_writable.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
module.exports = Writable;
|
|
function CorkedRequest(state) {
|
|
var _this = this;
|
|
this.next = null;
|
|
this.entry = null;
|
|
this.finish = function() {
|
|
onCorkedFinish(_this, state);
|
|
};
|
|
}
|
|
var Duplex;
|
|
Writable.WritableState = WritableState;
|
|
var internalUtil = {
|
|
deprecate: require_browser()
|
|
};
|
|
var Stream = require_stream_browser();
|
|
var Buffer14 = require_buffer().Buffer;
|
|
var OurUint8Array = window.Uint8Array || function() {
|
|
};
|
|
function _uint8ArrayToBuffer(chunk) {
|
|
return Buffer14.from(chunk);
|
|
}
|
|
function _isUint8Array(obj) {
|
|
return Buffer14.isBuffer(obj) || obj instanceof OurUint8Array;
|
|
}
|
|
var destroyImpl = require_destroy();
|
|
var _require = require_state();
|
|
var getHighWaterMark = _require.getHighWaterMark;
|
|
var _require$codes = require_errors_browser().codes;
|
|
var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
|
|
var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
|
|
var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
|
|
var ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE;
|
|
var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
|
|
var ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES;
|
|
var ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END;
|
|
var ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
|
|
var errorOrDestroy = destroyImpl.errorOrDestroy;
|
|
require_inherits_browser()(Writable, Stream);
|
|
function nop() {
|
|
}
|
|
function WritableState(options, stream, isDuplex) {
|
|
Duplex = Duplex || require_stream_duplex();
|
|
options = options || {};
|
|
if (typeof isDuplex !== "boolean")
|
|
isDuplex = stream instanceof Duplex;
|
|
this.objectMode = !!options.objectMode;
|
|
if (isDuplex)
|
|
this.objectMode = this.objectMode || !!options.writableObjectMode;
|
|
this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);
|
|
this.finalCalled = false;
|
|
this.needDrain = false;
|
|
this.ending = false;
|
|
this.ended = false;
|
|
this.finished = false;
|
|
this.destroyed = false;
|
|
var noDecode = options.decodeStrings === false;
|
|
this.decodeStrings = !noDecode;
|
|
this.defaultEncoding = options.defaultEncoding || "utf8";
|
|
this.length = 0;
|
|
this.writing = false;
|
|
this.corked = 0;
|
|
this.sync = true;
|
|
this.bufferProcessing = false;
|
|
this.onwrite = function(er) {
|
|
onwrite(stream, er);
|
|
};
|
|
this.writecb = null;
|
|
this.writelen = 0;
|
|
this.bufferedRequest = null;
|
|
this.lastBufferedRequest = null;
|
|
this.pendingcb = 0;
|
|
this.prefinished = false;
|
|
this.errorEmitted = false;
|
|
this.emitClose = options.emitClose !== false;
|
|
this.autoDestroy = !!options.autoDestroy;
|
|
this.bufferedRequestCount = 0;
|
|
this.corkedRequestsFree = new CorkedRequest(this);
|
|
}
|
|
WritableState.prototype.getBuffer = function getBuffer() {
|
|
var current = this.bufferedRequest;
|
|
var out = [];
|
|
while (current) {
|
|
out.push(current);
|
|
current = current.next;
|
|
}
|
|
return out;
|
|
};
|
|
(function() {
|
|
try {
|
|
Object.defineProperty(WritableState.prototype, "buffer", {
|
|
get: internalUtil.deprecate(function writableStateBufferGetter() {
|
|
return this.getBuffer();
|
|
}, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
|
|
});
|
|
} catch (_) {
|
|
}
|
|
})();
|
|
var realHasInstance;
|
|
if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
|
|
realHasInstance = Function.prototype[Symbol.hasInstance];
|
|
Object.defineProperty(Writable, Symbol.hasInstance, {
|
|
value: function value(object) {
|
|
if (realHasInstance.call(this, object))
|
|
return true;
|
|
if (this !== Writable)
|
|
return false;
|
|
return object && object._writableState instanceof WritableState;
|
|
}
|
|
});
|
|
} else {
|
|
realHasInstance = function realHasInstance2(object) {
|
|
return object instanceof this;
|
|
};
|
|
}
|
|
function Writable(options) {
|
|
Duplex = Duplex || require_stream_duplex();
|
|
var isDuplex = this instanceof Duplex;
|
|
if (!isDuplex && !realHasInstance.call(Writable, this))
|
|
return new Writable(options);
|
|
this._writableState = new WritableState(options, this, isDuplex);
|
|
this.writable = true;
|
|
if (options) {
|
|
if (typeof options.write === "function")
|
|
this._write = options.write;
|
|
if (typeof options.writev === "function")
|
|
this._writev = options.writev;
|
|
if (typeof options.destroy === "function")
|
|
this._destroy = options.destroy;
|
|
if (typeof options.final === "function")
|
|
this._final = options.final;
|
|
}
|
|
Stream.call(this);
|
|
}
|
|
Writable.prototype.pipe = function() {
|
|
errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
|
|
};
|
|
function writeAfterEnd(stream, cb) {
|
|
var er = new ERR_STREAM_WRITE_AFTER_END();
|
|
errorOrDestroy(stream, er);
|
|
process.nextTick(cb, er);
|
|
}
|
|
function validChunk(stream, state, chunk, cb) {
|
|
var er;
|
|
if (chunk === null) {
|
|
er = new ERR_STREAM_NULL_VALUES();
|
|
} else if (typeof chunk !== "string" && !state.objectMode) {
|
|
er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
|
|
}
|
|
if (er) {
|
|
errorOrDestroy(stream, er);
|
|
process.nextTick(cb, er);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
Writable.prototype.write = function(chunk, encoding, cb) {
|
|
var state = this._writableState;
|
|
var ret = false;
|
|
var isBuf = !state.objectMode && _isUint8Array(chunk);
|
|
if (isBuf && !Buffer14.isBuffer(chunk)) {
|
|
chunk = _uint8ArrayToBuffer(chunk);
|
|
}
|
|
if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (isBuf)
|
|
encoding = "buffer";
|
|
else if (!encoding)
|
|
encoding = state.defaultEncoding;
|
|
if (typeof cb !== "function")
|
|
cb = nop;
|
|
if (state.ending)
|
|
writeAfterEnd(this, cb);
|
|
else if (isBuf || validChunk(this, state, chunk, cb)) {
|
|
state.pendingcb++;
|
|
ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
|
|
}
|
|
return ret;
|
|
};
|
|
Writable.prototype.cork = function() {
|
|
this._writableState.corked++;
|
|
};
|
|
Writable.prototype.uncork = function() {
|
|
var state = this._writableState;
|
|
if (state.corked) {
|
|
state.corked--;
|
|
if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest)
|
|
clearBuffer(this, state);
|
|
}
|
|
};
|
|
Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
|
|
if (typeof encoding === "string")
|
|
encoding = encoding.toLowerCase();
|
|
if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1))
|
|
throw new ERR_UNKNOWN_ENCODING(encoding);
|
|
this._writableState.defaultEncoding = encoding;
|
|
return this;
|
|
};
|
|
Object.defineProperty(Writable.prototype, "writableBuffer", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._writableState && this._writableState.getBuffer();
|
|
}
|
|
});
|
|
function decodeChunk(state, chunk, encoding) {
|
|
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
|
|
chunk = Buffer14.from(chunk, encoding);
|
|
}
|
|
return chunk;
|
|
}
|
|
Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._writableState.highWaterMark;
|
|
}
|
|
});
|
|
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
|
|
if (!isBuf) {
|
|
var newChunk = decodeChunk(state, chunk, encoding);
|
|
if (chunk !== newChunk) {
|
|
isBuf = true;
|
|
encoding = "buffer";
|
|
chunk = newChunk;
|
|
}
|
|
}
|
|
var len = state.objectMode ? 1 : chunk.length;
|
|
state.length += len;
|
|
var ret = state.length < state.highWaterMark;
|
|
if (!ret)
|
|
state.needDrain = true;
|
|
if (state.writing || state.corked) {
|
|
var last = state.lastBufferedRequest;
|
|
state.lastBufferedRequest = {
|
|
chunk,
|
|
encoding,
|
|
isBuf,
|
|
callback: cb,
|
|
next: null
|
|
};
|
|
if (last) {
|
|
last.next = state.lastBufferedRequest;
|
|
} else {
|
|
state.bufferedRequest = state.lastBufferedRequest;
|
|
}
|
|
state.bufferedRequestCount += 1;
|
|
} else {
|
|
doWrite(stream, state, false, len, chunk, encoding, cb);
|
|
}
|
|
return ret;
|
|
}
|
|
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
|
|
state.writelen = len;
|
|
state.writecb = cb;
|
|
state.writing = true;
|
|
state.sync = true;
|
|
if (state.destroyed)
|
|
state.onwrite(new ERR_STREAM_DESTROYED("write"));
|
|
else if (writev)
|
|
stream._writev(chunk, state.onwrite);
|
|
else
|
|
stream._write(chunk, encoding, state.onwrite);
|
|
state.sync = false;
|
|
}
|
|
function onwriteError(stream, state, sync, er, cb) {
|
|
--state.pendingcb;
|
|
if (sync) {
|
|
process.nextTick(cb, er);
|
|
process.nextTick(finishMaybe, stream, state);
|
|
stream._writableState.errorEmitted = true;
|
|
errorOrDestroy(stream, er);
|
|
} else {
|
|
cb(er);
|
|
stream._writableState.errorEmitted = true;
|
|
errorOrDestroy(stream, er);
|
|
finishMaybe(stream, state);
|
|
}
|
|
}
|
|
function onwriteStateUpdate(state) {
|
|
state.writing = false;
|
|
state.writecb = null;
|
|
state.length -= state.writelen;
|
|
state.writelen = 0;
|
|
}
|
|
function onwrite(stream, er) {
|
|
var state = stream._writableState;
|
|
var sync = state.sync;
|
|
var cb = state.writecb;
|
|
if (typeof cb !== "function")
|
|
throw new ERR_MULTIPLE_CALLBACK();
|
|
onwriteStateUpdate(state);
|
|
if (er)
|
|
onwriteError(stream, state, sync, er, cb);
|
|
else {
|
|
var finished = needFinish(state) || stream.destroyed;
|
|
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
|
|
clearBuffer(stream, state);
|
|
}
|
|
if (sync) {
|
|
process.nextTick(afterWrite, stream, state, finished, cb);
|
|
} else {
|
|
afterWrite(stream, state, finished, cb);
|
|
}
|
|
}
|
|
}
|
|
function afterWrite(stream, state, finished, cb) {
|
|
if (!finished)
|
|
onwriteDrain(stream, state);
|
|
state.pendingcb--;
|
|
cb();
|
|
finishMaybe(stream, state);
|
|
}
|
|
function onwriteDrain(stream, state) {
|
|
if (state.length === 0 && state.needDrain) {
|
|
state.needDrain = false;
|
|
stream.emit("drain");
|
|
}
|
|
}
|
|
function clearBuffer(stream, state) {
|
|
state.bufferProcessing = true;
|
|
var entry = state.bufferedRequest;
|
|
if (stream._writev && entry && entry.next) {
|
|
var l = state.bufferedRequestCount;
|
|
var buffer = new Array(l);
|
|
var holder = state.corkedRequestsFree;
|
|
holder.entry = entry;
|
|
var count = 0;
|
|
var allBuffers = true;
|
|
while (entry) {
|
|
buffer[count] = entry;
|
|
if (!entry.isBuf)
|
|
allBuffers = false;
|
|
entry = entry.next;
|
|
count += 1;
|
|
}
|
|
buffer.allBuffers = allBuffers;
|
|
doWrite(stream, state, true, state.length, buffer, "", holder.finish);
|
|
state.pendingcb++;
|
|
state.lastBufferedRequest = null;
|
|
if (holder.next) {
|
|
state.corkedRequestsFree = holder.next;
|
|
holder.next = null;
|
|
} else {
|
|
state.corkedRequestsFree = new CorkedRequest(state);
|
|
}
|
|
state.bufferedRequestCount = 0;
|
|
} else {
|
|
while (entry) {
|
|
var chunk = entry.chunk;
|
|
var encoding = entry.encoding;
|
|
var cb = entry.callback;
|
|
var len = state.objectMode ? 1 : chunk.length;
|
|
doWrite(stream, state, false, len, chunk, encoding, cb);
|
|
entry = entry.next;
|
|
state.bufferedRequestCount--;
|
|
if (state.writing) {
|
|
break;
|
|
}
|
|
}
|
|
if (entry === null)
|
|
state.lastBufferedRequest = null;
|
|
}
|
|
state.bufferedRequest = entry;
|
|
state.bufferProcessing = false;
|
|
}
|
|
Writable.prototype._write = function(chunk, encoding, cb) {
|
|
cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
|
|
};
|
|
Writable.prototype._writev = null;
|
|
Writable.prototype.end = function(chunk, encoding, cb) {
|
|
var state = this._writableState;
|
|
if (typeof chunk === "function") {
|
|
cb = chunk;
|
|
chunk = null;
|
|
encoding = null;
|
|
} else if (typeof encoding === "function") {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
if (chunk !== null && chunk !== void 0)
|
|
this.write(chunk, encoding);
|
|
if (state.corked) {
|
|
state.corked = 1;
|
|
this.uncork();
|
|
}
|
|
if (!state.ending)
|
|
endWritable(this, state, cb);
|
|
return this;
|
|
};
|
|
Object.defineProperty(Writable.prototype, "writableLength", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._writableState.length;
|
|
}
|
|
});
|
|
function needFinish(state) {
|
|
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
|
|
}
|
|
function callFinal(stream, state) {
|
|
stream._final(function(err) {
|
|
state.pendingcb--;
|
|
if (err) {
|
|
errorOrDestroy(stream, err);
|
|
}
|
|
state.prefinished = true;
|
|
stream.emit("prefinish");
|
|
finishMaybe(stream, state);
|
|
});
|
|
}
|
|
function prefinish(stream, state) {
|
|
if (!state.prefinished && !state.finalCalled) {
|
|
if (typeof stream._final === "function" && !state.destroyed) {
|
|
state.pendingcb++;
|
|
state.finalCalled = true;
|
|
process.nextTick(callFinal, stream, state);
|
|
} else {
|
|
state.prefinished = true;
|
|
stream.emit("prefinish");
|
|
}
|
|
}
|
|
}
|
|
function finishMaybe(stream, state) {
|
|
var need = needFinish(state);
|
|
if (need) {
|
|
prefinish(stream, state);
|
|
if (state.pendingcb === 0) {
|
|
state.finished = true;
|
|
stream.emit("finish");
|
|
if (state.autoDestroy) {
|
|
var rState = stream._readableState;
|
|
if (!rState || rState.autoDestroy && rState.endEmitted) {
|
|
stream.destroy();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return need;
|
|
}
|
|
function endWritable(stream, state, cb) {
|
|
state.ending = true;
|
|
finishMaybe(stream, state);
|
|
if (cb) {
|
|
if (state.finished)
|
|
process.nextTick(cb);
|
|
else
|
|
stream.once("finish", cb);
|
|
}
|
|
state.ended = true;
|
|
stream.writable = false;
|
|
}
|
|
function onCorkedFinish(corkReq, state, err) {
|
|
var entry = corkReq.entry;
|
|
corkReq.entry = null;
|
|
while (entry) {
|
|
var cb = entry.callback;
|
|
state.pendingcb--;
|
|
cb(err);
|
|
entry = entry.next;
|
|
}
|
|
state.corkedRequestsFree.next = corkReq;
|
|
}
|
|
Object.defineProperty(Writable.prototype, "destroyed", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
if (this._writableState === void 0) {
|
|
return false;
|
|
}
|
|
return this._writableState.destroyed;
|
|
},
|
|
set: function set(value) {
|
|
if (!this._writableState) {
|
|
return;
|
|
}
|
|
this._writableState.destroyed = value;
|
|
}
|
|
});
|
|
Writable.prototype.destroy = destroyImpl.destroy;
|
|
Writable.prototype._undestroy = destroyImpl.undestroy;
|
|
Writable.prototype._destroy = function(err, cb) {
|
|
cb(err);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_duplex.js
|
|
var require_stream_duplex = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var objectKeys = Object.keys || function(obj) {
|
|
var keys2 = [];
|
|
for (var key2 in obj) {
|
|
keys2.push(key2);
|
|
}
|
|
return keys2;
|
|
};
|
|
module.exports = Duplex;
|
|
var Readable = require_stream_readable();
|
|
var Writable = require_stream_writable();
|
|
require_inherits_browser()(Duplex, Readable);
|
|
{
|
|
keys = objectKeys(Writable.prototype);
|
|
for (v = 0; v < keys.length; v++) {
|
|
method = keys[v];
|
|
if (!Duplex.prototype[method])
|
|
Duplex.prototype[method] = Writable.prototype[method];
|
|
}
|
|
}
|
|
var keys;
|
|
var method;
|
|
var v;
|
|
function Duplex(options) {
|
|
if (!(this instanceof Duplex))
|
|
return new Duplex(options);
|
|
Readable.call(this, options);
|
|
Writable.call(this, options);
|
|
this.allowHalfOpen = true;
|
|
if (options) {
|
|
if (options.readable === false)
|
|
this.readable = false;
|
|
if (options.writable === false)
|
|
this.writable = false;
|
|
if (options.allowHalfOpen === false) {
|
|
this.allowHalfOpen = false;
|
|
this.once("end", onend);
|
|
}
|
|
}
|
|
}
|
|
Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._writableState.highWaterMark;
|
|
}
|
|
});
|
|
Object.defineProperty(Duplex.prototype, "writableBuffer", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._writableState && this._writableState.getBuffer();
|
|
}
|
|
});
|
|
Object.defineProperty(Duplex.prototype, "writableLength", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._writableState.length;
|
|
}
|
|
});
|
|
function onend() {
|
|
if (this._writableState.ended)
|
|
return;
|
|
process.nextTick(onEndNT, this);
|
|
}
|
|
function onEndNT(self) {
|
|
self.end();
|
|
}
|
|
Object.defineProperty(Duplex.prototype, "destroyed", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
if (this._readableState === void 0 || this._writableState === void 0) {
|
|
return false;
|
|
}
|
|
return this._readableState.destroyed && this._writableState.destroyed;
|
|
},
|
|
set: function set(value) {
|
|
if (this._readableState === void 0 || this._writableState === void 0) {
|
|
return;
|
|
}
|
|
this._readableState.destroyed = value;
|
|
this._writableState.destroyed = value;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/safe-buffer/index.js
|
|
var require_safe_buffer = __commonJS({
|
|
"node_modules/safe-buffer/index.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var buffer = require_buffer();
|
|
var Buffer14 = buffer.Buffer;
|
|
function copyProps(src, dst) {
|
|
for (var key2 in src) {
|
|
dst[key2] = src[key2];
|
|
}
|
|
}
|
|
if (Buffer14.from && Buffer14.alloc && Buffer14.allocUnsafe && Buffer14.allocUnsafeSlow) {
|
|
module.exports = buffer;
|
|
} else {
|
|
copyProps(buffer, exports);
|
|
exports.Buffer = SafeBuffer;
|
|
}
|
|
function SafeBuffer(arg, encodingOrOffset, length) {
|
|
return Buffer14(arg, encodingOrOffset, length);
|
|
}
|
|
SafeBuffer.prototype = Object.create(Buffer14.prototype);
|
|
copyProps(Buffer14, SafeBuffer);
|
|
SafeBuffer.from = function(arg, encodingOrOffset, length) {
|
|
if (typeof arg === "number") {
|
|
throw new TypeError("Argument must not be a number");
|
|
}
|
|
return Buffer14(arg, encodingOrOffset, length);
|
|
};
|
|
SafeBuffer.alloc = function(size, fill, encoding) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
var buf2 = Buffer14(size);
|
|
if (fill !== void 0) {
|
|
if (typeof encoding === "string") {
|
|
buf2.fill(fill, encoding);
|
|
} else {
|
|
buf2.fill(fill);
|
|
}
|
|
} else {
|
|
buf2.fill(0);
|
|
}
|
|
return buf2;
|
|
};
|
|
SafeBuffer.allocUnsafe = function(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
return Buffer14(size);
|
|
};
|
|
SafeBuffer.allocUnsafeSlow = function(size) {
|
|
if (typeof size !== "number") {
|
|
throw new TypeError("Argument must be a number");
|
|
}
|
|
return buffer.SlowBuffer(size);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/string_decoder/lib/string_decoder.js
|
|
var require_string_decoder = __commonJS({
|
|
"node_modules/string_decoder/lib/string_decoder.js"(exports) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var Buffer14 = require_safe_buffer().Buffer;
|
|
var isEncoding = Buffer14.isEncoding || function(encoding) {
|
|
encoding = "" + encoding;
|
|
switch (encoding && encoding.toLowerCase()) {
|
|
case "hex":
|
|
case "utf8":
|
|
case "utf-8":
|
|
case "ascii":
|
|
case "binary":
|
|
case "base64":
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
case "raw":
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
function _normalizeEncoding(enc) {
|
|
if (!enc)
|
|
return "utf8";
|
|
var retried;
|
|
while (true) {
|
|
switch (enc) {
|
|
case "utf8":
|
|
case "utf-8":
|
|
return "utf8";
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return "utf16le";
|
|
case "latin1":
|
|
case "binary":
|
|
return "latin1";
|
|
case "base64":
|
|
case "ascii":
|
|
case "hex":
|
|
return enc;
|
|
default:
|
|
if (retried)
|
|
return;
|
|
enc = ("" + enc).toLowerCase();
|
|
retried = true;
|
|
}
|
|
}
|
|
}
|
|
function normalizeEncoding(enc) {
|
|
var nenc = _normalizeEncoding(enc);
|
|
if (typeof nenc !== "string" && (Buffer14.isEncoding === isEncoding || !isEncoding(enc)))
|
|
throw new Error("Unknown encoding: " + enc);
|
|
return nenc || enc;
|
|
}
|
|
exports.StringDecoder = StringDecoder;
|
|
function StringDecoder(encoding) {
|
|
this.encoding = normalizeEncoding(encoding);
|
|
var nb;
|
|
switch (this.encoding) {
|
|
case "utf16le":
|
|
this.text = utf16Text;
|
|
this.end = utf16End;
|
|
nb = 4;
|
|
break;
|
|
case "utf8":
|
|
this.fillLast = utf8FillLast;
|
|
nb = 4;
|
|
break;
|
|
case "base64":
|
|
this.text = base64Text;
|
|
this.end = base64End;
|
|
nb = 3;
|
|
break;
|
|
default:
|
|
this.write = simpleWrite;
|
|
this.end = simpleEnd;
|
|
return;
|
|
}
|
|
this.lastNeed = 0;
|
|
this.lastTotal = 0;
|
|
this.lastChar = Buffer14.allocUnsafe(nb);
|
|
}
|
|
StringDecoder.prototype.write = function(buf2) {
|
|
if (buf2.length === 0)
|
|
return "";
|
|
var r;
|
|
var i;
|
|
if (this.lastNeed) {
|
|
r = this.fillLast(buf2);
|
|
if (r === void 0)
|
|
return "";
|
|
i = this.lastNeed;
|
|
this.lastNeed = 0;
|
|
} else {
|
|
i = 0;
|
|
}
|
|
if (i < buf2.length)
|
|
return r ? r + this.text(buf2, i) : this.text(buf2, i);
|
|
return r || "";
|
|
};
|
|
StringDecoder.prototype.end = utf8End;
|
|
StringDecoder.prototype.text = utf8Text;
|
|
StringDecoder.prototype.fillLast = function(buf2) {
|
|
if (this.lastNeed <= buf2.length) {
|
|
buf2.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
|
|
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
|
|
}
|
|
buf2.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf2.length);
|
|
this.lastNeed -= buf2.length;
|
|
};
|
|
function utf8CheckByte(byte) {
|
|
if (byte <= 127)
|
|
return 0;
|
|
else if (byte >> 5 === 6)
|
|
return 2;
|
|
else if (byte >> 4 === 14)
|
|
return 3;
|
|
else if (byte >> 3 === 30)
|
|
return 4;
|
|
return byte >> 6 === 2 ? -1 : -2;
|
|
}
|
|
function utf8CheckIncomplete(self, buf2, i) {
|
|
var j = buf2.length - 1;
|
|
if (j < i)
|
|
return 0;
|
|
var nb = utf8CheckByte(buf2[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0)
|
|
self.lastNeed = nb - 1;
|
|
return nb;
|
|
}
|
|
if (--j < i || nb === -2)
|
|
return 0;
|
|
nb = utf8CheckByte(buf2[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0)
|
|
self.lastNeed = nb - 2;
|
|
return nb;
|
|
}
|
|
if (--j < i || nb === -2)
|
|
return 0;
|
|
nb = utf8CheckByte(buf2[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0) {
|
|
if (nb === 2)
|
|
nb = 0;
|
|
else
|
|
self.lastNeed = nb - 3;
|
|
}
|
|
return nb;
|
|
}
|
|
return 0;
|
|
}
|
|
function utf8CheckExtraBytes(self, buf2, p) {
|
|
if ((buf2[0] & 192) !== 128) {
|
|
self.lastNeed = 0;
|
|
return "\uFFFD";
|
|
}
|
|
if (self.lastNeed > 1 && buf2.length > 1) {
|
|
if ((buf2[1] & 192) !== 128) {
|
|
self.lastNeed = 1;
|
|
return "\uFFFD";
|
|
}
|
|
if (self.lastNeed > 2 && buf2.length > 2) {
|
|
if ((buf2[2] & 192) !== 128) {
|
|
self.lastNeed = 2;
|
|
return "\uFFFD";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function utf8FillLast(buf2) {
|
|
var p = this.lastTotal - this.lastNeed;
|
|
var r = utf8CheckExtraBytes(this, buf2, p);
|
|
if (r !== void 0)
|
|
return r;
|
|
if (this.lastNeed <= buf2.length) {
|
|
buf2.copy(this.lastChar, p, 0, this.lastNeed);
|
|
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
|
|
}
|
|
buf2.copy(this.lastChar, p, 0, buf2.length);
|
|
this.lastNeed -= buf2.length;
|
|
}
|
|
function utf8Text(buf2, i) {
|
|
var total = utf8CheckIncomplete(this, buf2, i);
|
|
if (!this.lastNeed)
|
|
return buf2.toString("utf8", i);
|
|
this.lastTotal = total;
|
|
var end = buf2.length - (total - this.lastNeed);
|
|
buf2.copy(this.lastChar, 0, end);
|
|
return buf2.toString("utf8", i, end);
|
|
}
|
|
function utf8End(buf2) {
|
|
var r = buf2 && buf2.length ? this.write(buf2) : "";
|
|
if (this.lastNeed)
|
|
return r + "\uFFFD";
|
|
return r;
|
|
}
|
|
function utf16Text(buf2, i) {
|
|
if ((buf2.length - i) % 2 === 0) {
|
|
var r = buf2.toString("utf16le", i);
|
|
if (r) {
|
|
var c = r.charCodeAt(r.length - 1);
|
|
if (c >= 55296 && c <= 56319) {
|
|
this.lastNeed = 2;
|
|
this.lastTotal = 4;
|
|
this.lastChar[0] = buf2[buf2.length - 2];
|
|
this.lastChar[1] = buf2[buf2.length - 1];
|
|
return r.slice(0, -1);
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
this.lastNeed = 1;
|
|
this.lastTotal = 2;
|
|
this.lastChar[0] = buf2[buf2.length - 1];
|
|
return buf2.toString("utf16le", i, buf2.length - 1);
|
|
}
|
|
function utf16End(buf2) {
|
|
var r = buf2 && buf2.length ? this.write(buf2) : "";
|
|
if (this.lastNeed) {
|
|
var end = this.lastTotal - this.lastNeed;
|
|
return r + this.lastChar.toString("utf16le", 0, end);
|
|
}
|
|
return r;
|
|
}
|
|
function base64Text(buf2, i) {
|
|
var n = (buf2.length - i) % 3;
|
|
if (n === 0)
|
|
return buf2.toString("base64", i);
|
|
this.lastNeed = 3 - n;
|
|
this.lastTotal = 3;
|
|
if (n === 1) {
|
|
this.lastChar[0] = buf2[buf2.length - 1];
|
|
} else {
|
|
this.lastChar[0] = buf2[buf2.length - 2];
|
|
this.lastChar[1] = buf2[buf2.length - 1];
|
|
}
|
|
return buf2.toString("base64", i, buf2.length - n);
|
|
}
|
|
function base64End(buf2) {
|
|
var r = buf2 && buf2.length ? this.write(buf2) : "";
|
|
if (this.lastNeed)
|
|
return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
|
|
return r;
|
|
}
|
|
function simpleWrite(buf2) {
|
|
return buf2.toString(this.encoding);
|
|
}
|
|
function simpleEnd(buf2) {
|
|
return buf2 && buf2.length ? this.write(buf2) : "";
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/end-of-stream.js
|
|
var require_end_of_stream = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var ERR_STREAM_PREMATURE_CLOSE = require_errors_browser().codes.ERR_STREAM_PREMATURE_CLOSE;
|
|
function once(callback) {
|
|
var called = false;
|
|
return function() {
|
|
if (called)
|
|
return;
|
|
called = true;
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
callback.apply(this, args);
|
|
};
|
|
}
|
|
function noop3() {
|
|
}
|
|
function isRequest(stream) {
|
|
return stream.setHeader && typeof stream.abort === "function";
|
|
}
|
|
function eos(stream, opts, callback) {
|
|
if (typeof opts === "function")
|
|
return eos(stream, null, opts);
|
|
if (!opts)
|
|
opts = {};
|
|
callback = once(callback || noop3);
|
|
var readable = opts.readable || opts.readable !== false && stream.readable;
|
|
var writable2 = opts.writable || opts.writable !== false && stream.writable;
|
|
var onlegacyfinish = function onlegacyfinish2() {
|
|
if (!stream.writable)
|
|
onfinish();
|
|
};
|
|
var writableEnded = stream._writableState && stream._writableState.finished;
|
|
var onfinish = function onfinish2() {
|
|
writable2 = false;
|
|
writableEnded = true;
|
|
if (!readable)
|
|
callback.call(stream);
|
|
};
|
|
var readableEnded = stream._readableState && stream._readableState.endEmitted;
|
|
var onend = function onend2() {
|
|
readable = false;
|
|
readableEnded = true;
|
|
if (!writable2)
|
|
callback.call(stream);
|
|
};
|
|
var onerror = function onerror2(err) {
|
|
callback.call(stream, err);
|
|
};
|
|
var onclose = function onclose2() {
|
|
var err;
|
|
if (readable && !readableEnded) {
|
|
if (!stream._readableState || !stream._readableState.ended)
|
|
err = new ERR_STREAM_PREMATURE_CLOSE();
|
|
return callback.call(stream, err);
|
|
}
|
|
if (writable2 && !writableEnded) {
|
|
if (!stream._writableState || !stream._writableState.ended)
|
|
err = new ERR_STREAM_PREMATURE_CLOSE();
|
|
return callback.call(stream, err);
|
|
}
|
|
};
|
|
var onrequest = function onrequest2() {
|
|
stream.req.on("finish", onfinish);
|
|
};
|
|
if (isRequest(stream)) {
|
|
stream.on("complete", onfinish);
|
|
stream.on("abort", onclose);
|
|
if (stream.req)
|
|
onrequest();
|
|
else
|
|
stream.on("request", onrequest);
|
|
} else if (writable2 && !stream._writableState) {
|
|
stream.on("end", onlegacyfinish);
|
|
stream.on("close", onlegacyfinish);
|
|
}
|
|
stream.on("end", onend);
|
|
stream.on("finish", onfinish);
|
|
if (opts.error !== false)
|
|
stream.on("error", onerror);
|
|
stream.on("close", onclose);
|
|
return function() {
|
|
stream.removeListener("complete", onfinish);
|
|
stream.removeListener("abort", onclose);
|
|
stream.removeListener("request", onrequest);
|
|
if (stream.req)
|
|
stream.req.removeListener("finish", onfinish);
|
|
stream.removeListener("end", onlegacyfinish);
|
|
stream.removeListener("close", onlegacyfinish);
|
|
stream.removeListener("finish", onfinish);
|
|
stream.removeListener("end", onend);
|
|
stream.removeListener("error", onerror);
|
|
stream.removeListener("close", onclose);
|
|
};
|
|
}
|
|
module.exports = eos;
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/async_iterator.js
|
|
var require_async_iterator = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/async_iterator.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var _Object$setPrototypeO;
|
|
function _defineProperty(obj, key2, value) {
|
|
if (key2 in obj) {
|
|
Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });
|
|
} else {
|
|
obj[key2] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
var finished = require_end_of_stream();
|
|
var kLastResolve = Symbol("lastResolve");
|
|
var kLastReject = Symbol("lastReject");
|
|
var kError = Symbol("error");
|
|
var kEnded = Symbol("ended");
|
|
var kLastPromise = Symbol("lastPromise");
|
|
var kHandlePromise = Symbol("handlePromise");
|
|
var kStream = Symbol("stream");
|
|
function createIterResult(value, done) {
|
|
return {
|
|
value,
|
|
done
|
|
};
|
|
}
|
|
function readAndResolve(iter) {
|
|
var resolve = iter[kLastResolve];
|
|
if (resolve !== null) {
|
|
var data = iter[kStream].read();
|
|
if (data !== null) {
|
|
iter[kLastPromise] = null;
|
|
iter[kLastResolve] = null;
|
|
iter[kLastReject] = null;
|
|
resolve(createIterResult(data, false));
|
|
}
|
|
}
|
|
}
|
|
function onReadable(iter) {
|
|
process.nextTick(readAndResolve, iter);
|
|
}
|
|
function wrapForNext(lastPromise, iter) {
|
|
return function(resolve, reject) {
|
|
lastPromise.then(function() {
|
|
if (iter[kEnded]) {
|
|
resolve(createIterResult(void 0, true));
|
|
return;
|
|
}
|
|
iter[kHandlePromise](resolve, reject);
|
|
}, reject);
|
|
};
|
|
}
|
|
var AsyncIteratorPrototype = Object.getPrototypeOf(function() {
|
|
});
|
|
var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
|
|
get stream() {
|
|
return this[kStream];
|
|
},
|
|
next: function next() {
|
|
var _this = this;
|
|
var error = this[kError];
|
|
if (error !== null) {
|
|
return Promise.reject(error);
|
|
}
|
|
if (this[kEnded]) {
|
|
return Promise.resolve(createIterResult(void 0, true));
|
|
}
|
|
if (this[kStream].destroyed) {
|
|
return new Promise(function(resolve, reject) {
|
|
process.nextTick(function() {
|
|
if (_this[kError]) {
|
|
reject(_this[kError]);
|
|
} else {
|
|
resolve(createIterResult(void 0, true));
|
|
}
|
|
});
|
|
});
|
|
}
|
|
var lastPromise = this[kLastPromise];
|
|
var promise2;
|
|
if (lastPromise) {
|
|
promise2 = new Promise(wrapForNext(lastPromise, this));
|
|
} else {
|
|
var data = this[kStream].read();
|
|
if (data !== null) {
|
|
return Promise.resolve(createIterResult(data, false));
|
|
}
|
|
promise2 = new Promise(this[kHandlePromise]);
|
|
}
|
|
this[kLastPromise] = promise2;
|
|
return promise2;
|
|
}
|
|
}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function() {
|
|
return this;
|
|
}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
|
|
var _this2 = this;
|
|
return new Promise(function(resolve, reject) {
|
|
_this2[kStream].destroy(null, function(err) {
|
|
if (err) {
|
|
reject(err);
|
|
return;
|
|
}
|
|
resolve(createIterResult(void 0, true));
|
|
});
|
|
});
|
|
}), _Object$setPrototypeO), AsyncIteratorPrototype);
|
|
var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator2(stream) {
|
|
var _Object$create;
|
|
var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
|
|
value: stream,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kLastResolve, {
|
|
value: null,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kLastReject, {
|
|
value: null,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kError, {
|
|
value: null,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kEnded, {
|
|
value: stream._readableState.endEmitted,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kHandlePromise, {
|
|
value: function value(resolve, reject) {
|
|
var data = iterator[kStream].read();
|
|
if (data) {
|
|
iterator[kLastPromise] = null;
|
|
iterator[kLastResolve] = null;
|
|
iterator[kLastReject] = null;
|
|
resolve(createIterResult(data, false));
|
|
} else {
|
|
iterator[kLastResolve] = resolve;
|
|
iterator[kLastReject] = reject;
|
|
}
|
|
},
|
|
writable: true
|
|
}), _Object$create));
|
|
iterator[kLastPromise] = null;
|
|
finished(stream, function(err) {
|
|
if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
|
|
var reject = iterator[kLastReject];
|
|
if (reject !== null) {
|
|
iterator[kLastPromise] = null;
|
|
iterator[kLastResolve] = null;
|
|
iterator[kLastReject] = null;
|
|
reject(err);
|
|
}
|
|
iterator[kError] = err;
|
|
return;
|
|
}
|
|
var resolve = iterator[kLastResolve];
|
|
if (resolve !== null) {
|
|
iterator[kLastPromise] = null;
|
|
iterator[kLastResolve] = null;
|
|
iterator[kLastReject] = null;
|
|
resolve(createIterResult(void 0, true));
|
|
}
|
|
iterator[kEnded] = true;
|
|
});
|
|
stream.on("readable", onReadable.bind(null, iterator));
|
|
return iterator;
|
|
};
|
|
module.exports = createReadableStreamAsyncIterator;
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/from-browser.js
|
|
var require_from_browser = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/from-browser.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
module.exports = function() {
|
|
throw new Error("Readable.from is not available in the browser");
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_readable.js
|
|
var require_stream_readable = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_readable.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
module.exports = Readable;
|
|
var Duplex;
|
|
Readable.ReadableState = ReadableState;
|
|
var EE = require_events().EventEmitter;
|
|
var EElistenerCount = function EElistenerCount2(emitter, type) {
|
|
return emitter.listeners(type).length;
|
|
};
|
|
var Stream = require_stream_browser();
|
|
var Buffer14 = require_buffer().Buffer;
|
|
var OurUint8Array = window.Uint8Array || function() {
|
|
};
|
|
function _uint8ArrayToBuffer(chunk) {
|
|
return Buffer14.from(chunk);
|
|
}
|
|
function _isUint8Array(obj) {
|
|
return Buffer14.isBuffer(obj) || obj instanceof OurUint8Array;
|
|
}
|
|
var debugUtil = require_util();
|
|
var debug;
|
|
if (debugUtil && debugUtil.debuglog) {
|
|
debug = debugUtil.debuglog("stream");
|
|
} else {
|
|
debug = function debug2() {
|
|
};
|
|
}
|
|
var BufferList = require_buffer_list();
|
|
var destroyImpl = require_destroy();
|
|
var _require = require_state();
|
|
var getHighWaterMark = _require.getHighWaterMark;
|
|
var _require$codes = require_errors_browser().codes;
|
|
var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
|
|
var ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF;
|
|
var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
|
|
var ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
|
|
var StringDecoder;
|
|
var createReadableStreamAsyncIterator;
|
|
var from;
|
|
require_inherits_browser()(Readable, Stream);
|
|
var errorOrDestroy = destroyImpl.errorOrDestroy;
|
|
var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
|
|
function prependListener(emitter, event, fn) {
|
|
if (typeof emitter.prependListener === "function")
|
|
return emitter.prependListener(event, fn);
|
|
if (!emitter._events || !emitter._events[event])
|
|
emitter.on(event, fn);
|
|
else if (Array.isArray(emitter._events[event]))
|
|
emitter._events[event].unshift(fn);
|
|
else
|
|
emitter._events[event] = [fn, emitter._events[event]];
|
|
}
|
|
function ReadableState(options, stream, isDuplex) {
|
|
Duplex = Duplex || require_stream_duplex();
|
|
options = options || {};
|
|
if (typeof isDuplex !== "boolean")
|
|
isDuplex = stream instanceof Duplex;
|
|
this.objectMode = !!options.objectMode;
|
|
if (isDuplex)
|
|
this.objectMode = this.objectMode || !!options.readableObjectMode;
|
|
this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex);
|
|
this.buffer = new BufferList();
|
|
this.length = 0;
|
|
this.pipes = null;
|
|
this.pipesCount = 0;
|
|
this.flowing = null;
|
|
this.ended = false;
|
|
this.endEmitted = false;
|
|
this.reading = false;
|
|
this.sync = true;
|
|
this.needReadable = false;
|
|
this.emittedReadable = false;
|
|
this.readableListening = false;
|
|
this.resumeScheduled = false;
|
|
this.paused = true;
|
|
this.emitClose = options.emitClose !== false;
|
|
this.autoDestroy = !!options.autoDestroy;
|
|
this.destroyed = false;
|
|
this.defaultEncoding = options.defaultEncoding || "utf8";
|
|
this.awaitDrain = 0;
|
|
this.readingMore = false;
|
|
this.decoder = null;
|
|
this.encoding = null;
|
|
if (options.encoding) {
|
|
if (!StringDecoder)
|
|
StringDecoder = require_string_decoder().StringDecoder;
|
|
this.decoder = new StringDecoder(options.encoding);
|
|
this.encoding = options.encoding;
|
|
}
|
|
}
|
|
function Readable(options) {
|
|
Duplex = Duplex || require_stream_duplex();
|
|
if (!(this instanceof Readable))
|
|
return new Readable(options);
|
|
var isDuplex = this instanceof Duplex;
|
|
this._readableState = new ReadableState(options, this, isDuplex);
|
|
this.readable = true;
|
|
if (options) {
|
|
if (typeof options.read === "function")
|
|
this._read = options.read;
|
|
if (typeof options.destroy === "function")
|
|
this._destroy = options.destroy;
|
|
}
|
|
Stream.call(this);
|
|
}
|
|
Object.defineProperty(Readable.prototype, "destroyed", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
if (this._readableState === void 0) {
|
|
return false;
|
|
}
|
|
return this._readableState.destroyed;
|
|
},
|
|
set: function set(value) {
|
|
if (!this._readableState) {
|
|
return;
|
|
}
|
|
this._readableState.destroyed = value;
|
|
}
|
|
});
|
|
Readable.prototype.destroy = destroyImpl.destroy;
|
|
Readable.prototype._undestroy = destroyImpl.undestroy;
|
|
Readable.prototype._destroy = function(err, cb) {
|
|
cb(err);
|
|
};
|
|
Readable.prototype.push = function(chunk, encoding) {
|
|
var state = this._readableState;
|
|
var skipChunkCheck;
|
|
if (!state.objectMode) {
|
|
if (typeof chunk === "string") {
|
|
encoding = encoding || state.defaultEncoding;
|
|
if (encoding !== state.encoding) {
|
|
chunk = Buffer14.from(chunk, encoding);
|
|
encoding = "";
|
|
}
|
|
skipChunkCheck = true;
|
|
}
|
|
} else {
|
|
skipChunkCheck = true;
|
|
}
|
|
return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
|
|
};
|
|
Readable.prototype.unshift = function(chunk) {
|
|
return readableAddChunk(this, chunk, null, true, false);
|
|
};
|
|
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
|
|
debug("readableAddChunk", chunk);
|
|
var state = stream._readableState;
|
|
if (chunk === null) {
|
|
state.reading = false;
|
|
onEofChunk(stream, state);
|
|
} else {
|
|
var er;
|
|
if (!skipChunkCheck)
|
|
er = chunkInvalid(state, chunk);
|
|
if (er) {
|
|
errorOrDestroy(stream, er);
|
|
} else if (state.objectMode || chunk && chunk.length > 0) {
|
|
if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer14.prototype) {
|
|
chunk = _uint8ArrayToBuffer(chunk);
|
|
}
|
|
if (addToFront) {
|
|
if (state.endEmitted)
|
|
errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
|
|
else
|
|
addChunk(stream, state, chunk, true);
|
|
} else if (state.ended) {
|
|
errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
|
|
} else if (state.destroyed) {
|
|
return false;
|
|
} else {
|
|
state.reading = false;
|
|
if (state.decoder && !encoding) {
|
|
chunk = state.decoder.write(chunk);
|
|
if (state.objectMode || chunk.length !== 0)
|
|
addChunk(stream, state, chunk, false);
|
|
else
|
|
maybeReadMore(stream, state);
|
|
} else {
|
|
addChunk(stream, state, chunk, false);
|
|
}
|
|
}
|
|
} else if (!addToFront) {
|
|
state.reading = false;
|
|
maybeReadMore(stream, state);
|
|
}
|
|
}
|
|
return !state.ended && (state.length < state.highWaterMark || state.length === 0);
|
|
}
|
|
function addChunk(stream, state, chunk, addToFront) {
|
|
if (state.flowing && state.length === 0 && !state.sync) {
|
|
state.awaitDrain = 0;
|
|
stream.emit("data", chunk);
|
|
} else {
|
|
state.length += state.objectMode ? 1 : chunk.length;
|
|
if (addToFront)
|
|
state.buffer.unshift(chunk);
|
|
else
|
|
state.buffer.push(chunk);
|
|
if (state.needReadable)
|
|
emitReadable(stream);
|
|
}
|
|
maybeReadMore(stream, state);
|
|
}
|
|
function chunkInvalid(state, chunk) {
|
|
var er;
|
|
if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
|
|
er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
|
|
}
|
|
return er;
|
|
}
|
|
Readable.prototype.isPaused = function() {
|
|
return this._readableState.flowing === false;
|
|
};
|
|
Readable.prototype.setEncoding = function(enc) {
|
|
if (!StringDecoder)
|
|
StringDecoder = require_string_decoder().StringDecoder;
|
|
var decoder = new StringDecoder(enc);
|
|
this._readableState.decoder = decoder;
|
|
this._readableState.encoding = this._readableState.decoder.encoding;
|
|
var p = this._readableState.buffer.head;
|
|
var content = "";
|
|
while (p !== null) {
|
|
content += decoder.write(p.data);
|
|
p = p.next;
|
|
}
|
|
this._readableState.buffer.clear();
|
|
if (content !== "")
|
|
this._readableState.buffer.push(content);
|
|
this._readableState.length = content.length;
|
|
return this;
|
|
};
|
|
var MAX_HWM = 1073741824;
|
|
function computeNewHighWaterMark(n) {
|
|
if (n >= MAX_HWM) {
|
|
n = MAX_HWM;
|
|
} else {
|
|
n--;
|
|
n |= n >>> 1;
|
|
n |= n >>> 2;
|
|
n |= n >>> 4;
|
|
n |= n >>> 8;
|
|
n |= n >>> 16;
|
|
n++;
|
|
}
|
|
return n;
|
|
}
|
|
function howMuchToRead(n, state) {
|
|
if (n <= 0 || state.length === 0 && state.ended)
|
|
return 0;
|
|
if (state.objectMode)
|
|
return 1;
|
|
if (n !== n) {
|
|
if (state.flowing && state.length)
|
|
return state.buffer.head.data.length;
|
|
else
|
|
return state.length;
|
|
}
|
|
if (n > state.highWaterMark)
|
|
state.highWaterMark = computeNewHighWaterMark(n);
|
|
if (n <= state.length)
|
|
return n;
|
|
if (!state.ended) {
|
|
state.needReadable = true;
|
|
return 0;
|
|
}
|
|
return state.length;
|
|
}
|
|
Readable.prototype.read = function(n) {
|
|
debug("read", n);
|
|
n = parseInt(n, 10);
|
|
var state = this._readableState;
|
|
var nOrig = n;
|
|
if (n !== 0)
|
|
state.emittedReadable = false;
|
|
if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
|
|
debug("read: emitReadable", state.length, state.ended);
|
|
if (state.length === 0 && state.ended)
|
|
endReadable(this);
|
|
else
|
|
emitReadable(this);
|
|
return null;
|
|
}
|
|
n = howMuchToRead(n, state);
|
|
if (n === 0 && state.ended) {
|
|
if (state.length === 0)
|
|
endReadable(this);
|
|
return null;
|
|
}
|
|
var doRead = state.needReadable;
|
|
debug("need readable", doRead);
|
|
if (state.length === 0 || state.length - n < state.highWaterMark) {
|
|
doRead = true;
|
|
debug("length less than watermark", doRead);
|
|
}
|
|
if (state.ended || state.reading) {
|
|
doRead = false;
|
|
debug("reading or ended", doRead);
|
|
} else if (doRead) {
|
|
debug("do read");
|
|
state.reading = true;
|
|
state.sync = true;
|
|
if (state.length === 0)
|
|
state.needReadable = true;
|
|
this._read(state.highWaterMark);
|
|
state.sync = false;
|
|
if (!state.reading)
|
|
n = howMuchToRead(nOrig, state);
|
|
}
|
|
var ret;
|
|
if (n > 0)
|
|
ret = fromList(n, state);
|
|
else
|
|
ret = null;
|
|
if (ret === null) {
|
|
state.needReadable = state.length <= state.highWaterMark;
|
|
n = 0;
|
|
} else {
|
|
state.length -= n;
|
|
state.awaitDrain = 0;
|
|
}
|
|
if (state.length === 0) {
|
|
if (!state.ended)
|
|
state.needReadable = true;
|
|
if (nOrig !== n && state.ended)
|
|
endReadable(this);
|
|
}
|
|
if (ret !== null)
|
|
this.emit("data", ret);
|
|
return ret;
|
|
};
|
|
function onEofChunk(stream, state) {
|
|
debug("onEofChunk");
|
|
if (state.ended)
|
|
return;
|
|
if (state.decoder) {
|
|
var chunk = state.decoder.end();
|
|
if (chunk && chunk.length) {
|
|
state.buffer.push(chunk);
|
|
state.length += state.objectMode ? 1 : chunk.length;
|
|
}
|
|
}
|
|
state.ended = true;
|
|
if (state.sync) {
|
|
emitReadable(stream);
|
|
} else {
|
|
state.needReadable = false;
|
|
if (!state.emittedReadable) {
|
|
state.emittedReadable = true;
|
|
emitReadable_(stream);
|
|
}
|
|
}
|
|
}
|
|
function emitReadable(stream) {
|
|
var state = stream._readableState;
|
|
debug("emitReadable", state.needReadable, state.emittedReadable);
|
|
state.needReadable = false;
|
|
if (!state.emittedReadable) {
|
|
debug("emitReadable", state.flowing);
|
|
state.emittedReadable = true;
|
|
process.nextTick(emitReadable_, stream);
|
|
}
|
|
}
|
|
function emitReadable_(stream) {
|
|
var state = stream._readableState;
|
|
debug("emitReadable_", state.destroyed, state.length, state.ended);
|
|
if (!state.destroyed && (state.length || state.ended)) {
|
|
stream.emit("readable");
|
|
state.emittedReadable = false;
|
|
}
|
|
state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
|
|
flow(stream);
|
|
}
|
|
function maybeReadMore(stream, state) {
|
|
if (!state.readingMore) {
|
|
state.readingMore = true;
|
|
process.nextTick(maybeReadMore_, stream, state);
|
|
}
|
|
}
|
|
function maybeReadMore_(stream, state) {
|
|
while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
|
|
var len = state.length;
|
|
debug("maybeReadMore read 0");
|
|
stream.read(0);
|
|
if (len === state.length)
|
|
break;
|
|
}
|
|
state.readingMore = false;
|
|
}
|
|
Readable.prototype._read = function(n) {
|
|
errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));
|
|
};
|
|
Readable.prototype.pipe = function(dest, pipeOpts) {
|
|
var src = this;
|
|
var state = this._readableState;
|
|
switch (state.pipesCount) {
|
|
case 0:
|
|
state.pipes = dest;
|
|
break;
|
|
case 1:
|
|
state.pipes = [state.pipes, dest];
|
|
break;
|
|
default:
|
|
state.pipes.push(dest);
|
|
break;
|
|
}
|
|
state.pipesCount += 1;
|
|
debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
|
|
var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
|
|
var endFn = doEnd ? onend : unpipe;
|
|
if (state.endEmitted)
|
|
process.nextTick(endFn);
|
|
else
|
|
src.once("end", endFn);
|
|
dest.on("unpipe", onunpipe);
|
|
function onunpipe(readable, unpipeInfo) {
|
|
debug("onunpipe");
|
|
if (readable === src) {
|
|
if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
|
|
unpipeInfo.hasUnpiped = true;
|
|
cleanup();
|
|
}
|
|
}
|
|
}
|
|
function onend() {
|
|
debug("onend");
|
|
dest.end();
|
|
}
|
|
var ondrain = pipeOnDrain(src);
|
|
dest.on("drain", ondrain);
|
|
var cleanedUp = false;
|
|
function cleanup() {
|
|
debug("cleanup");
|
|
dest.removeListener("close", onclose);
|
|
dest.removeListener("finish", onfinish);
|
|
dest.removeListener("drain", ondrain);
|
|
dest.removeListener("error", onerror);
|
|
dest.removeListener("unpipe", onunpipe);
|
|
src.removeListener("end", onend);
|
|
src.removeListener("end", unpipe);
|
|
src.removeListener("data", ondata);
|
|
cleanedUp = true;
|
|
if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain))
|
|
ondrain();
|
|
}
|
|
src.on("data", ondata);
|
|
function ondata(chunk) {
|
|
debug("ondata");
|
|
var ret = dest.write(chunk);
|
|
debug("dest.write", ret);
|
|
if (ret === false) {
|
|
if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
|
|
debug("false write response, pause", state.awaitDrain);
|
|
state.awaitDrain++;
|
|
}
|
|
src.pause();
|
|
}
|
|
}
|
|
function onerror(er) {
|
|
debug("onerror", er);
|
|
unpipe();
|
|
dest.removeListener("error", onerror);
|
|
if (EElistenerCount(dest, "error") === 0)
|
|
errorOrDestroy(dest, er);
|
|
}
|
|
prependListener(dest, "error", onerror);
|
|
function onclose() {
|
|
dest.removeListener("finish", onfinish);
|
|
unpipe();
|
|
}
|
|
dest.once("close", onclose);
|
|
function onfinish() {
|
|
debug("onfinish");
|
|
dest.removeListener("close", onclose);
|
|
unpipe();
|
|
}
|
|
dest.once("finish", onfinish);
|
|
function unpipe() {
|
|
debug("unpipe");
|
|
src.unpipe(dest);
|
|
}
|
|
dest.emit("pipe", src);
|
|
if (!state.flowing) {
|
|
debug("pipe resume");
|
|
src.resume();
|
|
}
|
|
return dest;
|
|
};
|
|
function pipeOnDrain(src) {
|
|
return function pipeOnDrainFunctionResult() {
|
|
var state = src._readableState;
|
|
debug("pipeOnDrain", state.awaitDrain);
|
|
if (state.awaitDrain)
|
|
state.awaitDrain--;
|
|
if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
|
|
state.flowing = true;
|
|
flow(src);
|
|
}
|
|
};
|
|
}
|
|
Readable.prototype.unpipe = function(dest) {
|
|
var state = this._readableState;
|
|
var unpipeInfo = {
|
|
hasUnpiped: false
|
|
};
|
|
if (state.pipesCount === 0)
|
|
return this;
|
|
if (state.pipesCount === 1) {
|
|
if (dest && dest !== state.pipes)
|
|
return this;
|
|
if (!dest)
|
|
dest = state.pipes;
|
|
state.pipes = null;
|
|
state.pipesCount = 0;
|
|
state.flowing = false;
|
|
if (dest)
|
|
dest.emit("unpipe", this, unpipeInfo);
|
|
return this;
|
|
}
|
|
if (!dest) {
|
|
var dests = state.pipes;
|
|
var len = state.pipesCount;
|
|
state.pipes = null;
|
|
state.pipesCount = 0;
|
|
state.flowing = false;
|
|
for (var i = 0; i < len; i++) {
|
|
dests[i].emit("unpipe", this, {
|
|
hasUnpiped: false
|
|
});
|
|
}
|
|
return this;
|
|
}
|
|
var index = indexOf(state.pipes, dest);
|
|
if (index === -1)
|
|
return this;
|
|
state.pipes.splice(index, 1);
|
|
state.pipesCount -= 1;
|
|
if (state.pipesCount === 1)
|
|
state.pipes = state.pipes[0];
|
|
dest.emit("unpipe", this, unpipeInfo);
|
|
return this;
|
|
};
|
|
Readable.prototype.on = function(ev, fn) {
|
|
var res = Stream.prototype.on.call(this, ev, fn);
|
|
var state = this._readableState;
|
|
if (ev === "data") {
|
|
state.readableListening = this.listenerCount("readable") > 0;
|
|
if (state.flowing !== false)
|
|
this.resume();
|
|
} else if (ev === "readable") {
|
|
if (!state.endEmitted && !state.readableListening) {
|
|
state.readableListening = state.needReadable = true;
|
|
state.flowing = false;
|
|
state.emittedReadable = false;
|
|
debug("on readable", state.length, state.reading);
|
|
if (state.length) {
|
|
emitReadable(this);
|
|
} else if (!state.reading) {
|
|
process.nextTick(nReadingNextTick, this);
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
Readable.prototype.addListener = Readable.prototype.on;
|
|
Readable.prototype.removeListener = function(ev, fn) {
|
|
var res = Stream.prototype.removeListener.call(this, ev, fn);
|
|
if (ev === "readable") {
|
|
process.nextTick(updateReadableListening, this);
|
|
}
|
|
return res;
|
|
};
|
|
Readable.prototype.removeAllListeners = function(ev) {
|
|
var res = Stream.prototype.removeAllListeners.apply(this, arguments);
|
|
if (ev === "readable" || ev === void 0) {
|
|
process.nextTick(updateReadableListening, this);
|
|
}
|
|
return res;
|
|
};
|
|
function updateReadableListening(self) {
|
|
var state = self._readableState;
|
|
state.readableListening = self.listenerCount("readable") > 0;
|
|
if (state.resumeScheduled && !state.paused) {
|
|
state.flowing = true;
|
|
} else if (self.listenerCount("data") > 0) {
|
|
self.resume();
|
|
}
|
|
}
|
|
function nReadingNextTick(self) {
|
|
debug("readable nexttick read 0");
|
|
self.read(0);
|
|
}
|
|
Readable.prototype.resume = function() {
|
|
var state = this._readableState;
|
|
if (!state.flowing) {
|
|
debug("resume");
|
|
state.flowing = !state.readableListening;
|
|
resume(this, state);
|
|
}
|
|
state.paused = false;
|
|
return this;
|
|
};
|
|
function resume(stream, state) {
|
|
if (!state.resumeScheduled) {
|
|
state.resumeScheduled = true;
|
|
process.nextTick(resume_, stream, state);
|
|
}
|
|
}
|
|
function resume_(stream, state) {
|
|
debug("resume", state.reading);
|
|
if (!state.reading) {
|
|
stream.read(0);
|
|
}
|
|
state.resumeScheduled = false;
|
|
stream.emit("resume");
|
|
flow(stream);
|
|
if (state.flowing && !state.reading)
|
|
stream.read(0);
|
|
}
|
|
Readable.prototype.pause = function() {
|
|
debug("call pause flowing=%j", this._readableState.flowing);
|
|
if (this._readableState.flowing !== false) {
|
|
debug("pause");
|
|
this._readableState.flowing = false;
|
|
this.emit("pause");
|
|
}
|
|
this._readableState.paused = true;
|
|
return this;
|
|
};
|
|
function flow(stream) {
|
|
var state = stream._readableState;
|
|
debug("flow", state.flowing);
|
|
while (state.flowing && stream.read() !== null) {
|
|
;
|
|
}
|
|
}
|
|
Readable.prototype.wrap = function(stream) {
|
|
var _this = this;
|
|
var state = this._readableState;
|
|
var paused = false;
|
|
stream.on("end", function() {
|
|
debug("wrapped end");
|
|
if (state.decoder && !state.ended) {
|
|
var chunk = state.decoder.end();
|
|
if (chunk && chunk.length)
|
|
_this.push(chunk);
|
|
}
|
|
_this.push(null);
|
|
});
|
|
stream.on("data", function(chunk) {
|
|
debug("wrapped data");
|
|
if (state.decoder)
|
|
chunk = state.decoder.write(chunk);
|
|
if (state.objectMode && (chunk === null || chunk === void 0))
|
|
return;
|
|
else if (!state.objectMode && (!chunk || !chunk.length))
|
|
return;
|
|
var ret = _this.push(chunk);
|
|
if (!ret) {
|
|
paused = true;
|
|
stream.pause();
|
|
}
|
|
});
|
|
for (var i in stream) {
|
|
if (this[i] === void 0 && typeof stream[i] === "function") {
|
|
this[i] = function methodWrap(method) {
|
|
return function methodWrapReturnFunction() {
|
|
return stream[method].apply(stream, arguments);
|
|
};
|
|
}(i);
|
|
}
|
|
}
|
|
for (var n = 0; n < kProxyEvents.length; n++) {
|
|
stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
|
|
}
|
|
this._read = function(n2) {
|
|
debug("wrapped _read", n2);
|
|
if (paused) {
|
|
paused = false;
|
|
stream.resume();
|
|
}
|
|
};
|
|
return this;
|
|
};
|
|
if (typeof Symbol === "function") {
|
|
Readable.prototype[Symbol.asyncIterator] = function() {
|
|
if (createReadableStreamAsyncIterator === void 0) {
|
|
createReadableStreamAsyncIterator = require_async_iterator();
|
|
}
|
|
return createReadableStreamAsyncIterator(this);
|
|
};
|
|
}
|
|
Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._readableState.highWaterMark;
|
|
}
|
|
});
|
|
Object.defineProperty(Readable.prototype, "readableBuffer", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._readableState && this._readableState.buffer;
|
|
}
|
|
});
|
|
Object.defineProperty(Readable.prototype, "readableFlowing", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._readableState.flowing;
|
|
},
|
|
set: function set(state) {
|
|
if (this._readableState) {
|
|
this._readableState.flowing = state;
|
|
}
|
|
}
|
|
});
|
|
Readable._fromList = fromList;
|
|
Object.defineProperty(Readable.prototype, "readableLength", {
|
|
enumerable: false,
|
|
get: function get2() {
|
|
return this._readableState.length;
|
|
}
|
|
});
|
|
function fromList(n, state) {
|
|
if (state.length === 0)
|
|
return null;
|
|
var ret;
|
|
if (state.objectMode)
|
|
ret = state.buffer.shift();
|
|
else if (!n || n >= state.length) {
|
|
if (state.decoder)
|
|
ret = state.buffer.join("");
|
|
else if (state.buffer.length === 1)
|
|
ret = state.buffer.first();
|
|
else
|
|
ret = state.buffer.concat(state.length);
|
|
state.buffer.clear();
|
|
} else {
|
|
ret = state.buffer.consume(n, state.decoder);
|
|
}
|
|
return ret;
|
|
}
|
|
function endReadable(stream) {
|
|
var state = stream._readableState;
|
|
debug("endReadable", state.endEmitted);
|
|
if (!state.endEmitted) {
|
|
state.ended = true;
|
|
process.nextTick(endReadableNT, state, stream);
|
|
}
|
|
}
|
|
function endReadableNT(state, stream) {
|
|
debug("endReadableNT", state.endEmitted, state.length);
|
|
if (!state.endEmitted && state.length === 0) {
|
|
state.endEmitted = true;
|
|
stream.readable = false;
|
|
stream.emit("end");
|
|
if (state.autoDestroy) {
|
|
var wState = stream._writableState;
|
|
if (!wState || wState.autoDestroy && wState.finished) {
|
|
stream.destroy();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (typeof Symbol === "function") {
|
|
Readable.from = function(iterable, opts) {
|
|
if (from === void 0) {
|
|
from = require_from_browser();
|
|
}
|
|
return from(Readable, iterable, opts);
|
|
};
|
|
}
|
|
function indexOf(xs, x) {
|
|
for (var i = 0, l = xs.length; i < l; i++) {
|
|
if (xs[i] === x)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_transform.js
|
|
var require_stream_transform = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_transform.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
module.exports = Transform;
|
|
var _require$codes = require_errors_browser().codes;
|
|
var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
|
|
var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
|
|
var ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING;
|
|
var ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
|
|
var Duplex = require_stream_duplex();
|
|
require_inherits_browser()(Transform, Duplex);
|
|
function afterTransform(er, data) {
|
|
var ts4 = this._transformState;
|
|
ts4.transforming = false;
|
|
var cb = ts4.writecb;
|
|
if (cb === null) {
|
|
return this.emit("error", new ERR_MULTIPLE_CALLBACK());
|
|
}
|
|
ts4.writechunk = null;
|
|
ts4.writecb = null;
|
|
if (data != null)
|
|
this.push(data);
|
|
cb(er);
|
|
var rs = this._readableState;
|
|
rs.reading = false;
|
|
if (rs.needReadable || rs.length < rs.highWaterMark) {
|
|
this._read(rs.highWaterMark);
|
|
}
|
|
}
|
|
function Transform(options) {
|
|
if (!(this instanceof Transform))
|
|
return new Transform(options);
|
|
Duplex.call(this, options);
|
|
this._transformState = {
|
|
afterTransform: afterTransform.bind(this),
|
|
needTransform: false,
|
|
transforming: false,
|
|
writecb: null,
|
|
writechunk: null,
|
|
writeencoding: null
|
|
};
|
|
this._readableState.needReadable = true;
|
|
this._readableState.sync = false;
|
|
if (options) {
|
|
if (typeof options.transform === "function")
|
|
this._transform = options.transform;
|
|
if (typeof options.flush === "function")
|
|
this._flush = options.flush;
|
|
}
|
|
this.on("prefinish", prefinish);
|
|
}
|
|
function prefinish() {
|
|
var _this = this;
|
|
if (typeof this._flush === "function" && !this._readableState.destroyed) {
|
|
this._flush(function(er, data) {
|
|
done(_this, er, data);
|
|
});
|
|
} else {
|
|
done(this, null, null);
|
|
}
|
|
}
|
|
Transform.prototype.push = function(chunk, encoding) {
|
|
this._transformState.needTransform = false;
|
|
return Duplex.prototype.push.call(this, chunk, encoding);
|
|
};
|
|
Transform.prototype._transform = function(chunk, encoding, cb) {
|
|
cb(new ERR_METHOD_NOT_IMPLEMENTED("_transform()"));
|
|
};
|
|
Transform.prototype._write = function(chunk, encoding, cb) {
|
|
var ts4 = this._transformState;
|
|
ts4.writecb = cb;
|
|
ts4.writechunk = chunk;
|
|
ts4.writeencoding = encoding;
|
|
if (!ts4.transforming) {
|
|
var rs = this._readableState;
|
|
if (ts4.needTransform || rs.needReadable || rs.length < rs.highWaterMark)
|
|
this._read(rs.highWaterMark);
|
|
}
|
|
};
|
|
Transform.prototype._read = function(n) {
|
|
var ts4 = this._transformState;
|
|
if (ts4.writechunk !== null && !ts4.transforming) {
|
|
ts4.transforming = true;
|
|
this._transform(ts4.writechunk, ts4.writeencoding, ts4.afterTransform);
|
|
} else {
|
|
ts4.needTransform = true;
|
|
}
|
|
};
|
|
Transform.prototype._destroy = function(err, cb) {
|
|
Duplex.prototype._destroy.call(this, err, function(err2) {
|
|
cb(err2);
|
|
});
|
|
};
|
|
function done(stream, er, data) {
|
|
if (er)
|
|
return stream.emit("error", er);
|
|
if (data != null)
|
|
stream.push(data);
|
|
if (stream._writableState.length)
|
|
throw new ERR_TRANSFORM_WITH_LENGTH_0();
|
|
if (stream._transformState.transforming)
|
|
throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
|
|
return stream.push(null);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_passthrough.js
|
|
var require_stream_passthrough = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_passthrough.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
module.exports = PassThrough;
|
|
var Transform = require_stream_transform();
|
|
require_inherits_browser()(PassThrough, Transform);
|
|
function PassThrough(options) {
|
|
if (!(this instanceof PassThrough))
|
|
return new PassThrough(options);
|
|
Transform.call(this, options);
|
|
}
|
|
PassThrough.prototype._transform = function(chunk, encoding, cb) {
|
|
cb(null, chunk);
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/pipeline.js
|
|
var require_pipeline = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/pipeline.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var eos;
|
|
function once(callback) {
|
|
var called = false;
|
|
return function() {
|
|
if (called)
|
|
return;
|
|
called = true;
|
|
callback.apply(void 0, arguments);
|
|
};
|
|
}
|
|
var _require$codes = require_errors_browser().codes;
|
|
var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
|
|
var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
|
|
function noop3(err) {
|
|
if (err)
|
|
throw err;
|
|
}
|
|
function isRequest(stream) {
|
|
return stream.setHeader && typeof stream.abort === "function";
|
|
}
|
|
function destroyer(stream, reading, writing, callback) {
|
|
callback = once(callback);
|
|
var closed = false;
|
|
stream.on("close", function() {
|
|
closed = true;
|
|
});
|
|
if (eos === void 0)
|
|
eos = require_end_of_stream();
|
|
eos(stream, {
|
|
readable: reading,
|
|
writable: writing
|
|
}, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
closed = true;
|
|
callback();
|
|
});
|
|
var destroyed = false;
|
|
return function(err) {
|
|
if (closed)
|
|
return;
|
|
if (destroyed)
|
|
return;
|
|
destroyed = true;
|
|
if (isRequest(stream))
|
|
return stream.abort();
|
|
if (typeof stream.destroy === "function")
|
|
return stream.destroy();
|
|
callback(err || new ERR_STREAM_DESTROYED("pipe"));
|
|
};
|
|
}
|
|
function call(fn) {
|
|
fn();
|
|
}
|
|
function pipe(from, to) {
|
|
return from.pipe(to);
|
|
}
|
|
function popCallback(streams) {
|
|
if (!streams.length)
|
|
return noop3;
|
|
if (typeof streams[streams.length - 1] !== "function")
|
|
return noop3;
|
|
return streams.pop();
|
|
}
|
|
function pipeline() {
|
|
for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
streams[_key] = arguments[_key];
|
|
}
|
|
var callback = popCallback(streams);
|
|
if (Array.isArray(streams[0]))
|
|
streams = streams[0];
|
|
if (streams.length < 2) {
|
|
throw new ERR_MISSING_ARGS("streams");
|
|
}
|
|
var error;
|
|
var destroys = streams.map(function(stream, i) {
|
|
var reading = i < streams.length - 1;
|
|
var writing = i > 0;
|
|
return destroyer(stream, reading, writing, function(err) {
|
|
if (!error)
|
|
error = err;
|
|
if (err)
|
|
destroys.forEach(call);
|
|
if (reading)
|
|
return;
|
|
destroys.forEach(call);
|
|
callback(error);
|
|
});
|
|
});
|
|
return streams.reduce(pipe);
|
|
}
|
|
module.exports = pipeline;
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/node_modules/readable-stream/readable-browser.js
|
|
var require_readable_browser = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/node_modules/readable-stream/readable-browser.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
exports = module.exports = require_stream_readable();
|
|
exports.Stream = exports;
|
|
exports.Readable = exports;
|
|
exports.Writable = require_stream_writable();
|
|
exports.Duplex = require_stream_duplex();
|
|
exports.Transform = require_stream_transform();
|
|
exports.PassThrough = require_stream_passthrough();
|
|
exports.finished = require_end_of_stream();
|
|
exports.pipeline = require_pipeline();
|
|
}
|
|
});
|
|
|
|
// node_modules/readable-web-to-node-stream/lib/index.js
|
|
var require_lib = __commonJS({
|
|
"node_modules/readable-web-to-node-stream/lib/index.js"(exports) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ReadableWebToNodeStream = void 0;
|
|
var readable_stream_1 = require_readable_browser();
|
|
var ReadableWebToNodeStream2 = class extends readable_stream_1.Readable {
|
|
constructor(stream) {
|
|
super();
|
|
this.bytesRead = 0;
|
|
this.released = false;
|
|
this.reader = stream.getReader();
|
|
}
|
|
async _read() {
|
|
if (this.released) {
|
|
this.push(null);
|
|
return;
|
|
}
|
|
this.pendingRead = this.reader.read();
|
|
const data = await this.pendingRead;
|
|
delete this.pendingRead;
|
|
if (data.done || this.released) {
|
|
this.push(null);
|
|
} else {
|
|
this.bytesRead += data.value.length;
|
|
this.push(data.value);
|
|
}
|
|
}
|
|
async waitForReadToComplete() {
|
|
if (this.pendingRead) {
|
|
await this.pendingRead;
|
|
}
|
|
}
|
|
async close() {
|
|
await this.syncAndRelease();
|
|
}
|
|
async syncAndRelease() {
|
|
this.released = true;
|
|
await this.waitForReadToComplete();
|
|
await this.reader.releaseLock();
|
|
}
|
|
};
|
|
exports.ReadableWebToNodeStream = ReadableWebToNodeStream2;
|
|
}
|
|
});
|
|
|
|
// node_modules/base-x/src/index.js
|
|
var require_src = __commonJS({
|
|
"node_modules/base-x/src/index.js"(exports, module) {
|
|
"use strict";
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function base(ALPHABET) {
|
|
if (ALPHABET.length >= 255) {
|
|
throw new TypeError("Alphabet too long");
|
|
}
|
|
var BASE_MAP = new Uint8Array(256);
|
|
for (var j = 0; j < BASE_MAP.length; j++) {
|
|
BASE_MAP[j] = 255;
|
|
}
|
|
for (var i = 0; i < ALPHABET.length; i++) {
|
|
var x = ALPHABET.charAt(i);
|
|
var xc = x.charCodeAt(0);
|
|
if (BASE_MAP[xc] !== 255) {
|
|
throw new TypeError(x + " is ambiguous");
|
|
}
|
|
BASE_MAP[xc] = i;
|
|
}
|
|
var BASE = ALPHABET.length;
|
|
var LEADER = ALPHABET.charAt(0);
|
|
var FACTOR = Math.log(BASE) / Math.log(256);
|
|
var iFACTOR = Math.log(256) / Math.log(BASE);
|
|
function encode2(source) {
|
|
if (source instanceof Uint8Array) {
|
|
} else if (ArrayBuffer.isView(source)) {
|
|
source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
|
|
} else if (Array.isArray(source)) {
|
|
source = Uint8Array.from(source);
|
|
}
|
|
if (!(source instanceof Uint8Array)) {
|
|
throw new TypeError("Expected Uint8Array");
|
|
}
|
|
if (source.length === 0) {
|
|
return "";
|
|
}
|
|
var zeroes = 0;
|
|
var length = 0;
|
|
var pbegin = 0;
|
|
var pend = source.length;
|
|
while (pbegin !== pend && source[pbegin] === 0) {
|
|
pbegin++;
|
|
zeroes++;
|
|
}
|
|
var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
|
|
var b58 = new Uint8Array(size);
|
|
while (pbegin !== pend) {
|
|
var carry = source[pbegin];
|
|
var i2 = 0;
|
|
for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
|
|
carry += 256 * b58[it1] >>> 0;
|
|
b58[it1] = carry % BASE >>> 0;
|
|
carry = carry / BASE >>> 0;
|
|
}
|
|
if (carry !== 0) {
|
|
throw new Error("Non-zero carry");
|
|
}
|
|
length = i2;
|
|
pbegin++;
|
|
}
|
|
var it2 = size - length;
|
|
while (it2 !== size && b58[it2] === 0) {
|
|
it2++;
|
|
}
|
|
var str = LEADER.repeat(zeroes);
|
|
for (; it2 < size; ++it2) {
|
|
str += ALPHABET.charAt(b58[it2]);
|
|
}
|
|
return str;
|
|
}
|
|
function decodeUnsafe(source) {
|
|
if (typeof source !== "string") {
|
|
throw new TypeError("Expected String");
|
|
}
|
|
if (source.length === 0) {
|
|
return new Uint8Array();
|
|
}
|
|
var psz = 0;
|
|
var zeroes = 0;
|
|
var length = 0;
|
|
while (source[psz] === LEADER) {
|
|
zeroes++;
|
|
psz++;
|
|
}
|
|
var size = (source.length - psz) * FACTOR + 1 >>> 0;
|
|
var b256 = new Uint8Array(size);
|
|
while (source[psz]) {
|
|
var carry = BASE_MAP[source.charCodeAt(psz)];
|
|
if (carry === 255) {
|
|
return;
|
|
}
|
|
var i2 = 0;
|
|
for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
|
|
carry += BASE * b256[it3] >>> 0;
|
|
b256[it3] = carry % 256 >>> 0;
|
|
carry = carry / 256 >>> 0;
|
|
}
|
|
if (carry !== 0) {
|
|
throw new Error("Non-zero carry");
|
|
}
|
|
length = i2;
|
|
psz++;
|
|
}
|
|
var it4 = size - length;
|
|
while (it4 !== size && b256[it4] === 0) {
|
|
it4++;
|
|
}
|
|
var vch = new Uint8Array(zeroes + (size - it4));
|
|
var j2 = zeroes;
|
|
while (it4 !== size) {
|
|
vch[j2++] = b256[it4++];
|
|
}
|
|
return vch;
|
|
}
|
|
function decode3(string) {
|
|
var buffer = decodeUnsafe(string);
|
|
if (buffer) {
|
|
return buffer;
|
|
}
|
|
throw new Error("Non-base" + BASE + " character");
|
|
}
|
|
return {
|
|
encode: encode2,
|
|
decodeUnsafe,
|
|
decode: decode3
|
|
};
|
|
}
|
|
module.exports = base;
|
|
}
|
|
});
|
|
|
|
// node_modules/bs58/index.js
|
|
var require_bs58 = __commonJS({
|
|
"node_modules/bs58/index.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var basex = require_src();
|
|
var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
|
|
module.exports = basex(ALPHABET);
|
|
}
|
|
});
|
|
|
|
// node_modules/jpeg-js/lib/encoder.js
|
|
var require_encoder = __commonJS({
|
|
"node_modules/jpeg-js/lib/encoder.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var btoa = btoa || function(buf2) {
|
|
return Buffer2.from(buf2).toString("base64");
|
|
};
|
|
function JPEGEncoder(quality) {
|
|
var self = this;
|
|
var fround = Math.round;
|
|
var ffloor = Math.floor;
|
|
var YTable = new Array(64);
|
|
var UVTable = new Array(64);
|
|
var fdtbl_Y = new Array(64);
|
|
var fdtbl_UV = new Array(64);
|
|
var YDC_HT2;
|
|
var UVDC_HT2;
|
|
var YAC_HT2;
|
|
var UVAC_HT2;
|
|
var bitcode2 = new Array(65535);
|
|
var category2 = new Array(65535);
|
|
var outputfDCTQuant = new Array(64);
|
|
var DU = new Array(64);
|
|
var byteout = [];
|
|
var bytenew = 0;
|
|
var bytepos = 7;
|
|
var YDU = new Array(64);
|
|
var UDU = new Array(64);
|
|
var VDU = new Array(64);
|
|
var clt = new Array(256);
|
|
var RGB_YUV_TABLE = new Array(2048);
|
|
var currentQuality;
|
|
var ZigZag = [
|
|
0,
|
|
1,
|
|
5,
|
|
6,
|
|
14,
|
|
15,
|
|
27,
|
|
28,
|
|
2,
|
|
4,
|
|
7,
|
|
13,
|
|
16,
|
|
26,
|
|
29,
|
|
42,
|
|
3,
|
|
8,
|
|
12,
|
|
17,
|
|
25,
|
|
30,
|
|
41,
|
|
43,
|
|
9,
|
|
11,
|
|
18,
|
|
24,
|
|
31,
|
|
40,
|
|
44,
|
|
53,
|
|
10,
|
|
19,
|
|
23,
|
|
32,
|
|
39,
|
|
45,
|
|
52,
|
|
54,
|
|
20,
|
|
22,
|
|
33,
|
|
38,
|
|
46,
|
|
51,
|
|
55,
|
|
60,
|
|
21,
|
|
34,
|
|
37,
|
|
47,
|
|
50,
|
|
56,
|
|
59,
|
|
61,
|
|
35,
|
|
36,
|
|
48,
|
|
49,
|
|
57,
|
|
58,
|
|
62,
|
|
63
|
|
];
|
|
var std_dc_luminance_nrcodes2 = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
|
|
var std_dc_luminance_values2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
|
|
var std_ac_luminance_nrcodes2 = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125];
|
|
var std_ac_luminance_values2 = [
|
|
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
|
|
];
|
|
var std_dc_chrominance_nrcodes2 = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
|
|
var std_dc_chrominance_values2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
|
|
var std_ac_chrominance_nrcodes2 = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119];
|
|
var std_ac_chrominance_values2 = [
|
|
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 initQuantTables(sf) {
|
|
var YQT = [
|
|
16,
|
|
11,
|
|
10,
|
|
16,
|
|
24,
|
|
40,
|
|
51,
|
|
61,
|
|
12,
|
|
12,
|
|
14,
|
|
19,
|
|
26,
|
|
58,
|
|
60,
|
|
55,
|
|
14,
|
|
13,
|
|
16,
|
|
24,
|
|
40,
|
|
57,
|
|
69,
|
|
56,
|
|
14,
|
|
17,
|
|
22,
|
|
29,
|
|
51,
|
|
87,
|
|
80,
|
|
62,
|
|
18,
|
|
22,
|
|
37,
|
|
56,
|
|
68,
|
|
109,
|
|
103,
|
|
77,
|
|
24,
|
|
35,
|
|
55,
|
|
64,
|
|
81,
|
|
104,
|
|
113,
|
|
92,
|
|
49,
|
|
64,
|
|
78,
|
|
87,
|
|
103,
|
|
121,
|
|
120,
|
|
101,
|
|
72,
|
|
92,
|
|
95,
|
|
98,
|
|
112,
|
|
100,
|
|
103,
|
|
99
|
|
];
|
|
for (var i = 0; i < 64; i++) {
|
|
var t = ffloor((YQT[i] * sf + 50) / 100);
|
|
if (t < 1) {
|
|
t = 1;
|
|
} else if (t > 255) {
|
|
t = 255;
|
|
}
|
|
YTable[ZigZag[i]] = t;
|
|
}
|
|
var UVQT = [
|
|
17,
|
|
18,
|
|
24,
|
|
47,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
18,
|
|
21,
|
|
26,
|
|
66,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
24,
|
|
26,
|
|
56,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
47,
|
|
66,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99,
|
|
99
|
|
];
|
|
for (var j = 0; j < 64; j++) {
|
|
var u = ffloor((UVQT[j] * sf + 50) / 100);
|
|
if (u < 1) {
|
|
u = 1;
|
|
} else if (u > 255) {
|
|
u = 255;
|
|
}
|
|
UVTable[ZigZag[j]] = u;
|
|
}
|
|
var aasf = [
|
|
1,
|
|
1.387039845,
|
|
1.306562965,
|
|
1.175875602,
|
|
1,
|
|
0.785694958,
|
|
0.5411961,
|
|
0.275899379
|
|
];
|
|
var k = 0;
|
|
for (var row = 0; row < 8; row++) {
|
|
for (var col = 0; col < 8; col++) {
|
|
fdtbl_Y[k] = 1 / (YTable[ZigZag[k]] * aasf[row] * aasf[col] * 8);
|
|
fdtbl_UV[k] = 1 / (UVTable[ZigZag[k]] * aasf[row] * aasf[col] * 8);
|
|
k++;
|
|
}
|
|
}
|
|
}
|
|
function computeHuffmanTbl(nrcodes, std_table) {
|
|
var codevalue = 0;
|
|
var pos_in_table = 0;
|
|
var HT = new Array();
|
|
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;
|
|
}
|
|
function initHuffmanTbl() {
|
|
YDC_HT2 = computeHuffmanTbl(std_dc_luminance_nrcodes2, std_dc_luminance_values2);
|
|
UVDC_HT2 = computeHuffmanTbl(std_dc_chrominance_nrcodes2, std_dc_chrominance_values2);
|
|
YAC_HT2 = computeHuffmanTbl(std_ac_luminance_nrcodes2, std_ac_luminance_values2);
|
|
UVAC_HT2 = computeHuffmanTbl(std_ac_chrominance_nrcodes2, std_ac_chrominance_values2);
|
|
}
|
|
function initCategoryNumber() {
|
|
var nrlower = 1;
|
|
var nrupper = 2;
|
|
for (var cat = 1; cat <= 15; cat++) {
|
|
for (var nr = nrlower; nr < nrupper; nr++) {
|
|
category2[32767 + nr] = cat;
|
|
bitcode2[32767 + nr] = [];
|
|
bitcode2[32767 + nr][1] = cat;
|
|
bitcode2[32767 + nr][0] = nr;
|
|
}
|
|
for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {
|
|
category2[32767 + nrneg] = cat;
|
|
bitcode2[32767 + nrneg] = [];
|
|
bitcode2[32767 + nrneg][1] = cat;
|
|
bitcode2[32767 + nrneg][0] = nrupper - 1 + nrneg;
|
|
}
|
|
nrlower <<= 1;
|
|
nrupper <<= 1;
|
|
}
|
|
}
|
|
function initRGBYUVTable() {
|
|
for (var i = 0; i < 256; i++) {
|
|
RGB_YUV_TABLE[i] = 19595 * i;
|
|
RGB_YUV_TABLE[i + 256 >> 0] = 38470 * i;
|
|
RGB_YUV_TABLE[i + 512 >> 0] = 7471 * i + 32768;
|
|
RGB_YUV_TABLE[i + 768 >> 0] = -11059 * i;
|
|
RGB_YUV_TABLE[i + 1024 >> 0] = -21709 * i;
|
|
RGB_YUV_TABLE[i + 1280 >> 0] = 32768 * i + 8421375;
|
|
RGB_YUV_TABLE[i + 1536 >> 0] = -27439 * i;
|
|
RGB_YUV_TABLE[i + 1792 >> 0] = -5329 * i;
|
|
}
|
|
}
|
|
function writeBits(bs) {
|
|
var value = bs[0];
|
|
var posval = bs[1] - 1;
|
|
while (posval >= 0) {
|
|
if (value & 1 << posval) {
|
|
bytenew |= 1 << bytepos;
|
|
}
|
|
posval--;
|
|
bytepos--;
|
|
if (bytepos < 0) {
|
|
if (bytenew == 255) {
|
|
writeByte(255);
|
|
writeByte(0);
|
|
} else {
|
|
writeByte(bytenew);
|
|
}
|
|
bytepos = 7;
|
|
bytenew = 0;
|
|
}
|
|
}
|
|
}
|
|
function writeByte(value) {
|
|
byteout.push(value);
|
|
}
|
|
function writeWord(value) {
|
|
writeByte(value >> 8 & 255);
|
|
writeByte(value & 255);
|
|
}
|
|
function fDCTQuant(data, fdtbl) {
|
|
var d0, d1, d2, d3, d4, d5, d6, d7;
|
|
var dataOff = 0;
|
|
var i;
|
|
var I8 = 8;
|
|
var I64 = 64;
|
|
for (i = 0; i < I8; ++i) {
|
|
d0 = data[dataOff];
|
|
d1 = data[dataOff + 1];
|
|
d2 = data[dataOff + 2];
|
|
d3 = data[dataOff + 3];
|
|
d4 = data[dataOff + 4];
|
|
d5 = data[dataOff + 5];
|
|
d6 = data[dataOff + 6];
|
|
d7 = data[dataOff + 7];
|
|
var tmp0 = d0 + d7;
|
|
var tmp7 = d0 - d7;
|
|
var tmp1 = d1 + d6;
|
|
var tmp6 = d1 - d6;
|
|
var tmp2 = d2 + d5;
|
|
var tmp5 = d2 - d5;
|
|
var tmp3 = d3 + d4;
|
|
var tmp4 = d3 - d4;
|
|
var tmp10 = tmp0 + tmp3;
|
|
var tmp13 = tmp0 - tmp3;
|
|
var tmp11 = tmp1 + tmp2;
|
|
var tmp12 = tmp1 - tmp2;
|
|
data[dataOff] = tmp10 + tmp11;
|
|
data[dataOff + 4] = tmp10 - tmp11;
|
|
var z1 = (tmp12 + tmp13) * 0.707106781;
|
|
data[dataOff + 2] = tmp13 + z1;
|
|
data[dataOff + 6] = tmp13 - z1;
|
|
tmp10 = tmp4 + tmp5;
|
|
tmp11 = tmp5 + tmp6;
|
|
tmp12 = tmp6 + tmp7;
|
|
var z5 = (tmp10 - tmp12) * 0.382683433;
|
|
var z2 = 0.5411961 * tmp10 + z5;
|
|
var z4 = 1.306562965 * tmp12 + z5;
|
|
var z3 = tmp11 * 0.707106781;
|
|
var z11 = tmp7 + z3;
|
|
var z13 = tmp7 - z3;
|
|
data[dataOff + 5] = z13 + z2;
|
|
data[dataOff + 3] = z13 - z2;
|
|
data[dataOff + 1] = z11 + z4;
|
|
data[dataOff + 7] = z11 - z4;
|
|
dataOff += 8;
|
|
}
|
|
dataOff = 0;
|
|
for (i = 0; i < I8; ++i) {
|
|
d0 = data[dataOff];
|
|
d1 = data[dataOff + 8];
|
|
d2 = data[dataOff + 16];
|
|
d3 = data[dataOff + 24];
|
|
d4 = data[dataOff + 32];
|
|
d5 = data[dataOff + 40];
|
|
d6 = data[dataOff + 48];
|
|
d7 = data[dataOff + 56];
|
|
var tmp0p2 = d0 + d7;
|
|
var tmp7p2 = d0 - d7;
|
|
var tmp1p2 = d1 + d6;
|
|
var tmp6p2 = d1 - d6;
|
|
var tmp2p2 = d2 + d5;
|
|
var tmp5p2 = d2 - d5;
|
|
var tmp3p2 = d3 + d4;
|
|
var tmp4p2 = d3 - d4;
|
|
var tmp10p2 = tmp0p2 + tmp3p2;
|
|
var tmp13p2 = tmp0p2 - tmp3p2;
|
|
var tmp11p2 = tmp1p2 + tmp2p2;
|
|
var tmp12p2 = tmp1p2 - tmp2p2;
|
|
data[dataOff] = tmp10p2 + tmp11p2;
|
|
data[dataOff + 32] = tmp10p2 - tmp11p2;
|
|
var z1p2 = (tmp12p2 + tmp13p2) * 0.707106781;
|
|
data[dataOff + 16] = tmp13p2 + z1p2;
|
|
data[dataOff + 48] = tmp13p2 - z1p2;
|
|
tmp10p2 = tmp4p2 + tmp5p2;
|
|
tmp11p2 = tmp5p2 + tmp6p2;
|
|
tmp12p2 = tmp6p2 + tmp7p2;
|
|
var z5p2 = (tmp10p2 - tmp12p2) * 0.382683433;
|
|
var z2p2 = 0.5411961 * tmp10p2 + z5p2;
|
|
var z4p2 = 1.306562965 * tmp12p2 + z5p2;
|
|
var z3p2 = tmp11p2 * 0.707106781;
|
|
var z11p2 = tmp7p2 + z3p2;
|
|
var z13p2 = tmp7p2 - z3p2;
|
|
data[dataOff + 40] = z13p2 + z2p2;
|
|
data[dataOff + 24] = z13p2 - z2p2;
|
|
data[dataOff + 8] = z11p2 + z4p2;
|
|
data[dataOff + 56] = z11p2 - z4p2;
|
|
dataOff++;
|
|
}
|
|
var fDCTQuant2;
|
|
for (i = 0; i < I64; ++i) {
|
|
fDCTQuant2 = data[i] * fdtbl[i];
|
|
outputfDCTQuant[i] = fDCTQuant2 > 0 ? fDCTQuant2 + 0.5 | 0 : fDCTQuant2 - 0.5 | 0;
|
|
}
|
|
return outputfDCTQuant;
|
|
}
|
|
function writeAPP0() {
|
|
writeWord(65504);
|
|
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);
|
|
}
|
|
function writeAPP1(exifBuffer) {
|
|
if (!exifBuffer)
|
|
return;
|
|
writeWord(65505);
|
|
if (exifBuffer[0] === 69 && exifBuffer[1] === 120 && exifBuffer[2] === 105 && exifBuffer[3] === 102) {
|
|
writeWord(exifBuffer.length + 2);
|
|
} else {
|
|
writeWord(exifBuffer.length + 5 + 2);
|
|
writeByte(69);
|
|
writeByte(120);
|
|
writeByte(105);
|
|
writeByte(102);
|
|
writeByte(0);
|
|
}
|
|
for (var i = 0; i < exifBuffer.length; i++) {
|
|
writeByte(exifBuffer[i]);
|
|
}
|
|
}
|
|
function writeSOF0(width, height) {
|
|
writeWord(65472);
|
|
writeWord(17);
|
|
writeByte(8);
|
|
writeWord(height);
|
|
writeWord(width);
|
|
writeByte(3);
|
|
writeByte(1);
|
|
writeByte(17);
|
|
writeByte(0);
|
|
writeByte(2);
|
|
writeByte(17);
|
|
writeByte(1);
|
|
writeByte(3);
|
|
writeByte(17);
|
|
writeByte(1);
|
|
}
|
|
function writeDQT() {
|
|
writeWord(65499);
|
|
writeWord(132);
|
|
writeByte(0);
|
|
for (var i = 0; i < 64; i++) {
|
|
writeByte(YTable[i]);
|
|
}
|
|
writeByte(1);
|
|
for (var j = 0; j < 64; j++) {
|
|
writeByte(UVTable[j]);
|
|
}
|
|
}
|
|
function writeDHT() {
|
|
writeWord(65476);
|
|
writeWord(418);
|
|
writeByte(0);
|
|
for (var i = 0; i < 16; i++) {
|
|
writeByte(std_dc_luminance_nrcodes2[i + 1]);
|
|
}
|
|
for (var j = 0; j <= 11; j++) {
|
|
writeByte(std_dc_luminance_values2[j]);
|
|
}
|
|
writeByte(16);
|
|
for (var k = 0; k < 16; k++) {
|
|
writeByte(std_ac_luminance_nrcodes2[k + 1]);
|
|
}
|
|
for (var l = 0; l <= 161; l++) {
|
|
writeByte(std_ac_luminance_values2[l]);
|
|
}
|
|
writeByte(1);
|
|
for (var m = 0; m < 16; m++) {
|
|
writeByte(std_dc_chrominance_nrcodes2[m + 1]);
|
|
}
|
|
for (var n = 0; n <= 11; n++) {
|
|
writeByte(std_dc_chrominance_values2[n]);
|
|
}
|
|
writeByte(17);
|
|
for (var o = 0; o < 16; o++) {
|
|
writeByte(std_ac_chrominance_nrcodes2[o + 1]);
|
|
}
|
|
for (var p = 0; p <= 161; p++) {
|
|
writeByte(std_ac_chrominance_values2[p]);
|
|
}
|
|
}
|
|
function writeCOM(comments) {
|
|
if (typeof comments === "undefined" || comments.constructor !== Array)
|
|
return;
|
|
comments.forEach((e) => {
|
|
if (typeof e !== "string")
|
|
return;
|
|
writeWord(65534);
|
|
var l = e.length;
|
|
writeWord(l + 2);
|
|
var i;
|
|
for (i = 0; i < l; i++)
|
|
writeByte(e.charCodeAt(i));
|
|
});
|
|
}
|
|
function writeSOS() {
|
|
writeWord(65498);
|
|
writeWord(12);
|
|
writeByte(3);
|
|
writeByte(1);
|
|
writeByte(0);
|
|
writeByte(2);
|
|
writeByte(17);
|
|
writeByte(3);
|
|
writeByte(17);
|
|
writeByte(0);
|
|
writeByte(63);
|
|
writeByte(0);
|
|
}
|
|
function processDU(CDU, fdtbl, DC, HTDC, HTAC) {
|
|
var EOB = HTAC[0];
|
|
var M16zeroes = HTAC[240];
|
|
var pos;
|
|
var I16 = 16;
|
|
var I63 = 63;
|
|
var I64 = 64;
|
|
var DU_DCT = fDCTQuant(CDU, fdtbl);
|
|
for (var j = 0; j < I64; ++j) {
|
|
DU[ZigZag[j]] = DU_DCT[j];
|
|
}
|
|
var Diff = DU[0] - DC;
|
|
DC = DU[0];
|
|
if (Diff == 0) {
|
|
writeBits(HTDC[0]);
|
|
} else {
|
|
pos = 32767 + Diff;
|
|
writeBits(HTDC[category2[pos]]);
|
|
writeBits(bitcode2[pos]);
|
|
}
|
|
var end0pos = 63;
|
|
for (; end0pos > 0 && DU[end0pos] == 0; end0pos--) {
|
|
}
|
|
;
|
|
if (end0pos == 0) {
|
|
writeBits(EOB);
|
|
return DC;
|
|
}
|
|
var i = 1;
|
|
var lng;
|
|
while (i <= end0pos) {
|
|
var startpos = i;
|
|
for (; DU[i] == 0 && i <= end0pos; ++i) {
|
|
}
|
|
var nrzeroes = i - startpos;
|
|
if (nrzeroes >= I16) {
|
|
lng = nrzeroes >> 4;
|
|
for (var nrmarker = 1; nrmarker <= lng; ++nrmarker)
|
|
writeBits(M16zeroes);
|
|
nrzeroes = nrzeroes & 15;
|
|
}
|
|
pos = 32767 + DU[i];
|
|
writeBits(HTAC[(nrzeroes << 4) + category2[pos]]);
|
|
writeBits(bitcode2[pos]);
|
|
i++;
|
|
}
|
|
if (end0pos != I63) {
|
|
writeBits(EOB);
|
|
}
|
|
return DC;
|
|
}
|
|
function initCharLookupTable() {
|
|
var sfcc = String.fromCharCode;
|
|
for (var i = 0; i < 256; i++) {
|
|
clt[i] = sfcc(i);
|
|
}
|
|
}
|
|
this.encode = function(image, quality2) {
|
|
var time_start = new Date().getTime();
|
|
if (quality2)
|
|
setQuality(quality2);
|
|
byteout = new Array();
|
|
bytenew = 0;
|
|
bytepos = 7;
|
|
writeWord(65496);
|
|
writeAPP0();
|
|
writeCOM(image.comments);
|
|
writeAPP1(image.exifBuffer);
|
|
writeDQT();
|
|
writeSOF0(image.width, image.height);
|
|
writeDHT();
|
|
writeSOS();
|
|
var DCY = 0;
|
|
var DCU = 0;
|
|
var DCV = 0;
|
|
bytenew = 0;
|
|
bytepos = 7;
|
|
this.encode.displayName = "_encode_";
|
|
var imageData = image.data;
|
|
var width = image.width;
|
|
var height = image.height;
|
|
var quadWidth = width * 4;
|
|
var tripleWidth = width * 3;
|
|
var x, y = 0;
|
|
var r, g, b;
|
|
var start, p, col, row, pos;
|
|
while (y < height) {
|
|
x = 0;
|
|
while (x < quadWidth) {
|
|
start = quadWidth * y + x;
|
|
p = start;
|
|
col = -1;
|
|
row = 0;
|
|
for (pos = 0; pos < 64; pos++) {
|
|
row = pos >> 3;
|
|
col = (pos & 7) * 4;
|
|
p = start + row * quadWidth + col;
|
|
if (y + row >= height) {
|
|
p -= quadWidth * (y + 1 + row - height);
|
|
}
|
|
if (x + col >= quadWidth) {
|
|
p -= x + col - quadWidth + 4;
|
|
}
|
|
r = imageData[p++];
|
|
g = imageData[p++];
|
|
b = imageData[p++];
|
|
YDU[pos] = (RGB_YUV_TABLE[r] + RGB_YUV_TABLE[g + 256 >> 0] + RGB_YUV_TABLE[b + 512 >> 0] >> 16) - 128;
|
|
UDU[pos] = (RGB_YUV_TABLE[r + 768 >> 0] + RGB_YUV_TABLE[g + 1024 >> 0] + RGB_YUV_TABLE[b + 1280 >> 0] >> 16) - 128;
|
|
VDU[pos] = (RGB_YUV_TABLE[r + 1280 >> 0] + RGB_YUV_TABLE[g + 1536 >> 0] + RGB_YUV_TABLE[b + 1792 >> 0] >> 16) - 128;
|
|
}
|
|
DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT2, YAC_HT2);
|
|
DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT2, UVAC_HT2);
|
|
DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT2, UVAC_HT2);
|
|
x += 32;
|
|
}
|
|
y += 8;
|
|
}
|
|
if (bytepos >= 0) {
|
|
var fillbits = [];
|
|
fillbits[1] = bytepos + 1;
|
|
fillbits[0] = (1 << bytepos + 1) - 1;
|
|
writeBits(fillbits);
|
|
}
|
|
writeWord(65497);
|
|
if (typeof module === "undefined")
|
|
return new Uint8Array(byteout);
|
|
return Buffer2.from(byteout);
|
|
var jpegDataUri = "data:image/jpeg;base64," + btoa(byteout.join(""));
|
|
byteout = [];
|
|
var duration = new Date().getTime() - time_start;
|
|
return jpegDataUri;
|
|
};
|
|
function setQuality(quality2) {
|
|
if (quality2 <= 0) {
|
|
quality2 = 1;
|
|
}
|
|
if (quality2 > 100) {
|
|
quality2 = 100;
|
|
}
|
|
if (currentQuality == quality2)
|
|
return;
|
|
var sf = 0;
|
|
if (quality2 < 50) {
|
|
sf = Math.floor(5e3 / quality2);
|
|
} else {
|
|
sf = Math.floor(200 - quality2 * 2);
|
|
}
|
|
initQuantTables(sf);
|
|
currentQuality = quality2;
|
|
}
|
|
function init5() {
|
|
var time_start = new Date().getTime();
|
|
if (!quality)
|
|
quality = 50;
|
|
initCharLookupTable();
|
|
initHuffmanTbl();
|
|
initCategoryNumber();
|
|
initRGBYUVTable();
|
|
setQuality(quality);
|
|
var duration = new Date().getTime() - time_start;
|
|
}
|
|
init5();
|
|
}
|
|
if (typeof module !== "undefined") {
|
|
module.exports = encode2;
|
|
} else if (typeof window !== "undefined") {
|
|
window["jpeg-js"] = window["jpeg-js"] || {};
|
|
window["jpeg-js"].encode = encode2;
|
|
}
|
|
function encode2(imgData, qu) {
|
|
if (typeof qu === "undefined")
|
|
qu = 50;
|
|
var encoder = new JPEGEncoder(qu);
|
|
var data = encoder.encode(imgData, qu);
|
|
return {
|
|
data,
|
|
width: imgData.width,
|
|
height: imgData.height
|
|
};
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/jpeg-js/lib/decoder.js
|
|
var require_decoder = __commonJS({
|
|
"node_modules/jpeg-js/lib/decoder.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var JpegImage = function jpegImage() {
|
|
"use strict";
|
|
var dctZigZag = new Int32Array([
|
|
0,
|
|
1,
|
|
8,
|
|
16,
|
|
9,
|
|
2,
|
|
3,
|
|
10,
|
|
17,
|
|
24,
|
|
32,
|
|
25,
|
|
18,
|
|
11,
|
|
4,
|
|
5,
|
|
12,
|
|
19,
|
|
26,
|
|
33,
|
|
40,
|
|
48,
|
|
41,
|
|
34,
|
|
27,
|
|
20,
|
|
13,
|
|
6,
|
|
7,
|
|
14,
|
|
21,
|
|
28,
|
|
35,
|
|
42,
|
|
49,
|
|
56,
|
|
57,
|
|
50,
|
|
43,
|
|
36,
|
|
29,
|
|
22,
|
|
15,
|
|
23,
|
|
30,
|
|
37,
|
|
44,
|
|
51,
|
|
58,
|
|
59,
|
|
52,
|
|
45,
|
|
38,
|
|
31,
|
|
39,
|
|
46,
|
|
53,
|
|
60,
|
|
61,
|
|
54,
|
|
47,
|
|
55,
|
|
62,
|
|
63
|
|
]);
|
|
var dctCos1 = 4017;
|
|
var dctSin1 = 799;
|
|
var dctCos3 = 3406;
|
|
var dctSin3 = 2276;
|
|
var dctCos6 = 1567;
|
|
var dctSin6 = 3784;
|
|
var dctSqrt2 = 5793;
|
|
var dctSqrt1d2 = 2896;
|
|
function constructor() {
|
|
}
|
|
function buildHuffmanTable2(codeLengths, values) {
|
|
var k = 0, code = [], i, j, length = 16;
|
|
while (length > 0 && !codeLengths[length - 1])
|
|
length--;
|
|
code.push({ children: [], index: 0 });
|
|
var p = code[0], q;
|
|
for (i = 0; i < length; i++) {
|
|
for (j = 0; j < codeLengths[i]; j++) {
|
|
p = code.pop();
|
|
p.children[p.index] = values[k];
|
|
while (p.index > 0) {
|
|
if (code.length === 0)
|
|
throw new Error("Could not recreate Huffman Table");
|
|
p = code.pop();
|
|
}
|
|
p.index++;
|
|
code.push(p);
|
|
while (code.length <= i) {
|
|
code.push(q = { children: [], index: 0 });
|
|
p.children[p.index] = q.children;
|
|
p = q;
|
|
}
|
|
k++;
|
|
}
|
|
if (i + 1 < length) {
|
|
code.push(q = { children: [], index: 0 });
|
|
p.children[p.index] = q.children;
|
|
p = q;
|
|
}
|
|
}
|
|
return code[0].children;
|
|
}
|
|
function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, opts) {
|
|
var precision = frame.precision;
|
|
var samplesPerLine = frame.samplesPerLine;
|
|
var scanLines = frame.scanLines;
|
|
var mcusPerLine = frame.mcusPerLine;
|
|
var progressive = frame.progressive;
|
|
var maxH = frame.maxH, maxV = frame.maxV;
|
|
var startOffset = offset, bitsData = 0, bitsCount = 0;
|
|
function readBit() {
|
|
if (bitsCount > 0) {
|
|
bitsCount--;
|
|
return bitsData >> bitsCount & 1;
|
|
}
|
|
bitsData = data[offset++];
|
|
if (bitsData == 255) {
|
|
var nextByte = data[offset++];
|
|
if (nextByte) {
|
|
throw new Error("unexpected marker: " + (bitsData << 8 | nextByte).toString(16));
|
|
}
|
|
}
|
|
bitsCount = 7;
|
|
return bitsData >>> 7;
|
|
}
|
|
function decodeHuffman(tree) {
|
|
var node = tree, bit;
|
|
while ((bit = readBit()) !== null) {
|
|
node = node[bit];
|
|
if (typeof node === "number")
|
|
return node;
|
|
if (typeof node !== "object")
|
|
throw new Error("invalid huffman sequence");
|
|
}
|
|
return null;
|
|
}
|
|
function receive(length) {
|
|
var n2 = 0;
|
|
while (length > 0) {
|
|
var bit = readBit();
|
|
if (bit === null)
|
|
return;
|
|
n2 = n2 << 1 | bit;
|
|
length--;
|
|
}
|
|
return n2;
|
|
}
|
|
function receiveAndExtend(length) {
|
|
var n2 = receive(length);
|
|
if (n2 >= 1 << length - 1)
|
|
return n2;
|
|
return n2 + (-1 << length) + 1;
|
|
}
|
|
function decodeBaseline(component2, zz) {
|
|
var t = decodeHuffman(component2.huffmanTableDC);
|
|
var diff = t === 0 ? 0 : receiveAndExtend(t);
|
|
zz[0] = component2.pred += diff;
|
|
var k2 = 1;
|
|
while (k2 < 64) {
|
|
var rs = decodeHuffman(component2.huffmanTableAC);
|
|
var s = rs & 15, r = rs >> 4;
|
|
if (s === 0) {
|
|
if (r < 15)
|
|
break;
|
|
k2 += 16;
|
|
continue;
|
|
}
|
|
k2 += r;
|
|
var z = dctZigZag[k2];
|
|
zz[z] = receiveAndExtend(s);
|
|
k2++;
|
|
}
|
|
}
|
|
function decodeDCFirst(component2, zz) {
|
|
var t = decodeHuffman(component2.huffmanTableDC);
|
|
var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
|
|
zz[0] = component2.pred += diff;
|
|
}
|
|
function decodeDCSuccessive(component2, zz) {
|
|
zz[0] |= readBit() << successive;
|
|
}
|
|
var eobrun = 0;
|
|
function decodeACFirst(component2, zz) {
|
|
if (eobrun > 0) {
|
|
eobrun--;
|
|
return;
|
|
}
|
|
var k2 = spectralStart, e = spectralEnd;
|
|
while (k2 <= e) {
|
|
var rs = decodeHuffman(component2.huffmanTableAC);
|
|
var s = rs & 15, r = rs >> 4;
|
|
if (s === 0) {
|
|
if (r < 15) {
|
|
eobrun = receive(r) + (1 << r) - 1;
|
|
break;
|
|
}
|
|
k2 += 16;
|
|
continue;
|
|
}
|
|
k2 += r;
|
|
var z = dctZigZag[k2];
|
|
zz[z] = receiveAndExtend(s) * (1 << successive);
|
|
k2++;
|
|
}
|
|
}
|
|
var successiveACState = 0, successiveACNextValue;
|
|
function decodeACSuccessive(component2, zz) {
|
|
var k2 = spectralStart, e = spectralEnd, r = 0;
|
|
while (k2 <= e) {
|
|
var z = dctZigZag[k2];
|
|
var direction = zz[z] < 0 ? -1 : 1;
|
|
switch (successiveACState) {
|
|
case 0:
|
|
var rs = decodeHuffman(component2.huffmanTableAC);
|
|
var s = rs & 15, r = rs >> 4;
|
|
if (s === 0) {
|
|
if (r < 15) {
|
|
eobrun = receive(r) + (1 << r);
|
|
successiveACState = 4;
|
|
} else {
|
|
r = 16;
|
|
successiveACState = 1;
|
|
}
|
|
} else {
|
|
if (s !== 1)
|
|
throw new Error("invalid ACn encoding");
|
|
successiveACNextValue = receiveAndExtend(s);
|
|
successiveACState = r ? 2 : 3;
|
|
}
|
|
continue;
|
|
case 1:
|
|
case 2:
|
|
if (zz[z])
|
|
zz[z] += (readBit() << successive) * direction;
|
|
else {
|
|
r--;
|
|
if (r === 0)
|
|
successiveACState = successiveACState == 2 ? 3 : 0;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (zz[z])
|
|
zz[z] += (readBit() << successive) * direction;
|
|
else {
|
|
zz[z] = successiveACNextValue << successive;
|
|
successiveACState = 0;
|
|
}
|
|
break;
|
|
case 4:
|
|
if (zz[z])
|
|
zz[z] += (readBit() << successive) * direction;
|
|
break;
|
|
}
|
|
k2++;
|
|
}
|
|
if (successiveACState === 4) {
|
|
eobrun--;
|
|
if (eobrun === 0)
|
|
successiveACState = 0;
|
|
}
|
|
}
|
|
function decodeMcu(component2, decode4, mcu2, row, col) {
|
|
var mcuRow = mcu2 / mcusPerLine | 0;
|
|
var mcuCol = mcu2 % mcusPerLine;
|
|
var blockRow = mcuRow * component2.v + row;
|
|
var blockCol = mcuCol * component2.h + col;
|
|
if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)
|
|
return;
|
|
decode4(component2, component2.blocks[blockRow][blockCol]);
|
|
}
|
|
function decodeBlock(component2, decode4, mcu2) {
|
|
var blockRow = mcu2 / component2.blocksPerLine | 0;
|
|
var blockCol = mcu2 % component2.blocksPerLine;
|
|
if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)
|
|
return;
|
|
decode4(component2, component2.blocks[blockRow][blockCol]);
|
|
}
|
|
var componentsLength = components.length;
|
|
var component, i, j, k, n;
|
|
var decodeFn;
|
|
if (progressive) {
|
|
if (spectralStart === 0)
|
|
decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
|
|
else
|
|
decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
|
|
} else {
|
|
decodeFn = decodeBaseline;
|
|
}
|
|
var mcu = 0, marker;
|
|
var mcuExpected;
|
|
if (componentsLength == 1) {
|
|
mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
|
|
} else {
|
|
mcuExpected = mcusPerLine * frame.mcusPerColumn;
|
|
}
|
|
if (!resetInterval)
|
|
resetInterval = mcuExpected;
|
|
var h, v;
|
|
while (mcu < mcuExpected) {
|
|
for (i = 0; i < componentsLength; i++)
|
|
components[i].pred = 0;
|
|
eobrun = 0;
|
|
if (componentsLength == 1) {
|
|
component = components[0];
|
|
for (n = 0; n < resetInterval; n++) {
|
|
decodeBlock(component, decodeFn, mcu);
|
|
mcu++;
|
|
}
|
|
} else {
|
|
for (n = 0; n < resetInterval; n++) {
|
|
for (i = 0; i < componentsLength; i++) {
|
|
component = components[i];
|
|
h = component.h;
|
|
v = component.v;
|
|
for (j = 0; j < v; j++) {
|
|
for (k = 0; k < h; k++) {
|
|
decodeMcu(component, decodeFn, mcu, j, k);
|
|
}
|
|
}
|
|
}
|
|
mcu++;
|
|
if (mcu === mcuExpected)
|
|
break;
|
|
}
|
|
}
|
|
if (mcu === mcuExpected) {
|
|
do {
|
|
if (data[offset] === 255) {
|
|
if (data[offset + 1] !== 0) {
|
|
break;
|
|
}
|
|
}
|
|
offset += 1;
|
|
} while (offset < data.length - 2);
|
|
}
|
|
bitsCount = 0;
|
|
marker = data[offset] << 8 | data[offset + 1];
|
|
if (marker < 65280) {
|
|
throw new Error("marker was not found");
|
|
}
|
|
if (marker >= 65488 && marker <= 65495) {
|
|
offset += 2;
|
|
} else
|
|
break;
|
|
}
|
|
return offset - startOffset;
|
|
}
|
|
function buildComponentData(frame, component) {
|
|
var lines = [];
|
|
var blocksPerLine = component.blocksPerLine;
|
|
var blocksPerColumn = component.blocksPerColumn;
|
|
var samplesPerLine = blocksPerLine << 3;
|
|
var R = new Int32Array(64), r = new Uint8Array(64);
|
|
function quantizeAndInverse(zz, dataOut, dataIn) {
|
|
var qt = component.quantizationTable;
|
|
var v0, v1, v2, v3, v4, v5, v6, v7, t;
|
|
var p = dataIn;
|
|
var i2;
|
|
for (i2 = 0; i2 < 64; i2++)
|
|
p[i2] = zz[i2] * qt[i2];
|
|
for (i2 = 0; i2 < 8; ++i2) {
|
|
var row = 8 * i2;
|
|
if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 && p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 && p[7 + row] == 0) {
|
|
t = dctSqrt2 * p[0 + row] + 512 >> 10;
|
|
p[0 + row] = t;
|
|
p[1 + row] = t;
|
|
p[2 + row] = t;
|
|
p[3 + row] = t;
|
|
p[4 + row] = t;
|
|
p[5 + row] = t;
|
|
p[6 + row] = t;
|
|
p[7 + row] = t;
|
|
continue;
|
|
}
|
|
v0 = dctSqrt2 * p[0 + row] + 128 >> 8;
|
|
v1 = dctSqrt2 * p[4 + row] + 128 >> 8;
|
|
v2 = p[2 + row];
|
|
v3 = p[6 + row];
|
|
v4 = dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128 >> 8;
|
|
v7 = dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128 >> 8;
|
|
v5 = p[3 + row] << 4;
|
|
v6 = p[5 + row] << 4;
|
|
t = v0 - v1 + 1 >> 1;
|
|
v0 = v0 + v1 + 1 >> 1;
|
|
v1 = t;
|
|
t = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8;
|
|
v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8;
|
|
v3 = t;
|
|
t = v4 - v6 + 1 >> 1;
|
|
v4 = v4 + v6 + 1 >> 1;
|
|
v6 = t;
|
|
t = v7 + v5 + 1 >> 1;
|
|
v5 = v7 - v5 + 1 >> 1;
|
|
v7 = t;
|
|
t = v0 - v3 + 1 >> 1;
|
|
v0 = v0 + v3 + 1 >> 1;
|
|
v3 = t;
|
|
t = v1 - v2 + 1 >> 1;
|
|
v1 = v1 + v2 + 1 >> 1;
|
|
v2 = t;
|
|
t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
|
|
v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
|
|
v7 = t;
|
|
t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
|
|
v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
|
|
v6 = t;
|
|
p[0 + row] = v0 + v7;
|
|
p[7 + row] = v0 - v7;
|
|
p[1 + row] = v1 + v6;
|
|
p[6 + row] = v1 - v6;
|
|
p[2 + row] = v2 + v5;
|
|
p[5 + row] = v2 - v5;
|
|
p[3 + row] = v3 + v4;
|
|
p[4 + row] = v3 - v4;
|
|
}
|
|
for (i2 = 0; i2 < 8; ++i2) {
|
|
var col = i2;
|
|
if (p[1 * 8 + col] == 0 && p[2 * 8 + col] == 0 && p[3 * 8 + col] == 0 && p[4 * 8 + col] == 0 && p[5 * 8 + col] == 0 && p[6 * 8 + col] == 0 && p[7 * 8 + col] == 0) {
|
|
t = dctSqrt2 * dataIn[i2 + 0] + 8192 >> 14;
|
|
p[0 * 8 + col] = t;
|
|
p[1 * 8 + col] = t;
|
|
p[2 * 8 + col] = t;
|
|
p[3 * 8 + col] = t;
|
|
p[4 * 8 + col] = t;
|
|
p[5 * 8 + col] = t;
|
|
p[6 * 8 + col] = t;
|
|
p[7 * 8 + col] = t;
|
|
continue;
|
|
}
|
|
v0 = dctSqrt2 * p[0 * 8 + col] + 2048 >> 12;
|
|
v1 = dctSqrt2 * p[4 * 8 + col] + 2048 >> 12;
|
|
v2 = p[2 * 8 + col];
|
|
v3 = p[6 * 8 + col];
|
|
v4 = dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048 >> 12;
|
|
v7 = dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048 >> 12;
|
|
v5 = p[3 * 8 + col];
|
|
v6 = p[5 * 8 + col];
|
|
t = v0 - v1 + 1 >> 1;
|
|
v0 = v0 + v1 + 1 >> 1;
|
|
v1 = t;
|
|
t = v2 * dctSin6 + v3 * dctCos6 + 2048 >> 12;
|
|
v2 = v2 * dctCos6 - v3 * dctSin6 + 2048 >> 12;
|
|
v3 = t;
|
|
t = v4 - v6 + 1 >> 1;
|
|
v4 = v4 + v6 + 1 >> 1;
|
|
v6 = t;
|
|
t = v7 + v5 + 1 >> 1;
|
|
v5 = v7 - v5 + 1 >> 1;
|
|
v7 = t;
|
|
t = v0 - v3 + 1 >> 1;
|
|
v0 = v0 + v3 + 1 >> 1;
|
|
v3 = t;
|
|
t = v1 - v2 + 1 >> 1;
|
|
v1 = v1 + v2 + 1 >> 1;
|
|
v2 = t;
|
|
t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
|
|
v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
|
|
v7 = t;
|
|
t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
|
|
v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
|
|
v6 = t;
|
|
p[0 * 8 + col] = v0 + v7;
|
|
p[7 * 8 + col] = v0 - v7;
|
|
p[1 * 8 + col] = v1 + v6;
|
|
p[6 * 8 + col] = v1 - v6;
|
|
p[2 * 8 + col] = v2 + v5;
|
|
p[5 * 8 + col] = v2 - v5;
|
|
p[3 * 8 + col] = v3 + v4;
|
|
p[4 * 8 + col] = v3 - v4;
|
|
}
|
|
for (i2 = 0; i2 < 64; ++i2) {
|
|
var sample2 = 128 + (p[i2] + 8 >> 4);
|
|
dataOut[i2] = sample2 < 0 ? 0 : sample2 > 255 ? 255 : sample2;
|
|
}
|
|
}
|
|
requestMemoryAllocation(samplesPerLine * blocksPerColumn * 8);
|
|
var i, j;
|
|
for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
|
|
var scanLine = blockRow << 3;
|
|
for (i = 0; i < 8; i++)
|
|
lines.push(new Uint8Array(samplesPerLine));
|
|
for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
|
|
quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
|
|
var offset = 0, sample = blockCol << 3;
|
|
for (j = 0; j < 8; j++) {
|
|
var line = lines[scanLine + j];
|
|
for (i = 0; i < 8; i++)
|
|
line[sample + i] = r[offset++];
|
|
}
|
|
}
|
|
}
|
|
return lines;
|
|
}
|
|
function clampTo8bit(a) {
|
|
return a < 0 ? 0 : a > 255 ? 255 : a;
|
|
}
|
|
constructor.prototype = {
|
|
load: function load(path) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", path, true);
|
|
xhr.responseType = "arraybuffer";
|
|
xhr.onload = function() {
|
|
var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);
|
|
this.parse(data);
|
|
if (this.onload)
|
|
this.onload();
|
|
}.bind(this);
|
|
xhr.send(null);
|
|
},
|
|
parse: function parse(data) {
|
|
var maxResolutionInPixels = this.opts.maxResolutionInMP * 1e3 * 1e3;
|
|
var offset = 0, length = data.length;
|
|
function readUint16() {
|
|
var value = data[offset] << 8 | data[offset + 1];
|
|
offset += 2;
|
|
return value;
|
|
}
|
|
function readDataBlock() {
|
|
var length2 = readUint16();
|
|
var array = data.subarray(offset, offset + length2 - 2);
|
|
offset += array.length;
|
|
return array;
|
|
}
|
|
function prepareComponents(frame2) {
|
|
var maxH2 = 1, maxV2 = 1;
|
|
var component2, componentId2;
|
|
for (componentId2 in frame2.components) {
|
|
if (frame2.components.hasOwnProperty(componentId2)) {
|
|
component2 = frame2.components[componentId2];
|
|
if (maxH2 < component2.h)
|
|
maxH2 = component2.h;
|
|
if (maxV2 < component2.v)
|
|
maxV2 = component2.v;
|
|
}
|
|
}
|
|
var mcusPerLine = Math.ceil(frame2.samplesPerLine / 8 / maxH2);
|
|
var mcusPerColumn = Math.ceil(frame2.scanLines / 8 / maxV2);
|
|
for (componentId2 in frame2.components) {
|
|
if (frame2.components.hasOwnProperty(componentId2)) {
|
|
component2 = frame2.components[componentId2];
|
|
var blocksPerLine = Math.ceil(Math.ceil(frame2.samplesPerLine / 8) * component2.h / maxH2);
|
|
var blocksPerColumn = Math.ceil(Math.ceil(frame2.scanLines / 8) * component2.v / maxV2);
|
|
var blocksPerLineForMcu = mcusPerLine * component2.h;
|
|
var blocksPerColumnForMcu = mcusPerColumn * component2.v;
|
|
var blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
|
|
var blocks = [];
|
|
requestMemoryAllocation(blocksToAllocate * 256);
|
|
for (var i2 = 0; i2 < blocksPerColumnForMcu; i2++) {
|
|
var row = [];
|
|
for (var j2 = 0; j2 < blocksPerLineForMcu; j2++)
|
|
row.push(new Int32Array(64));
|
|
blocks.push(row);
|
|
}
|
|
component2.blocksPerLine = blocksPerLine;
|
|
component2.blocksPerColumn = blocksPerColumn;
|
|
component2.blocks = blocks;
|
|
}
|
|
}
|
|
frame2.maxH = maxH2;
|
|
frame2.maxV = maxV2;
|
|
frame2.mcusPerLine = mcusPerLine;
|
|
frame2.mcusPerColumn = mcusPerColumn;
|
|
}
|
|
var jfif = null;
|
|
var adobe = null;
|
|
var pixels = null;
|
|
var frame, resetInterval;
|
|
var quantizationTables = [], frames = [];
|
|
var huffmanTablesAC = [], huffmanTablesDC = [];
|
|
var fileMarker = readUint16();
|
|
var malformedDataOffset = -1;
|
|
this.comments = [];
|
|
if (fileMarker != 65496) {
|
|
throw new Error("SOI not found");
|
|
}
|
|
fileMarker = readUint16();
|
|
while (fileMarker != 65497) {
|
|
var i, j, l;
|
|
switch (fileMarker) {
|
|
case 65280:
|
|
break;
|
|
case 65504:
|
|
case 65505:
|
|
case 65506:
|
|
case 65507:
|
|
case 65508:
|
|
case 65509:
|
|
case 65510:
|
|
case 65511:
|
|
case 65512:
|
|
case 65513:
|
|
case 65514:
|
|
case 65515:
|
|
case 65516:
|
|
case 65517:
|
|
case 65518:
|
|
case 65519:
|
|
case 65534:
|
|
var appData = readDataBlock();
|
|
if (fileMarker === 65534) {
|
|
var comment = String.fromCharCode.apply(null, appData);
|
|
this.comments.push(comment);
|
|
}
|
|
if (fileMarker === 65504) {
|
|
if (appData[0] === 74 && appData[1] === 70 && appData[2] === 73 && appData[3] === 70 && appData[4] === 0) {
|
|
jfif = {
|
|
version: { major: appData[5], minor: appData[6] },
|
|
densityUnits: appData[7],
|
|
xDensity: appData[8] << 8 | appData[9],
|
|
yDensity: appData[10] << 8 | appData[11],
|
|
thumbWidth: appData[12],
|
|
thumbHeight: appData[13],
|
|
thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
|
|
};
|
|
}
|
|
}
|
|
if (fileMarker === 65505) {
|
|
if (appData[0] === 69 && appData[1] === 120 && appData[2] === 105 && appData[3] === 102 && appData[4] === 0) {
|
|
this.exifBuffer = appData.subarray(5, appData.length);
|
|
}
|
|
}
|
|
if (fileMarker === 65518) {
|
|
if (appData[0] === 65 && appData[1] === 100 && appData[2] === 111 && appData[3] === 98 && appData[4] === 101 && appData[5] === 0) {
|
|
adobe = {
|
|
version: appData[6],
|
|
flags0: appData[7] << 8 | appData[8],
|
|
flags1: appData[9] << 8 | appData[10],
|
|
transformCode: appData[11]
|
|
};
|
|
}
|
|
}
|
|
break;
|
|
case 65499:
|
|
var quantizationTablesLength = readUint16();
|
|
var quantizationTablesEnd = quantizationTablesLength + offset - 2;
|
|
while (offset < quantizationTablesEnd) {
|
|
var quantizationTableSpec = data[offset++];
|
|
requestMemoryAllocation(64 * 4);
|
|
var tableData = new Int32Array(64);
|
|
if (quantizationTableSpec >> 4 === 0) {
|
|
for (j = 0; j < 64; j++) {
|
|
var z = dctZigZag[j];
|
|
tableData[z] = data[offset++];
|
|
}
|
|
} else if (quantizationTableSpec >> 4 === 1) {
|
|
for (j = 0; j < 64; j++) {
|
|
var z = dctZigZag[j];
|
|
tableData[z] = readUint16();
|
|
}
|
|
} else
|
|
throw new Error("DQT: invalid table spec");
|
|
quantizationTables[quantizationTableSpec & 15] = tableData;
|
|
}
|
|
break;
|
|
case 65472:
|
|
case 65473:
|
|
case 65474:
|
|
readUint16();
|
|
frame = {};
|
|
frame.extended = fileMarker === 65473;
|
|
frame.progressive = fileMarker === 65474;
|
|
frame.precision = data[offset++];
|
|
frame.scanLines = readUint16();
|
|
frame.samplesPerLine = readUint16();
|
|
frame.components = {};
|
|
frame.componentsOrder = [];
|
|
var pixelsInFrame = frame.scanLines * frame.samplesPerLine;
|
|
if (pixelsInFrame > maxResolutionInPixels) {
|
|
var exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);
|
|
throw new Error(`maxResolutionInMP limit exceeded by ${exceededAmount}MP`);
|
|
}
|
|
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;
|
|
var qId = data[offset + 2];
|
|
if (h <= 0 || v <= 0) {
|
|
throw new Error("Invalid sampling factor, expected values above 0");
|
|
}
|
|
frame.componentsOrder.push(componentId);
|
|
frame.components[componentId] = {
|
|
h,
|
|
v,
|
|
quantizationIdx: qId
|
|
};
|
|
offset += 3;
|
|
}
|
|
prepareComponents(frame);
|
|
frames.push(frame);
|
|
break;
|
|
case 65476:
|
|
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];
|
|
}
|
|
requestMemoryAllocation(16 + codeLengthSum);
|
|
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] = buildHuffmanTable2(codeLengths, huffmanValues);
|
|
}
|
|
break;
|
|
case 65501:
|
|
readUint16();
|
|
resetInterval = readUint16();
|
|
break;
|
|
case 65500:
|
|
readUint16();
|
|
readUint16();
|
|
break;
|
|
case 65498:
|
|
var scanLength = readUint16();
|
|
var selectorsCount = data[offset++];
|
|
var components = [], component;
|
|
for (i = 0; i < selectorsCount; i++) {
|
|
component = frame.components[data[offset++]];
|
|
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 processed2 = decodeScan(
|
|
data,
|
|
offset,
|
|
frame,
|
|
components,
|
|
resetInterval,
|
|
spectralStart,
|
|
spectralEnd,
|
|
successiveApproximation >> 4,
|
|
successiveApproximation & 15,
|
|
this.opts
|
|
);
|
|
offset += processed2;
|
|
break;
|
|
case 65535:
|
|
if (data[offset] !== 255) {
|
|
offset--;
|
|
}
|
|
break;
|
|
default:
|
|
if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) {
|
|
offset -= 3;
|
|
break;
|
|
} else if (fileMarker === 224 || fileMarker == 225) {
|
|
if (malformedDataOffset !== -1) {
|
|
throw new Error(`first unknown JPEG marker at offset ${malformedDataOffset.toString(16)}, second unknown JPEG marker ${fileMarker.toString(16)} at offset ${(offset - 1).toString(16)}`);
|
|
}
|
|
malformedDataOffset = offset - 1;
|
|
const nextOffset = readUint16();
|
|
if (data[offset + nextOffset - 2] === 255) {
|
|
offset += nextOffset - 2;
|
|
break;
|
|
}
|
|
}
|
|
throw new Error("unknown JPEG marker " + fileMarker.toString(16));
|
|
}
|
|
fileMarker = readUint16();
|
|
}
|
|
if (frames.length != 1)
|
|
throw new Error("only single frame JPEGs supported");
|
|
for (var i = 0; i < frames.length; i++) {
|
|
var cp2 = frames[i].components;
|
|
for (var j in cp2) {
|
|
cp2[j].quantizationTable = quantizationTables[cp2[j].quantizationIdx];
|
|
delete cp2[j].quantizationIdx;
|
|
}
|
|
}
|
|
this.width = frame.samplesPerLine;
|
|
this.height = frame.scanLines;
|
|
this.jfif = jfif;
|
|
this.adobe = adobe;
|
|
this.components = [];
|
|
for (var i = 0; i < frame.componentsOrder.length; i++) {
|
|
var component = frame.components[frame.componentsOrder[i]];
|
|
this.components.push({
|
|
lines: buildComponentData(frame, component),
|
|
scaleX: component.h / frame.maxH,
|
|
scaleY: component.v / frame.maxV
|
|
});
|
|
}
|
|
},
|
|
getData: function getData(width, height) {
|
|
var scaleX = this.width / width, scaleY = this.height / height;
|
|
var component1, component2, component3, component4;
|
|
var component1Line, component2Line, component3Line, component4Line;
|
|
var x, y;
|
|
var offset = 0;
|
|
var Y, Cb, Cr, K, C, M, Ye, R, G, B;
|
|
var colorTransform;
|
|
var dataLength = width * height * this.components.length;
|
|
requestMemoryAllocation(dataLength);
|
|
var data = new Uint8Array(dataLength);
|
|
switch (this.components.length) {
|
|
case 1:
|
|
component1 = this.components[0];
|
|
for (y = 0; y < height; y++) {
|
|
component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
|
|
for (x = 0; x < width; x++) {
|
|
Y = component1Line[0 | x * component1.scaleX * scaleX];
|
|
data[offset++] = Y;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
component1 = this.components[0];
|
|
component2 = this.components[1];
|
|
for (y = 0; y < height; y++) {
|
|
component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
|
|
component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
|
|
for (x = 0; x < width; x++) {
|
|
Y = component1Line[0 | x * component1.scaleX * scaleX];
|
|
data[offset++] = Y;
|
|
Y = component2Line[0 | x * component2.scaleX * scaleX];
|
|
data[offset++] = Y;
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
colorTransform = true;
|
|
if (this.adobe && this.adobe.transformCode)
|
|
colorTransform = true;
|
|
else if (typeof this.opts.colorTransform !== "undefined")
|
|
colorTransform = !!this.opts.colorTransform;
|
|
component1 = this.components[0];
|
|
component2 = this.components[1];
|
|
component3 = this.components[2];
|
|
for (y = 0; y < height; y++) {
|
|
component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
|
|
component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
|
|
component3Line = component3.lines[0 | y * component3.scaleY * scaleY];
|
|
for (x = 0; x < width; x++) {
|
|
if (!colorTransform) {
|
|
R = component1Line[0 | x * component1.scaleX * scaleX];
|
|
G = component2Line[0 | x * component2.scaleX * scaleX];
|
|
B = component3Line[0 | x * component3.scaleX * scaleX];
|
|
} else {
|
|
Y = component1Line[0 | x * component1.scaleX * scaleX];
|
|
Cb = component2Line[0 | x * component2.scaleX * scaleX];
|
|
Cr = component3Line[0 | x * component3.scaleX * scaleX];
|
|
R = clampTo8bit(Y + 1.402 * (Cr - 128));
|
|
G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
|
|
B = clampTo8bit(Y + 1.772 * (Cb - 128));
|
|
}
|
|
data[offset++] = R;
|
|
data[offset++] = G;
|
|
data[offset++] = B;
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
if (!this.adobe)
|
|
throw new Error("Unsupported color mode (4 components)");
|
|
colorTransform = false;
|
|
if (this.adobe && this.adobe.transformCode)
|
|
colorTransform = true;
|
|
else if (typeof this.opts.colorTransform !== "undefined")
|
|
colorTransform = !!this.opts.colorTransform;
|
|
component1 = this.components[0];
|
|
component2 = this.components[1];
|
|
component3 = this.components[2];
|
|
component4 = this.components[3];
|
|
for (y = 0; y < height; y++) {
|
|
component1Line = component1.lines[0 | y * component1.scaleY * scaleY];
|
|
component2Line = component2.lines[0 | y * component2.scaleY * scaleY];
|
|
component3Line = component3.lines[0 | y * component3.scaleY * scaleY];
|
|
component4Line = component4.lines[0 | y * component4.scaleY * scaleY];
|
|
for (x = 0; x < width; x++) {
|
|
if (!colorTransform) {
|
|
C = component1Line[0 | x * component1.scaleX * scaleX];
|
|
M = component2Line[0 | x * component2.scaleX * scaleX];
|
|
Ye = component3Line[0 | x * component3.scaleX * scaleX];
|
|
K = component4Line[0 | x * component4.scaleX * scaleX];
|
|
} else {
|
|
Y = component1Line[0 | x * component1.scaleX * scaleX];
|
|
Cb = component2Line[0 | x * component2.scaleX * scaleX];
|
|
Cr = component3Line[0 | x * component3.scaleX * scaleX];
|
|
K = component4Line[0 | x * component4.scaleX * scaleX];
|
|
C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128));
|
|
M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));
|
|
Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128));
|
|
}
|
|
data[offset++] = 255 - C;
|
|
data[offset++] = 255 - M;
|
|
data[offset++] = 255 - Ye;
|
|
data[offset++] = 255 - K;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error("Unsupported color mode");
|
|
}
|
|
return data;
|
|
},
|
|
copyToImageData: function copyToImageData(imageData, formatAsRGBA) {
|
|
var width = imageData.width, height = imageData.height;
|
|
var imageDataArray = imageData.data;
|
|
var data = this.getData(width, height);
|
|
var i = 0, j = 0, x, y;
|
|
var Y, K, C, M, R, G, B;
|
|
switch (this.components.length) {
|
|
case 1:
|
|
for (y = 0; y < height; y++) {
|
|
for (x = 0; x < width; x++) {
|
|
Y = data[i++];
|
|
imageDataArray[j++] = Y;
|
|
imageDataArray[j++] = Y;
|
|
imageDataArray[j++] = Y;
|
|
if (formatAsRGBA) {
|
|
imageDataArray[j++] = 255;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
for (y = 0; y < height; y++) {
|
|
for (x = 0; x < width; x++) {
|
|
R = data[i++];
|
|
G = data[i++];
|
|
B = data[i++];
|
|
imageDataArray[j++] = R;
|
|
imageDataArray[j++] = G;
|
|
imageDataArray[j++] = B;
|
|
if (formatAsRGBA) {
|
|
imageDataArray[j++] = 255;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
for (y = 0; y < height; y++) {
|
|
for (x = 0; x < width; x++) {
|
|
C = data[i++];
|
|
M = data[i++];
|
|
Y = data[i++];
|
|
K = data[i++];
|
|
R = 255 - clampTo8bit(C * (1 - K / 255) + K);
|
|
G = 255 - clampTo8bit(M * (1 - K / 255) + K);
|
|
B = 255 - clampTo8bit(Y * (1 - K / 255) + K);
|
|
imageDataArray[j++] = R;
|
|
imageDataArray[j++] = G;
|
|
imageDataArray[j++] = B;
|
|
if (formatAsRGBA) {
|
|
imageDataArray[j++] = 255;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error("Unsupported color mode");
|
|
}
|
|
}
|
|
};
|
|
var totalBytesAllocated = 0;
|
|
var maxMemoryUsageBytes = 0;
|
|
function requestMemoryAllocation(increaseAmount = 0) {
|
|
var totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
|
|
if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
|
|
var exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
|
|
throw new Error(`maxMemoryUsageInMB limit exceeded by at least ${exceededAmount}MB`);
|
|
}
|
|
totalBytesAllocated = totalMemoryImpactBytes;
|
|
}
|
|
constructor.resetMaxMemoryUsage = function(maxMemoryUsageBytes_) {
|
|
totalBytesAllocated = 0;
|
|
maxMemoryUsageBytes = maxMemoryUsageBytes_;
|
|
};
|
|
constructor.getBytesAllocated = function() {
|
|
return totalBytesAllocated;
|
|
};
|
|
constructor.requestMemoryAllocation = requestMemoryAllocation;
|
|
return constructor;
|
|
}();
|
|
if (typeof module !== "undefined") {
|
|
module.exports = decode3;
|
|
} else if (typeof window !== "undefined") {
|
|
window["jpeg-js"] = window["jpeg-js"] || {};
|
|
window["jpeg-js"].decode = decode3;
|
|
}
|
|
function decode3(jpegData, userOpts = {}) {
|
|
var defaultOpts = {
|
|
colorTransform: void 0,
|
|
useTArray: false,
|
|
formatAsRGBA: true,
|
|
tolerantDecoding: true,
|
|
maxResolutionInMP: 100,
|
|
maxMemoryUsageInMB: 512
|
|
};
|
|
var opts = { ...defaultOpts, ...userOpts };
|
|
var arr = new Uint8Array(jpegData);
|
|
var decoder = new JpegImage();
|
|
decoder.opts = opts;
|
|
JpegImage.resetMaxMemoryUsage(opts.maxMemoryUsageInMB * 1024 * 1024);
|
|
decoder.parse(arr);
|
|
var channels = opts.formatAsRGBA ? 4 : 3;
|
|
var bytesNeeded = decoder.width * decoder.height * channels;
|
|
try {
|
|
JpegImage.requestMemoryAllocation(bytesNeeded);
|
|
var image = {
|
|
width: decoder.width,
|
|
height: decoder.height,
|
|
exifBuffer: decoder.exifBuffer,
|
|
data: opts.useTArray ? new Uint8Array(bytesNeeded) : Buffer2.alloc(bytesNeeded)
|
|
};
|
|
if (decoder.comments.length > 0) {
|
|
image["comments"] = decoder.comments;
|
|
}
|
|
} catch (err) {
|
|
if (err instanceof RangeError) {
|
|
throw new Error("Could not allocate enough memory for the image. Required: " + bytesNeeded);
|
|
}
|
|
if (err instanceof ReferenceError) {
|
|
if (err.message === "Buffer is not defined") {
|
|
throw new Error("Buffer is not globally defined in this environment. Consider setting useTArray to true");
|
|
}
|
|
}
|
|
throw err;
|
|
}
|
|
decoder.copyToImageData(image, opts.formatAsRGBA);
|
|
return image;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/jpeg-js/index.js
|
|
var require_jpeg_js = __commonJS({
|
|
"node_modules/jpeg-js/index.js"(exports, module) {
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var encode2 = require_encoder();
|
|
var decode3 = require_decoder();
|
|
module.exports = {
|
|
encode: encode2,
|
|
decode: decode3
|
|
};
|
|
}
|
|
});
|
|
|
|
// src/main.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_buffer9 = __toESM(require_buffer(), 1);
|
|
|
|
// src/stores.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/svelte/store/index.mjs
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/svelte/internal/index.mjs
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function noop() {
|
|
}
|
|
var identity = (x) => x;
|
|
function assign(tar, src) {
|
|
for (const k in src)
|
|
tar[k] = src[k];
|
|
return tar;
|
|
}
|
|
function run(fn) {
|
|
return fn();
|
|
}
|
|
function blank_object() {
|
|
return /* @__PURE__ */ Object.create(null);
|
|
}
|
|
function run_all(fns) {
|
|
fns.forEach(run);
|
|
}
|
|
function is_function(thing) {
|
|
return typeof thing === "function";
|
|
}
|
|
function safe_not_equal(a, b) {
|
|
return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function");
|
|
}
|
|
var src_url_equal_anchor;
|
|
function src_url_equal(element_src, url) {
|
|
if (!src_url_equal_anchor) {
|
|
src_url_equal_anchor = document.createElement("a");
|
|
}
|
|
src_url_equal_anchor.href = url;
|
|
return element_src === src_url_equal_anchor.href;
|
|
}
|
|
function is_empty(obj) {
|
|
return Object.keys(obj).length === 0;
|
|
}
|
|
function subscribe(store, ...callbacks) {
|
|
if (store == null) {
|
|
return noop;
|
|
}
|
|
const unsub = store.subscribe(...callbacks);
|
|
return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
|
|
}
|
|
function component_subscribe(component, store, callback) {
|
|
component.$$.on_destroy.push(subscribe(store, callback));
|
|
}
|
|
function create_slot(definition, ctx, $$scope, fn) {
|
|
if (definition) {
|
|
const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
|
|
return definition[0](slot_ctx);
|
|
}
|
|
}
|
|
function get_slot_context(definition, ctx, $$scope, fn) {
|
|
return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx;
|
|
}
|
|
function get_slot_changes(definition, $$scope, dirty, fn) {
|
|
if (definition[2] && fn) {
|
|
const lets = definition[2](fn(dirty));
|
|
if ($$scope.dirty === void 0) {
|
|
return lets;
|
|
}
|
|
if (typeof lets === "object") {
|
|
const merged = [];
|
|
const len = Math.max($$scope.dirty.length, lets.length);
|
|
for (let i = 0; i < len; i += 1) {
|
|
merged[i] = $$scope.dirty[i] | lets[i];
|
|
}
|
|
return merged;
|
|
}
|
|
return $$scope.dirty | lets;
|
|
}
|
|
return $$scope.dirty;
|
|
}
|
|
function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {
|
|
if (slot_changes) {
|
|
const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
|
|
slot.p(slot_context, slot_changes);
|
|
}
|
|
}
|
|
function get_all_dirty_from_scope($$scope) {
|
|
if ($$scope.ctx.length > 32) {
|
|
const dirty = [];
|
|
const length = $$scope.ctx.length / 32;
|
|
for (let i = 0; i < length; i++) {
|
|
dirty[i] = -1;
|
|
}
|
|
return dirty;
|
|
}
|
|
return -1;
|
|
}
|
|
function null_to_empty(value) {
|
|
return value == null ? "" : value;
|
|
}
|
|
function set_store_value(store, ret, value) {
|
|
store.set(value);
|
|
return ret;
|
|
}
|
|
var is_client = typeof window !== "undefined";
|
|
var now = is_client ? () => window.performance.now() : () => Date.now();
|
|
var raf = is_client ? (cb) => requestAnimationFrame(cb) : noop;
|
|
var tasks = /* @__PURE__ */ new Set();
|
|
function run_tasks(now2) {
|
|
tasks.forEach((task) => {
|
|
if (!task.c(now2)) {
|
|
tasks.delete(task);
|
|
task.f();
|
|
}
|
|
});
|
|
if (tasks.size !== 0)
|
|
raf(run_tasks);
|
|
}
|
|
function loop(callback) {
|
|
let task;
|
|
if (tasks.size === 0)
|
|
raf(run_tasks);
|
|
return {
|
|
promise: new Promise((fulfill) => {
|
|
tasks.add(task = { c: callback, f: fulfill });
|
|
}),
|
|
abort() {
|
|
tasks.delete(task);
|
|
}
|
|
};
|
|
}
|
|
var is_hydrating = false;
|
|
function start_hydrating() {
|
|
is_hydrating = true;
|
|
}
|
|
function end_hydrating() {
|
|
is_hydrating = false;
|
|
}
|
|
function append(target, node) {
|
|
target.appendChild(node);
|
|
}
|
|
function append_styles(target, style_sheet_id, styles) {
|
|
const append_styles_to = get_root_for_style(target);
|
|
if (!append_styles_to.getElementById(style_sheet_id)) {
|
|
const style = element("style");
|
|
style.id = style_sheet_id;
|
|
style.textContent = styles;
|
|
append_stylesheet(append_styles_to, style);
|
|
}
|
|
}
|
|
function get_root_for_style(node) {
|
|
if (!node)
|
|
return document;
|
|
const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
|
|
if (root && root.host) {
|
|
return root;
|
|
}
|
|
return node.ownerDocument;
|
|
}
|
|
function append_empty_stylesheet(node) {
|
|
const style_element = element("style");
|
|
append_stylesheet(get_root_for_style(node), style_element);
|
|
return style_element.sheet;
|
|
}
|
|
function append_stylesheet(node, style) {
|
|
append(node.head || node, style);
|
|
return style.sheet;
|
|
}
|
|
function insert(target, node, anchor) {
|
|
target.insertBefore(node, anchor || null);
|
|
}
|
|
function detach(node) {
|
|
if (node.parentNode) {
|
|
node.parentNode.removeChild(node);
|
|
}
|
|
}
|
|
function destroy_each(iterations, detaching) {
|
|
for (let i = 0; i < iterations.length; i += 1) {
|
|
if (iterations[i])
|
|
iterations[i].d(detaching);
|
|
}
|
|
}
|
|
function element(name) {
|
|
return document.createElement(name);
|
|
}
|
|
function svg_element(name) {
|
|
return document.createElementNS("http://www.w3.org/2000/svg", name);
|
|
}
|
|
function text(data) {
|
|
return document.createTextNode(data);
|
|
}
|
|
function space() {
|
|
return text(" ");
|
|
}
|
|
function empty() {
|
|
return text("");
|
|
}
|
|
function listen(node, event, handler, options) {
|
|
node.addEventListener(event, handler, options);
|
|
return () => node.removeEventListener(event, handler, options);
|
|
}
|
|
function attr(node, attribute, value) {
|
|
if (value == null)
|
|
node.removeAttribute(attribute);
|
|
else if (node.getAttribute(attribute) !== value)
|
|
node.setAttribute(attribute, value);
|
|
}
|
|
function to_number(value) {
|
|
return value === "" ? null : +value;
|
|
}
|
|
function children(element2) {
|
|
return Array.from(element2.childNodes);
|
|
}
|
|
function set_data(text2, data) {
|
|
data = "" + data;
|
|
if (text2.wholeText !== data)
|
|
text2.data = data;
|
|
}
|
|
function set_input_value(input, value) {
|
|
input.value = value == null ? "" : value;
|
|
}
|
|
function set_style(node, key2, value, important) {
|
|
if (value === null) {
|
|
node.style.removeProperty(key2);
|
|
} else {
|
|
node.style.setProperty(key2, value, important ? "important" : "");
|
|
}
|
|
}
|
|
function select_option(select, value) {
|
|
for (let i = 0; i < select.options.length; i += 1) {
|
|
const option = select.options[i];
|
|
if (option.__value === value) {
|
|
option.selected = true;
|
|
return;
|
|
}
|
|
}
|
|
select.selectedIndex = -1;
|
|
}
|
|
function select_value(select) {
|
|
const selected_option = select.querySelector(":checked") || select.options[0];
|
|
return selected_option && selected_option.__value;
|
|
}
|
|
function toggle_class(element2, name, toggle) {
|
|
element2.classList[toggle ? "add" : "remove"](name);
|
|
}
|
|
function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
|
|
const e = document.createEvent("CustomEvent");
|
|
e.initCustomEvent(type, bubbles, cancelable, detail);
|
|
return e;
|
|
}
|
|
var HtmlTag = class {
|
|
constructor(is_svg = false) {
|
|
this.is_svg = false;
|
|
this.is_svg = is_svg;
|
|
this.e = this.n = null;
|
|
}
|
|
c(html) {
|
|
this.h(html);
|
|
}
|
|
m(html, target, anchor = null) {
|
|
if (!this.e) {
|
|
if (this.is_svg)
|
|
this.e = svg_element(target.nodeName);
|
|
else
|
|
this.e = element(target.nodeName);
|
|
this.t = target;
|
|
this.c(html);
|
|
}
|
|
this.i(anchor);
|
|
}
|
|
h(html) {
|
|
this.e.innerHTML = html;
|
|
this.n = Array.from(this.e.childNodes);
|
|
}
|
|
i(anchor) {
|
|
for (let i = 0; i < this.n.length; i += 1) {
|
|
insert(this.t, this.n[i], anchor);
|
|
}
|
|
}
|
|
p(html) {
|
|
this.d();
|
|
this.h(html);
|
|
this.i(this.a);
|
|
}
|
|
d() {
|
|
this.n.forEach(detach);
|
|
}
|
|
};
|
|
var managed_styles = /* @__PURE__ */ new Map();
|
|
var active = 0;
|
|
function hash(str) {
|
|
let hash2 = 5381;
|
|
let i = str.length;
|
|
while (i--)
|
|
hash2 = (hash2 << 5) - hash2 ^ str.charCodeAt(i);
|
|
return hash2 >>> 0;
|
|
}
|
|
function create_style_information(doc, node) {
|
|
const info = { stylesheet: append_empty_stylesheet(node), rules: {} };
|
|
managed_styles.set(doc, info);
|
|
return info;
|
|
}
|
|
function create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {
|
|
const step = 16.666 / duration;
|
|
let keyframes = "{\n";
|
|
for (let p = 0; p <= 1; p += step) {
|
|
const t = a + (b - a) * ease(p);
|
|
keyframes += p * 100 + `%{${fn(t, 1 - t)}}
|
|
`;
|
|
}
|
|
const rule = keyframes + `100% {${fn(b, 1 - b)}}
|
|
}`;
|
|
const name = `__svelte_${hash(rule)}_${uid}`;
|
|
const doc = get_root_for_style(node);
|
|
const { stylesheet, rules } = managed_styles.get(doc) || create_style_information(doc, node);
|
|
if (!rules[name]) {
|
|
rules[name] = true;
|
|
stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
|
|
}
|
|
const animation = node.style.animation || "";
|
|
node.style.animation = `${animation ? `${animation}, ` : ""}${name} ${duration}ms linear ${delay}ms 1 both`;
|
|
active += 1;
|
|
return name;
|
|
}
|
|
function delete_rule(node, name) {
|
|
const previous = (node.style.animation || "").split(", ");
|
|
const next = previous.filter(
|
|
name ? (anim) => anim.indexOf(name) < 0 : (anim) => anim.indexOf("__svelte") === -1
|
|
);
|
|
const deleted = previous.length - next.length;
|
|
if (deleted) {
|
|
node.style.animation = next.join(", ");
|
|
active -= deleted;
|
|
if (!active)
|
|
clear_rules();
|
|
}
|
|
}
|
|
function clear_rules() {
|
|
raf(() => {
|
|
if (active)
|
|
return;
|
|
managed_styles.forEach((info) => {
|
|
const { ownerNode } = info.stylesheet;
|
|
if (ownerNode)
|
|
detach(ownerNode);
|
|
});
|
|
managed_styles.clear();
|
|
});
|
|
}
|
|
var current_component;
|
|
function set_current_component(component) {
|
|
current_component = component;
|
|
}
|
|
function get_current_component() {
|
|
if (!current_component)
|
|
throw new Error("Function called outside component initialization");
|
|
return current_component;
|
|
}
|
|
function beforeUpdate(fn) {
|
|
get_current_component().$$.before_update.push(fn);
|
|
}
|
|
function onMount(fn) {
|
|
get_current_component().$$.on_mount.push(fn);
|
|
}
|
|
function onDestroy(fn) {
|
|
get_current_component().$$.on_destroy.push(fn);
|
|
}
|
|
function createEventDispatcher() {
|
|
const component = get_current_component();
|
|
return (type, detail, { cancelable = false } = {}) => {
|
|
const callbacks = component.$$.callbacks[type];
|
|
if (callbacks) {
|
|
const event = custom_event(type, detail, { cancelable });
|
|
callbacks.slice().forEach((fn) => {
|
|
fn.call(component, event);
|
|
});
|
|
return !event.defaultPrevented;
|
|
}
|
|
return true;
|
|
};
|
|
}
|
|
function setContext(key2, context) {
|
|
get_current_component().$$.context.set(key2, context);
|
|
return context;
|
|
}
|
|
function getContext(key2) {
|
|
return get_current_component().$$.context.get(key2);
|
|
}
|
|
function bubble(component, event) {
|
|
const callbacks = component.$$.callbacks[event.type];
|
|
if (callbacks) {
|
|
callbacks.slice().forEach((fn) => fn.call(this, event));
|
|
}
|
|
}
|
|
var dirty_components = [];
|
|
var binding_callbacks = [];
|
|
var render_callbacks = [];
|
|
var flush_callbacks = [];
|
|
var resolved_promise = Promise.resolve();
|
|
var update_scheduled = false;
|
|
function schedule_update() {
|
|
if (!update_scheduled) {
|
|
update_scheduled = true;
|
|
resolved_promise.then(flush);
|
|
}
|
|
}
|
|
function add_render_callback(fn) {
|
|
render_callbacks.push(fn);
|
|
}
|
|
var seen_callbacks = /* @__PURE__ */ new Set();
|
|
var flushidx = 0;
|
|
function flush() {
|
|
const saved_component = current_component;
|
|
do {
|
|
while (flushidx < dirty_components.length) {
|
|
const component = dirty_components[flushidx];
|
|
flushidx++;
|
|
set_current_component(component);
|
|
update(component.$$);
|
|
}
|
|
set_current_component(null);
|
|
dirty_components.length = 0;
|
|
flushidx = 0;
|
|
while (binding_callbacks.length)
|
|
binding_callbacks.pop()();
|
|
for (let i = 0; i < render_callbacks.length; i += 1) {
|
|
const callback = render_callbacks[i];
|
|
if (!seen_callbacks.has(callback)) {
|
|
seen_callbacks.add(callback);
|
|
callback();
|
|
}
|
|
}
|
|
render_callbacks.length = 0;
|
|
} while (dirty_components.length);
|
|
while (flush_callbacks.length) {
|
|
flush_callbacks.pop()();
|
|
}
|
|
update_scheduled = false;
|
|
seen_callbacks.clear();
|
|
set_current_component(saved_component);
|
|
}
|
|
function update($$) {
|
|
if ($$.fragment !== null) {
|
|
$$.update();
|
|
run_all($$.before_update);
|
|
const dirty = $$.dirty;
|
|
$$.dirty = [-1];
|
|
$$.fragment && $$.fragment.p($$.ctx, dirty);
|
|
$$.after_update.forEach(add_render_callback);
|
|
}
|
|
}
|
|
var promise;
|
|
function wait() {
|
|
if (!promise) {
|
|
promise = Promise.resolve();
|
|
promise.then(() => {
|
|
promise = null;
|
|
});
|
|
}
|
|
return promise;
|
|
}
|
|
function dispatch(node, direction, kind) {
|
|
node.dispatchEvent(custom_event(`${direction ? "intro" : "outro"}${kind}`));
|
|
}
|
|
var outroing = /* @__PURE__ */ new Set();
|
|
var outros;
|
|
function group_outros() {
|
|
outros = {
|
|
r: 0,
|
|
c: [],
|
|
p: outros
|
|
};
|
|
}
|
|
function check_outros() {
|
|
if (!outros.r) {
|
|
run_all(outros.c);
|
|
}
|
|
outros = outros.p;
|
|
}
|
|
function transition_in(block, local) {
|
|
if (block && block.i) {
|
|
outroing.delete(block);
|
|
block.i(local);
|
|
}
|
|
}
|
|
function transition_out(block, local, detach2, callback) {
|
|
if (block && block.o) {
|
|
if (outroing.has(block))
|
|
return;
|
|
outroing.add(block);
|
|
outros.c.push(() => {
|
|
outroing.delete(block);
|
|
if (callback) {
|
|
if (detach2)
|
|
block.d(1);
|
|
callback();
|
|
}
|
|
});
|
|
block.o(local);
|
|
} else if (callback) {
|
|
callback();
|
|
}
|
|
}
|
|
var null_transition = { duration: 0 };
|
|
function create_bidirectional_transition(node, fn, params, intro) {
|
|
const options = { direction: "both" };
|
|
let config = fn(node, params, options);
|
|
let t = intro ? 0 : 1;
|
|
let running_program = null;
|
|
let pending_program = null;
|
|
let animation_name = null;
|
|
function clear_animation() {
|
|
if (animation_name)
|
|
delete_rule(node, animation_name);
|
|
}
|
|
function init5(program, duration) {
|
|
const d = program.b - t;
|
|
duration *= Math.abs(d);
|
|
return {
|
|
a: t,
|
|
b: program.b,
|
|
d,
|
|
duration,
|
|
start: program.start,
|
|
end: program.start + duration,
|
|
group: program.group
|
|
};
|
|
}
|
|
function go2(b) {
|
|
const { delay = 0, duration = 300, easing = identity, tick: tick2 = noop, css } = config || null_transition;
|
|
const program = {
|
|
start: now() + delay,
|
|
b
|
|
};
|
|
if (!b) {
|
|
program.group = outros;
|
|
outros.r += 1;
|
|
}
|
|
if (running_program || pending_program) {
|
|
pending_program = program;
|
|
} else {
|
|
if (css) {
|
|
clear_animation();
|
|
animation_name = create_rule(node, t, b, duration, delay, easing, css);
|
|
}
|
|
if (b)
|
|
tick2(0, 1);
|
|
running_program = init5(program, duration);
|
|
add_render_callback(() => dispatch(node, b, "start"));
|
|
loop((now2) => {
|
|
if (pending_program && now2 > pending_program.start) {
|
|
running_program = init5(pending_program, duration);
|
|
pending_program = null;
|
|
dispatch(node, running_program.b, "start");
|
|
if (css) {
|
|
clear_animation();
|
|
animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);
|
|
}
|
|
}
|
|
if (running_program) {
|
|
if (now2 >= running_program.end) {
|
|
tick2(t = running_program.b, 1 - t);
|
|
dispatch(node, running_program.b, "end");
|
|
if (!pending_program) {
|
|
if (running_program.b) {
|
|
clear_animation();
|
|
} else {
|
|
if (!--running_program.group.r)
|
|
run_all(running_program.group.c);
|
|
}
|
|
}
|
|
running_program = null;
|
|
} else if (now2 >= running_program.start) {
|
|
const p = now2 - running_program.start;
|
|
t = running_program.a + running_program.d * easing(p / running_program.duration);
|
|
tick2(t, 1 - t);
|
|
}
|
|
}
|
|
return !!(running_program || pending_program);
|
|
});
|
|
}
|
|
}
|
|
return {
|
|
run(b) {
|
|
if (is_function(config)) {
|
|
wait().then(() => {
|
|
config = config(options);
|
|
go2(b);
|
|
});
|
|
} else {
|
|
go2(b);
|
|
}
|
|
},
|
|
end() {
|
|
clear_animation();
|
|
running_program = pending_program = null;
|
|
}
|
|
};
|
|
}
|
|
function destroy_block(block, lookup) {
|
|
block.d(1);
|
|
lookup.delete(block.key);
|
|
}
|
|
function outro_and_destroy_block(block, lookup) {
|
|
transition_out(block, 1, 1, () => {
|
|
lookup.delete(block.key);
|
|
});
|
|
}
|
|
function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block8, next, get_context) {
|
|
let o = old_blocks.length;
|
|
let n = list.length;
|
|
let i = o;
|
|
const old_indexes = {};
|
|
while (i--)
|
|
old_indexes[old_blocks[i].key] = i;
|
|
const new_blocks = [];
|
|
const new_lookup = /* @__PURE__ */ new Map();
|
|
const deltas = /* @__PURE__ */ new Map();
|
|
i = n;
|
|
while (i--) {
|
|
const child_ctx = get_context(ctx, list, i);
|
|
const key2 = get_key(child_ctx);
|
|
let block = lookup.get(key2);
|
|
if (!block) {
|
|
block = create_each_block8(key2, child_ctx);
|
|
block.c();
|
|
} else if (dynamic) {
|
|
block.p(child_ctx, dirty);
|
|
}
|
|
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();
|
|
function insert2(block) {
|
|
transition_in(block, 1);
|
|
block.m(node, next);
|
|
lookup.set(block.key, block);
|
|
next = block.first;
|
|
n--;
|
|
}
|
|
while (o && n) {
|
|
const new_block = new_blocks[n - 1];
|
|
const old_block = old_blocks[o - 1];
|
|
const new_key = new_block.key;
|
|
const old_key = old_block.key;
|
|
if (new_block === old_block) {
|
|
next = new_block.first;
|
|
o--;
|
|
n--;
|
|
} else if (!new_lookup.has(old_key)) {
|
|
destroy(old_block, lookup);
|
|
o--;
|
|
} else if (!lookup.has(new_key) || will_move.has(new_key)) {
|
|
insert2(new_block);
|
|
} else if (did_move.has(old_key)) {
|
|
o--;
|
|
} else if (deltas.get(new_key) > deltas.get(old_key)) {
|
|
did_move.add(new_key);
|
|
insert2(new_block);
|
|
} else {
|
|
will_move.add(old_key);
|
|
o--;
|
|
}
|
|
}
|
|
while (o--) {
|
|
const old_block = old_blocks[o];
|
|
if (!new_lookup.has(old_block.key))
|
|
destroy(old_block, lookup);
|
|
}
|
|
while (n)
|
|
insert2(new_blocks[n - 1]);
|
|
return new_blocks;
|
|
}
|
|
function create_component(block) {
|
|
block && block.c();
|
|
}
|
|
function mount_component(component, target, anchor, customElement) {
|
|
const { fragment, after_update } = component.$$;
|
|
fragment && fragment.m(target, anchor);
|
|
if (!customElement) {
|
|
add_render_callback(() => {
|
|
const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
|
|
if (component.$$.on_destroy) {
|
|
component.$$.on_destroy.push(...new_on_destroy);
|
|
} else {
|
|
run_all(new_on_destroy);
|
|
}
|
|
component.$$.on_mount = [];
|
|
});
|
|
}
|
|
after_update.forEach(add_render_callback);
|
|
}
|
|
function destroy_component(component, detaching) {
|
|
const $$ = component.$$;
|
|
if ($$.fragment !== null) {
|
|
run_all($$.on_destroy);
|
|
$$.fragment && $$.fragment.d(detaching);
|
|
$$.on_destroy = $$.fragment = null;
|
|
$$.ctx = [];
|
|
}
|
|
}
|
|
function make_dirty(component, i) {
|
|
if (component.$$.dirty[0] === -1) {
|
|
dirty_components.push(component);
|
|
schedule_update();
|
|
component.$$.dirty.fill(0);
|
|
}
|
|
component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
|
|
}
|
|
function init(component, options, instance18, create_fragment18, not_equal, props, append_styles2, dirty = [-1]) {
|
|
const parent_component = current_component;
|
|
set_current_component(component);
|
|
const $$ = component.$$ = {
|
|
fragment: null,
|
|
ctx: [],
|
|
props,
|
|
update: noop,
|
|
not_equal,
|
|
bound: blank_object(),
|
|
on_mount: [],
|
|
on_destroy: [],
|
|
on_disconnect: [],
|
|
before_update: [],
|
|
after_update: [],
|
|
context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
|
|
callbacks: blank_object(),
|
|
dirty,
|
|
skip_bound: false,
|
|
root: options.target || parent_component.$$.root
|
|
};
|
|
append_styles2 && append_styles2($$.root);
|
|
let ready = false;
|
|
$$.ctx = instance18 ? instance18(component, options.props || {}, (i, ret, ...rest) => {
|
|
const value = rest.length ? rest[0] : ret;
|
|
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
|
|
if (!$$.skip_bound && $$.bound[i])
|
|
$$.bound[i](value);
|
|
if (ready)
|
|
make_dirty(component, i);
|
|
}
|
|
return ret;
|
|
}) : [];
|
|
$$.update();
|
|
ready = true;
|
|
run_all($$.before_update);
|
|
$$.fragment = create_fragment18 ? create_fragment18($$.ctx) : false;
|
|
if (options.target) {
|
|
if (options.hydrate) {
|
|
start_hydrating();
|
|
const nodes = children(options.target);
|
|
$$.fragment && $$.fragment.l(nodes);
|
|
nodes.forEach(detach);
|
|
} else {
|
|
$$.fragment && $$.fragment.c();
|
|
}
|
|
if (options.intro)
|
|
transition_in(component.$$.fragment);
|
|
mount_component(component, options.target, options.anchor, options.customElement);
|
|
end_hydrating();
|
|
flush();
|
|
}
|
|
set_current_component(parent_component);
|
|
}
|
|
var SvelteElement;
|
|
if (typeof HTMLElement === "function") {
|
|
SvelteElement = class extends HTMLElement {
|
|
constructor() {
|
|
super();
|
|
this.attachShadow({ mode: "open" });
|
|
}
|
|
connectedCallback() {
|
|
const { on_mount } = this.$$;
|
|
this.$$.on_disconnect = on_mount.map(run).filter(is_function);
|
|
for (const key2 in this.$$.slotted) {
|
|
this.appendChild(this.$$.slotted[key2]);
|
|
}
|
|
}
|
|
attributeChangedCallback(attr2, _oldValue, newValue) {
|
|
this[attr2] = newValue;
|
|
}
|
|
disconnectedCallback() {
|
|
run_all(this.$$.on_disconnect);
|
|
}
|
|
$destroy() {
|
|
destroy_component(this, 1);
|
|
this.$destroy = noop;
|
|
}
|
|
$on(type, callback) {
|
|
if (!is_function(callback)) {
|
|
return noop;
|
|
}
|
|
const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
|
|
callbacks.push(callback);
|
|
return () => {
|
|
const index = callbacks.indexOf(callback);
|
|
if (index !== -1)
|
|
callbacks.splice(index, 1);
|
|
};
|
|
}
|
|
$set($$props) {
|
|
if (this.$$set && !is_empty($$props)) {
|
|
this.$$.skip_bound = true;
|
|
this.$$set($$props);
|
|
this.$$.skip_bound = false;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
var SvelteComponent = class {
|
|
$destroy() {
|
|
destroy_component(this, 1);
|
|
this.$destroy = noop;
|
|
}
|
|
$on(type, callback) {
|
|
if (!is_function(callback)) {
|
|
return noop;
|
|
}
|
|
const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
|
|
callbacks.push(callback);
|
|
return () => {
|
|
const index = callbacks.indexOf(callback);
|
|
if (index !== -1)
|
|
callbacks.splice(index, 1);
|
|
};
|
|
}
|
|
$set($$props) {
|
|
if (this.$$set && !is_empty($$props)) {
|
|
this.$$.skip_bound = true;
|
|
this.$$set($$props);
|
|
this.$$.skip_bound = false;
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/svelte/store/index.mjs
|
|
var subscriber_queue = [];
|
|
function writable(value, start = noop) {
|
|
let stop;
|
|
const subscribers = /* @__PURE__ */ new Set();
|
|
function set(new_value) {
|
|
if (safe_not_equal(value, new_value)) {
|
|
value = new_value;
|
|
if (stop) {
|
|
const run_queue = !subscriber_queue.length;
|
|
for (const subscriber of subscribers) {
|
|
subscriber[1]();
|
|
subscriber_queue.push(subscriber, value);
|
|
}
|
|
if (run_queue) {
|
|
for (let i = 0; i < subscriber_queue.length; i += 2) {
|
|
subscriber_queue[i][0](subscriber_queue[i + 1]);
|
|
}
|
|
subscriber_queue.length = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function update2(fn) {
|
|
set(fn(value));
|
|
}
|
|
function subscribe2(run3, invalidate = noop) {
|
|
const subscriber = [run3, invalidate];
|
|
subscribers.add(subscriber);
|
|
if (subscribers.size === 1) {
|
|
stop = start(set) || noop;
|
|
}
|
|
run3(value);
|
|
return () => {
|
|
subscribers.delete(subscriber);
|
|
if (subscribers.size === 0) {
|
|
stop();
|
|
stop = null;
|
|
}
|
|
};
|
|
}
|
|
return { set, update: update2, subscribe: subscribe2 };
|
|
}
|
|
|
|
// src/platform.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// src/requests.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var xmlhttprequest;
|
|
if (true)
|
|
xmlhttprequest = typeof GM_xmlhttpRequest != "undefined" ? GM_xmlhttpRequest : typeof GM != "undefined" ? GM.xmlHttpRequest : window["GM_xmlhttpRequest"];
|
|
var headerStringToObject = (s) => Object.fromEntries(s.split("\n").map((e) => {
|
|
const [name, ...rest] = e.split(":");
|
|
return [name.toLowerCase(), rest.join(":").trim()];
|
|
}));
|
|
function GM_head(...[url, opt]) {
|
|
return new Promise((resolve, reject) => {
|
|
const gmopt = {
|
|
url: url.toString(),
|
|
data: opt?.body?.toString(),
|
|
method: "HEAD",
|
|
onload: (resp) => {
|
|
if (resp.status / 100 >= 4)
|
|
reject(new Error("response error"));
|
|
else
|
|
resolve(resp.responseHeaders);
|
|
},
|
|
ontimeout: () => reject(new Error("fetch timeout")),
|
|
onerror: () => reject(new Error("fetch error")),
|
|
onabort: () => reject(new Error("fetch abort"))
|
|
};
|
|
xmlhttprequest(gmopt);
|
|
});
|
|
}
|
|
var GM_fetch = (...[url, opt, lisn]) => {
|
|
function blobTo(to, blob) {
|
|
if (to == "arrayBuffer" && blob.arrayBuffer) {
|
|
const ret = blob.arrayBuffer();
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const fileReader = new FileReader();
|
|
fileReader.onload = function(event) {
|
|
if (!event)
|
|
return;
|
|
if (to == "base64")
|
|
resolve(event.target.result);
|
|
else
|
|
resolve(event.target.result);
|
|
};
|
|
if (to == "arrayBuffer")
|
|
fileReader.readAsArrayBuffer(blob);
|
|
else if (to == "base64")
|
|
fileReader.readAsDataURL(blob);
|
|
else if (to == "text")
|
|
fileReader.readAsText(blob, "utf-8");
|
|
else
|
|
reject(new Error("unknown to"));
|
|
});
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const gmopt = {
|
|
url: url.toString(),
|
|
data: opt?.body,
|
|
responseType: "blob",
|
|
headers: opt?.headers,
|
|
method: opt?.method || "GET",
|
|
...lisn ? {
|
|
onprogress: (prog) => {
|
|
if (prog.loaded != prog.total && prog.total != 0)
|
|
lisn.dispatchEvent(new CustomEvent("progress", { detail: [prog.loaded, prog.total] }));
|
|
}
|
|
} : {},
|
|
onload: (resp) => {
|
|
if (resp.status / 100 >= 4) {
|
|
reject(new Error("Server Error: " + resp.status));
|
|
return;
|
|
}
|
|
const blob = resp.response;
|
|
const ref = resp;
|
|
ref.blob = () => Promise.resolve(blob);
|
|
ref.arrayBuffer = () => blobTo("arrayBuffer", blob);
|
|
ref.text = () => blobTo("text", blob);
|
|
ref.json = async () => JSON.parse(await blobTo("text", blob));
|
|
resolve(resp);
|
|
},
|
|
ontimeout: () => reject(new Error("fetch timeout")),
|
|
onerror: (...args) => {
|
|
reject(new Error("fetch error"));
|
|
},
|
|
onabort: () => reject(new Error("fetch abort"))
|
|
};
|
|
xmlhttprequest(gmopt);
|
|
});
|
|
};
|
|
|
|
// src/platform.ts
|
|
var lqueue = {};
|
|
var localSet = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value));
|
|
var port1;
|
|
console.log("userscript", false);
|
|
if (false) {
|
|
port1 = {
|
|
onmessage(ev) {
|
|
lqueue[ev.data.id](ev.data);
|
|
},
|
|
postMessage(msg, tr4) {
|
|
msgBuff.push([msg, tr4]);
|
|
}
|
|
};
|
|
}
|
|
var gid = 0;
|
|
var sendCmd = (cmd, tr4, overwrite = false, todelete = false) => {
|
|
const prom = new Promise((_) => {
|
|
const id = gid++;
|
|
if (overwrite)
|
|
cmd.id = id;
|
|
lqueue[id] = (e) => {
|
|
_(e.res);
|
|
if (todelete)
|
|
delete lqueue[id];
|
|
};
|
|
port1.postMessage({ id, ...cmd }, tr4 || []);
|
|
});
|
|
return prom;
|
|
};
|
|
var bridge = (name, f) => {
|
|
if (true)
|
|
return f;
|
|
if (false)
|
|
return f;
|
|
return (...args) => {
|
|
return sendCmd({ name, args });
|
|
};
|
|
};
|
|
var Bridged = (ctor) => {
|
|
const keys = Object.getOwnPropertyNames(ctor).filter((k) => typeof ctor[k] == "function");
|
|
for (const k of keys)
|
|
ctor[k] = bridge(k, ctor[k]);
|
|
};
|
|
if (false) {
|
|
}
|
|
var Platform = class {
|
|
static async openInTab(src, opts) {
|
|
if (true) {
|
|
return GM.openInTab(src, opts);
|
|
}
|
|
const obj = false ? chrome : browser;
|
|
let i;
|
|
if (opts.insert)
|
|
i = (await obj.tabs.getCurrent()).index + 1;
|
|
return obj.tabs.create({ active: opts.active, url: src, index: i });
|
|
}
|
|
static async getValue(key2, def) {
|
|
const ret = def;
|
|
const d = await chrome.storage.local.get([key2]);
|
|
if (typeof d[key2] == "string")
|
|
return { ...def, ...await JSON.parse("" + d[key2] || "{}") };
|
|
return ret;
|
|
}
|
|
static setValue(name, val) {
|
|
localSet(name, val);
|
|
}
|
|
};
|
|
__publicField(Platform, "cmdid", 0);
|
|
Platform = __decorateClass([
|
|
Bridged
|
|
], Platform);
|
|
async function getHeaders(s) {
|
|
if (true)
|
|
return headerStringToObject(await GM_head(s));
|
|
const res = await ifetch(s, {
|
|
method: "HEAD"
|
|
});
|
|
return res.headers;
|
|
}
|
|
async function ifetch(...[url, opt, lisn]) {
|
|
if (false)
|
|
return corsFetch(url.toString(), opt, lisn);
|
|
return GM_fetch(url, opt, lisn);
|
|
}
|
|
|
|
// src/stores.ts
|
|
var localLoad = async (key2, def) => {
|
|
const ret = await Platform.getValue(key2, def);
|
|
return ret;
|
|
};
|
|
var localSet2 = (key2, value) => {
|
|
if (false) {
|
|
return;
|
|
}
|
|
chrome.storage.local.set({ [key2]: JSON.stringify(value) });
|
|
};
|
|
var initial_settings = {
|
|
loop: true,
|
|
dh: false,
|
|
pmeth: 5,
|
|
xpv: false,
|
|
xpi: false,
|
|
hyd: false,
|
|
notcata: false,
|
|
ak: "",
|
|
auto_embed: 0,
|
|
auto_tags: "",
|
|
te: false,
|
|
eye: false,
|
|
ca: false,
|
|
pre: false,
|
|
prev: false,
|
|
sh: false,
|
|
ep: false,
|
|
tm: false,
|
|
dvc: false,
|
|
expte: false,
|
|
mdist: -1,
|
|
phash: false,
|
|
hotlink: false,
|
|
jpeg: false,
|
|
vercheck: false,
|
|
cache: void 0,
|
|
fhost: 0,
|
|
maxe: 5,
|
|
conc: 8,
|
|
ho: false,
|
|
blacklist: [],
|
|
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/"
|
|
}
|
|
]
|
|
};
|
|
var settings = writable();
|
|
var appState = writable({
|
|
isCatalog: false,
|
|
is4chanX: false,
|
|
akValid: false,
|
|
herror: "",
|
|
client: null,
|
|
processing: 0,
|
|
processed: 0,
|
|
foundPosts: []
|
|
});
|
|
settings.subscribe((newVal) => {
|
|
if (newVal)
|
|
localSet2("settingsv2", newVal);
|
|
});
|
|
|
|
// src/debounce.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var nativeMax = Math.max;
|
|
var nativeMin = Math.min;
|
|
function debounce(func, wait2, options) {
|
|
let lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
|
|
wait2 = Number(wait2) || 0;
|
|
if (typeof options === "object") {
|
|
leading = !!options.leading;
|
|
maxing = "maxWait" in options;
|
|
maxWait = maxing ? nativeMax(Number(options.maxWait) || 0, wait2) : maxWait;
|
|
trailing = "trailing" in options ? !!options.trailing : trailing;
|
|
}
|
|
function invokeFunc(time) {
|
|
const args = lastArgs, thisArg = lastThis;
|
|
lastArgs = lastThis = void 0;
|
|
lastInvokeTime = time;
|
|
result = func.apply(thisArg, args);
|
|
return result;
|
|
}
|
|
function leadingEdge(time) {
|
|
lastInvokeTime = time;
|
|
timerId = setTimeout(timerExpired, wait2);
|
|
return leading ? invokeFunc(time) : result;
|
|
}
|
|
function remainingWait(time) {
|
|
const timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait2 - timeSinceLastCall;
|
|
console.log("remainingWait");
|
|
return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
|
|
}
|
|
function shouldInvoke(time) {
|
|
const timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
|
|
return lastCallTime === void 0 || timeSinceLastCall >= wait2 || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
|
|
}
|
|
function timerExpired() {
|
|
const time = Date.now();
|
|
if (shouldInvoke(time)) {
|
|
return trailingEdge(time);
|
|
}
|
|
timerId = setTimeout(timerExpired, remainingWait(time));
|
|
}
|
|
function trailingEdge(time) {
|
|
timerId = void 0;
|
|
if (trailing && lastArgs) {
|
|
return invokeFunc(time);
|
|
}
|
|
lastArgs = lastThis = void 0;
|
|
return result;
|
|
}
|
|
function cancel() {
|
|
if (timerId !== void 0) {
|
|
clearTimeout(timerId);
|
|
}
|
|
lastInvokeTime = 0;
|
|
lastArgs = lastCallTime = lastThis = timerId = void 0;
|
|
}
|
|
function flush2() {
|
|
return timerId === void 0 ? result : trailingEdge(Date.now());
|
|
}
|
|
function debounced(...args) {
|
|
const time = Date.now(), isInvoking = shouldInvoke(time);
|
|
lastArgs = args;
|
|
lastThis = this;
|
|
lastCallTime = time;
|
|
if (isInvoking) {
|
|
if (timerId === void 0) {
|
|
return leadingEdge(lastCallTime);
|
|
}
|
|
if (maxing) {
|
|
timerId = setTimeout(timerExpired, wait2);
|
|
return invokeFunc(lastCallTime);
|
|
}
|
|
}
|
|
if (timerId === void 0) {
|
|
timerId = setTimeout(timerExpired, wait2);
|
|
}
|
|
return result;
|
|
}
|
|
debounced.cancel = cancel;
|
|
debounced.flush = flush2;
|
|
return debounced;
|
|
}
|
|
|
|
// src/global.css
|
|
var global_default = ".pee-hidden {\n display: none;\n}\n\n.extractedImg {\n width: auto;\n height: auto;\n max-width: 125px;\n max-height: 125px;\n cursor: pointer;\n}\n\n#delform .postContainer>div.embedfound {\n border-right: 3px dashed green !important;\n}\n\n#delform .postContainer>div.hasembed {\n border-right: 3px dashed deeppink !important;\n}\n\n.hasembed.catalog-post {\n border: 3px dashed deeppink !important;\n}\n\n#delform .postContainer>div.hasext {\n border-right: 3px dashed goldenrod !important;\n}\n\n#delform .postContainer>div.hasmultiple {\n border-right: 3px dashed cornflowerblue !important;\n}\n\n.post_wrapper.embedfound {\n border-right: 3px dashed green !important;\n}\n\n.post_wrapper.hasembed {\n border-right: 3px dashed deeppink !important;\n}\n\n.post_wrapper.hasext {\n border-right: 3px dashed goldenrod !important;\n}\n\n.post_wrapper.hasmultiple {\n border-right: 3px dashed cornflowerblue !important;\n}\n\n.hasext.catalog-post {\n border: 3px dashed goldenrod !important;\n}\n\n.expanded-image>.post>.file .fileThumb>img[data-md5] {\n display: none;\n}\n\n.expanded-image>.post>.file .fileThumb .full-image {\n display: inline;\n}\n\n.peee-settings {\n position: fixed;\n top: 0;\n width: 100%;\n height: 100%;\n pointer-events: none;\n}\n\ndiv.hasemb .catalog-host img {\n border: 1px solid deeppink;\n}\n\ndiv.hasext .catalog-host img {\n border: 1px solid goldenrod;\n}\n\ndiv.hasmultiple .catalog-host img {\n border: 1px solid cornflowerblue;\n}\n\n.catalog-host img {\n position: absolute;\n top: -5px;\n right: 0px;\n max-width: 80px;\n max-height: 80px;\n box-shadow: 0px 0px 4px 2px #00000090;\n}\n\n.fileThumb.fiilehost {\n margin-left: 0 !important;\n display: flex;\n gap: 20px;\n}\n\n#qr > form {\n overflow: visible !important;\n}\n\n.theme_default .post_wrapper > .thread_image_box {\n display: flex;\n}\n\n.theme_default .post_wrapper > .thread_image_box > a {\n margin-right: 20px;\n}\n\ndiv.post {\n overflow: auto;\n}";
|
|
|
|
// src/pngv3.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_buffer3 = __toESM(require_buffer(), 1);
|
|
|
|
// src/png.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_crc_32 = __toESM(require_crc32(), 1);
|
|
var import_buffer = __toESM(require_buffer(), 1);
|
|
var PNGDecoder = class {
|
|
constructor(reader, strict = true) {
|
|
this.reader = reader;
|
|
this.strict = strict;
|
|
this.repr = import_buffer.Buffer.from([]);
|
|
}
|
|
repr;
|
|
req = 8;
|
|
ptr = 8;
|
|
stopped = false;
|
|
async catchup() {
|
|
while (this.repr.byteLength < this.req) {
|
|
const chunk = await this.reader.read();
|
|
if (chunk.done) {
|
|
if (this.strict)
|
|
throw new Error(`Unexpected EOF, got ${this.repr.byteLength}, required ${this.req}, ${chunk.value}`);
|
|
this.stopped = true;
|
|
return;
|
|
}
|
|
this.repr = import_buffer.Buffer.concat([this.repr, chunk.value]);
|
|
}
|
|
}
|
|
async *chunks() {
|
|
while (true) {
|
|
this.req += 8;
|
|
await this.catchup();
|
|
if (this.stopped)
|
|
break;
|
|
const length = this.repr.readUInt32BE(this.ptr);
|
|
const name = this.repr.slice(this.ptr + 4, this.ptr + 8).toString();
|
|
this.ptr += 4;
|
|
this.req += length + 4;
|
|
await this.catchup();
|
|
yield [
|
|
name,
|
|
this.repr.slice(this.ptr, this.ptr + length + 4),
|
|
this.ptr + length > this.repr.length ? -1 : this.repr.readUInt32BE(this.ptr + length + 4),
|
|
this.ptr
|
|
];
|
|
if (this.stopped)
|
|
break;
|
|
this.ptr += length + 8;
|
|
if (name == "IEND")
|
|
break;
|
|
}
|
|
}
|
|
async dtor() {
|
|
}
|
|
};
|
|
var PNGEncoder = class {
|
|
writer;
|
|
constructor(bytes) {
|
|
this.writer = bytes.getWriter();
|
|
this.writer.write(import_buffer.Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
|
|
}
|
|
async insertchunk(chunk) {
|
|
let b = import_buffer.Buffer.alloc(4);
|
|
const buff = chunk[1];
|
|
b.writeInt32BE(buff.length - 4, 0);
|
|
await this.writer.write(b);
|
|
await this.writer.write(buff);
|
|
b = import_buffer.Buffer.alloc(4);
|
|
b.writeInt32BE((0, import_crc_32.buf)(buff), 0);
|
|
await this.writer.write(b);
|
|
}
|
|
async dtor() {
|
|
this.writer.releaseLock();
|
|
}
|
|
};
|
|
|
|
// src/utils.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_buffer2 = __toESM(require_buffer(), 1);
|
|
|
|
// src/assets/hasembed.png
|
|
var hasembed_exports = {};
|
|
__export(hasembed_exports, {
|
|
default: () => hasembed_default
|
|
});
|
|
var hasembed_default = __toBinary("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");
|
|
|
|
// src/filehosts.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function parseForm(data) {
|
|
const form = new FormData();
|
|
Object.entries(data).filter(([key2, value]) => value !== null).map(([key2, value]) => form.append(key2, value));
|
|
return form;
|
|
}
|
|
var catbox = (domain2, serving) => ({
|
|
domain: domain2,
|
|
serving,
|
|
async uploadFile(inj) {
|
|
const resp = await ifetch(`https://${domain2}/user/api.php`, {
|
|
method: "POST",
|
|
body: parseForm({
|
|
reqtype: "fileupload",
|
|
fileToUpload: inj
|
|
})
|
|
});
|
|
return resp.text();
|
|
}
|
|
});
|
|
var filehosts = [
|
|
catbox("catbox.moe", "files.catbox.moe")
|
|
];
|
|
|
|
// node_modules/file-type/browser.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_node_buffer4 = __toESM(require_buffer(), 1);
|
|
var import_readable_web_to_node_stream = __toESM(require_lib(), 1);
|
|
|
|
// node_modules/file-type/core.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_node_buffer3 = __toESM(require_buffer(), 1);
|
|
|
|
// node_modules/token-types/lib/index.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var ieee754 = __toESM(require_ieee754(), 1);
|
|
var import_node_buffer = __toESM(require_buffer(), 1);
|
|
function dv(array) {
|
|
return new DataView(array.buffer, array.byteOffset);
|
|
}
|
|
var UINT8 = {
|
|
len: 1,
|
|
get(array, offset) {
|
|
return dv(array).getUint8(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint8(offset, value);
|
|
return offset + 1;
|
|
}
|
|
};
|
|
var UINT16_LE = {
|
|
len: 2,
|
|
get(array, offset) {
|
|
return dv(array).getUint16(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint16(offset, value, true);
|
|
return offset + 2;
|
|
}
|
|
};
|
|
var UINT16_BE = {
|
|
len: 2,
|
|
get(array, offset) {
|
|
return dv(array).getUint16(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint16(offset, value);
|
|
return offset + 2;
|
|
}
|
|
};
|
|
var UINT32_LE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getUint32(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint32(offset, value, true);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
var UINT32_BE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getUint32(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint32(offset, value);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
var INT32_BE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getInt32(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setInt32(offset, value);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
var UINT64_LE = {
|
|
len: 8,
|
|
get(array, offset) {
|
|
return dv(array).getBigUint64(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setBigUint64(offset, value, true);
|
|
return offset + 8;
|
|
}
|
|
};
|
|
var StringType = class {
|
|
constructor(len, encoding) {
|
|
this.len = len;
|
|
this.encoding = encoding;
|
|
}
|
|
get(uint8Array, offset) {
|
|
return import_node_buffer.Buffer.from(uint8Array).toString(this.encoding, offset, offset + this.len);
|
|
}
|
|
};
|
|
var AnsiStringType = class {
|
|
constructor(len) {
|
|
this.len = len;
|
|
}
|
|
static decode(buffer, offset, until) {
|
|
let str = "";
|
|
for (let i = offset; i < until; ++i) {
|
|
str += AnsiStringType.codePointToString(AnsiStringType.singleByteDecoder(buffer[i]));
|
|
}
|
|
return str;
|
|
}
|
|
static inRange(a, min, max) {
|
|
return min <= a && a <= max;
|
|
}
|
|
static codePointToString(cp2) {
|
|
if (cp2 <= 65535) {
|
|
return String.fromCharCode(cp2);
|
|
} else {
|
|
cp2 -= 65536;
|
|
return String.fromCharCode((cp2 >> 10) + 55296, (cp2 & 1023) + 56320);
|
|
}
|
|
}
|
|
static singleByteDecoder(bite) {
|
|
if (AnsiStringType.inRange(bite, 0, 127)) {
|
|
return bite;
|
|
}
|
|
const codePoint = AnsiStringType.windows1252[bite - 128];
|
|
if (codePoint === null) {
|
|
throw Error("invaliding encoding");
|
|
}
|
|
return codePoint;
|
|
}
|
|
get(buffer, offset = 0) {
|
|
return AnsiStringType.decode(buffer, offset, offset + this.len);
|
|
}
|
|
};
|
|
AnsiStringType.windows1252 = [
|
|
8364,
|
|
129,
|
|
8218,
|
|
402,
|
|
8222,
|
|
8230,
|
|
8224,
|
|
8225,
|
|
710,
|
|
8240,
|
|
352,
|
|
8249,
|
|
338,
|
|
141,
|
|
381,
|
|
143,
|
|
144,
|
|
8216,
|
|
8217,
|
|
8220,
|
|
8221,
|
|
8226,
|
|
8211,
|
|
8212,
|
|
732,
|
|
8482,
|
|
353,
|
|
8250,
|
|
339,
|
|
157,
|
|
382,
|
|
376,
|
|
160,
|
|
161,
|
|
162,
|
|
163,
|
|
164,
|
|
165,
|
|
166,
|
|
167,
|
|
168,
|
|
169,
|
|
170,
|
|
171,
|
|
172,
|
|
173,
|
|
174,
|
|
175,
|
|
176,
|
|
177,
|
|
178,
|
|
179,
|
|
180,
|
|
181,
|
|
182,
|
|
183,
|
|
184,
|
|
185,
|
|
186,
|
|
187,
|
|
188,
|
|
189,
|
|
190,
|
|
191,
|
|
192,
|
|
193,
|
|
194,
|
|
195,
|
|
196,
|
|
197,
|
|
198,
|
|
199,
|
|
200,
|
|
201,
|
|
202,
|
|
203,
|
|
204,
|
|
205,
|
|
206,
|
|
207,
|
|
208,
|
|
209,
|
|
210,
|
|
211,
|
|
212,
|
|
213,
|
|
214,
|
|
215,
|
|
216,
|
|
217,
|
|
218,
|
|
219,
|
|
220,
|
|
221,
|
|
222,
|
|
223,
|
|
224,
|
|
225,
|
|
226,
|
|
227,
|
|
228,
|
|
229,
|
|
230,
|
|
231,
|
|
232,
|
|
233,
|
|
234,
|
|
235,
|
|
236,
|
|
237,
|
|
238,
|
|
239,
|
|
240,
|
|
241,
|
|
242,
|
|
243,
|
|
244,
|
|
245,
|
|
246,
|
|
247,
|
|
248,
|
|
249,
|
|
250,
|
|
251,
|
|
252,
|
|
253,
|
|
254,
|
|
255
|
|
];
|
|
|
|
// node_modules/strtok3/lib/core.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/strtok3/lib/ReadStreamTokenizer.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/strtok3/lib/AbstractTokenizer.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/peek-readable/lib/index.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/peek-readable/lib/EndOfFileStream.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var defaultMessages = "End-Of-Stream";
|
|
var EndOfStreamError = class extends Error {
|
|
constructor() {
|
|
super(defaultMessages);
|
|
}
|
|
};
|
|
|
|
// node_modules/peek-readable/lib/StreamReader.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/peek-readable/lib/Deferred.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/peek-readable/lib/StreamReader.js
|
|
var maxStreamReadSize = 1 * 1024 * 1024;
|
|
|
|
// node_modules/strtok3/lib/AbstractTokenizer.js
|
|
var import_node_buffer2 = __toESM(require_buffer(), 1);
|
|
var AbstractTokenizer = class {
|
|
constructor(fileInfo) {
|
|
this.position = 0;
|
|
this.numBuffer = new Uint8Array(8);
|
|
this.fileInfo = fileInfo ? fileInfo : {};
|
|
}
|
|
async readToken(token, position = this.position) {
|
|
const uint8Array = import_node_buffer2.Buffer.alloc(token.len);
|
|
const len = await this.readBuffer(uint8Array, { position });
|
|
if (len < token.len)
|
|
throw new EndOfStreamError();
|
|
return token.get(uint8Array, 0);
|
|
}
|
|
async peekToken(token, position = this.position) {
|
|
const uint8Array = import_node_buffer2.Buffer.alloc(token.len);
|
|
const len = await this.peekBuffer(uint8Array, { position });
|
|
if (len < token.len)
|
|
throw new EndOfStreamError();
|
|
return token.get(uint8Array, 0);
|
|
}
|
|
async readNumber(token) {
|
|
const len = await this.readBuffer(this.numBuffer, { length: token.len });
|
|
if (len < token.len)
|
|
throw new EndOfStreamError();
|
|
return token.get(this.numBuffer, 0);
|
|
}
|
|
async peekNumber(token) {
|
|
const len = await this.peekBuffer(this.numBuffer, { length: token.len });
|
|
if (len < token.len)
|
|
throw new EndOfStreamError();
|
|
return token.get(this.numBuffer, 0);
|
|
}
|
|
async ignore(length) {
|
|
if (this.fileInfo.size !== void 0) {
|
|
const bytesLeft = this.fileInfo.size - this.position;
|
|
if (length > bytesLeft) {
|
|
this.position += bytesLeft;
|
|
return bytesLeft;
|
|
}
|
|
}
|
|
this.position += length;
|
|
return length;
|
|
}
|
|
async close() {
|
|
}
|
|
normalizeOptions(uint8Array, options) {
|
|
if (options && options.position !== void 0 && options.position < this.position) {
|
|
throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
|
|
}
|
|
if (options) {
|
|
return {
|
|
mayBeLess: options.mayBeLess === true,
|
|
offset: options.offset ? options.offset : 0,
|
|
length: options.length ? options.length : uint8Array.length - (options.offset ? options.offset : 0),
|
|
position: options.position ? options.position : this.position
|
|
};
|
|
}
|
|
return {
|
|
mayBeLess: false,
|
|
offset: 0,
|
|
length: uint8Array.length,
|
|
position: this.position
|
|
};
|
|
}
|
|
};
|
|
|
|
// node_modules/strtok3/lib/BufferTokenizer.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var BufferTokenizer = class extends AbstractTokenizer {
|
|
constructor(uint8Array, fileInfo) {
|
|
super(fileInfo);
|
|
this.uint8Array = uint8Array;
|
|
this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : uint8Array.length;
|
|
}
|
|
async readBuffer(uint8Array, options) {
|
|
if (options && options.position) {
|
|
if (options.position < this.position) {
|
|
throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
|
|
}
|
|
this.position = options.position;
|
|
}
|
|
const bytesRead = await this.peekBuffer(uint8Array, options);
|
|
this.position += bytesRead;
|
|
return bytesRead;
|
|
}
|
|
async peekBuffer(uint8Array, options) {
|
|
const normOptions = this.normalizeOptions(uint8Array, options);
|
|
const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
|
|
if (!normOptions.mayBeLess && bytes2read < normOptions.length) {
|
|
throw new EndOfStreamError();
|
|
} else {
|
|
uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read), normOptions.offset);
|
|
return bytes2read;
|
|
}
|
|
}
|
|
async close() {
|
|
}
|
|
};
|
|
|
|
// node_modules/strtok3/lib/core.js
|
|
function fromBuffer(uint8Array, fileInfo) {
|
|
return new BufferTokenizer(uint8Array, fileInfo);
|
|
}
|
|
|
|
// node_modules/file-type/util.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function stringToBytes(string) {
|
|
return [...string].map((character) => character.charCodeAt(0));
|
|
}
|
|
function tarHeaderChecksumMatches(buffer, offset = 0) {
|
|
const readSum = Number.parseInt(buffer.toString("utf8", 148, 154).replace(/\0.*$/, "").trim(), 8);
|
|
if (Number.isNaN(readSum)) {
|
|
return false;
|
|
}
|
|
let sum = 8 * 32;
|
|
for (let index = offset; index < offset + 148; index++) {
|
|
sum += buffer[index];
|
|
}
|
|
for (let index = offset + 156; index < offset + 512; index++) {
|
|
sum += buffer[index];
|
|
}
|
|
return readSum === sum;
|
|
}
|
|
var uint32SyncSafeToken = {
|
|
get: (buffer, offset) => buffer[offset + 3] & 127 | buffer[offset + 2] << 7 | buffer[offset + 1] << 14 | buffer[offset] << 21,
|
|
len: 4
|
|
};
|
|
|
|
// node_modules/file-type/supported.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var extensions = [
|
|
"jpg",
|
|
"png",
|
|
"apng",
|
|
"gif",
|
|
"webp",
|
|
"flif",
|
|
"xcf",
|
|
"cr2",
|
|
"cr3",
|
|
"orf",
|
|
"arw",
|
|
"dng",
|
|
"nef",
|
|
"rw2",
|
|
"raf",
|
|
"tif",
|
|
"bmp",
|
|
"icns",
|
|
"jxr",
|
|
"psd",
|
|
"indd",
|
|
"zip",
|
|
"tar",
|
|
"rar",
|
|
"gz",
|
|
"bz2",
|
|
"7z",
|
|
"dmg",
|
|
"mp4",
|
|
"mid",
|
|
"mkv",
|
|
"webm",
|
|
"mov",
|
|
"avi",
|
|
"mpg",
|
|
"mp2",
|
|
"mp3",
|
|
"m4a",
|
|
"oga",
|
|
"ogg",
|
|
"ogv",
|
|
"opus",
|
|
"flac",
|
|
"wav",
|
|
"spx",
|
|
"amr",
|
|
"pdf",
|
|
"epub",
|
|
"elf",
|
|
"exe",
|
|
"swf",
|
|
"rtf",
|
|
"wasm",
|
|
"woff",
|
|
"woff2",
|
|
"eot",
|
|
"ttf",
|
|
"otf",
|
|
"ico",
|
|
"flv",
|
|
"ps",
|
|
"xz",
|
|
"sqlite",
|
|
"nes",
|
|
"crx",
|
|
"xpi",
|
|
"cab",
|
|
"deb",
|
|
"ar",
|
|
"rpm",
|
|
"Z",
|
|
"lz",
|
|
"cfb",
|
|
"mxf",
|
|
"mts",
|
|
"blend",
|
|
"bpg",
|
|
"docx",
|
|
"pptx",
|
|
"xlsx",
|
|
"3gp",
|
|
"3g2",
|
|
"jp2",
|
|
"jpm",
|
|
"jpx",
|
|
"mj2",
|
|
"aif",
|
|
"qcp",
|
|
"odt",
|
|
"ods",
|
|
"odp",
|
|
"xml",
|
|
"mobi",
|
|
"heic",
|
|
"cur",
|
|
"ktx",
|
|
"ape",
|
|
"wv",
|
|
"dcm",
|
|
"ics",
|
|
"glb",
|
|
"pcap",
|
|
"dsf",
|
|
"lnk",
|
|
"alias",
|
|
"voc",
|
|
"ac3",
|
|
"m4v",
|
|
"m4p",
|
|
"m4b",
|
|
"f4v",
|
|
"f4p",
|
|
"f4b",
|
|
"f4a",
|
|
"mie",
|
|
"asf",
|
|
"ogm",
|
|
"ogx",
|
|
"mpc",
|
|
"arrow",
|
|
"shp",
|
|
"aac",
|
|
"mp1",
|
|
"it",
|
|
"s3m",
|
|
"xm",
|
|
"ai",
|
|
"skp",
|
|
"avif",
|
|
"eps",
|
|
"lzh",
|
|
"pgp",
|
|
"asar",
|
|
"stl",
|
|
"chm",
|
|
"3mf",
|
|
"zst",
|
|
"jxl",
|
|
"vcf"
|
|
];
|
|
var mimeTypes = [
|
|
"image/jpeg",
|
|
"image/png",
|
|
"image/gif",
|
|
"image/webp",
|
|
"image/flif",
|
|
"image/x-xcf",
|
|
"image/x-canon-cr2",
|
|
"image/x-canon-cr3",
|
|
"image/tiff",
|
|
"image/bmp",
|
|
"image/vnd.ms-photo",
|
|
"image/vnd.adobe.photoshop",
|
|
"application/x-indesign",
|
|
"application/epub+zip",
|
|
"application/x-xpinstall",
|
|
"application/vnd.oasis.opendocument.text",
|
|
"application/vnd.oasis.opendocument.spreadsheet",
|
|
"application/vnd.oasis.opendocument.presentation",
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presentation",
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
|
"application/zip",
|
|
"application/x-tar",
|
|
"application/x-rar-compressed",
|
|
"application/gzip",
|
|
"application/x-bzip2",
|
|
"application/x-7z-compressed",
|
|
"application/x-apple-diskimage",
|
|
"application/x-apache-arrow",
|
|
"video/mp4",
|
|
"audio/midi",
|
|
"video/x-matroska",
|
|
"video/webm",
|
|
"video/quicktime",
|
|
"video/vnd.avi",
|
|
"audio/vnd.wave",
|
|
"audio/qcelp",
|
|
"audio/x-ms-asf",
|
|
"video/x-ms-asf",
|
|
"application/vnd.ms-asf",
|
|
"video/mpeg",
|
|
"video/3gpp",
|
|
"audio/mpeg",
|
|
"audio/mp4",
|
|
"audio/opus",
|
|
"video/ogg",
|
|
"audio/ogg",
|
|
"application/ogg",
|
|
"audio/x-flac",
|
|
"audio/ape",
|
|
"audio/wavpack",
|
|
"audio/amr",
|
|
"application/pdf",
|
|
"application/x-elf",
|
|
"application/x-msdownload",
|
|
"application/x-shockwave-flash",
|
|
"application/rtf",
|
|
"application/wasm",
|
|
"font/woff",
|
|
"font/woff2",
|
|
"application/vnd.ms-fontobject",
|
|
"font/ttf",
|
|
"font/otf",
|
|
"image/x-icon",
|
|
"video/x-flv",
|
|
"application/postscript",
|
|
"application/eps",
|
|
"application/x-xz",
|
|
"application/x-sqlite3",
|
|
"application/x-nintendo-nes-rom",
|
|
"application/x-google-chrome-extension",
|
|
"application/vnd.ms-cab-compressed",
|
|
"application/x-deb",
|
|
"application/x-unix-archive",
|
|
"application/x-rpm",
|
|
"application/x-compress",
|
|
"application/x-lzip",
|
|
"application/x-cfb",
|
|
"application/x-mie",
|
|
"application/mxf",
|
|
"video/mp2t",
|
|
"application/x-blender",
|
|
"image/bpg",
|
|
"image/jp2",
|
|
"image/jpx",
|
|
"image/jpm",
|
|
"image/mj2",
|
|
"audio/aiff",
|
|
"application/xml",
|
|
"application/x-mobipocket-ebook",
|
|
"image/heif",
|
|
"image/heif-sequence",
|
|
"image/heic",
|
|
"image/heic-sequence",
|
|
"image/icns",
|
|
"image/ktx",
|
|
"application/dicom",
|
|
"audio/x-musepack",
|
|
"text/calendar",
|
|
"text/vcard",
|
|
"model/gltf-binary",
|
|
"application/vnd.tcpdump.pcap",
|
|
"audio/x-dsf",
|
|
"application/x.ms.shortcut",
|
|
"application/x.apple.alias",
|
|
"audio/x-voc",
|
|
"audio/vnd.dolby.dd-raw",
|
|
"audio/x-m4a",
|
|
"image/apng",
|
|
"image/x-olympus-orf",
|
|
"image/x-sony-arw",
|
|
"image/x-adobe-dng",
|
|
"image/x-nikon-nef",
|
|
"image/x-panasonic-rw2",
|
|
"image/x-fujifilm-raf",
|
|
"video/x-m4v",
|
|
"video/3gpp2",
|
|
"application/x-esri-shape",
|
|
"audio/aac",
|
|
"audio/x-it",
|
|
"audio/x-s3m",
|
|
"audio/x-xm",
|
|
"video/MP1S",
|
|
"video/MP2P",
|
|
"application/vnd.sketchup.skp",
|
|
"image/avif",
|
|
"application/x-lzh-compressed",
|
|
"application/pgp-encrypted",
|
|
"application/x-asar",
|
|
"model/stl",
|
|
"application/vnd.ms-htmlhelp",
|
|
"model/3mf",
|
|
"image/jxl",
|
|
"application/zstd"
|
|
];
|
|
|
|
// node_modules/file-type/core.js
|
|
var minimumBytes = 4100;
|
|
async function fileTypeFromBuffer(input) {
|
|
if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
|
|
throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
|
|
}
|
|
const buffer = input instanceof Uint8Array ? input : new Uint8Array(input);
|
|
if (!(buffer?.length > 1)) {
|
|
return;
|
|
}
|
|
return fileTypeFromTokenizer(fromBuffer(buffer));
|
|
}
|
|
function _check(buffer, headers, options) {
|
|
options = {
|
|
offset: 0,
|
|
...options
|
|
};
|
|
for (const [index, header] of headers.entries()) {
|
|
if (options.mask) {
|
|
if (header !== (options.mask[index] & buffer[index + options.offset])) {
|
|
return false;
|
|
}
|
|
} else if (header !== buffer[index + options.offset]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
async function fileTypeFromTokenizer(tokenizer) {
|
|
try {
|
|
return new FileTypeParser().parse(tokenizer);
|
|
} catch (error) {
|
|
if (!(error instanceof EndOfStreamError)) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
var FileTypeParser = class {
|
|
check(header, options) {
|
|
return _check(this.buffer, header, options);
|
|
}
|
|
checkString(header, options) {
|
|
return this.check(stringToBytes(header), options);
|
|
}
|
|
async parse(tokenizer) {
|
|
this.buffer = import_node_buffer3.Buffer.alloc(minimumBytes);
|
|
if (tokenizer.fileInfo.size === void 0) {
|
|
tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
|
|
}
|
|
this.tokenizer = tokenizer;
|
|
await tokenizer.peekBuffer(this.buffer, { length: 12, mayBeLess: true });
|
|
if (this.check([66, 77])) {
|
|
return {
|
|
ext: "bmp",
|
|
mime: "image/bmp"
|
|
};
|
|
}
|
|
if (this.check([11, 119])) {
|
|
return {
|
|
ext: "ac3",
|
|
mime: "audio/vnd.dolby.dd-raw"
|
|
};
|
|
}
|
|
if (this.check([120, 1])) {
|
|
return {
|
|
ext: "dmg",
|
|
mime: "application/x-apple-diskimage"
|
|
};
|
|
}
|
|
if (this.check([77, 90])) {
|
|
return {
|
|
ext: "exe",
|
|
mime: "application/x-msdownload"
|
|
};
|
|
}
|
|
if (this.check([37, 33])) {
|
|
await tokenizer.peekBuffer(this.buffer, { length: 24, mayBeLess: true });
|
|
if (this.checkString("PS-Adobe-", { offset: 2 }) && this.checkString(" EPSF-", { offset: 14 })) {
|
|
return {
|
|
ext: "eps",
|
|
mime: "application/eps"
|
|
};
|
|
}
|
|
return {
|
|
ext: "ps",
|
|
mime: "application/postscript"
|
|
};
|
|
}
|
|
if (this.check([31, 160]) || this.check([31, 157])) {
|
|
return {
|
|
ext: "Z",
|
|
mime: "application/x-compress"
|
|
};
|
|
}
|
|
if (this.check([239, 187, 191])) {
|
|
this.tokenizer.ignore(3);
|
|
return this.parse(tokenizer);
|
|
}
|
|
if (this.check([71, 73, 70])) {
|
|
return {
|
|
ext: "gif",
|
|
mime: "image/gif"
|
|
};
|
|
}
|
|
if (this.check([255, 216, 255])) {
|
|
return {
|
|
ext: "jpg",
|
|
mime: "image/jpeg"
|
|
};
|
|
}
|
|
if (this.check([73, 73, 188])) {
|
|
return {
|
|
ext: "jxr",
|
|
mime: "image/vnd.ms-photo"
|
|
};
|
|
}
|
|
if (this.check([31, 139, 8])) {
|
|
return {
|
|
ext: "gz",
|
|
mime: "application/gzip"
|
|
};
|
|
}
|
|
if (this.check([66, 90, 104])) {
|
|
return {
|
|
ext: "bz2",
|
|
mime: "application/x-bzip2"
|
|
};
|
|
}
|
|
if (this.checkString("ID3")) {
|
|
await tokenizer.ignore(6);
|
|
const id3HeaderLength = await tokenizer.readToken(uint32SyncSafeToken);
|
|
if (tokenizer.position + id3HeaderLength > tokenizer.fileInfo.size) {
|
|
return {
|
|
ext: "mp3",
|
|
mime: "audio/mpeg"
|
|
};
|
|
}
|
|
await tokenizer.ignore(id3HeaderLength);
|
|
return fileTypeFromTokenizer(tokenizer);
|
|
}
|
|
if (this.checkString("MP+")) {
|
|
return {
|
|
ext: "mpc",
|
|
mime: "audio/x-musepack"
|
|
};
|
|
}
|
|
if ((this.buffer[0] === 67 || this.buffer[0] === 70) && this.check([87, 83], { offset: 1 })) {
|
|
return {
|
|
ext: "swf",
|
|
mime: "application/x-shockwave-flash"
|
|
};
|
|
}
|
|
if (this.checkString("FLIF")) {
|
|
return {
|
|
ext: "flif",
|
|
mime: "image/flif"
|
|
};
|
|
}
|
|
if (this.checkString("8BPS")) {
|
|
return {
|
|
ext: "psd",
|
|
mime: "image/vnd.adobe.photoshop"
|
|
};
|
|
}
|
|
if (this.checkString("WEBP", { offset: 8 })) {
|
|
return {
|
|
ext: "webp",
|
|
mime: "image/webp"
|
|
};
|
|
}
|
|
if (this.checkString("MPCK")) {
|
|
return {
|
|
ext: "mpc",
|
|
mime: "audio/x-musepack"
|
|
};
|
|
}
|
|
if (this.checkString("FORM")) {
|
|
return {
|
|
ext: "aif",
|
|
mime: "audio/aiff"
|
|
};
|
|
}
|
|
if (this.checkString("icns", { offset: 0 })) {
|
|
return {
|
|
ext: "icns",
|
|
mime: "image/icns"
|
|
};
|
|
}
|
|
if (this.check([80, 75, 3, 4])) {
|
|
try {
|
|
while (tokenizer.position + 30 < tokenizer.fileInfo.size) {
|
|
await tokenizer.readBuffer(this.buffer, { length: 30 });
|
|
const zipHeader = {
|
|
compressedSize: this.buffer.readUInt32LE(18),
|
|
uncompressedSize: this.buffer.readUInt32LE(22),
|
|
filenameLength: this.buffer.readUInt16LE(26),
|
|
extraFieldLength: this.buffer.readUInt16LE(28)
|
|
};
|
|
zipHeader.filename = await tokenizer.readToken(new StringType(zipHeader.filenameLength, "utf-8"));
|
|
await tokenizer.ignore(zipHeader.extraFieldLength);
|
|
if (zipHeader.filename === "META-INF/mozilla.rsa") {
|
|
return {
|
|
ext: "xpi",
|
|
mime: "application/x-xpinstall"
|
|
};
|
|
}
|
|
if (zipHeader.filename.endsWith(".rels") || zipHeader.filename.endsWith(".xml")) {
|
|
const type = zipHeader.filename.split("/")[0];
|
|
switch (type) {
|
|
case "_rels":
|
|
break;
|
|
case "word":
|
|
return {
|
|
ext: "docx",
|
|
mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
|
|
};
|
|
case "ppt":
|
|
return {
|
|
ext: "pptx",
|
|
mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
|
|
};
|
|
case "xl":
|
|
return {
|
|
ext: "xlsx",
|
|
mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
|
|
};
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (zipHeader.filename.startsWith("xl/")) {
|
|
return {
|
|
ext: "xlsx",
|
|
mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
|
|
};
|
|
}
|
|
if (zipHeader.filename.startsWith("3D/") && zipHeader.filename.endsWith(".model")) {
|
|
return {
|
|
ext: "3mf",
|
|
mime: "model/3mf"
|
|
};
|
|
}
|
|
if (zipHeader.filename === "mimetype" && zipHeader.compressedSize === zipHeader.uncompressedSize) {
|
|
let mimeType = await tokenizer.readToken(new StringType(zipHeader.compressedSize, "utf-8"));
|
|
mimeType = mimeType.trim();
|
|
switch (mimeType) {
|
|
case "application/epub+zip":
|
|
return {
|
|
ext: "epub",
|
|
mime: "application/epub+zip"
|
|
};
|
|
case "application/vnd.oasis.opendocument.text":
|
|
return {
|
|
ext: "odt",
|
|
mime: "application/vnd.oasis.opendocument.text"
|
|
};
|
|
case "application/vnd.oasis.opendocument.spreadsheet":
|
|
return {
|
|
ext: "ods",
|
|
mime: "application/vnd.oasis.opendocument.spreadsheet"
|
|
};
|
|
case "application/vnd.oasis.opendocument.presentation":
|
|
return {
|
|
ext: "odp",
|
|
mime: "application/vnd.oasis.opendocument.presentation"
|
|
};
|
|
default:
|
|
}
|
|
}
|
|
if (zipHeader.compressedSize === 0) {
|
|
let nextHeaderIndex = -1;
|
|
while (nextHeaderIndex < 0 && tokenizer.position < tokenizer.fileInfo.size) {
|
|
await tokenizer.peekBuffer(this.buffer, { mayBeLess: true });
|
|
nextHeaderIndex = this.buffer.indexOf("504B0304", 0, "hex");
|
|
await tokenizer.ignore(nextHeaderIndex >= 0 ? nextHeaderIndex : this.buffer.length);
|
|
}
|
|
} else {
|
|
await tokenizer.ignore(zipHeader.compressedSize);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
if (!(error instanceof EndOfStreamError)) {
|
|
throw error;
|
|
}
|
|
}
|
|
return {
|
|
ext: "zip",
|
|
mime: "application/zip"
|
|
};
|
|
}
|
|
if (this.checkString("OggS")) {
|
|
await tokenizer.ignore(28);
|
|
const type = import_node_buffer3.Buffer.alloc(8);
|
|
await tokenizer.readBuffer(type);
|
|
if (_check(type, [79, 112, 117, 115, 72, 101, 97, 100])) {
|
|
return {
|
|
ext: "opus",
|
|
mime: "audio/opus"
|
|
};
|
|
}
|
|
if (_check(type, [128, 116, 104, 101, 111, 114, 97])) {
|
|
return {
|
|
ext: "ogv",
|
|
mime: "video/ogg"
|
|
};
|
|
}
|
|
if (_check(type, [1, 118, 105, 100, 101, 111, 0])) {
|
|
return {
|
|
ext: "ogm",
|
|
mime: "video/ogg"
|
|
};
|
|
}
|
|
if (_check(type, [127, 70, 76, 65, 67])) {
|
|
return {
|
|
ext: "oga",
|
|
mime: "audio/ogg"
|
|
};
|
|
}
|
|
if (_check(type, [83, 112, 101, 101, 120, 32, 32])) {
|
|
return {
|
|
ext: "spx",
|
|
mime: "audio/ogg"
|
|
};
|
|
}
|
|
if (_check(type, [1, 118, 111, 114, 98, 105, 115])) {
|
|
return {
|
|
ext: "ogg",
|
|
mime: "audio/ogg"
|
|
};
|
|
}
|
|
return {
|
|
ext: "ogx",
|
|
mime: "application/ogg"
|
|
};
|
|
}
|
|
if (this.check([80, 75]) && (this.buffer[2] === 3 || this.buffer[2] === 5 || this.buffer[2] === 7) && (this.buffer[3] === 4 || this.buffer[3] === 6 || this.buffer[3] === 8)) {
|
|
return {
|
|
ext: "zip",
|
|
mime: "application/zip"
|
|
};
|
|
}
|
|
if (this.checkString("ftyp", { offset: 4 }) && (this.buffer[8] & 96) !== 0) {
|
|
const brandMajor = this.buffer.toString("binary", 8, 12).replace("\0", " ").trim();
|
|
switch (brandMajor) {
|
|
case "avif":
|
|
case "avis":
|
|
return { ext: "avif", mime: "image/avif" };
|
|
case "mif1":
|
|
return { ext: "heic", mime: "image/heif" };
|
|
case "msf1":
|
|
return { ext: "heic", mime: "image/heif-sequence" };
|
|
case "heic":
|
|
case "heix":
|
|
return { ext: "heic", mime: "image/heic" };
|
|
case "hevc":
|
|
case "hevx":
|
|
return { ext: "heic", mime: "image/heic-sequence" };
|
|
case "qt":
|
|
return { ext: "mov", mime: "video/quicktime" };
|
|
case "M4V":
|
|
case "M4VH":
|
|
case "M4VP":
|
|
return { ext: "m4v", mime: "video/x-m4v" };
|
|
case "M4P":
|
|
return { ext: "m4p", mime: "video/mp4" };
|
|
case "M4B":
|
|
return { ext: "m4b", mime: "audio/mp4" };
|
|
case "M4A":
|
|
return { ext: "m4a", mime: "audio/x-m4a" };
|
|
case "F4V":
|
|
return { ext: "f4v", mime: "video/mp4" };
|
|
case "F4P":
|
|
return { ext: "f4p", mime: "video/mp4" };
|
|
case "F4A":
|
|
return { ext: "f4a", mime: "audio/mp4" };
|
|
case "F4B":
|
|
return { ext: "f4b", mime: "audio/mp4" };
|
|
case "crx":
|
|
return { ext: "cr3", mime: "image/x-canon-cr3" };
|
|
default:
|
|
if (brandMajor.startsWith("3g")) {
|
|
if (brandMajor.startsWith("3g2")) {
|
|
return { ext: "3g2", mime: "video/3gpp2" };
|
|
}
|
|
return { ext: "3gp", mime: "video/3gpp" };
|
|
}
|
|
return { ext: "mp4", mime: "video/mp4" };
|
|
}
|
|
}
|
|
if (this.checkString("MThd")) {
|
|
return {
|
|
ext: "mid",
|
|
mime: "audio/midi"
|
|
};
|
|
}
|
|
if (this.checkString("wOFF") && (this.check([0, 1, 0, 0], { offset: 4 }) || this.checkString("OTTO", { offset: 4 }))) {
|
|
return {
|
|
ext: "woff",
|
|
mime: "font/woff"
|
|
};
|
|
}
|
|
if (this.checkString("wOF2") && (this.check([0, 1, 0, 0], { offset: 4 }) || this.checkString("OTTO", { offset: 4 }))) {
|
|
return {
|
|
ext: "woff2",
|
|
mime: "font/woff2"
|
|
};
|
|
}
|
|
if (this.check([212, 195, 178, 161]) || this.check([161, 178, 195, 212])) {
|
|
return {
|
|
ext: "pcap",
|
|
mime: "application/vnd.tcpdump.pcap"
|
|
};
|
|
}
|
|
if (this.checkString("DSD ")) {
|
|
return {
|
|
ext: "dsf",
|
|
mime: "audio/x-dsf"
|
|
};
|
|
}
|
|
if (this.checkString("LZIP")) {
|
|
return {
|
|
ext: "lz",
|
|
mime: "application/x-lzip"
|
|
};
|
|
}
|
|
if (this.checkString("fLaC")) {
|
|
return {
|
|
ext: "flac",
|
|
mime: "audio/x-flac"
|
|
};
|
|
}
|
|
if (this.check([66, 80, 71, 251])) {
|
|
return {
|
|
ext: "bpg",
|
|
mime: "image/bpg"
|
|
};
|
|
}
|
|
if (this.checkString("wvpk")) {
|
|
return {
|
|
ext: "wv",
|
|
mime: "audio/wavpack"
|
|
};
|
|
}
|
|
if (this.checkString("%PDF")) {
|
|
await tokenizer.ignore(1350);
|
|
const maxBufferSize = 10 * 1024 * 1024;
|
|
const buffer = import_node_buffer3.Buffer.alloc(Math.min(maxBufferSize, tokenizer.fileInfo.size));
|
|
await tokenizer.readBuffer(buffer, { mayBeLess: true });
|
|
if (buffer.includes(import_node_buffer3.Buffer.from("AIPrivateData"))) {
|
|
return {
|
|
ext: "ai",
|
|
mime: "application/postscript"
|
|
};
|
|
}
|
|
return {
|
|
ext: "pdf",
|
|
mime: "application/pdf"
|
|
};
|
|
}
|
|
if (this.check([0, 97, 115, 109])) {
|
|
return {
|
|
ext: "wasm",
|
|
mime: "application/wasm"
|
|
};
|
|
}
|
|
if (this.check([73, 73])) {
|
|
const fileType = await this.readTiffHeader(false);
|
|
if (fileType) {
|
|
return fileType;
|
|
}
|
|
}
|
|
if (this.check([77, 77])) {
|
|
const fileType = await this.readTiffHeader(true);
|
|
if (fileType) {
|
|
return fileType;
|
|
}
|
|
}
|
|
if (this.checkString("MAC ")) {
|
|
return {
|
|
ext: "ape",
|
|
mime: "audio/ape"
|
|
};
|
|
}
|
|
if (this.check([26, 69, 223, 163])) {
|
|
async function readField() {
|
|
const msb = await tokenizer.peekNumber(UINT8);
|
|
let mask = 128;
|
|
let ic = 0;
|
|
while ((msb & mask) === 0 && mask !== 0) {
|
|
++ic;
|
|
mask >>= 1;
|
|
}
|
|
const id = import_node_buffer3.Buffer.alloc(ic + 1);
|
|
await tokenizer.readBuffer(id);
|
|
return id;
|
|
}
|
|
async function readElement() {
|
|
const id = await readField();
|
|
const lengthField = await readField();
|
|
lengthField[0] ^= 128 >> lengthField.length - 1;
|
|
const nrLength = Math.min(6, lengthField.length);
|
|
return {
|
|
id: id.readUIntBE(0, id.length),
|
|
len: lengthField.readUIntBE(lengthField.length - nrLength, nrLength)
|
|
};
|
|
}
|
|
async function readChildren(children2) {
|
|
while (children2 > 0) {
|
|
const element2 = await readElement();
|
|
if (element2.id === 17026) {
|
|
const rawValue = await tokenizer.readToken(new StringType(element2.len, "utf-8"));
|
|
return rawValue.replace(/\00.*$/g, "");
|
|
}
|
|
await tokenizer.ignore(element2.len);
|
|
--children2;
|
|
}
|
|
}
|
|
const re = await readElement();
|
|
const docType = await readChildren(re.len);
|
|
switch (docType) {
|
|
case "webm":
|
|
return {
|
|
ext: "webm",
|
|
mime: "video/webm"
|
|
};
|
|
case "matroska":
|
|
return {
|
|
ext: "mkv",
|
|
mime: "video/x-matroska"
|
|
};
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
if (this.check([82, 73, 70, 70])) {
|
|
if (this.check([65, 86, 73], { offset: 8 })) {
|
|
return {
|
|
ext: "avi",
|
|
mime: "video/vnd.avi"
|
|
};
|
|
}
|
|
if (this.check([87, 65, 86, 69], { offset: 8 })) {
|
|
return {
|
|
ext: "wav",
|
|
mime: "audio/vnd.wave"
|
|
};
|
|
}
|
|
if (this.check([81, 76, 67, 77], { offset: 8 })) {
|
|
return {
|
|
ext: "qcp",
|
|
mime: "audio/qcelp"
|
|
};
|
|
}
|
|
}
|
|
if (this.checkString("SQLi")) {
|
|
return {
|
|
ext: "sqlite",
|
|
mime: "application/x-sqlite3"
|
|
};
|
|
}
|
|
if (this.check([78, 69, 83, 26])) {
|
|
return {
|
|
ext: "nes",
|
|
mime: "application/x-nintendo-nes-rom"
|
|
};
|
|
}
|
|
if (this.checkString("Cr24")) {
|
|
return {
|
|
ext: "crx",
|
|
mime: "application/x-google-chrome-extension"
|
|
};
|
|
}
|
|
if (this.checkString("MSCF") || this.checkString("ISc(")) {
|
|
return {
|
|
ext: "cab",
|
|
mime: "application/vnd.ms-cab-compressed"
|
|
};
|
|
}
|
|
if (this.check([237, 171, 238, 219])) {
|
|
return {
|
|
ext: "rpm",
|
|
mime: "application/x-rpm"
|
|
};
|
|
}
|
|
if (this.check([197, 208, 211, 198])) {
|
|
return {
|
|
ext: "eps",
|
|
mime: "application/eps"
|
|
};
|
|
}
|
|
if (this.check([40, 181, 47, 253])) {
|
|
return {
|
|
ext: "zst",
|
|
mime: "application/zstd"
|
|
};
|
|
}
|
|
if (this.check([127, 69, 76, 70])) {
|
|
return {
|
|
ext: "elf",
|
|
mime: "application/x-elf"
|
|
};
|
|
}
|
|
if (this.check([79, 84, 84, 79, 0])) {
|
|
return {
|
|
ext: "otf",
|
|
mime: "font/otf"
|
|
};
|
|
}
|
|
if (this.checkString("#!AMR")) {
|
|
return {
|
|
ext: "amr",
|
|
mime: "audio/amr"
|
|
};
|
|
}
|
|
if (this.checkString("{\\rtf")) {
|
|
return {
|
|
ext: "rtf",
|
|
mime: "application/rtf"
|
|
};
|
|
}
|
|
if (this.check([70, 76, 86, 1])) {
|
|
return {
|
|
ext: "flv",
|
|
mime: "video/x-flv"
|
|
};
|
|
}
|
|
if (this.checkString("IMPM")) {
|
|
return {
|
|
ext: "it",
|
|
mime: "audio/x-it"
|
|
};
|
|
}
|
|
if (this.checkString("-lh0-", { offset: 2 }) || this.checkString("-lh1-", { offset: 2 }) || this.checkString("-lh2-", { offset: 2 }) || this.checkString("-lh3-", { offset: 2 }) || this.checkString("-lh4-", { offset: 2 }) || this.checkString("-lh5-", { offset: 2 }) || this.checkString("-lh6-", { offset: 2 }) || this.checkString("-lh7-", { offset: 2 }) || this.checkString("-lzs-", { offset: 2 }) || this.checkString("-lz4-", { offset: 2 }) || this.checkString("-lz5-", { offset: 2 }) || this.checkString("-lhd-", { offset: 2 })) {
|
|
return {
|
|
ext: "lzh",
|
|
mime: "application/x-lzh-compressed"
|
|
};
|
|
}
|
|
if (this.check([0, 0, 1, 186])) {
|
|
if (this.check([33], { offset: 4, mask: [241] })) {
|
|
return {
|
|
ext: "mpg",
|
|
mime: "video/MP1S"
|
|
};
|
|
}
|
|
if (this.check([68], { offset: 4, mask: [196] })) {
|
|
return {
|
|
ext: "mpg",
|
|
mime: "video/MP2P"
|
|
};
|
|
}
|
|
}
|
|
if (this.checkString("ITSF")) {
|
|
return {
|
|
ext: "chm",
|
|
mime: "application/vnd.ms-htmlhelp"
|
|
};
|
|
}
|
|
if (this.check([253, 55, 122, 88, 90, 0])) {
|
|
return {
|
|
ext: "xz",
|
|
mime: "application/x-xz"
|
|
};
|
|
}
|
|
if (this.checkString("<?xml ")) {
|
|
return {
|
|
ext: "xml",
|
|
mime: "application/xml"
|
|
};
|
|
}
|
|
if (this.check([55, 122, 188, 175, 39, 28])) {
|
|
return {
|
|
ext: "7z",
|
|
mime: "application/x-7z-compressed"
|
|
};
|
|
}
|
|
if (this.check([82, 97, 114, 33, 26, 7]) && (this.buffer[6] === 0 || this.buffer[6] === 1)) {
|
|
return {
|
|
ext: "rar",
|
|
mime: "application/x-rar-compressed"
|
|
};
|
|
}
|
|
if (this.checkString("solid ")) {
|
|
return {
|
|
ext: "stl",
|
|
mime: "model/stl"
|
|
};
|
|
}
|
|
if (this.checkString("BLENDER")) {
|
|
return {
|
|
ext: "blend",
|
|
mime: "application/x-blender"
|
|
};
|
|
}
|
|
if (this.checkString("!<arch>")) {
|
|
await tokenizer.ignore(8);
|
|
const string = await tokenizer.readToken(new StringType(13, "ascii"));
|
|
if (string === "debian-binary") {
|
|
return {
|
|
ext: "deb",
|
|
mime: "application/x-deb"
|
|
};
|
|
}
|
|
return {
|
|
ext: "ar",
|
|
mime: "application/x-unix-archive"
|
|
};
|
|
}
|
|
if (this.check([137, 80, 78, 71, 13, 10, 26, 10])) {
|
|
await tokenizer.ignore(8);
|
|
async function readChunkHeader() {
|
|
return {
|
|
length: await tokenizer.readToken(INT32_BE),
|
|
type: await tokenizer.readToken(new StringType(4, "binary"))
|
|
};
|
|
}
|
|
do {
|
|
const chunk = await readChunkHeader();
|
|
if (chunk.length < 0) {
|
|
return;
|
|
}
|
|
switch (chunk.type) {
|
|
case "IDAT":
|
|
return {
|
|
ext: "png",
|
|
mime: "image/png"
|
|
};
|
|
case "acTL":
|
|
return {
|
|
ext: "apng",
|
|
mime: "image/apng"
|
|
};
|
|
default:
|
|
await tokenizer.ignore(chunk.length + 4);
|
|
}
|
|
} while (tokenizer.position + 8 < tokenizer.fileInfo.size);
|
|
return {
|
|
ext: "png",
|
|
mime: "image/png"
|
|
};
|
|
}
|
|
if (this.check([65, 82, 82, 79, 87, 49, 0, 0])) {
|
|
return {
|
|
ext: "arrow",
|
|
mime: "application/x-apache-arrow"
|
|
};
|
|
}
|
|
if (this.check([103, 108, 84, 70, 2, 0, 0, 0])) {
|
|
return {
|
|
ext: "glb",
|
|
mime: "model/gltf-binary"
|
|
};
|
|
}
|
|
if (this.check([102, 114, 101, 101], { offset: 4 }) || this.check([109, 100, 97, 116], { offset: 4 }) || this.check([109, 111, 111, 118], { offset: 4 }) || this.check([119, 105, 100, 101], { offset: 4 })) {
|
|
return {
|
|
ext: "mov",
|
|
mime: "video/quicktime"
|
|
};
|
|
}
|
|
if (this.check([73, 73, 82, 79, 8, 0, 0, 0, 24])) {
|
|
return {
|
|
ext: "orf",
|
|
mime: "image/x-olympus-orf"
|
|
};
|
|
}
|
|
if (this.checkString("gimp xcf ")) {
|
|
return {
|
|
ext: "xcf",
|
|
mime: "image/x-xcf"
|
|
};
|
|
}
|
|
if (this.check([73, 73, 85, 0, 24, 0, 0, 0, 136, 231, 116, 216])) {
|
|
return {
|
|
ext: "rw2",
|
|
mime: "image/x-panasonic-rw2"
|
|
};
|
|
}
|
|
if (this.check([48, 38, 178, 117, 142, 102, 207, 17, 166, 217])) {
|
|
async function readHeader() {
|
|
const guid = import_node_buffer3.Buffer.alloc(16);
|
|
await tokenizer.readBuffer(guid);
|
|
return {
|
|
id: guid,
|
|
size: Number(await tokenizer.readToken(UINT64_LE))
|
|
};
|
|
}
|
|
await tokenizer.ignore(30);
|
|
while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
|
|
const header = await readHeader();
|
|
let payload = header.size - 24;
|
|
if (_check(header.id, [145, 7, 220, 183, 183, 169, 207, 17, 142, 230, 0, 192, 12, 32, 83, 101])) {
|
|
const typeId = import_node_buffer3.Buffer.alloc(16);
|
|
payload -= await tokenizer.readBuffer(typeId);
|
|
if (_check(typeId, [64, 158, 105, 248, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
|
|
return {
|
|
ext: "asf",
|
|
mime: "audio/x-ms-asf"
|
|
};
|
|
}
|
|
if (_check(typeId, [192, 239, 25, 188, 77, 91, 207, 17, 168, 253, 0, 128, 95, 92, 68, 43])) {
|
|
return {
|
|
ext: "asf",
|
|
mime: "video/x-ms-asf"
|
|
};
|
|
}
|
|
break;
|
|
}
|
|
await tokenizer.ignore(payload);
|
|
}
|
|
return {
|
|
ext: "asf",
|
|
mime: "application/vnd.ms-asf"
|
|
};
|
|
}
|
|
if (this.check([171, 75, 84, 88, 32, 49, 49, 187, 13, 10, 26, 10])) {
|
|
return {
|
|
ext: "ktx",
|
|
mime: "image/ktx"
|
|
};
|
|
}
|
|
if ((this.check([126, 16, 4]) || this.check([126, 24, 4])) && this.check([48, 77, 73, 69], { offset: 4 })) {
|
|
return {
|
|
ext: "mie",
|
|
mime: "application/x-mie"
|
|
};
|
|
}
|
|
if (this.check([39, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], { offset: 2 })) {
|
|
return {
|
|
ext: "shp",
|
|
mime: "application/x-esri-shape"
|
|
};
|
|
}
|
|
if (this.check([0, 0, 0, 12, 106, 80, 32, 32, 13, 10, 135, 10])) {
|
|
await tokenizer.ignore(20);
|
|
const type = await tokenizer.readToken(new StringType(4, "ascii"));
|
|
switch (type) {
|
|
case "jp2 ":
|
|
return {
|
|
ext: "jp2",
|
|
mime: "image/jp2"
|
|
};
|
|
case "jpx ":
|
|
return {
|
|
ext: "jpx",
|
|
mime: "image/jpx"
|
|
};
|
|
case "jpm ":
|
|
return {
|
|
ext: "jpm",
|
|
mime: "image/jpm"
|
|
};
|
|
case "mjp2":
|
|
return {
|
|
ext: "mj2",
|
|
mime: "image/mj2"
|
|
};
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
if (this.check([255, 10]) || this.check([0, 0, 0, 12, 74, 88, 76, 32, 13, 10, 135, 10])) {
|
|
return {
|
|
ext: "jxl",
|
|
mime: "image/jxl"
|
|
};
|
|
}
|
|
if (this.check([254, 255])) {
|
|
if (this.check([0, 60, 0, 63, 0, 120, 0, 109, 0, 108], { offset: 2 })) {
|
|
return {
|
|
ext: "xml",
|
|
mime: "application/xml"
|
|
};
|
|
}
|
|
return void 0;
|
|
}
|
|
if (this.check([0, 0, 1, 186]) || this.check([0, 0, 1, 179])) {
|
|
return {
|
|
ext: "mpg",
|
|
mime: "video/mpeg"
|
|
};
|
|
}
|
|
if (this.check([0, 1, 0, 0, 0])) {
|
|
return {
|
|
ext: "ttf",
|
|
mime: "font/ttf"
|
|
};
|
|
}
|
|
if (this.check([0, 0, 1, 0])) {
|
|
return {
|
|
ext: "ico",
|
|
mime: "image/x-icon"
|
|
};
|
|
}
|
|
if (this.check([0, 0, 2, 0])) {
|
|
return {
|
|
ext: "cur",
|
|
mime: "image/x-icon"
|
|
};
|
|
}
|
|
if (this.check([208, 207, 17, 224, 161, 177, 26, 225])) {
|
|
return {
|
|
ext: "cfb",
|
|
mime: "application/x-cfb"
|
|
};
|
|
}
|
|
await tokenizer.peekBuffer(this.buffer, { length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: true });
|
|
if (this.checkString("BEGIN:")) {
|
|
if (this.checkString("VCARD", { offset: 6 })) {
|
|
return {
|
|
ext: "vcf",
|
|
mime: "text/vcard"
|
|
};
|
|
}
|
|
if (this.checkString("VCALENDAR", { offset: 6 })) {
|
|
return {
|
|
ext: "ics",
|
|
mime: "text/calendar"
|
|
};
|
|
}
|
|
}
|
|
if (this.checkString("FUJIFILMCCD-RAW")) {
|
|
return {
|
|
ext: "raf",
|
|
mime: "image/x-fujifilm-raf"
|
|
};
|
|
}
|
|
if (this.checkString("Extended Module:")) {
|
|
return {
|
|
ext: "xm",
|
|
mime: "audio/x-xm"
|
|
};
|
|
}
|
|
if (this.checkString("Creative Voice File")) {
|
|
return {
|
|
ext: "voc",
|
|
mime: "audio/x-voc"
|
|
};
|
|
}
|
|
if (this.check([4, 0, 0, 0]) && this.buffer.length >= 16) {
|
|
const jsonSize = this.buffer.readUInt32LE(12);
|
|
if (jsonSize > 12 && this.buffer.length >= jsonSize + 16) {
|
|
try {
|
|
const header = this.buffer.slice(16, jsonSize + 16).toString();
|
|
const json = JSON.parse(header);
|
|
if (json.files) {
|
|
return {
|
|
ext: "asar",
|
|
mime: "application/x-asar"
|
|
};
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
}
|
|
if (this.check([6, 14, 43, 52, 2, 5, 1, 1, 13, 1, 2, 1, 1, 2])) {
|
|
return {
|
|
ext: "mxf",
|
|
mime: "application/mxf"
|
|
};
|
|
}
|
|
if (this.checkString("SCRM", { offset: 44 })) {
|
|
return {
|
|
ext: "s3m",
|
|
mime: "audio/x-s3m"
|
|
};
|
|
}
|
|
if (this.check([71]) && this.check([71], { offset: 188 })) {
|
|
return {
|
|
ext: "mts",
|
|
mime: "video/mp2t"
|
|
};
|
|
}
|
|
if (this.check([71], { offset: 4 }) && this.check([71], { offset: 196 })) {
|
|
return {
|
|
ext: "mts",
|
|
mime: "video/mp2t"
|
|
};
|
|
}
|
|
if (this.check([66, 79, 79, 75, 77, 79, 66, 73], { offset: 60 })) {
|
|
return {
|
|
ext: "mobi",
|
|
mime: "application/x-mobipocket-ebook"
|
|
};
|
|
}
|
|
if (this.check([68, 73, 67, 77], { offset: 128 })) {
|
|
return {
|
|
ext: "dcm",
|
|
mime: "application/dicom"
|
|
};
|
|
}
|
|
if (this.check([76, 0, 0, 0, 1, 20, 2, 0, 0, 0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70])) {
|
|
return {
|
|
ext: "lnk",
|
|
mime: "application/x.ms.shortcut"
|
|
};
|
|
}
|
|
if (this.check([98, 111, 111, 107, 0, 0, 0, 0, 109, 97, 114, 107, 0, 0, 0, 0])) {
|
|
return {
|
|
ext: "alias",
|
|
mime: "application/x.apple.alias"
|
|
};
|
|
}
|
|
if (this.check([76, 80], { offset: 34 }) && (this.check([0, 0, 1], { offset: 8 }) || this.check([1, 0, 2], { offset: 8 }) || this.check([2, 0, 2], { offset: 8 }))) {
|
|
return {
|
|
ext: "eot",
|
|
mime: "application/vnd.ms-fontobject"
|
|
};
|
|
}
|
|
if (this.check([6, 6, 237, 245, 216, 29, 70, 229, 189, 49, 239, 231, 254, 116, 183, 29])) {
|
|
return {
|
|
ext: "indd",
|
|
mime: "application/x-indesign"
|
|
};
|
|
}
|
|
await tokenizer.peekBuffer(this.buffer, { length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: true });
|
|
if (tarHeaderChecksumMatches(this.buffer)) {
|
|
return {
|
|
ext: "tar",
|
|
mime: "application/x-tar"
|
|
};
|
|
}
|
|
if (this.check([255, 254])) {
|
|
if (this.check([60, 0, 63, 0, 120, 0, 109, 0, 108, 0], { offset: 2 })) {
|
|
return {
|
|
ext: "xml",
|
|
mime: "application/xml"
|
|
};
|
|
}
|
|
if (this.check([255, 14, 83, 0, 107, 0, 101, 0, 116, 0, 99, 0, 104, 0, 85, 0, 112, 0, 32, 0, 77, 0, 111, 0, 100, 0, 101, 0, 108, 0], { offset: 2 })) {
|
|
return {
|
|
ext: "skp",
|
|
mime: "application/vnd.sketchup.skp"
|
|
};
|
|
}
|
|
return void 0;
|
|
}
|
|
if (this.checkString("-----BEGIN PGP MESSAGE-----")) {
|
|
return {
|
|
ext: "pgp",
|
|
mime: "application/pgp-encrypted"
|
|
};
|
|
}
|
|
if (this.buffer.length >= 2 && this.check([255, 224], { offset: 0, mask: [255, 224] })) {
|
|
if (this.check([16], { offset: 1, mask: [22] })) {
|
|
if (this.check([8], { offset: 1, mask: [8] })) {
|
|
return {
|
|
ext: "aac",
|
|
mime: "audio/aac"
|
|
};
|
|
}
|
|
return {
|
|
ext: "aac",
|
|
mime: "audio/aac"
|
|
};
|
|
}
|
|
if (this.check([2], { offset: 1, mask: [6] })) {
|
|
return {
|
|
ext: "mp3",
|
|
mime: "audio/mpeg"
|
|
};
|
|
}
|
|
if (this.check([4], { offset: 1, mask: [6] })) {
|
|
return {
|
|
ext: "mp2",
|
|
mime: "audio/mpeg"
|
|
};
|
|
}
|
|
if (this.check([6], { offset: 1, mask: [6] })) {
|
|
return {
|
|
ext: "mp1",
|
|
mime: "audio/mpeg"
|
|
};
|
|
}
|
|
}
|
|
}
|
|
async readTiffTag(bigEndian) {
|
|
const tagId = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
|
|
this.tokenizer.ignore(10);
|
|
switch (tagId) {
|
|
case 50341:
|
|
return {
|
|
ext: "arw",
|
|
mime: "image/x-sony-arw"
|
|
};
|
|
case 50706:
|
|
return {
|
|
ext: "dng",
|
|
mime: "image/x-adobe-dng"
|
|
};
|
|
default:
|
|
}
|
|
}
|
|
async readTiffIFD(bigEndian) {
|
|
const numberOfTags = await this.tokenizer.readToken(bigEndian ? UINT16_BE : UINT16_LE);
|
|
for (let n = 0; n < numberOfTags; ++n) {
|
|
const fileType = await this.readTiffTag(bigEndian);
|
|
if (fileType) {
|
|
return fileType;
|
|
}
|
|
}
|
|
}
|
|
async readTiffHeader(bigEndian) {
|
|
const version = (bigEndian ? UINT16_BE : UINT16_LE).get(this.buffer, 2);
|
|
const ifdOffset = (bigEndian ? UINT32_BE : UINT32_LE).get(this.buffer, 4);
|
|
if (version === 42) {
|
|
if (ifdOffset >= 6) {
|
|
if (this.checkString("CR", { offset: 8 })) {
|
|
return {
|
|
ext: "cr2",
|
|
mime: "image/x-canon-cr2"
|
|
};
|
|
}
|
|
if (ifdOffset >= 8 && (this.check([28, 0, 254, 0], { offset: 8 }) || this.check([31, 0, 11, 0], { offset: 8 }))) {
|
|
return {
|
|
ext: "nef",
|
|
mime: "image/x-nikon-nef"
|
|
};
|
|
}
|
|
}
|
|
await this.tokenizer.ignore(ifdOffset);
|
|
const fileType = await this.readTiffIFD(false);
|
|
return fileType ? fileType : {
|
|
ext: "tif",
|
|
mime: "image/tiff"
|
|
};
|
|
}
|
|
if (version === 43) {
|
|
return {
|
|
ext: "tif",
|
|
mime: "image/tiff"
|
|
};
|
|
}
|
|
}
|
|
};
|
|
var supportedExtensions = new Set(extensions);
|
|
var supportedMimeTypes = new Set(mimeTypes);
|
|
|
|
// src/utils.ts
|
|
var csettings;
|
|
settings.subscribe((b) => {
|
|
csettings = b;
|
|
});
|
|
var generateUglyThumbnail = async (f) => {
|
|
const can = document.createElement("canvas");
|
|
const [sw, sh] = [125, 125];
|
|
const url = URL.createObjectURL(f);
|
|
let source;
|
|
let iw, ih;
|
|
if (f.type.startsWith("image")) {
|
|
const imgElem = document.createElement("img");
|
|
imgElem.src = url;
|
|
await new Promise((_) => imgElem.onload = _);
|
|
[iw, ih] = [imgElem.naturalWidth, imgElem.naturalHeight];
|
|
source = imgElem;
|
|
} else if (f.type.startsWith("video")) {
|
|
const vidElem = document.createElement("video");
|
|
vidElem.src = url;
|
|
await new Promise((_) => vidElem.onloadedmetadata = _);
|
|
vidElem.currentTime = 0;
|
|
await new Promise((_) => vidElem.onloadeddata = _);
|
|
await new Promise(requestAnimationFrame);
|
|
await new Promise(requestAnimationFrame);
|
|
await new Promise(requestAnimationFrame);
|
|
[iw, ih] = [vidElem.videoWidth, vidElem.videoHeight];
|
|
source = vidElem;
|
|
} else
|
|
return import_buffer2.Buffer.alloc(0);
|
|
const scale = Math.min(1, sw / iw, sh / ih);
|
|
const dims = [~~(iw * scale), ~~(ih * scale)];
|
|
can.width = dims[0];
|
|
can.height = dims[1];
|
|
const ctx = can.getContext("2d");
|
|
if (!ctx)
|
|
return import_buffer2.Buffer.alloc(0);
|
|
ctx.drawImage(source, 0, 0, dims[0], dims[1]);
|
|
const blob = await new Promise((_) => can.toBlob(_));
|
|
if (!blob)
|
|
return import_buffer2.Buffer.alloc(0);
|
|
return import_buffer2.Buffer.from(await blob.arrayBuffer());
|
|
};
|
|
var generateThumbnail = async (f) => {
|
|
try {
|
|
return await generateProperThumbnail(f);
|
|
} catch {
|
|
return await generateUglyThumbnail(f);
|
|
}
|
|
};
|
|
var generateProperThumbnail = async (f) => {
|
|
const can = document.createElement("canvas");
|
|
const [sw, sh] = [125, 125];
|
|
const url = URL.createObjectURL(f);
|
|
let source;
|
|
let iw, ih;
|
|
if (f.type.startsWith("image")) {
|
|
const imgElem = document.createElement("img");
|
|
imgElem.src = url;
|
|
await new Promise((_) => imgElem.onload = _);
|
|
[iw, ih] = [imgElem.naturalWidth, imgElem.naturalHeight];
|
|
source = imgElem;
|
|
} else if (f.type.startsWith("video")) {
|
|
const vidElem = document.createElement("video");
|
|
vidElem.src = url;
|
|
await new Promise((_) => vidElem.onloadedmetadata = _);
|
|
vidElem.currentTime = 0;
|
|
await new Promise((_) => vidElem.onloadeddata = _);
|
|
await new Promise(requestAnimationFrame);
|
|
await new Promise(requestAnimationFrame);
|
|
await new Promise(requestAnimationFrame);
|
|
[iw, ih] = [vidElem.videoWidth, vidElem.videoHeight];
|
|
source = vidElem;
|
|
} else
|
|
return import_buffer2.Buffer.alloc(0);
|
|
const scale = Math.min(1, sw / iw, sh / ih);
|
|
const dims = [~~(iw * scale), ~~(ih * scale)];
|
|
can.width = dims[0];
|
|
can.height = dims[1];
|
|
const ctx = can.getContext("bitmaprenderer");
|
|
const bmp = await createImageBitmap(source, { resizeHeight: dims[1], resizeWidth: dims[0], resizeQuality: "high" });
|
|
if (!ctx)
|
|
return import_buffer2.Buffer.alloc(0);
|
|
ctx?.transferFromImageBitmap(bmp);
|
|
const blob = await new Promise((_) => can.toBlob(_));
|
|
if (!blob)
|
|
return import_buffer2.Buffer.alloc(0);
|
|
return import_buffer2.Buffer.from(await blob.arrayBuffer());
|
|
};
|
|
var buildPeeFile = async (f) => {
|
|
if (false)
|
|
return buildPeeFileFF(f);
|
|
let thumbnail = import_buffer2.Buffer.alloc(0);
|
|
thumbnail = await generateThumbnail(f);
|
|
const namebuf = import_buffer2.Buffer.from(f.name);
|
|
const ret = import_buffer2.Buffer.alloc(4 + 1 + namebuf.byteLength + 1 + (thumbnail.byteLength != 0 ? 4 + thumbnail.byteLength : 0) + f.size);
|
|
let ptr = 0;
|
|
ret.write("PEE\0", 0);
|
|
ptr += 4;
|
|
ret[ptr++] = 1 | +(thumbnail.length != 0) << 2;
|
|
namebuf.copy(ret, ptr);
|
|
ptr += namebuf.byteLength;
|
|
ret[ptr++] = 0;
|
|
if (thumbnail.length > 0) {
|
|
ret.writeInt32LE(thumbnail.byteLength, ptr);
|
|
ptr += 4;
|
|
thumbnail.copy(ret, ptr);
|
|
ptr += thumbnail.byteLength;
|
|
}
|
|
const content = await f.arrayBuffer();
|
|
import_buffer2.Buffer.from(content).copy(ret, ptr);
|
|
return new Blob([ret]);
|
|
};
|
|
var getThreadInfo = async (board, op) => {
|
|
const res = await (await fetch(`https://shoujo.coom.tech/data/${board}/${op}`)).json();
|
|
return Object.fromEntries(res.map((e) => [e.id, e]));
|
|
};
|
|
var threadDataCache = writable();
|
|
var cthreadDataCache;
|
|
threadDataCache.subscribe((newval) => {
|
|
cthreadDataCache = newval;
|
|
});
|
|
var refreshThreadDataCache = async (board, op) => {
|
|
console.log("refreshing thread info cache...");
|
|
threadDataCache.set(await getThreadInfo(board, op));
|
|
};
|
|
var getThreadDataCache = async (board, op) => {
|
|
if (!cthreadDataCache)
|
|
await refreshThreadDataCache(board, op);
|
|
else {
|
|
console.log("skipped thread cache refresh...");
|
|
}
|
|
return threadDataCache;
|
|
};
|
|
var getEmbedsFromCache = async (board, op, pid) => {
|
|
if (!csettings)
|
|
throw new Error("Settings uninit");
|
|
await getThreadDataCache(board, op);
|
|
const target = +pid.slice(pid.match(/\d/).index);
|
|
const cachedData = cthreadDataCache[target];
|
|
if (!cachedData)
|
|
return;
|
|
const ret = [];
|
|
if ("pee" in cachedData.data) {
|
|
const files = await decodeCoom3Payload(import_buffer2.Buffer.from(cachedData.data.pee.join(" ")));
|
|
ret.push([files, false]);
|
|
}
|
|
if ("third" in cachedData.data) {
|
|
if (csettings.phash) {
|
|
if ((cachedData.mdist || Number.POSITIVE_INFINITY) < (csettings.mdist || 5))
|
|
return ret;
|
|
}
|
|
let cachedFile;
|
|
const data = cachedData.data.third;
|
|
const prev = data.preview_url;
|
|
const full = data.full_url;
|
|
const fn = new URL(full).pathname.split("/").slice(-1)[0];
|
|
const end = [{
|
|
source: data.source,
|
|
page: {
|
|
title: "PEE Cache",
|
|
url: data.page
|
|
},
|
|
filename: fn,
|
|
thumbnail: csettings.hotlink ? prev || full : import_buffer2.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()),
|
|
data: csettings.hotlink ? full || prev : { url: full || prev }
|
|
}];
|
|
ret.push([end, true]);
|
|
}
|
|
return ret;
|
|
};
|
|
var decodeCoom3Payload = async (buff) => {
|
|
if (!csettings)
|
|
throw new Error("Settings uninit");
|
|
const allowed_domains = filehosts.map((e) => e.serving.replaceAll(".", "\\."));
|
|
const pees = buff.toString().split(" ").slice(0, csettings.maxe).filter((e) => allowed_domains.some((v) => e.match(`https://(.*\\.)?${v}/`)));
|
|
return (await Promise.all(pees.map(async (pee) => {
|
|
try {
|
|
const m = pee.match(/(?<protocol>https?):\/\/(?<domain>.*?)(?<file>\/.*)/);
|
|
if (!m)
|
|
return;
|
|
const { domain: domain2, file } = m.groups;
|
|
const headers = await getHeaders(pee);
|
|
const res = await ifetch(pee, {
|
|
headers: { range: "bytes=0-32767" },
|
|
mode: "cors"
|
|
});
|
|
const size = +headers["content-length"] || 0;
|
|
const header = import_buffer2.Buffer.from(await res.arrayBuffer());
|
|
let hptr = 0;
|
|
if (header.slice(0, 4).toString() == "PEE\0")
|
|
hptr += 4;
|
|
else
|
|
return;
|
|
const flags = header[hptr];
|
|
const hasFn = !!(flags & 1);
|
|
const hasTags = !!(flags & 2);
|
|
const hasThumbnail = !!(flags & 4);
|
|
let [ptr, ptr2] = [hptr + 1, hptr + 1];
|
|
let fn = "embedded";
|
|
let tags = [];
|
|
let thumb = import_buffer2.Buffer.from(hasembed_default);
|
|
if (hasFn) {
|
|
while (header[ptr2] != 0)
|
|
ptr2++;
|
|
fn = header.slice(ptr, ptr2).toString();
|
|
ptr = ++ptr2;
|
|
}
|
|
if (hasTags) {
|
|
while (header[ptr2] != 0)
|
|
ptr2++;
|
|
tags = header.slice(ptr, ptr2).toString().split(/\s+/);
|
|
}
|
|
let thumbsize = 0;
|
|
if (hasThumbnail) {
|
|
thumbsize = header.readInt32LE(ptr);
|
|
ptr += 4;
|
|
if (header.byteLength >= ptr + thumbsize)
|
|
thumb = header.slice(ptr, ptr + thumbsize);
|
|
else
|
|
thumb = import_buffer2.Buffer.from(await (await ifetch(pee, { headers: { "user-agent": "", range: `bytes=${ptr}-${ptr + thumbsize}` } })).arrayBuffer());
|
|
ptr += thumbsize;
|
|
}
|
|
const unzip = { url: pee, headers: { "user-agent": "", range: `bytes=${ptr}-${size - 1}` } };
|
|
let data;
|
|
data = unzip;
|
|
if (size < 3072) {
|
|
thumb = data = import_buffer2.Buffer.from(await (await ifetch(unzip.url, { headers: unzip.headers })).arrayBuffer());
|
|
}
|
|
return {
|
|
filename: fn,
|
|
data,
|
|
thumbnail: thumb
|
|
};
|
|
} catch (e) {
|
|
console.warn(e);
|
|
}
|
|
}))).filter((e) => e).map((e) => e);
|
|
};
|
|
var fireNotification = (type, content, lifetime = 3) => {
|
|
externalDispatch("CreateNotification", {
|
|
type,
|
|
content,
|
|
lifetime
|
|
});
|
|
};
|
|
var uploadFiles = async (injs) => {
|
|
let total = 0;
|
|
fireNotification("info", `Uploading ${injs.length} files...`);
|
|
return await Promise.all(injs.map(async (inj) => {
|
|
if (!csettings)
|
|
throw new Error("Settings uninit");
|
|
const peefile = await buildPeeFile(inj);
|
|
const ret = await filehosts[csettings.fhost || 0].uploadFile(peefile);
|
|
fireNotification("info", `Uploaded files [${++total}/${injs.length}] ${ret}`);
|
|
return ret;
|
|
}));
|
|
};
|
|
var getSelectedFile = () => {
|
|
return new Promise((res) => {
|
|
document.addEventListener("QRFile", (e) => res(e.detail), { once: true });
|
|
document.dispatchEvent(new CustomEvent("QRGetFile"));
|
|
});
|
|
};
|
|
async function embeddedToBlob(...efs) {
|
|
return (await Promise.all(efs.map(async (ef) => {
|
|
let buff;
|
|
if (typeof ef.data == "string") {
|
|
const req = await ifetch(ef.data);
|
|
buff = import_buffer2.Buffer.from(await req.arrayBuffer());
|
|
} else if (!(ef.data instanceof Uint8Array))
|
|
buff = await ef.data();
|
|
else
|
|
buff = ef.data;
|
|
const mim = await fileTypeFromBuffer(buff);
|
|
const file = new File([buff], ef.filename, { type: mim?.mime });
|
|
return file;
|
|
}))).filter((e) => e);
|
|
}
|
|
async function addToEmbeds(...efs) {
|
|
const files = await embeddedToBlob(...efs);
|
|
const links = await uploadFiles(files);
|
|
document.dispatchEvent(new CustomEvent("AddPEE", { detail: links }));
|
|
}
|
|
async function getFileFromHydrus(client, tags, args) {
|
|
const results = (await client.idsByTags(tags, args)).file_ids;
|
|
const metas = await client.getMetaDataByIds(results);
|
|
return await Promise.all(
|
|
results.map(async (id, idx) => {
|
|
return [
|
|
id,
|
|
{
|
|
thumbnail: import_buffer2.Buffer.from(
|
|
await client.getThumbnail(id)
|
|
),
|
|
data: async () => import_buffer2.Buffer.from(
|
|
await client.getFile(id)
|
|
),
|
|
filename: metas.metadata[idx].hash + metas.metadata[idx].ext
|
|
}
|
|
];
|
|
})
|
|
);
|
|
}
|
|
function externalDispatch(name, data) {
|
|
let event;
|
|
if (false) {
|
|
const clonedDetail = cloneInto(data, document.defaultView);
|
|
event = new CustomEvent(name, { detail: clonedDetail });
|
|
} else {
|
|
event = new CustomEvent(name, { detail: data });
|
|
}
|
|
document.dispatchEvent(event);
|
|
}
|
|
var peeTarget = class {
|
|
targets = {};
|
|
addEventListener(ev, cb) {
|
|
this.targets[ev] = this.targets[ev] || [];
|
|
this.targets[ev].push(cb);
|
|
}
|
|
dispatchEvent(ev) {
|
|
const evs = this.targets[ev.type];
|
|
if (evs)
|
|
for (const cb of evs)
|
|
cb(ev);
|
|
return true;
|
|
}
|
|
removeEventListener(ev, cb) {
|
|
const evs = this.targets[ev];
|
|
if (!evs)
|
|
return;
|
|
for (let i = 0; i < evs.length; ++i) {
|
|
if (evs[i] == cb) {
|
|
evs.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/pngv3.ts
|
|
var bs58 = __toESM(require_bs58(), 1);
|
|
|
|
// src/bitstream.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var revbyte = (n, len = 8) => {
|
|
let acc = 0;
|
|
let n2 = n;
|
|
let len2 = len;
|
|
while (len2) {
|
|
acc = acc * 2 + (n2 & 1);
|
|
n2 >>= 1;
|
|
len2--;
|
|
}
|
|
return acc;
|
|
};
|
|
var BitstreamReader = class {
|
|
buffers = [];
|
|
bufferedLength = 0;
|
|
_offsetIntoBuffer = 0;
|
|
_bufferIndex = 0;
|
|
_offset = 0;
|
|
get bufferIndex() {
|
|
return this._bufferIndex;
|
|
}
|
|
get offset() {
|
|
return this._offset;
|
|
}
|
|
get available() {
|
|
return this.bufferedLength - this.skippedLength;
|
|
}
|
|
skippedLength = 0;
|
|
getBit(offset) {
|
|
const byte = this.buffers[0][offset >> 3];
|
|
return +!!(byte & 1 << (offset & 7));
|
|
}
|
|
readSync(length) {
|
|
let value = 0;
|
|
if (this._offset >> 3 > this.buffers[0].byteLength) {
|
|
throw "Out of data";
|
|
}
|
|
for (let i = length - 1; i >= 0; --i) {
|
|
value = value * 2 + this.getBit(this._offset + i);
|
|
}
|
|
this._offset += length;
|
|
this.bufferedLength -= length;
|
|
return value;
|
|
}
|
|
addBuffer(buffer) {
|
|
this.buffers.push(buffer);
|
|
this.bufferedLength += buffer.length * 8;
|
|
}
|
|
};
|
|
var BitstreamWriter = class {
|
|
constructor(stream, bufferSize = 1) {
|
|
this.stream = stream;
|
|
bufferSize = 1;
|
|
this.buffer = new Uint8Array(bufferSize);
|
|
}
|
|
pendingBits = 0;
|
|
buffer;
|
|
bufferoffset = 0;
|
|
_offset = 0;
|
|
get offset() {
|
|
return this._offset;
|
|
}
|
|
get byteOffset() {
|
|
return this.pendingBits;
|
|
}
|
|
end() {
|
|
this.flush();
|
|
}
|
|
flush() {
|
|
this.stream.write(new Uint8Array(this.buffer));
|
|
this.bufferoffset = 0;
|
|
this.buffer.fill(0);
|
|
}
|
|
setBit(b) {
|
|
let byte = this.buffer[0];
|
|
byte |= b << (this._offset & 7);
|
|
this.buffer[0] = byte;
|
|
this._offset += 1;
|
|
if (++this.bufferoffset == this.buffer.length * 8) {
|
|
this.flush();
|
|
}
|
|
}
|
|
write(length, value) {
|
|
while (length--) {
|
|
this.setBit(value & 1);
|
|
value >>= 1;
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/dh-deflate.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var TINF_OK = 0;
|
|
var Tree = class {
|
|
table = new Uint16Array(16);
|
|
trans = new Uint16Array(288);
|
|
};
|
|
var getPathTo = (tree, value) => {
|
|
if (tree[0] === value)
|
|
return "0";
|
|
if (tree[1] === value)
|
|
return "1";
|
|
let p;
|
|
if (typeof tree[0] != "number")
|
|
p = getPathTo(tree[0], value);
|
|
let b = "0";
|
|
if (!p) {
|
|
if (tree[1] && typeof tree[1] != "number")
|
|
p = getPathTo(tree[1], value);
|
|
b = "1";
|
|
}
|
|
if (p)
|
|
return b + p;
|
|
};
|
|
function buildHuffmanTable(codeLengths, values) {
|
|
let k = 0, code = [], i, j, length = 16;
|
|
while (length > 0 && !codeLengths[length - 1])
|
|
length--;
|
|
code.push({ children: [], index: 0 });
|
|
let p = code[0], q;
|
|
for (i = 0; i < length; i++) {
|
|
for (j = 0; j < codeLengths[i]; j++) {
|
|
p = code.pop();
|
|
p.children[p.index] = values[k];
|
|
while (p.index > 0) {
|
|
if (code.length === 0)
|
|
throw new Error("Could not recreate Huffman Table");
|
|
p = code.pop();
|
|
}
|
|
p.index++;
|
|
code.push(p);
|
|
while (code.length <= i) {
|
|
code.push(q = { children: [], index: 0 });
|
|
p.children[p.index] = q.children;
|
|
p = q;
|
|
}
|
|
k++;
|
|
}
|
|
if (i + 1 < length) {
|
|
code.push(q = { children: [], index: 0 });
|
|
p.children[p.index] = q.children;
|
|
p = q;
|
|
}
|
|
}
|
|
return code[0].children;
|
|
}
|
|
var Data = class {
|
|
constructor(source, dests, to_hide, hidden) {
|
|
this.source = source;
|
|
this.dests = dests;
|
|
this.to_hide = to_hide;
|
|
this.hidden = hidden;
|
|
this.ltree = new Tree();
|
|
this.dtree = new Tree();
|
|
}
|
|
pathMap = /* @__PURE__ */ new Map();
|
|
computeReverse() {
|
|
this.rltree = buildHuffmanTable(this.ltree.table, this.ltree.trans)[0];
|
|
this.rdtree = buildHuffmanTable(this.dtree.table, this.dtree.trans)[0];
|
|
this.adists = new Set(this.rdtree.flat(16));
|
|
}
|
|
ltree;
|
|
dtree;
|
|
rltree;
|
|
rdtree;
|
|
adists;
|
|
dest = [];
|
|
};
|
|
var sltree = new Tree();
|
|
var sdtree = new Tree();
|
|
var rltree;
|
|
var rdtree;
|
|
var sadist;
|
|
var length_bits = new Uint8Array(30);
|
|
var length_base = new Uint16Array(30);
|
|
var dist_bits = new Uint8Array(30);
|
|
var dist_base = new Uint16Array(30);
|
|
var clcidx = new Uint8Array([
|
|
16,
|
|
17,
|
|
18,
|
|
0,
|
|
8,
|
|
7,
|
|
9,
|
|
6,
|
|
10,
|
|
5,
|
|
11,
|
|
4,
|
|
12,
|
|
3,
|
|
13,
|
|
2,
|
|
14,
|
|
1,
|
|
15
|
|
]);
|
|
var code_tree = new Tree();
|
|
var lengths = new Uint8Array(288 + 32);
|
|
function tinf_build_bits_base(bits, base, delta, first) {
|
|
let i, sum;
|
|
for (i = 0; i < delta; ++i)
|
|
bits[i] = 0;
|
|
for (i = 0; i < 30 - delta; ++i)
|
|
bits[i + delta] = i / delta | 0;
|
|
for (sum = first, i = 0; i < 30; ++i) {
|
|
base[i] = sum;
|
|
sum += 1 << bits[i];
|
|
}
|
|
}
|
|
function tinf_build_fixed_trees(lt, dt) {
|
|
let i;
|
|
for (i = 0; i < 7; ++i)
|
|
lt.table[i] = 0;
|
|
lt.table[7] = 24;
|
|
lt.table[8] = 152;
|
|
lt.table[9] = 112;
|
|
for (i = 0; i < 24; ++i)
|
|
lt.trans[i] = 256 + i;
|
|
for (i = 0; i < 144; ++i)
|
|
lt.trans[24 + i] = i;
|
|
for (i = 0; i < 8; ++i)
|
|
lt.trans[24 + 144 + i] = 280 + i;
|
|
for (i = 0; i < 112; ++i)
|
|
lt.trans[24 + 144 + 8 + i] = 144 + i;
|
|
for (i = 0; i < 5; ++i)
|
|
dt.table[i] = 0;
|
|
dt.table[5] = 32;
|
|
for (i = 0; i < 32; ++i)
|
|
dt.trans[i] = i;
|
|
}
|
|
var offs = new Uint16Array(16);
|
|
function tinf_build_tree(t, lengths2, off, num) {
|
|
let i, sum;
|
|
for (i = 0; i < 16; ++i)
|
|
t.table[i] = 0;
|
|
for (i = 0; i < num; ++i)
|
|
t.table[lengths2[off + i]]++;
|
|
t.table[0] = 0;
|
|
for (sum = 0, i = 0; i < 16; ++i) {
|
|
offs[i] = sum;
|
|
sum += t.table[i];
|
|
}
|
|
for (i = 0; i < num; ++i) {
|
|
if (lengths2[off + i])
|
|
t.trans[offs[lengths2[off + i]]++] = i;
|
|
}
|
|
}
|
|
function tinf_getbit(d) {
|
|
const v = d.source.readSync(1);
|
|
return v;
|
|
}
|
|
var loff = 0;
|
|
var loffs = [];
|
|
function tinf_read_bits(d, num, base) {
|
|
if (!num)
|
|
return base;
|
|
const v = d.source.readSync(num) + base;
|
|
loff = v;
|
|
loffs.push(v);
|
|
if (loffs.length > 4) {
|
|
loffs.shift();
|
|
}
|
|
return v;
|
|
}
|
|
function tinf_decode_symbol(d, t, copy = true, ext = {}) {
|
|
let sum = 0, cur = 0, len = 0;
|
|
let s = 0;
|
|
do {
|
|
const b = d.source.readSync(1);
|
|
copy && d.hidden?.write(1, b);
|
|
s = s << 1 | b;
|
|
cur = 2 * cur + b;
|
|
++len;
|
|
sum += t.table[len];
|
|
cur -= t.table[len];
|
|
} while (cur >= 0);
|
|
ext.length = len;
|
|
ext.sym = s;
|
|
return t.trans[sum + cur];
|
|
}
|
|
function tinf_decode_trees(d, lt, dt, copy = true) {
|
|
let i, num, length;
|
|
const hlit = tinf_read_bits(d, 5, 257);
|
|
copy && d.hidden?.write(5, hlit - 257);
|
|
const hdist = tinf_read_bits(d, 5, 1);
|
|
copy && d.hidden?.write(5, hdist - 1);
|
|
const hclen = tinf_read_bits(d, 4, 4);
|
|
copy && d.hidden?.write(4, hclen - 4);
|
|
for (i = 0; i < 19; ++i)
|
|
lengths[i] = 0;
|
|
for (i = 0; i < hclen; ++i) {
|
|
const clen = tinf_read_bits(d, 3, 0);
|
|
copy && d.hidden?.write(3, clen);
|
|
lengths[clcidx[i]] = clen;
|
|
}
|
|
tinf_build_tree(code_tree, lengths, 0, 19);
|
|
for (num = 0; num < hlit + hdist; ) {
|
|
const sym = tinf_decode_symbol(d, code_tree, copy);
|
|
let prev;
|
|
switch (sym) {
|
|
case 16:
|
|
prev = lengths[num - 1];
|
|
length = tinf_read_bits(d, 2, 3);
|
|
copy && d.hidden?.write(2, length - 3);
|
|
for (; length; --length) {
|
|
lengths[num++] = prev;
|
|
}
|
|
break;
|
|
case 17:
|
|
length = tinf_read_bits(d, 3, 3);
|
|
copy && d.hidden?.write(3, length - 3);
|
|
for (; length; --length) {
|
|
lengths[num++] = 0;
|
|
}
|
|
break;
|
|
case 18:
|
|
length = tinf_read_bits(d, 7, 11);
|
|
copy && d.hidden?.write(7, length - 11);
|
|
for (; length; --length) {
|
|
lengths[num++] = 0;
|
|
}
|
|
break;
|
|
default:
|
|
lengths[num++] = sym;
|
|
break;
|
|
}
|
|
}
|
|
tinf_build_tree(lt, lengths, 0, hlit);
|
|
tinf_build_tree(dt, lengths, hlit, hdist);
|
|
}
|
|
var get_symbol = (value, bits_table, base_table) => {
|
|
let i = 0;
|
|
for (i = 0; i < base_table.length; ++i) {
|
|
if (base_table[i] > value) {
|
|
i--;
|
|
return [i, bits_table[i], value - base_table[i]];
|
|
}
|
|
}
|
|
i--;
|
|
return [i, bits_table[i], value - base_table[i]];
|
|
};
|
|
var encode_symbol = (sym, tree, pathMap) => {
|
|
const code = getPathTo(tree, sym);
|
|
const v = {
|
|
length: code?.length,
|
|
val: parseInt(code, 2)
|
|
};
|
|
return v;
|
|
};
|
|
var capacity = 0;
|
|
function tinf_inflate_block_data(d, lt, dt) {
|
|
while (1) {
|
|
let sym = tinf_decode_symbol(d, lt);
|
|
if (sym === 256) {
|
|
return TINF_OK;
|
|
}
|
|
if (sym < 256) {
|
|
d.dest.push(sym);
|
|
} else {
|
|
sym -= 257;
|
|
const length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
|
|
if (length_bits[sym])
|
|
d.hidden?.write(length_bits[sym], length - length_base[sym]);
|
|
const ext = { length: 0, sym: 0 };
|
|
const dist = tinf_decode_symbol(d, dt, false, ext);
|
|
let backoffset = tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
|
|
const offs2 = d.dest.length - backoffset;
|
|
let match;
|
|
const skip = !d.to_hide || d.to_hide && d.to_hide instanceof BitstreamReader && d.to_hide.available == 0;
|
|
if (!skip && (match = Buffer2.from(d.dest.slice(offs2, offs2 + length))).length == length) {
|
|
let begin = d.dest.length - 32768;
|
|
if (begin < 0)
|
|
begin = 0;
|
|
let matches = [];
|
|
let o = 0;
|
|
const slic = Buffer2.from(d.dest.slice(begin + o, d.dest.length));
|
|
while (begin + o < d.dest.length) {
|
|
const r = slic.slice(o, d.dest.length).indexOf(match);
|
|
if (r >= 0) {
|
|
matches.push(r + begin + o);
|
|
o += r;
|
|
} else {
|
|
break;
|
|
}
|
|
o++;
|
|
}
|
|
if (matches.length > 1) {
|
|
matches = matches.map((e) => -(e - d.dest.length)).filter((e) => {
|
|
const [dsym2] = get_symbol(e, dist_bits, dist_base);
|
|
return d.adists.has(dsym2);
|
|
});
|
|
matches.reverse();
|
|
const v = Math.floor(Math.log2(matches.length));
|
|
capacity += v;
|
|
if (d.to_hide instanceof BitstreamReader) {
|
|
if (d.to_hide.available) {
|
|
const s = d.to_hide.readSync(Math.min(d.to_hide.available, v));
|
|
backoffset = matches[s];
|
|
}
|
|
} else {
|
|
const idx = matches.indexOf(backoffset);
|
|
d.to_hide.write(v, idx);
|
|
}
|
|
}
|
|
}
|
|
const [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);
|
|
const encdist = encode_symbol(dsym, d.rdtree, d.pathMap);
|
|
d.hidden?.write(encdist.length, revbyte(encdist.val, encdist.length));
|
|
d.hidden?.write(dlen, doff);
|
|
for (let i = offs2; i < offs2 + length; ++i) {
|
|
d.dest.push(d.dest[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function tinf_inflate_uncompressed_block(d) {
|
|
if (d.source.offset & 7)
|
|
d.source.readSync(8 - d.source.offset & 7);
|
|
if (d.hidden && d.hidden.offset & 7)
|
|
d.hidden?.write(8 - d.hidden.offset & 7, 0);
|
|
const length = d.source.readSync(16);
|
|
d.hidden?.write(16, length);
|
|
const invlength = d.source.readSync(16);
|
|
d.hidden?.write(16, invlength);
|
|
if (length !== (~invlength & 65535)) {
|
|
return -4;
|
|
}
|
|
for (let i = length; i; --i) {
|
|
const v = d.source.readSync(8);
|
|
d.dest.push(v);
|
|
d.hidden?.write(8, v);
|
|
}
|
|
return TINF_OK;
|
|
}
|
|
function tinf_uncompress(source, decompressed, to_hide, hidden, opt = 0) {
|
|
const decomp = decompressed ? new BitstreamWriter({ write: decompressed }) : null;
|
|
const hid = hidden && new BitstreamWriter({ write: hidden }, 4);
|
|
const d = new Data(source, decomp, to_hide, hid);
|
|
let res;
|
|
let bfinal, btype;
|
|
do {
|
|
bfinal = tinf_getbit(d);
|
|
d.hidden?.write(1, bfinal);
|
|
btype = tinf_read_bits(d, 2, 0);
|
|
d.hidden?.write(2, btype);
|
|
switch (btype) {
|
|
case 0:
|
|
res = tinf_inflate_uncompressed_block(d);
|
|
break;
|
|
case 1:
|
|
d.rdtree = rdtree;
|
|
d.rltree = rltree;
|
|
d.adists = sadist;
|
|
res = tinf_inflate_block_data(d, sltree, sdtree);
|
|
break;
|
|
case 2:
|
|
tinf_decode_trees(d, d.ltree, d.dtree);
|
|
d.computeReverse();
|
|
res = tinf_inflate_block_data(d, d.ltree, d.dtree);
|
|
break;
|
|
default:
|
|
res = -2;
|
|
}
|
|
if (res !== TINF_OK)
|
|
throw new Error("Data error " + res);
|
|
} while (!bfinal);
|
|
decomp?.end();
|
|
hid?.end();
|
|
}
|
|
tinf_build_fixed_trees(sltree, sdtree);
|
|
tinf_build_bits_base(length_bits, length_base, 4, 3);
|
|
tinf_build_bits_base(dist_bits, dist_base, 2, 1);
|
|
rltree = buildHuffmanTable(sltree.table, sltree.trans)[0];
|
|
rdtree = buildHuffmanTable(sdtree.table, sdtree.trans)[0];
|
|
sadist = new Set(rdtree.flat(16));
|
|
length_bits[28] = 0;
|
|
length_base[28] = 258;
|
|
|
|
// src/pngv3.ts
|
|
var csettings2;
|
|
settings.subscribe((b) => {
|
|
csettings2 = b;
|
|
});
|
|
var CUM3 = import_buffer3.Buffer.from("doo\0m");
|
|
var CUM4 = import_buffer3.Buffer.from("voo\0m");
|
|
var CUM5 = import_buffer3.Buffer.from("boo\0");
|
|
var CUM6 = import_buffer3.Buffer.from("Creation Time\0");
|
|
var CUM7 = import_buffer3.Buffer.from("Software\0");
|
|
var BufferReadStream = (b) => {
|
|
const ret = new ReadableStream({
|
|
pull(cont) {
|
|
cont.enqueue(b);
|
|
cont.close();
|
|
}
|
|
});
|
|
return ret;
|
|
};
|
|
var password = import_buffer3.Buffer.from("NOA");
|
|
var xor = (a, p) => {
|
|
let n = 0;
|
|
for (let i = 0; i < a.byteLength; ++i) {
|
|
a[i] ^= p[n];
|
|
n++;
|
|
n %= p.byteLength;
|
|
}
|
|
};
|
|
var prefs = {
|
|
"files.catbox.moe": "c",
|
|
"a.pomf.cat": "p",
|
|
"take-me-to.space": "t",
|
|
"z.zz.fo": "z"
|
|
};
|
|
var rprefs = {
|
|
"c": "files.catbox.moe",
|
|
"p": "a.pomf.cat",
|
|
"t": "take-me-to.space",
|
|
"z": "z.zz.fo"
|
|
};
|
|
var extractFromRawDeflate = (b) => {
|
|
const src = new BitstreamReader();
|
|
src.addBuffer(b);
|
|
const chnks = [];
|
|
const hidden = new BitstreamWriter({
|
|
write(chunk) {
|
|
for (const i of chunk) {
|
|
if (i >= 32 && i <= 128)
|
|
chnks.push(i);
|
|
else
|
|
throw "Finish";
|
|
}
|
|
}
|
|
});
|
|
try {
|
|
tinf_uncompress(src, void 0, hidden, void 0);
|
|
} catch (e) {
|
|
if (e == "Finish")
|
|
return import_buffer3.Buffer.from(chnks);
|
|
}
|
|
return false;
|
|
};
|
|
var extract = async (png, doextract = true) => {
|
|
const reader = BufferReadStream(png).getReader();
|
|
const sneed = new PNGDecoder(reader, false);
|
|
const ret = [];
|
|
let w;
|
|
if (!csettings2)
|
|
throw new Error("Settings uninit");
|
|
try {
|
|
let complete = false;
|
|
const idats = [];
|
|
for await (const [name, chunk, crc, offset] of sneed.chunks()) {
|
|
let buff;
|
|
switch (name) {
|
|
case "tEXt":
|
|
buff = chunk;
|
|
if (buff.slice(4, 4 + CUM3.length).equals(CUM3)) {
|
|
if (!doextract)
|
|
return true;
|
|
const k = await decodeCoom3Payload(buff.slice(4 + CUM3.length));
|
|
ret.push(...k.filter((e) => e));
|
|
}
|
|
if (buff.slice(4, 4 + CUM4.length).equals(CUM4)) {
|
|
if (!doextract)
|
|
return true;
|
|
const passed = buff.slice(4 + CUM4.length);
|
|
xor(passed, password);
|
|
const k = await decodeCoom3Payload(passed);
|
|
ret.push(...k.filter((e) => e));
|
|
}
|
|
if (buff.slice(4, 4 + CUM5.length).equals(CUM5)) {
|
|
if (!doextract)
|
|
return true;
|
|
const passed = buff.slice(4 + CUM5.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));
|
|
}
|
|
if (w = [CUM6, CUM7].find((e) => buff.slice(4, 4 + e.length).equals(e))) {
|
|
const passed = buff.slice(4 + w.length);
|
|
if (!passed.toString().match(/^[0-9a-zA-Z+/=]+$/g))
|
|
continue;
|
|
const decoders = [
|
|
(b) => import_buffer3.Buffer.from(b.toString(), "base64").toString(),
|
|
(b) => import_buffer3.Buffer.from(bs58.decode(passed.toString())).toString()
|
|
];
|
|
for (const d of decoders) {
|
|
try {
|
|
const decoded = d(passed).split(" ").map((e) => {
|
|
if (!(e[0] in rprefs))
|
|
throw "Uhh";
|
|
return `https://${rprefs[e[0]]}/${e.slice(1)}`;
|
|
}).join(" ");
|
|
if (!doextract)
|
|
return true;
|
|
const k = await decodeCoom3Payload(import_buffer3.Buffer.from(decoded));
|
|
ret.push(...k.filter((e) => e));
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case "IDAT":
|
|
if (ret.length)
|
|
return ret;
|
|
buff = chunk;
|
|
idats.push(buff.slice(4));
|
|
break;
|
|
case "IEND":
|
|
complete = true;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (idats.length) {
|
|
let decoded;
|
|
if ((decoded = extractFromRawDeflate(import_buffer3.Buffer.concat(idats).slice(2))) === false)
|
|
return false;
|
|
const dec = decoded.toString().split(" ").map((e) => {
|
|
if (!(e[0] in rprefs) || e.length < 5)
|
|
throw "Uhh";
|
|
return `https://${rprefs[e[0]]}/${e.slice(1)}`;
|
|
}).join(" ");
|
|
if (doextract)
|
|
return decodeCoom3Payload(import_buffer3.Buffer.from(dec));
|
|
return true;
|
|
}
|
|
} catch (e) {
|
|
if (e != "Uhh")
|
|
console.error(e);
|
|
} finally {
|
|
reader.releaseLock();
|
|
}
|
|
};
|
|
var buildChunk = (tag, data) => {
|
|
const ret = import_buffer3.Buffer.alloc(data.byteLength + 4);
|
|
ret.write(tag.slice(0, 4), 0);
|
|
data.copy(ret, 4);
|
|
return ret;
|
|
};
|
|
var BufferWriteStream = () => {
|
|
let b = import_buffer3.Buffer.from([]);
|
|
const ret = new WritableStream({
|
|
write(chunk) {
|
|
b = import_buffer3.Buffer.concat([b, chunk]);
|
|
console.log("finished appending");
|
|
}
|
|
});
|
|
return [ret, () => b];
|
|
};
|
|
var embedInRawDeflate = (b, h) => {
|
|
const src = new BitstreamReader();
|
|
const hid = new BitstreamReader();
|
|
hid.addBuffer(h);
|
|
src.addBuffer(b);
|
|
const chnks = [];
|
|
tinf_uncompress(src, void 0, hid, (c) => chnks.push(c));
|
|
return import_buffer3.Buffer.concat(chnks);
|
|
};
|
|
var inject_data = async (container, injb) => {
|
|
injb = import_buffer3.Buffer.concat([injb, import_buffer3.Buffer.from([0])]);
|
|
if (!csettings2)
|
|
throw new Error("Settings uninit");
|
|
if (csettings2.pmeth < 5) {
|
|
let magic = false;
|
|
const [writestream2, extract6] = BufferWriteStream();
|
|
const encoder = new PNGEncoder(writestream2);
|
|
const decoder = new PNGDecoder(container.stream().getReader());
|
|
for await (const [name, chunk, crc, offset] of decoder.chunks()) {
|
|
if (magic && name != "IDAT")
|
|
break;
|
|
if (!magic && name == "IDAT") {
|
|
const passed = import_buffer3.Buffer.from(injb);
|
|
switch (csettings2.pmeth) {
|
|
case 0:
|
|
await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM3, passed])), 0, 0]);
|
|
break;
|
|
case 1:
|
|
xor(passed, password);
|
|
await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM4, import_buffer3.Buffer.from(import_buffer3.Buffer.from(passed).toString("base64"))])), 0, 0]);
|
|
break;
|
|
case 2:
|
|
await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM5, import_buffer3.Buffer.from(import_buffer3.Buffer.from(passed).toString("base64"))])), 0, 0]);
|
|
break;
|
|
case 3:
|
|
await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM6, import_buffer3.Buffer.from(import_buffer3.Buffer.from(passed).toString("base64"))])), 0, 0]);
|
|
break;
|
|
case 4:
|
|
await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM7, import_buffer3.Buffer.from(bs58.encode(passed))])), 0, 0]);
|
|
break;
|
|
}
|
|
magic = true;
|
|
}
|
|
await encoder.insertchunk([name, chunk, crc, offset]);
|
|
}
|
|
await encoder.insertchunk([
|
|
"IEND",
|
|
buildChunk("IEND", import_buffer3.Buffer.from([])),
|
|
0,
|
|
0
|
|
]);
|
|
return extract6();
|
|
}
|
|
let pdec = new PNGDecoder(container.stream().getReader());
|
|
const concat = [];
|
|
for await (const chk of pdec.chunks())
|
|
if (chk[0] == "IDAT")
|
|
concat.push(chk[1].slice(4));
|
|
const comp = import_buffer3.Buffer.concat(concat);
|
|
const head = comp.slice(0, 2);
|
|
const chksum = comp.slice(-4);
|
|
const idatblk = embedInRawDeflate(comp.slice(2, -4), injb);
|
|
const [writestream, extract5] = BufferWriteStream();
|
|
const penc = new PNGEncoder(writestream);
|
|
pdec = new PNGDecoder(container.stream().getReader());
|
|
let ins = false;
|
|
for await (const chk of pdec.chunks()) {
|
|
if (chk[0] != "IDAT") {
|
|
await penc.insertchunk(chk);
|
|
} else {
|
|
if (!ins) {
|
|
await penc.insertchunk(["IDAT", import_buffer3.Buffer.concat([import_buffer3.Buffer.from("IDAT"), head, idatblk, chksum]), 0, 0]);
|
|
ins = true;
|
|
}
|
|
}
|
|
}
|
|
await penc.dtor();
|
|
console.log("Finished writing");
|
|
return extract5();
|
|
};
|
|
var inject = async (container, links) => {
|
|
links = links.map((link) => {
|
|
for (const h of filehosts) {
|
|
if (link.includes(h.serving)) {
|
|
const end = link.split("/").slice(-1)[0];
|
|
return `${prefs[h.serving]}${end}`;
|
|
}
|
|
}
|
|
return "";
|
|
});
|
|
const injb = import_buffer3.Buffer.from(links.join(" "));
|
|
return inject_data(container, injb);
|
|
};
|
|
var has_embed = async (png) => {
|
|
const r = await extract(png, false);
|
|
return !!r;
|
|
};
|
|
var pngv3_default = {
|
|
extract,
|
|
has_embed,
|
|
inject,
|
|
match: (fn) => !!fn.match(/\.png$/)
|
|
};
|
|
|
|
// src/jpg.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_buffer4 = __toESM(require_buffer(), 1);
|
|
|
|
// src/f5stego.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function* f5get() {
|
|
let extrBit = 0;
|
|
let k = 0;
|
|
for (let i = 0; i < 4; ++i) {
|
|
const b2 = yield;
|
|
k |= b2 << i;
|
|
}
|
|
k = (k & 15) + 1;
|
|
let toread = 8;
|
|
let len = 0;
|
|
while (toread--) {
|
|
const b2 = yield;
|
|
len = len * 2 + b2;
|
|
}
|
|
const b = yield;
|
|
toread += 8;
|
|
if (b)
|
|
toread += 7;
|
|
else
|
|
len *= 2;
|
|
while (toread--) {
|
|
const b2 = yield;
|
|
len = len * 2 + b2;
|
|
}
|
|
const rlen = revbyte(len, b ? 23 : 16);
|
|
len = rlen;
|
|
if (len > 256)
|
|
throw new Error("Too big for Smash");
|
|
len *= 8;
|
|
const chunks = [];
|
|
const bw = new BitstreamWriter({
|
|
write(chunk) {
|
|
chunks.push(chunk);
|
|
}
|
|
});
|
|
while (len) {
|
|
extrBit = yield;
|
|
bw.write(1, extrBit);
|
|
len--;
|
|
}
|
|
bw.end();
|
|
return Buffer2.concat(chunks).slice(0, rlen);
|
|
}
|
|
var bitcode = new Array(65535);
|
|
var category = new Array(65535);
|
|
var std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
|
|
var std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
|
|
var std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125];
|
|
var 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
|
|
];
|
|
var std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
|
|
var std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
|
|
var std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119];
|
|
var 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() {
|
|
let nrlower = 1;
|
|
let nrupper = 2;
|
|
for (let cat = 1; cat <= 15; cat++) {
|
|
for (let nr = nrlower; nr < nrupper; nr++) {
|
|
category[32767 + nr] = cat;
|
|
bitcode[32767 + nr] = [];
|
|
bitcode[32767 + nr][1] = cat;
|
|
bitcode[32767 + nr][0] = nr;
|
|
}
|
|
for (let 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) {
|
|
let codevalue = 0;
|
|
let pos_in_table = 0;
|
|
const HT = [];
|
|
for (let k = 1; k <= 16; k++) {
|
|
for (let 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);
|
|
var UVDC_HT = _computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values);
|
|
var YAC_HT = _computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values);
|
|
var UVAC_HT = _computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values);
|
|
var f5stego = class {
|
|
constructor(key2, maxPixels = 4096 * 4096) {
|
|
this.maxPixels = maxPixels;
|
|
}
|
|
embed(image, data, k) {
|
|
this.parse(image);
|
|
this.f5put(data, k);
|
|
return this.pack();
|
|
}
|
|
extract(image) {
|
|
try {
|
|
this.gengen = f5get();
|
|
this.gengen.next();
|
|
this.parse(image, true);
|
|
return this.f5get();
|
|
} catch (e) {
|
|
if (e instanceof Buffer2)
|
|
return e;
|
|
throw e;
|
|
}
|
|
}
|
|
#_raw;
|
|
#jfif;
|
|
#APPn;
|
|
#qts;
|
|
#frame = null;
|
|
#tail = null;
|
|
#_f5write(coeff, data, k) {
|
|
const coeff_count = coeff.length;
|
|
let _changed = 0, _embedded = 0, _examined = 0, _thrown = 0, shuffled_index = 0, i, n, ii;
|
|
let 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 ^= 0;
|
|
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 = ii;
|
|
if (shuffled_index % 64 === 0 || coeff[shuffled_index] === 0)
|
|
continue;
|
|
const 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 ^= 0;
|
|
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) {
|
|
let 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 ^= 0;
|
|
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;
|
|
}
|
|
const code_word = [];
|
|
let ci = null;
|
|
for (i = 0; i < n; i++) {
|
|
while (true) {
|
|
if (++ii >= coeff_count) {
|
|
throw "capacity exceeded " + _embedded / 8;
|
|
}
|
|
ci = 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 = 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)
|
|
};
|
|
}
|
|
f5put(data, k) {
|
|
if (!this.#frame)
|
|
throw "Parser not run";
|
|
let 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 (!("blocks" in comp)) {
|
|
throw "Blocks failed to be parsed";
|
|
}
|
|
return this.#_f5write(comp.blocks, t, k);
|
|
}
|
|
f5get() {
|
|
if (!this.#frame)
|
|
throw "Parser not run";
|
|
let comp = this.#frame.components[0];
|
|
if (comp.componentId != 1) {
|
|
for (let i = 0; i < this.#frame.components.length; i++) {
|
|
if (this.#frame.components[i].componentId == 1) {
|
|
comp = this.#frame.components[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!("blocks" in comp)) {
|
|
throw "Blocks failed to be parsed";
|
|
}
|
|
const coeff = new Int16Array(comp.blocks.length);
|
|
coeff.set(comp.blocks);
|
|
let pos = -1, extrBit = 0, cCount = coeff.length - 1;
|
|
let n, k = 0;
|
|
let 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 & 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;
|
|
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;
|
|
bitsAvail -= 8;
|
|
extrByte = extrByte >> 8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while (bitsAvail > 0) {
|
|
out[outPos++] = extrByte & 255;
|
|
bitsAvail -= 8;
|
|
extrByte = extrByte >> 8;
|
|
}
|
|
let 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);
|
|
}
|
|
gengen;
|
|
parse(data, tolerant = false) {
|
|
let offset = 0;
|
|
function _buildHuffmanTable(nrcodes, values) {
|
|
let codevalue = 0, pos_in_table = 0, HT = new Uint16Array(65536);
|
|
for (let k = 0; k < 16; k++) {
|
|
for (let j2 = 0; j2 < nrcodes[k]; j2++) {
|
|
for (let 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;
|
|
}
|
|
const decodeScan = (data2, offset2, frame, components, resetInterval2, spectralStart, spectralEnd, successivePrev, successive) => {
|
|
let startOffset = offset2, bitsData = 0, bitsCount = 0, eobrun = 0, p1 = 1 << successive, m1 = -1 << successive;
|
|
const prevpos = 0;
|
|
const decodeBaseline = (component2, pos) => {
|
|
while (bitsCount < 16) {
|
|
bitsData = (bitsData << 8) + (data2[offset2] | 0);
|
|
bitsCount += 8;
|
|
if (data2[offset2] == 255)
|
|
offset2++;
|
|
offset2++;
|
|
}
|
|
let t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535];
|
|
if (!t)
|
|
throw "invalid huffman sequence";
|
|
bitsCount -= t >>> 8;
|
|
t &= 255;
|
|
let 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;
|
|
let 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;
|
|
if (component2.blocks[pos + k2] < 1 << s - 1)
|
|
component2.blocks[pos + k2] += (-1 << s) + 1;
|
|
bitsCount -= s;
|
|
k2++;
|
|
}
|
|
};
|
|
function decodeDCFirst(component2, pos) {
|
|
let diff = 0;
|
|
while (bitsCount < 16) {
|
|
bitsData = (bitsData << 8) + (data2[offset2] | 0);
|
|
bitsCount += 8;
|
|
if (data2[offset2] == 255)
|
|
offset2++;
|
|
offset2++;
|
|
}
|
|
let 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;
|
|
}
|
|
if (!frame)
|
|
throw "Frame not parsed yet";
|
|
function decodeACFirst(component2, pos) {
|
|
if (eobrun > 0) {
|
|
eobrun--;
|
|
return;
|
|
}
|
|
let k2 = spectralStart, s, r;
|
|
while (k2 <= spectralEnd) {
|
|
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) {
|
|
let k2 = spectralStart, r, s;
|
|
if (frame == null)
|
|
throw "Frame not defined";
|
|
if (!eobrun) {
|
|
while (k2 <= spectralEnd) {
|
|
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 <= spectralEnd) {
|
|
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 <= spectralEnd) {
|
|
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--;
|
|
}
|
|
}
|
|
let decodeFn;
|
|
if (frame.progressive) {
|
|
if (spectralStart === 0)
|
|
decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
|
|
else
|
|
decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
|
|
} else {
|
|
decodeFn = decodeBaseline;
|
|
}
|
|
let marker, mcuExpected, i2, j2, k, n, mcusPerLine, mcusPerRow, x, y;
|
|
let lastflushidx = 0;
|
|
const flushBits = () => {
|
|
if (!this.gengen)
|
|
return;
|
|
const component2 = components.find((e) => e.componentId == 1);
|
|
while (component2.blocks[lastflushidx + 1] !== void 0) {
|
|
const blk = component2.blocks[lastflushidx];
|
|
if (blk != 0) {
|
|
const v = blk < 0 ? 1 - (blk & 1) : blk & 1;
|
|
const it = this.gengen.next(v);
|
|
if (it.done) {
|
|
throw it.value;
|
|
}
|
|
}
|
|
lastflushidx++;
|
|
}
|
|
};
|
|
if (components.length == 1) {
|
|
mcusPerLine = components[0].blocksPerLine;
|
|
mcusPerRow = components[0].blocksPerColumn;
|
|
mcuExpected = mcusPerRow * mcusPerLine;
|
|
if (!resetInterval2)
|
|
resetInterval2 = mcuExpected;
|
|
n = resetInterval2;
|
|
components[0].pred = 0;
|
|
eobrun = 0;
|
|
for (y = 0; y < mcusPerRow; y++) {
|
|
for (x = 0; x < mcusPerLine; x++) {
|
|
if (!n) {
|
|
n = resetInterval2;
|
|
components[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 < components.length; i2++) {
|
|
decodeFn(components[i2], (y * components[i2].blocksPerLineForMcu + x) * 64);
|
|
}
|
|
}
|
|
flushBits();
|
|
}
|
|
} else {
|
|
mcusPerLine = frame.mcusPerLine;
|
|
mcusPerRow = frame.mcusPerColumn;
|
|
mcuExpected = mcusPerRow * mcusPerLine;
|
|
if (!resetInterval2)
|
|
resetInterval2 = mcuExpected;
|
|
n = resetInterval2;
|
|
for (i2 = 0; i2 < components.length; i2++)
|
|
components[i2].pred = 0;
|
|
eobrun = 0;
|
|
for (y = 0; y < mcusPerRow; y++) {
|
|
for (x = 0; x < mcusPerLine; x++) {
|
|
if (!n) {
|
|
n = resetInterval2;
|
|
for (i2 = 0; i2 < components.length; i2++)
|
|
components[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 < components.length; i2++) {
|
|
for (j2 = 0; j2 < components[i2].v; j2++) {
|
|
for (k = 0; k < components[i2].h; k++) {
|
|
decodeFn(components[i2], ((y * components[i2].v + j2) * components[i2].blocksPerLineForMcu + x * components[i2].h + k) * 64);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
flushBits();
|
|
}
|
|
}
|
|
offset2 -= bitsCount / 8 | 0;
|
|
if (data2[offset2 - 1] == 255)
|
|
offset2--;
|
|
return offset2 - startOffset;
|
|
};
|
|
function readUint16() {
|
|
const value = data[offset] << 8 | data[offset + 1];
|
|
offset += 2;
|
|
return value;
|
|
}
|
|
function readDataBlock() {
|
|
const length = readUint16();
|
|
const 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;
|
|
let markerHi, markerLo, i, j, resetInterval, component;
|
|
const huffmanTablesAC = [];
|
|
const huffmanTablesDC = [];
|
|
while (1) {
|
|
if (offset >= data.length) {
|
|
if (tolerant)
|
|
break;
|
|
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;
|
|
let maxH = 0, maxV = 0;
|
|
for (i = 0; i < componentsCount; i++) {
|
|
componentId = data[offset];
|
|
const h = data[offset + 1] >> 4;
|
|
const v = data[offset + 1] & 15;
|
|
if (maxH < h)
|
|
maxH = h;
|
|
if (maxV < v)
|
|
maxV = v;
|
|
const qId = data[offset + 2];
|
|
const l = this.#frame.components.push({
|
|
componentId,
|
|
h,
|
|
v,
|
|
quantizationTable: qId
|
|
});
|
|
this.#frame.componentIds[componentId] = l - 1;
|
|
offset += 3;
|
|
}
|
|
this.#frame.maxH = maxH;
|
|
this.#frame.maxV = maxV;
|
|
const mcusPerLine = Math.ceil(this.#frame.samplesPerLine / 8 / maxH);
|
|
const mcusPerColumn = Math.ceil(this.#frame.scanLines / 8 / maxV);
|
|
for (i = 0; i < this.#frame.components.length; i++) {
|
|
component = this.#frame.components[i];
|
|
const blocksPerLine = Math.ceil(Math.ceil(this.#frame.samplesPerLine / 8) * component.h / maxH);
|
|
const blocksPerColumn = Math.ceil(Math.ceil(this.#frame.scanLines / 8) * component.v / maxV);
|
|
const blocksPerLineForMcu = mcusPerLine * component.h;
|
|
const blocksPerColumnForMcu = mcusPerColumn * component.v;
|
|
this.#frame.components[i] = {
|
|
...component,
|
|
blocks: new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu * 64),
|
|
blocksDC: new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu),
|
|
blocksPerLine,
|
|
blocksPerColumn,
|
|
blocksPerLineForMcu,
|
|
blocksPerColumnForMcu
|
|
};
|
|
}
|
|
this.#frame.mcusPerLine = mcusPerLine;
|
|
this.#frame.mcusPerColumn = mcusPerColumn;
|
|
}
|
|
if (markerLo == 196) {
|
|
const huffmanLength = readUint16();
|
|
for (i = 2; i < huffmanLength; ) {
|
|
const huffmanTableSpec = data[offset++];
|
|
const codeLengths = new Uint8Array(16);
|
|
let codeLengthSum = 0;
|
|
for (j = 0; j < 16; j++, offset++)
|
|
codeLengthSum += codeLengths[j] = data[offset];
|
|
const huffmanValues = new Uint8Array(codeLengthSum);
|
|
for (j = 0; j < codeLengthSum; j++, offset++)
|
|
huffmanValues[j] = data[offset];
|
|
i += 17 + codeLengthSum;
|
|
const v = _buildHuffmanTable(codeLengths, huffmanValues);
|
|
if (huffmanTableSpec >> 4 === 0)
|
|
huffmanTablesDC[huffmanTableSpec & 15] = v;
|
|
else
|
|
huffmanTablesAC[huffmanTableSpec & 15] = v;
|
|
}
|
|
}
|
|
if (markerLo == 221) {
|
|
resetInterval = readUint16();
|
|
}
|
|
if (markerLo == 218) {
|
|
if (this.#frame == null)
|
|
throw "SOS before SOF";
|
|
readUint16();
|
|
const selectorsCount = data[offset++];
|
|
const components = [];
|
|
for (i = 0; i < selectorsCount; i++) {
|
|
const componentIndex = this.#frame.componentIds[data[offset++]];
|
|
component = this.#frame.components[componentIndex];
|
|
const tableSpec = data[offset++];
|
|
component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
|
|
component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
|
|
components.push(component);
|
|
}
|
|
const spectralStart = data[offset++];
|
|
const spectralEnd = data[offset++];
|
|
const successiveApproximation = data[offset++];
|
|
const processed2 = decodeScan(
|
|
data,
|
|
offset,
|
|
this.#frame,
|
|
components,
|
|
resetInterval,
|
|
spectralStart,
|
|
spectralEnd,
|
|
successiveApproximation >> 4,
|
|
successiveApproximation & 15
|
|
);
|
|
offset += processed2;
|
|
}
|
|
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;
|
|
}
|
|
pack() {
|
|
let byteout;
|
|
let bytenew;
|
|
let bytepos;
|
|
let poslast;
|
|
let outpos;
|
|
let byte;
|
|
function writeByte(value) {
|
|
let 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) {
|
|
let 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 (let i2 = 0; i2 < self.#qts.length; i2++) {
|
|
writeWord(65499);
|
|
writeWord(self.#qts[i2].length + 2);
|
|
writeBlock(self.#qts[i2]);
|
|
}
|
|
}
|
|
function writeAPPn(self) {
|
|
for (let 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) {
|
|
if (!self.#frame)
|
|
throw "Frame not ready";
|
|
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 (let i2 = 0; i2 < self.#frame.components.length; i2++) {
|
|
const c2 = self.#frame.components[i2];
|
|
writeByte(c2.componentId);
|
|
writeByte(c2.h << 4 | c2.v);
|
|
writeByte(c2.quantizationTable);
|
|
}
|
|
}
|
|
function writeDHT(self) {
|
|
if (!self.#frame)
|
|
throw "Frame not ready";
|
|
writeWord(65476);
|
|
writeWord(31);
|
|
writeByte(0);
|
|
for (let i2 = 0; i2 < 16; i2++) {
|
|
writeByte(std_dc_luminance_nrcodes[i2 + 1]);
|
|
}
|
|
for (let j = 0; j <= 11; j++) {
|
|
writeByte(std_dc_luminance_values[j]);
|
|
}
|
|
writeWord(65476);
|
|
writeWord(181);
|
|
writeByte(16);
|
|
for (let k = 0; k < 16; k++) {
|
|
writeByte(std_ac_luminance_nrcodes[k + 1]);
|
|
}
|
|
for (let l = 0; l <= 161; l++) {
|
|
writeByte(std_ac_luminance_values[l]);
|
|
}
|
|
if (self.#frame.components.length != 1) {
|
|
writeWord(65476);
|
|
writeWord(31);
|
|
writeByte(1);
|
|
for (let m = 0; m < 16; m++) {
|
|
writeByte(std_dc_chrominance_nrcodes[m + 1]);
|
|
}
|
|
for (let n = 0; n <= 11; n++) {
|
|
writeByte(std_dc_chrominance_values[n]);
|
|
}
|
|
writeWord(65476);
|
|
writeWord(181);
|
|
writeByte(17);
|
|
for (let o = 0; o < 16; o++) {
|
|
writeByte(std_ac_chrominance_nrcodes[o + 1]);
|
|
}
|
|
for (let p = 0; p <= 161; p++) {
|
|
writeByte(std_ac_chrominance_values[p]);
|
|
}
|
|
}
|
|
}
|
|
function writeSOS(self) {
|
|
if (!self.#frame)
|
|
throw "Frame not ready";
|
|
writeWord(65498);
|
|
writeWord(6 + self.#frame.components.length * 2);
|
|
writeByte(self.#frame.components.length);
|
|
for (let i2 = 0; i2 < self.#frame.components.length; i2++) {
|
|
const 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) {
|
|
let pos, posval, t;
|
|
if (bytepos === 0)
|
|
bytenew = 0;
|
|
if (!("blocks" in comp))
|
|
throw "Blocks not parsed";
|
|
const 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;
|
|
}
|
|
}
|
|
let 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;
|
|
}
|
|
let i2 = 1;
|
|
let lng;
|
|
while (i2 <= end0pos) {
|
|
const startpos = i2;
|
|
for (; comp.blocks[POS + i2] === 0 && i2 <= end0pos; ++i2) {
|
|
}
|
|
let nrzeroes = i2 - startpos;
|
|
if (nrzeroes >= 16) {
|
|
lng = nrzeroes >> 4;
|
|
for (let 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;
|
|
if (!this.#frame)
|
|
throw "Frame not ready";
|
|
let c, mcuRow, mcuCol, blockRow, blockCol, mcu, i, v, h;
|
|
const 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);
|
|
}
|
|
};
|
|
|
|
// src/jpg.ts
|
|
var key = import_buffer4.Buffer.from("CUNNYCUNNYCUNNY");
|
|
var f5inst = new f5stego(key);
|
|
var inject2 = async (b, links) => {
|
|
if (b.size / 20 < links.join(" ").length)
|
|
throw "Image too small to embed.";
|
|
const arr = new Uint8Array(new Uint8Array(await b.arrayBuffer()));
|
|
const buff = f5inst.embed(arr, new TextEncoder().encode(links.join(" ")), 1);
|
|
return import_buffer4.Buffer.from(buff);
|
|
};
|
|
var has_embed2 = (b) => {
|
|
try {
|
|
const res = f5inst.extract(b);
|
|
if (!res)
|
|
return false;
|
|
if (res.length > 1024)
|
|
return false;
|
|
const str = import_buffer4.Buffer.from(res).toString();
|
|
if (!str.match(/^[a-zA-Z0-9:/.\-_ ]+$/))
|
|
return false;
|
|
return str;
|
|
} catch {
|
|
return false;
|
|
}
|
|
};
|
|
var extract2 = (b, ex) => {
|
|
return decodeCoom3Payload(import_buffer4.Buffer.from(ex));
|
|
};
|
|
var jpg_default = {
|
|
match: (fn) => !!fn.match(/\.jpe?g$/),
|
|
has_embed: has_embed2,
|
|
extract: extract2,
|
|
inject: inject2
|
|
};
|
|
|
|
// src/thirdeye.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_buffer5 = __toESM(require_buffer(), 1);
|
|
var import_jpeg_js = __toESM(require_jpeg_js(), 1);
|
|
|
|
// src/phash.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var median = (data) => {
|
|
const mdarr = data.slice(0);
|
|
mdarr.sort((a, b) => a - b);
|
|
if (mdarr.length % 2 === 0)
|
|
return (mdarr[mdarr.length / 2 - 1] + mdarr[mdarr.length / 2]) / 2;
|
|
return mdarr[Math.floor(mdarr.length / 2)];
|
|
};
|
|
var translate_blocks_to_bits = function(blocks, pixels_per_block) {
|
|
const half_block_value = pixels_per_block * 256 * 3 / 2;
|
|
const bandsize = blocks.length / 4;
|
|
for (let i = 0; i < 4; i++) {
|
|
const m = median(blocks.slice(i * bandsize, (i + 1) * bandsize));
|
|
for (let j = i * bandsize; j < (i + 1) * bandsize; j++) {
|
|
const v = blocks[j];
|
|
blocks[j] = Number(v > m || Math.abs(v - m) < 1 && m > half_block_value);
|
|
}
|
|
}
|
|
};
|
|
var bits_to_hexhash = (bitsArray) => {
|
|
const hex = [];
|
|
for (let i = 0; i < bitsArray.length; i += 4) {
|
|
const nibble = bitsArray.slice(i, i + 4);
|
|
hex.push(parseInt(nibble.join(""), 2).toString(16));
|
|
}
|
|
return hex.join("");
|
|
};
|
|
var bmvbhash_even = (data, bits) => {
|
|
const blocksize_x = Math.floor(data.width / bits);
|
|
const blocksize_y = Math.floor(data.height / bits);
|
|
const result = [];
|
|
for (let y = 0; y < bits; y++) {
|
|
for (let x = 0; x < bits; x++) {
|
|
let total = 0;
|
|
for (let iy = 0; iy < blocksize_y; iy++) {
|
|
for (let ix = 0; ix < blocksize_x; ix++) {
|
|
const cx = x * blocksize_x + ix;
|
|
const cy = y * blocksize_y + iy;
|
|
const ii = (cy * data.width + cx) * 4;
|
|
const alpha2 = data.data[ii + 3];
|
|
if (alpha2 === 0) {
|
|
total += 765;
|
|
} else {
|
|
total += data.data[ii] + data.data[ii + 1] + data.data[ii + 2];
|
|
}
|
|
}
|
|
}
|
|
result.push(total);
|
|
}
|
|
}
|
|
translate_blocks_to_bits(result, blocksize_x * blocksize_y);
|
|
return bits_to_hexhash(result);
|
|
};
|
|
|
|
// src/thirdeye.ts
|
|
var csettings3;
|
|
settings.subscribe((b) => {
|
|
csettings3 = b;
|
|
});
|
|
var gelquirk = (prefix) => (a) => {
|
|
let base = a.post || a.data || a;
|
|
if (!Array.isArray(base))
|
|
return [];
|
|
base = base.filter((e) => e.file_url);
|
|
return base.map((e) => ({
|
|
full_url: e.file_url,
|
|
preview_url: e.preview_url || e.preview_url,
|
|
source: e.source,
|
|
ext: e.file_ext || e.file_url.substr(e.file_url.lastIndexOf(".") + 1),
|
|
page: `${prefix}${e.id || e.parent_id}`,
|
|
tags: (e.tag_string || (e.tags && (Array.isArray(e.tags) && (typeof e.tags[0] == "string" ? e.tags.join(" ") : e.tags.map((e2) => e2.name_en).join(" "))) || e.tags) || "").split(" ")
|
|
})) || [];
|
|
};
|
|
var experimentalApi = false;
|
|
var black = /* @__PURE__ */ new Set();
|
|
var phashEn = false;
|
|
var mindist = 5;
|
|
settings.subscribe((s) => {
|
|
if (!s)
|
|
return;
|
|
experimentalApi = s.expte;
|
|
boorus = s.rsources.map((e) => ({
|
|
...e,
|
|
quirks: gelquirk(e.view)
|
|
}));
|
|
black = new Set(s.blacklist);
|
|
mindist = s.mdist || 5;
|
|
phashEn = s.phash;
|
|
});
|
|
var boorus = [];
|
|
var unlockQueue = Promise.resolve();
|
|
var cache = {};
|
|
var findFileFrom = async (b, hex, abort) => {
|
|
try {
|
|
if (b.domain in cache && hex in cache[b.domain])
|
|
return cache[b.domain][hex];
|
|
const res = await ifetch(`https://${b.domain}${b.endpoint}${hex}`);
|
|
const txt = await res.text();
|
|
const pres = JSON.parse(txt);
|
|
const tran = b.quirks(pres).filter((e) => !e.tags.some((e2) => black.has(e2)));
|
|
if (!(b.domain in cache))
|
|
cache[b.domain] = {};
|
|
cache[b.domain][hex] = tran;
|
|
return tran;
|
|
} catch (e) {
|
|
const error = e;
|
|
if (!error.message.includes("Unexpected end of JSON input"))
|
|
console.error(e);
|
|
return [];
|
|
}
|
|
};
|
|
var extract3 = async (b, fn) => {
|
|
if (!csettings3)
|
|
throw new Error("Settings uninit");
|
|
let result;
|
|
let booru;
|
|
for (const e of Object.values(boorus)) {
|
|
if (e.disabled)
|
|
continue;
|
|
result = await findFileFrom(e, fn.substring(0, 32));
|
|
if (result.length) {
|
|
booru = e.name;
|
|
break;
|
|
}
|
|
}
|
|
let cachedFile;
|
|
const prev = result[0].preview_url;
|
|
const full = result[0].full_url;
|
|
return [{
|
|
source: result[0].source,
|
|
page: {
|
|
title: booru,
|
|
url: result[0].page
|
|
},
|
|
filename: fn.substring(0, 33) + result[0].ext,
|
|
thumbnail: csettings3.hotlink ? prev || full : import_buffer5.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()),
|
|
data: csettings3.hotlink ? full || prev : { url: full || prev }
|
|
}];
|
|
};
|
|
var phash = (b) => {
|
|
const res = (0, import_jpeg_js.decode)(b);
|
|
return bmvbhash_even(res, 8);
|
|
};
|
|
var hammingDist = (a, b) => {
|
|
let res = BigInt("0x" + a) ^ BigInt("0x" + b);
|
|
let acc = 0;
|
|
while (res != 0n) {
|
|
acc += Number(res & 1n);
|
|
res >>= 1n;
|
|
}
|
|
return acc;
|
|
};
|
|
var has_embed3 = async (b, fn, prevlink) => {
|
|
if (import_buffer5.Buffer.from(fn, "hex").equals(b))
|
|
return false;
|
|
let result = void 0;
|
|
for (const e of Object.values(boorus)) {
|
|
if (e.disabled)
|
|
continue;
|
|
result = await findFileFrom(e, fn.substring(0, 32));
|
|
result = result.filter((e2) => e2.full_url || e2.preview_url);
|
|
if (result.length)
|
|
break;
|
|
}
|
|
if (result && result.length != 0 && phashEn && prevlink) {
|
|
if (!result[0].preview_url)
|
|
return true;
|
|
const getHash = async (l) => {
|
|
const ogreq = await ifetch(l);
|
|
const origPreview = await ogreq.arrayBuffer();
|
|
return phash(import_buffer5.Buffer.from(origPreview));
|
|
};
|
|
const [orighash, tehash] = await Promise.all([
|
|
getHash(prevlink),
|
|
getHash(result[0].preview_url)
|
|
]);
|
|
const d = hammingDist(orighash, tehash);
|
|
console.log(d, prevlink);
|
|
return d > mindist;
|
|
}
|
|
return result && result.length != 0;
|
|
};
|
|
var thirdeye_default = {
|
|
skip: true,
|
|
extract: extract3,
|
|
has_embed: has_embed3,
|
|
match: (fn) => !!fn.match(/^[0-9a-f]{32}\.....?/)
|
|
};
|
|
|
|
// src/pomf.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_buffer6 = __toESM(require_buffer(), 1);
|
|
var sources = [
|
|
{ host: "Catbox", prefix: "files.catbox.moe/" },
|
|
{ host: "Litter", prefix: "litter.catbox.moe/" },
|
|
{ host: "Zzzz", prefix: "z.zz.fo/" }
|
|
];
|
|
var csettings4;
|
|
settings.subscribe((b) => {
|
|
csettings4 = 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)/);
|
|
const isExt = fn.match(/\[.*=(.*)\]/);
|
|
let ext;
|
|
let source;
|
|
try {
|
|
if (isB64) {
|
|
ext = atob(isB64[1]);
|
|
} else if (isExt) {
|
|
ext = decodeURIComponent(isExt[1]);
|
|
if (ext.startsWith("https://"))
|
|
ext = ext.slice("https://".length);
|
|
for (const cs of sources)
|
|
if (ext.startsWith(cs.prefix)) {
|
|
source = cs.prefix;
|
|
ext = ext.slice(cs.prefix.length);
|
|
break;
|
|
}
|
|
}
|
|
} catch {
|
|
}
|
|
return { ext, source };
|
|
};
|
|
var extract4 = async (b, fn) => {
|
|
if (!csettings4)
|
|
throw new Error("Settings uninit");
|
|
const { ext, source } = getExt(fn);
|
|
let rsource;
|
|
for (const cs of sources) {
|
|
if (source && cs.prefix != source)
|
|
continue;
|
|
try {
|
|
await getHeaders("https://" + cs.prefix + ext);
|
|
rsource = "https://" + cs.prefix + ext;
|
|
break;
|
|
} catch {
|
|
}
|
|
}
|
|
return [{
|
|
filename: ext,
|
|
data: csettings4.hotlink ? rsource : { url: rsource },
|
|
thumbnail: import_buffer6.Buffer.from(hasembed_default)
|
|
}];
|
|
};
|
|
var has_embed4 = async (b, fn) => {
|
|
const { ext, source } = getExt(fn);
|
|
if (!ext)
|
|
return false;
|
|
for (const cs of sources) {
|
|
if (source && cs.prefix != source)
|
|
continue;
|
|
try {
|
|
const e = await getHeaders("https://" + cs.prefix + ext);
|
|
return true;
|
|
} catch {
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
var pomf_default = {
|
|
skip: true,
|
|
extract: extract4,
|
|
has_embed: has_embed4,
|
|
match: (fn) => !!getExt(fn)
|
|
};
|
|
|
|
// src/Components/App.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/svelte/index.mjs
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/svelte/transition/index.mjs
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/svelte/easing/index.mjs
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function cubicOut(t) {
|
|
const f = t - 1;
|
|
return f * f * f + 1;
|
|
}
|
|
|
|
// node_modules/svelte/transition/index.mjs
|
|
function slide(node, { delay = 0, duration = 400, easing = cubicOut } = {}) {
|
|
const style = getComputedStyle(node);
|
|
const opacity = +style.opacity;
|
|
const height = parseFloat(style.height);
|
|
const padding_top = parseFloat(style.paddingTop);
|
|
const padding_bottom = parseFloat(style.paddingBottom);
|
|
const margin_top = parseFloat(style.marginTop);
|
|
const margin_bottom = parseFloat(style.marginBottom);
|
|
const border_top_width = parseFloat(style.borderTopWidth);
|
|
const border_bottom_width = parseFloat(style.borderBottomWidth);
|
|
return {
|
|
delay,
|
|
duration,
|
|
easing,
|
|
css: (t) => `overflow: hidden;opacity: ${Math.min(t * 20, 1) * opacity};height: ${t * height}px;padding-top: ${t * padding_top}px;padding-bottom: ${t * padding_bottom}px;margin-top: ${t * margin_top}px;margin-bottom: ${t * margin_bottom}px;border-top-width: ${t * border_top_width}px;border-bottom-width: ${t * border_bottom_width}px;`
|
|
};
|
|
}
|
|
|
|
// src/Components/Dialog.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css(target) {
|
|
append_styles(target, "svelte-1edrz51", ".dialog.svelte-1edrz51{position:relative}");
|
|
}
|
|
function create_if_block(ctx) {
|
|
let div;
|
|
let current;
|
|
const default_slot_template = ctx[5].default;
|
|
const default_slot = create_slot(default_slot_template, ctx, ctx[4], null);
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
if (default_slot)
|
|
default_slot.c();
|
|
set_style(div, "top", ctx[0][1] + "px");
|
|
set_style(div, "left", ctx[0][0] + "px");
|
|
attr(div, "class", "dialog svelte-1edrz51");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if (default_slot) {
|
|
default_slot.m(div, null);
|
|
}
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (default_slot) {
|
|
if (default_slot.p && (!current || dirty & 16)) {
|
|
update_slot_base(
|
|
default_slot,
|
|
default_slot_template,
|
|
ctx2,
|
|
ctx2[4],
|
|
!current ? get_all_dirty_from_scope(ctx2[4]) : get_slot_changes(default_slot_template, ctx2[4], dirty, null),
|
|
null
|
|
);
|
|
}
|
|
}
|
|
if (!current || dirty & 1) {
|
|
set_style(div, "top", ctx2[0][1] + "px");
|
|
}
|
|
if (!current || dirty & 1) {
|
|
set_style(div, "left", ctx2[0][0] + "px");
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(default_slot, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(default_slot, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
if (default_slot)
|
|
default_slot.d(detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment(ctx) {
|
|
let if_block_anchor;
|
|
let current;
|
|
let if_block = ctx[1] && create_if_block(ctx);
|
|
return {
|
|
c() {
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (ctx2[1]) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
if (dirty & 2) {
|
|
transition_in(if_block, 1);
|
|
}
|
|
} else {
|
|
if_block = create_if_block(ctx2);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function setPos(p) {
|
|
}
|
|
function instance($$self, $$props, $$invalidate) {
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
|
let { pos = [0, 0] } = $$props;
|
|
let visible = false;
|
|
function toggle() {
|
|
$$invalidate(1, visible = !visible);
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("pos" in $$props2)
|
|
$$invalidate(0, pos = $$props2.pos);
|
|
if ("$$scope" in $$props2)
|
|
$$invalidate(4, $$scope = $$props2.$$scope);
|
|
};
|
|
return [pos, visible, toggle, setPos, $$scope, slots];
|
|
}
|
|
var Dialog = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance, create_fragment, safe_not_equal, { pos: 0, toggle: 2, setPos: 3 }, add_css);
|
|
}
|
|
get pos() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set pos(pos) {
|
|
this.$$set({ pos });
|
|
flush();
|
|
}
|
|
get toggle() {
|
|
return this.$$.ctx[2];
|
|
}
|
|
get setPos() {
|
|
return setPos;
|
|
}
|
|
};
|
|
var Dialog_default = Dialog;
|
|
|
|
// src/Components/Tag.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css2(target) {
|
|
append_styles(target, "svelte-gsq99c", ".tag.svelte-gsq99c.svelte-gsq99c{padding:5px;border:1px solid;border-radius:55px;cursor:pointer;display:inline-flex}.tag.toggled.svelte-gsq99c.svelte-gsq99c{background-color:rgb(213, 255, 212)}span.tag.svelte-gsq99c>span.svelte-gsq99c{margin-left:5px;border-left:1px solid;padding-left:5px}.tag.toggled.svelte-gsq99c.svelte-gsq99c:hover{color:white;background-color:rgb(255 156 156 / 80%);color:white}.tag.svelte-gsq99c.svelte-gsq99c:not(.toggled):hover{color:white;background-color:rgb(213, 255, 212);color:white}");
|
|
}
|
|
function create_if_block2(ctx) {
|
|
let span;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
span.textContent = "x";
|
|
attr(span, "class", "svelte-gsq99c");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(span, "click", ctx[4]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_fragment2(ctx) {
|
|
let span;
|
|
let t0;
|
|
let t1;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block = ctx[1] && create_if_block2(ctx);
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
t0 = text(ctx[0]);
|
|
t1 = space();
|
|
if (if_block)
|
|
if_block.c();
|
|
attr(span, "class", "tag svelte-gsq99c");
|
|
toggle_class(span, "toggle", ctx[1]);
|
|
toggle_class(span, "toggled", ctx[1] && ctx[2]);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
append(span, t0);
|
|
append(span, t1);
|
|
if (if_block)
|
|
if_block.m(span, null);
|
|
if (!mounted) {
|
|
dispose = listen(span, "click", ctx[5]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 1)
|
|
set_data(t0, ctx2[0]);
|
|
if (ctx2[1]) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block2(ctx2);
|
|
if_block.c();
|
|
if_block.m(span, null);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
if (dirty & 2) {
|
|
toggle_class(span, "toggle", ctx2[1]);
|
|
}
|
|
if (dirty & 6) {
|
|
toggle_class(span, "toggled", ctx2[1] && ctx2[2]);
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
if (if_block)
|
|
if_block.d();
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function instance2($$self, $$props, $$invalidate) {
|
|
let { tag } = $$props;
|
|
let { toggleable = false } = $$props;
|
|
let { toggled = false } = $$props;
|
|
const dispatch2 = createEventDispatcher();
|
|
const click_handler2 = (e) => (e.preventDefault(), dispatch2("remove"));
|
|
const click_handler_1 = () => dispatch2("toggle");
|
|
$$self.$$set = ($$props2) => {
|
|
if ("tag" in $$props2)
|
|
$$invalidate(0, tag = $$props2.tag);
|
|
if ("toggleable" in $$props2)
|
|
$$invalidate(1, toggleable = $$props2.toggleable);
|
|
if ("toggled" in $$props2)
|
|
$$invalidate(2, toggled = $$props2.toggled);
|
|
};
|
|
return [tag, toggleable, toggled, dispatch2, click_handler2, click_handler_1];
|
|
}
|
|
var Tag = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance2, create_fragment2, safe_not_equal, { tag: 0, toggleable: 1, toggled: 2 }, add_css2);
|
|
}
|
|
get tag() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set tag(tag) {
|
|
this.$$set({ tag });
|
|
flush();
|
|
}
|
|
get toggleable() {
|
|
return this.$$.ctx[1];
|
|
}
|
|
set toggleable(toggleable) {
|
|
this.$$set({ toggleable });
|
|
flush();
|
|
}
|
|
get toggled() {
|
|
return this.$$.ctx[2];
|
|
}
|
|
set toggled(toggled) {
|
|
this.$$set({ toggled });
|
|
flush();
|
|
}
|
|
};
|
|
var Tag_default = Tag;
|
|
|
|
// src/Components/Tabs.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css3(target) {
|
|
append_styles(target, "svelte-16zoarp", ".tabs.svelte-16zoarp{display:flex;flex-direction:column;gap:5px}");
|
|
}
|
|
function create_fragment3(ctx) {
|
|
let div;
|
|
let current;
|
|
const default_slot_template = ctx[1].default;
|
|
const default_slot = create_slot(default_slot_template, ctx, ctx[0], null);
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
if (default_slot)
|
|
default_slot.c();
|
|
attr(div, "class", "tabs svelte-16zoarp");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if (default_slot) {
|
|
default_slot.m(div, null);
|
|
}
|
|
current = true;
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (default_slot) {
|
|
if (default_slot.p && (!current || dirty & 1)) {
|
|
update_slot_base(
|
|
default_slot,
|
|
default_slot_template,
|
|
ctx2,
|
|
ctx2[0],
|
|
!current ? get_all_dirty_from_scope(ctx2[0]) : get_slot_changes(default_slot_template, ctx2[0], dirty, null),
|
|
null
|
|
);
|
|
}
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(default_slot, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(default_slot, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
if (default_slot)
|
|
default_slot.d(detaching);
|
|
}
|
|
};
|
|
}
|
|
var TABS = {};
|
|
function instance3($$self, $$props, $$invalidate) {
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
|
const tabs = [];
|
|
const panels = [];
|
|
const selectedTab = writable(null);
|
|
const selectedPanel = writable(null);
|
|
setContext(TABS, {
|
|
registerTab: (tab) => {
|
|
tabs.push(tab);
|
|
selectedTab.update((current) => current || tab);
|
|
onDestroy(() => {
|
|
const i = tabs.indexOf(tab);
|
|
tabs.splice(i, 1);
|
|
selectedTab.update((current) => current === tab ? tabs[i] || tabs[tabs.length - 1] : current);
|
|
});
|
|
},
|
|
registerPanel: (panel) => {
|
|
panels.push(panel);
|
|
selectedPanel.update((current) => current || panel);
|
|
onDestroy(() => {
|
|
const i = panels.indexOf(panel);
|
|
panels.splice(i, 1);
|
|
selectedPanel.update((current) => current === panel ? panels[i] || panels[panels.length - 1] : current);
|
|
});
|
|
},
|
|
selectTab: (tab) => {
|
|
const i = tabs.indexOf(tab);
|
|
selectedTab.set(tab);
|
|
selectedPanel.set(panels[i]);
|
|
},
|
|
selectedTab,
|
|
selectedPanel
|
|
});
|
|
$$self.$$set = ($$props2) => {
|
|
if ("$$scope" in $$props2)
|
|
$$invalidate(0, $$scope = $$props2.$$scope);
|
|
};
|
|
return [$$scope, slots];
|
|
}
|
|
var Tabs = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance3, create_fragment3, safe_not_equal, {}, add_css3);
|
|
}
|
|
};
|
|
var Tabs_default = Tabs;
|
|
|
|
// src/Components/TabList.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css4(target) {
|
|
append_styles(target, "svelte-1dd6kkg", ".tab-list.svelte-1dd6kkg{border-bottom:1px solid}");
|
|
}
|
|
function create_fragment4(ctx) {
|
|
let div;
|
|
let current;
|
|
const default_slot_template = ctx[1].default;
|
|
const default_slot = create_slot(default_slot_template, ctx, ctx[0], null);
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
if (default_slot)
|
|
default_slot.c();
|
|
attr(div, "class", "tab-list svelte-1dd6kkg");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
if (default_slot) {
|
|
default_slot.m(div, null);
|
|
}
|
|
current = true;
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (default_slot) {
|
|
if (default_slot.p && (!current || dirty & 1)) {
|
|
update_slot_base(
|
|
default_slot,
|
|
default_slot_template,
|
|
ctx2,
|
|
ctx2[0],
|
|
!current ? get_all_dirty_from_scope(ctx2[0]) : get_slot_changes(default_slot_template, ctx2[0], dirty, null),
|
|
null
|
|
);
|
|
}
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(default_slot, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(default_slot, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
if (default_slot)
|
|
default_slot.d(detaching);
|
|
}
|
|
};
|
|
}
|
|
function instance4($$self, $$props, $$invalidate) {
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
|
$$self.$$set = ($$props2) => {
|
|
if ("$$scope" in $$props2)
|
|
$$invalidate(0, $$scope = $$props2.$$scope);
|
|
};
|
|
return [$$scope, slots];
|
|
}
|
|
var TabList = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance4, create_fragment4, safe_not_equal, {}, add_css4);
|
|
}
|
|
};
|
|
var TabList_default = TabList;
|
|
|
|
// src/Components/Tab.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css5(target) {
|
|
append_styles(target, "svelte-1i25yaz", "button.svelte-1i25yaz{background:none;border:none;border-bottom:2px solid white;border-radius:0;margin:0;color:unset}button.svelte-1i25yaz:hover{cursor:pointer;background-color:#8d8d8d80}.selected.svelte-1i25yaz{border-bottom:2px solid;color:#f6ff76}");
|
|
}
|
|
function create_fragment5(ctx) {
|
|
let button;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
const default_slot_template = ctx[6].default;
|
|
const default_slot = create_slot(default_slot_template, ctx, ctx[5], null);
|
|
return {
|
|
c() {
|
|
button = element("button");
|
|
if (default_slot)
|
|
default_slot.c();
|
|
attr(button, "class", "svelte-1i25yaz");
|
|
toggle_class(button, "selected", ctx[0] === ctx[1]);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, button, anchor);
|
|
if (default_slot) {
|
|
default_slot.m(button, null);
|
|
}
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = listen(button, "click", ctx[7]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (default_slot) {
|
|
if (default_slot.p && (!current || dirty & 32)) {
|
|
update_slot_base(
|
|
default_slot,
|
|
default_slot_template,
|
|
ctx2,
|
|
ctx2[5],
|
|
!current ? get_all_dirty_from_scope(ctx2[5]) : get_slot_changes(default_slot_template, ctx2[5], dirty, null),
|
|
null
|
|
);
|
|
}
|
|
}
|
|
if (!current || dirty & 3) {
|
|
toggle_class(button, "selected", ctx2[0] === ctx2[1]);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(default_slot, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(default_slot, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(button);
|
|
if (default_slot)
|
|
default_slot.d(detaching);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function instance5($$self, $$props, $$invalidate) {
|
|
let $selectedTab;
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
|
const tab = {};
|
|
const { registerTab, selectTab, selectedTab } = getContext(TABS);
|
|
component_subscribe($$self, selectedTab, (value) => $$invalidate(0, $selectedTab = value));
|
|
const dispatch2 = createEventDispatcher();
|
|
registerTab(tab);
|
|
const click_handler2 = () => {
|
|
selectTab(tab);
|
|
dispatch2("select");
|
|
};
|
|
$$self.$$set = ($$props2) => {
|
|
if ("$$scope" in $$props2)
|
|
$$invalidate(5, $$scope = $$props2.$$scope);
|
|
};
|
|
return [
|
|
$selectedTab,
|
|
tab,
|
|
selectTab,
|
|
selectedTab,
|
|
dispatch2,
|
|
$$scope,
|
|
slots,
|
|
click_handler2
|
|
];
|
|
}
|
|
var Tab = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance5, create_fragment5, safe_not_equal, {}, add_css5);
|
|
}
|
|
};
|
|
var Tab_default = Tab;
|
|
|
|
// src/Components/TabPanel.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function create_if_block3(ctx) {
|
|
let current;
|
|
const default_slot_template = ctx[4].default;
|
|
const default_slot = create_slot(default_slot_template, ctx, ctx[3], null);
|
|
return {
|
|
c() {
|
|
if (default_slot)
|
|
default_slot.c();
|
|
},
|
|
m(target, anchor) {
|
|
if (default_slot) {
|
|
default_slot.m(target, anchor);
|
|
}
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (default_slot) {
|
|
if (default_slot.p && (!current || dirty & 8)) {
|
|
update_slot_base(
|
|
default_slot,
|
|
default_slot_template,
|
|
ctx2,
|
|
ctx2[3],
|
|
!current ? get_all_dirty_from_scope(ctx2[3]) : get_slot_changes(default_slot_template, ctx2[3], dirty, null),
|
|
null
|
|
);
|
|
}
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(default_slot, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(default_slot, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (default_slot)
|
|
default_slot.d(detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment6(ctx) {
|
|
let if_block_anchor;
|
|
let current;
|
|
let if_block = ctx[0] === ctx[1] && create_if_block3(ctx);
|
|
return {
|
|
c() {
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (ctx2[0] === ctx2[1]) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
if (dirty & 1) {
|
|
transition_in(if_block, 1);
|
|
}
|
|
} else {
|
|
if_block = create_if_block3(ctx2);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function instance6($$self, $$props, $$invalidate) {
|
|
let $selectedPanel;
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
|
const panel = {};
|
|
const { registerPanel, selectedPanel } = getContext(TABS);
|
|
component_subscribe($$self, selectedPanel, (value) => $$invalidate(0, $selectedPanel = value));
|
|
registerPanel(panel);
|
|
$$self.$$set = ($$props2) => {
|
|
if ("$$scope" in $$props2)
|
|
$$invalidate(3, $$scope = $$props2.$$scope);
|
|
};
|
|
return [$selectedPanel, panel, selectedPanel, $$scope, slots];
|
|
}
|
|
var TabPanel = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance6, create_fragment6, safe_not_equal, {});
|
|
}
|
|
};
|
|
var TabPanel_default = TabPanel;
|
|
|
|
// src/Components/HydrusSearch.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// src/Components/Embedding.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_buffer7 = __toESM(require_buffer(), 1);
|
|
function add_css6(target) {
|
|
append_styles(target, "svelte-olzxr6", ".plaace.svelte-olzxr6.svelte-olzxr6{cursor:pointer;max-width:100vw;max-height:100vh}.unzipping.svelte-olzxr6>img.svelte-olzxr6{filter:brightness(0.5) blur(10px)}.progress.svelte-olzxr6.svelte-olzxr6{color:black;-webkit-text-stroke:0.7px white;font-weight:bold;left:50%;top:50%;font-size:larger;display:inline-block;position:absolute;z-index:10}.hoverer.svelte-olzxr6.svelte-olzxr6{display:none;position:fixed;pointer-events:none}.visible.svelte-olzxr6.svelte-olzxr6{display:block;z-index:9}.contract.svelte-olzxr6 img.svelte-olzxr6,.contract.svelte-olzxr6 video.svelte-olzxr6{max-width:125px !important;max-height:125px !important;width:auto;height:auto}.plaace.svelte-olzxr6:not(.contract) video.svelte-olzxr6,.plaace.svelte-olzxr6:not(.contract) img.svelte-olzxr6,.hoverer.svelte-olzxr6>video.svelte-olzxr6,.hoverer.svelte-olzxr6>img.svelte-olzxr6{max-width:100vw;max-height:100vh}");
|
|
}
|
|
function create_if_block4(ctx) {
|
|
let if_block_anchor;
|
|
let if_block = (!ctx[19].eye || ctx[16]) && create_if_block_1(ctx);
|
|
return {
|
|
c() {
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (!ctx2[19].eye || ctx2[16]) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block_1(ctx2);
|
|
if_block.c();
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_1(ctx) {
|
|
let div0;
|
|
let t0;
|
|
let t1;
|
|
let t2;
|
|
let div1;
|
|
let t3;
|
|
let t4;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block0 = ctx[3] && create_if_block_7(ctx);
|
|
let if_block1 = ctx[4] && create_if_block_6(ctx);
|
|
let if_block2 = ctx[2] && create_if_block_5(ctx);
|
|
let if_block3 = ctx[17] && create_if_block_4(ctx);
|
|
let if_block4 = ctx[3] && create_if_block_3(ctx);
|
|
let if_block5 = ctx[2] && create_if_block_2(ctx);
|
|
return {
|
|
c() {
|
|
div0 = element("div");
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t0 = space();
|
|
if (if_block1)
|
|
if_block1.c();
|
|
t1 = space();
|
|
if (if_block2)
|
|
if_block2.c();
|
|
t2 = space();
|
|
div1 = element("div");
|
|
if (if_block3)
|
|
if_block3.c();
|
|
t3 = space();
|
|
if (if_block4)
|
|
if_block4.c();
|
|
t4 = space();
|
|
if (if_block5)
|
|
if_block5.c();
|
|
attr(div0, "class", "plaace svelte-olzxr6");
|
|
toggle_class(div0, "contract", ctx[7]);
|
|
attr(div1, "class", "hoverer svelte-olzxr6");
|
|
toggle_class(div1, "visible", ctx[8] && ctx[7]);
|
|
toggle_class(div1, "unzipping", ctx[17]);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div0, anchor);
|
|
if (if_block0)
|
|
if_block0.m(div0, null);
|
|
append(div0, t0);
|
|
if (if_block1)
|
|
if_block1.m(div0, null);
|
|
append(div0, t1);
|
|
if (if_block2)
|
|
if_block2.m(div0, null);
|
|
ctx[31](div0);
|
|
insert(target, t2, anchor);
|
|
insert(target, div1, anchor);
|
|
if (if_block3)
|
|
if_block3.m(div1, null);
|
|
append(div1, t3);
|
|
if (if_block4)
|
|
if_block4.m(div1, null);
|
|
append(div1, t4);
|
|
if (if_block5)
|
|
if_block5.m(div1, null);
|
|
ctx[33](div1);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(div0, "click", click_handler),
|
|
listen(div0, "auxclick", auxclick_handler),
|
|
listen(div0, "mousedown", ctx[1]),
|
|
listen(div0, "mouseover", ctx[20]),
|
|
listen(div0, "mouseout", ctx[21]),
|
|
listen(div0, "mousemove", ctx[22]),
|
|
listen(div0, "wheel", ctx[23])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (ctx2[3]) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx2, dirty);
|
|
} else {
|
|
if_block0 = create_if_block_7(ctx2);
|
|
if_block0.c();
|
|
if_block0.m(div0, t0);
|
|
}
|
|
} else if (if_block0) {
|
|
if_block0.d(1);
|
|
if_block0 = null;
|
|
}
|
|
if (ctx2[4]) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx2, dirty);
|
|
} else {
|
|
if_block1 = create_if_block_6(ctx2);
|
|
if_block1.c();
|
|
if_block1.m(div0, t1);
|
|
}
|
|
} else if (if_block1) {
|
|
if_block1.d(1);
|
|
if_block1 = null;
|
|
}
|
|
if (ctx2[2]) {
|
|
if (if_block2) {
|
|
if_block2.p(ctx2, dirty);
|
|
} else {
|
|
if_block2 = create_if_block_5(ctx2);
|
|
if_block2.c();
|
|
if_block2.m(div0, null);
|
|
}
|
|
} else if (if_block2) {
|
|
if_block2.d(1);
|
|
if_block2 = null;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
toggle_class(div0, "contract", ctx2[7]);
|
|
}
|
|
if (ctx2[17]) {
|
|
if (if_block3) {
|
|
if_block3.p(ctx2, dirty);
|
|
} else {
|
|
if_block3 = create_if_block_4(ctx2);
|
|
if_block3.c();
|
|
if_block3.m(div1, t3);
|
|
}
|
|
} else if (if_block3) {
|
|
if_block3.d(1);
|
|
if_block3 = null;
|
|
}
|
|
if (ctx2[3]) {
|
|
if (if_block4) {
|
|
if_block4.p(ctx2, dirty);
|
|
} else {
|
|
if_block4 = create_if_block_3(ctx2);
|
|
if_block4.c();
|
|
if_block4.m(div1, t4);
|
|
}
|
|
} else if (if_block4) {
|
|
if_block4.d(1);
|
|
if_block4 = null;
|
|
}
|
|
if (ctx2[2]) {
|
|
if (if_block5) {
|
|
if_block5.p(ctx2, dirty);
|
|
} else {
|
|
if_block5 = create_if_block_2(ctx2);
|
|
if_block5.c();
|
|
if_block5.m(div1, null);
|
|
}
|
|
} else if (if_block5) {
|
|
if_block5.d(1);
|
|
if_block5 = null;
|
|
}
|
|
if (dirty[0] & 384) {
|
|
toggle_class(div1, "visible", ctx2[8] && ctx2[7]);
|
|
}
|
|
if (dirty[0] & 131072) {
|
|
toggle_class(div1, "unzipping", ctx2[17]);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div0);
|
|
if (if_block0)
|
|
if_block0.d();
|
|
if (if_block1)
|
|
if_block1.d();
|
|
if (if_block2)
|
|
if_block2.d();
|
|
ctx[31](null);
|
|
if (detaching)
|
|
detach(t2);
|
|
if (detaching)
|
|
detach(div1);
|
|
if (if_block3)
|
|
if_block3.d();
|
|
if (if_block4)
|
|
if_block4.d();
|
|
if (if_block5)
|
|
if_block5.d();
|
|
ctx[33](null);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_7(ctx) {
|
|
let img;
|
|
let img_alt_value;
|
|
let img_src_value;
|
|
return {
|
|
c() {
|
|
img = element("img");
|
|
attr(img, "referrerpolicy", "no-referrer");
|
|
attr(img, "alt", img_alt_value = ctx[0].filename);
|
|
if (!src_url_equal(img.src, img_src_value = ctx[15] || ctx[6]))
|
|
attr(img, "src", img_src_value);
|
|
attr(img, "class", "svelte-olzxr6");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, img, anchor);
|
|
ctx[29](img);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 1 && img_alt_value !== (img_alt_value = ctx2[0].filename)) {
|
|
attr(img, "alt", img_alt_value);
|
|
}
|
|
if (dirty[0] & 32832 && !src_url_equal(img.src, img_src_value = ctx2[15] || ctx2[6])) {
|
|
attr(img, "src", img_src_value);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(img);
|
|
ctx[29](null);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_6(ctx) {
|
|
let audio;
|
|
let source;
|
|
let source_src_value;
|
|
let audio_src_value;
|
|
let audio_loop_value;
|
|
let audio_alt_value;
|
|
return {
|
|
c() {
|
|
audio = element("audio");
|
|
source = element("source");
|
|
if (!src_url_equal(source.src, source_src_value = ctx[15] || ctx[6]))
|
|
attr(source, "src", source_src_value);
|
|
attr(source, "type", ctx[9]);
|
|
attr(audio, "referrerpolicy", "no-referrer");
|
|
audio.controls = true;
|
|
if (!src_url_equal(audio.src, audio_src_value = ctx[15] || ctx[6]))
|
|
attr(audio, "src", audio_src_value);
|
|
audio.loop = audio_loop_value = ctx[19].loop;
|
|
attr(audio, "alt", audio_alt_value = ctx[0].filename);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, audio, anchor);
|
|
append(audio, source);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 32832 && !src_url_equal(source.src, source_src_value = ctx2[15] || ctx2[6])) {
|
|
attr(source, "src", source_src_value);
|
|
}
|
|
if (dirty[0] & 512) {
|
|
attr(source, "type", ctx2[9]);
|
|
}
|
|
if (dirty[0] & 32832 && !src_url_equal(audio.src, audio_src_value = ctx2[15] || ctx2[6])) {
|
|
attr(audio, "src", audio_src_value);
|
|
}
|
|
if (dirty[0] & 524288 && audio_loop_value !== (audio_loop_value = ctx2[19].loop)) {
|
|
audio.loop = audio_loop_value;
|
|
}
|
|
if (dirty[0] & 1 && audio_alt_value !== (audio_alt_value = ctx2[0].filename)) {
|
|
attr(audio, "alt", audio_alt_value);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(audio);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_5(ctx) {
|
|
let video;
|
|
let source;
|
|
let source_src_value;
|
|
let video_loop_value;
|
|
return {
|
|
c() {
|
|
video = element("video");
|
|
source = element("source");
|
|
attr(source, "referrerpolicy", "no-referrer");
|
|
if (!src_url_equal(source.src, source_src_value = ctx[15] || ctx[6]))
|
|
attr(source, "src", source_src_value);
|
|
attr(video, "type", ctx[9]);
|
|
attr(video, "referrerpolicy", "no-referrer");
|
|
video.loop = video_loop_value = ctx[19].loop;
|
|
attr(video, "class", "svelte-olzxr6");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, video, anchor);
|
|
append(video, source);
|
|
ctx[30](video);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 32832 && !src_url_equal(source.src, source_src_value = ctx2[15] || ctx2[6])) {
|
|
attr(source, "src", source_src_value);
|
|
}
|
|
if (dirty[0] & 512) {
|
|
attr(video, "type", ctx2[9]);
|
|
}
|
|
if (dirty[0] & 524288 && video_loop_value !== (video_loop_value = ctx2[19].loop)) {
|
|
video.loop = video_loop_value;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(video);
|
|
ctx[30](null);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_4(ctx) {
|
|
let span;
|
|
let t0;
|
|
let t1_value = ctx[18][0] + "";
|
|
let t1;
|
|
let t2;
|
|
let t3_value = ctx[18][1] + "";
|
|
let t3;
|
|
let t4;
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
t0 = text("[");
|
|
t1 = text(t1_value);
|
|
t2 = text(" / ");
|
|
t3 = text(t3_value);
|
|
t4 = text("]");
|
|
attr(span, "class", "progress svelte-olzxr6");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
append(span, t0);
|
|
append(span, t1);
|
|
append(span, t2);
|
|
append(span, t3);
|
|
append(span, t4);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 262144 && t1_value !== (t1_value = ctx2[18][0] + ""))
|
|
set_data(t1, t1_value);
|
|
if (dirty[0] & 262144 && t3_value !== (t3_value = ctx2[18][1] + ""))
|
|
set_data(t3, t3_value);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_3(ctx) {
|
|
let img;
|
|
let img_alt_value;
|
|
let img_src_value;
|
|
return {
|
|
c() {
|
|
img = element("img");
|
|
attr(img, "alt", img_alt_value = ctx[0].filename);
|
|
if (!src_url_equal(img.src, img_src_value = ctx[15] || ctx[6]))
|
|
attr(img, "src", img_src_value);
|
|
attr(img, "class", "svelte-olzxr6");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, img, anchor);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 1 && img_alt_value !== (img_alt_value = ctx2[0].filename)) {
|
|
attr(img, "alt", img_alt_value);
|
|
}
|
|
if (dirty[0] & 32832 && !src_url_equal(img.src, img_src_value = ctx2[15] || ctx2[6])) {
|
|
attr(img, "src", img_src_value);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(img);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_2(ctx) {
|
|
let video;
|
|
let source;
|
|
let source_src_value;
|
|
let video_loop_value;
|
|
return {
|
|
c() {
|
|
video = element("video");
|
|
source = element("source");
|
|
attr(source, "type", ctx[9]);
|
|
if (!src_url_equal(source.src, source_src_value = ctx[15] || ctx[6]))
|
|
attr(source, "src", source_src_value);
|
|
attr(source, "data-test", "");
|
|
video.loop = video_loop_value = ctx[19].loop;
|
|
attr(video, "class", "svelte-olzxr6");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, video, anchor);
|
|
append(video, source);
|
|
ctx[32](video);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 512) {
|
|
attr(source, "type", ctx2[9]);
|
|
}
|
|
if (dirty[0] & 32832 && !src_url_equal(source.src, source_src_value = ctx2[15] || ctx2[6])) {
|
|
attr(source, "src", source_src_value);
|
|
}
|
|
if (dirty[0] & 524288 && video_loop_value !== (video_loop_value = ctx2[19].loop)) {
|
|
video.loop = video_loop_value;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(video);
|
|
ctx[32](null);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment7(ctx) {
|
|
let if_block_anchor;
|
|
let if_block = !ctx[5] && create_if_block4(ctx);
|
|
return {
|
|
c() {
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (!ctx2[5]) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block4(ctx2);
|
|
if_block.c();
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function hasAudio(video) {
|
|
return video.mozHasAudio || !!video.webkitAudioDecodedByteCount || !!(video.audioTracks && video.audioTracks.length);
|
|
}
|
|
var click_handler = (e) => e.preventDefault();
|
|
var auxclick_handler = (e) => e.preventDefault();
|
|
function instance7($$self, $$props, $$invalidate) {
|
|
let $settings;
|
|
let $appState;
|
|
component_subscribe($$self, settings, ($$value) => $$invalidate(19, $settings = $$value));
|
|
component_subscribe($$self, appState, ($$value) => $$invalidate(38, $appState = $$value));
|
|
const dispatch2 = createEventDispatcher();
|
|
let { file } = $$props;
|
|
let isVideo = false;
|
|
let isImage = false;
|
|
let isAudio = false;
|
|
let isText = false;
|
|
let url = "";
|
|
let settled = false;
|
|
let contracted = true;
|
|
let hovering = false;
|
|
let ftype = "";
|
|
let place;
|
|
let hoverElem;
|
|
let imgElem;
|
|
let videoElem;
|
|
let hoverVideo;
|
|
let dims = [0, 0];
|
|
let furl = void 0;
|
|
let visible = false;
|
|
const isNotChrome = !navigator.userAgent.includes("Chrome/");
|
|
let { id = "" } = $$props;
|
|
document.addEventListener("reveal", (e) => {
|
|
if (e.detail.id == id)
|
|
$$invalidate(16, visible = !visible);
|
|
});
|
|
function isContracted() {
|
|
return contracted;
|
|
}
|
|
let content;
|
|
beforeUpdate(async () => {
|
|
if (settled)
|
|
return;
|
|
settled = true;
|
|
const thumb = file.thumbnail || file.data;
|
|
let type;
|
|
if (typeof thumb != "string") {
|
|
let buff = thumb instanceof Uint8Array ? thumb : await thumb();
|
|
type = await fileTypeFromBuffer(buff);
|
|
if (!type && file.filename.endsWith(".txt") && file.filename.startsWith("message")) {
|
|
type = { ext: "txt", mime: "text/plain" };
|
|
}
|
|
content = new Blob([buff], { type: type?.mime });
|
|
$$invalidate(6, url = URL.createObjectURL(content));
|
|
if (!type)
|
|
return;
|
|
} else {
|
|
let head = await getHeaders(thumb);
|
|
$$invalidate(6, url = thumb);
|
|
type = {
|
|
ext: "",
|
|
mime: head["content-type"].split(";")[0].trim()
|
|
};
|
|
}
|
|
$$invalidate(9, ftype = type.mime);
|
|
$$invalidate(2, isVideo = type.mime.startsWith("video/"));
|
|
$$invalidate(4, isAudio = type.mime.startsWith("audio/"));
|
|
$$invalidate(3, isImage = type.mime.startsWith("image/"));
|
|
$$invalidate(5, isText = type.mime.startsWith("text/plain"));
|
|
dispatch2("fileinfo", { type });
|
|
if (isImage) {
|
|
$$invalidate(7, contracted = !$settings.xpi);
|
|
}
|
|
if (isVideo) {
|
|
$$invalidate(7, contracted = !$settings.xpv && !$appState.isCatalog);
|
|
}
|
|
if ($appState.isCatalog)
|
|
$$invalidate(7, contracted = true);
|
|
if ($settings.pre) {
|
|
unzip();
|
|
}
|
|
if ($settings.prev) {
|
|
let obs = new IntersectionObserver(
|
|
(entries, obs2) => {
|
|
for (const item of entries) {
|
|
if (!item.isIntersecting)
|
|
continue;
|
|
unzip();
|
|
obs2.unobserve(place);
|
|
}
|
|
},
|
|
{
|
|
root: null,
|
|
rootMargin: "0px",
|
|
threshold: 0.01
|
|
}
|
|
);
|
|
obs.observe(place);
|
|
}
|
|
});
|
|
let unzipping = false;
|
|
let progress = [0, 0];
|
|
async function unzip() {
|
|
if (!file.thumbnail)
|
|
return;
|
|
if (unzipping)
|
|
return;
|
|
let type;
|
|
if (typeof file.data != "string") {
|
|
$$invalidate(17, unzipping = true);
|
|
let lisn = new peeTarget();
|
|
lisn.addEventListener("progress", (e) => {
|
|
$$invalidate(18, progress = e.detail);
|
|
});
|
|
let full = file.data instanceof Uint8Array ? file.data : await file.data(lisn);
|
|
type = await fileTypeFromBuffer(full);
|
|
if (!type && file.filename.endsWith(".txt") && file.filename.startsWith("message")) {
|
|
type = { ext: "txt", mime: "text/plain" };
|
|
}
|
|
content = new Blob([full], { type: type?.mime });
|
|
$$invalidate(15, furl = URL.createObjectURL(content));
|
|
} else {
|
|
$$invalidate(6, url = file.data);
|
|
$$invalidate(15, furl = file.data);
|
|
let head = await getHeaders(file.data);
|
|
type = {
|
|
ext: "",
|
|
mime: head["content-type"].split(";")[0].trim()
|
|
};
|
|
}
|
|
if (!type)
|
|
return;
|
|
$$invalidate(9, ftype = type.mime);
|
|
$$invalidate(2, isVideo = type.mime.startsWith("video/"));
|
|
$$invalidate(4, isAudio = type.mime.startsWith("audio/"));
|
|
$$invalidate(3, isImage = type.mime.startsWith("image/"));
|
|
$$invalidate(5, isText = type.mime.startsWith("text/plain"));
|
|
$$invalidate(17, unzipping = false);
|
|
dispatch2("fileinfo", { type });
|
|
if (hovering) {
|
|
setTimeout(
|
|
async () => {
|
|
do {
|
|
hoverUpdate();
|
|
await new Promise((_) => setTimeout(_, 20));
|
|
} while (dims[0] == 0 && dims[1] == 0);
|
|
},
|
|
20
|
|
);
|
|
}
|
|
}
|
|
let { inhibitExpand = false } = $$props;
|
|
async function bepis(ev) {
|
|
dispatch2("click", ev);
|
|
if (inhibitExpand)
|
|
return;
|
|
if ($appState.isCatalog)
|
|
return;
|
|
if (ev.button == 0) {
|
|
$$invalidate(7, contracted = !contracted);
|
|
if (hovering)
|
|
hoverStop();
|
|
if (contracted && isVideo) {
|
|
$$invalidate(13, videoElem.controls = false, videoElem);
|
|
videoElem.pause();
|
|
}
|
|
if (!contracted && isVideo) {
|
|
$$invalidate(13, videoElem.controls = true, videoElem);
|
|
setTimeout(
|
|
async () => {
|
|
$$invalidate(13, videoElem.currentTime = hoverVideo.currentTime || 0, videoElem);
|
|
await videoElem.play();
|
|
},
|
|
10
|
|
);
|
|
}
|
|
if (file.thumbnail && !furl) {
|
|
unzip();
|
|
}
|
|
ev.preventDefault();
|
|
} else if (ev.button == 1) {
|
|
let src = furl || url;
|
|
if (ev.altKey && file.source) {
|
|
src = file.source;
|
|
}
|
|
if (ev.shiftKey && file.page) {
|
|
src = file.page.url;
|
|
}
|
|
ev.preventDefault();
|
|
if (isNotChrome) {
|
|
window.open(src, "_blank");
|
|
} else
|
|
await Platform.openInTab(src, { active: false, insert: true });
|
|
}
|
|
}
|
|
const getViewport = () => (typeof visualViewport != "undefined" ? () => [visualViewport.width, visualViewport.height] : () => [document.documentElement.clientWidth, document.documentElement.clientHeight])();
|
|
function recompute() {
|
|
const [sw, sh] = getViewport();
|
|
let [iw, ih] = [0, 0];
|
|
if (isImage) {
|
|
[iw, ih] = [imgElem.naturalWidth, imgElem.naturalHeight];
|
|
} else if (isVideo) {
|
|
[iw, ih] = [videoElem.videoWidth, videoElem.videoHeight];
|
|
}
|
|
let scale = Math.min(1, sw / iw, sh / ih);
|
|
dims = [~~(iw * scale), ~~(ih * scale)];
|
|
$$invalidate(11, hoverElem.style.width = `${dims[0]}px`, hoverElem);
|
|
$$invalidate(11, hoverElem.style.height = `${dims[1]}px`, hoverElem);
|
|
}
|
|
async function hoverStart(ev) {
|
|
if (!(isVideo || isImage))
|
|
return;
|
|
if ($settings.dh)
|
|
return;
|
|
if (file.thumbnail && !furl) {
|
|
unzip();
|
|
}
|
|
if (!isImage && !isVideo)
|
|
return;
|
|
if (!contracted)
|
|
return;
|
|
recompute();
|
|
$$invalidate(8, hovering = true);
|
|
if (isVideo) {
|
|
try {
|
|
await hoverVideo.play();
|
|
} catch (e) {
|
|
$$invalidate(14, hoverVideo.muted = true, hoverVideo);
|
|
$$invalidate(14, hoverVideo.volume = 0, hoverVideo);
|
|
await hoverVideo.play();
|
|
}
|
|
}
|
|
}
|
|
function hoverStop(ev) {
|
|
if ($settings.dh)
|
|
return;
|
|
$$invalidate(8, hovering = false);
|
|
if (isVideo)
|
|
hoverVideo.pause();
|
|
}
|
|
let lastev;
|
|
function hoverUpdate(ev) {
|
|
lastev = lastev || ev;
|
|
if ($settings.dh)
|
|
return;
|
|
if (!contracted)
|
|
return;
|
|
if (!(isVideo || isImage))
|
|
return;
|
|
recompute();
|
|
const [sw, sh] = [visualViewport.width, visualViewport.height];
|
|
if (dims[0] == 0 && dims[1] == 0)
|
|
recompute();
|
|
let width = dims[0];
|
|
let height = dims[1] + 25;
|
|
let { clientX, clientY } = ev || lastev;
|
|
let top = Math.max(0, clientY * (sh - height) / sh);
|
|
let threshold = sw / 2;
|
|
let marginX = (clientX <= threshold ? clientX : sw - clientX) + 45;
|
|
marginX = Math.min(marginX, sw - width);
|
|
marginX = marginX + "px";
|
|
let [left, right] = clientX <= threshold ? [marginX, ""] : ["", marginX];
|
|
let { style } = hoverElem;
|
|
style.top = top + "px";
|
|
style.left = left;
|
|
style.right = right;
|
|
}
|
|
function adjustAudio(ev) {
|
|
if (!$settings.ca)
|
|
return;
|
|
if (!isVideo)
|
|
return;
|
|
if ($settings.dh && contracted)
|
|
return;
|
|
if (!hasAudio(videoElem))
|
|
return;
|
|
let vol = videoElem.volume * (ev.deltaY > 0 ? 0.9 : 1.1);
|
|
vol = Math.max(0, Math.min(1, vol));
|
|
$$invalidate(13, videoElem.volume = vol, videoElem);
|
|
$$invalidate(14, hoverVideo.volume = videoElem.volume, hoverVideo);
|
|
$$invalidate(14, hoverVideo.muted = vol < 0, hoverVideo);
|
|
ev.preventDefault();
|
|
}
|
|
function img_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
imgElem = $$value;
|
|
$$invalidate(12, imgElem);
|
|
});
|
|
}
|
|
function video_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
videoElem = $$value;
|
|
$$invalidate(13, videoElem);
|
|
});
|
|
}
|
|
function div0_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
place = $$value;
|
|
$$invalidate(10, place);
|
|
});
|
|
}
|
|
function video_binding_1($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
hoverVideo = $$value;
|
|
$$invalidate(14, hoverVideo);
|
|
});
|
|
}
|
|
function div1_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
hoverElem = $$value;
|
|
$$invalidate(11, hoverElem);
|
|
});
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("file" in $$props2)
|
|
$$invalidate(0, file = $$props2.file);
|
|
if ("id" in $$props2)
|
|
$$invalidate(26, id = $$props2.id);
|
|
if ("inhibitExpand" in $$props2)
|
|
$$invalidate(28, inhibitExpand = $$props2.inhibitExpand);
|
|
};
|
|
return [
|
|
file,
|
|
bepis,
|
|
isVideo,
|
|
isImage,
|
|
isAudio,
|
|
isText,
|
|
url,
|
|
contracted,
|
|
hovering,
|
|
ftype,
|
|
place,
|
|
hoverElem,
|
|
imgElem,
|
|
videoElem,
|
|
hoverVideo,
|
|
furl,
|
|
visible,
|
|
unzipping,
|
|
progress,
|
|
$settings,
|
|
hoverStart,
|
|
hoverStop,
|
|
hoverUpdate,
|
|
adjustAudio,
|
|
dispatch2,
|
|
isNotChrome,
|
|
id,
|
|
isContracted,
|
|
inhibitExpand,
|
|
img_binding,
|
|
video_binding,
|
|
div0_binding,
|
|
video_binding_1,
|
|
div1_binding
|
|
];
|
|
}
|
|
var Embedding = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(
|
|
this,
|
|
options,
|
|
instance7,
|
|
create_fragment7,
|
|
safe_not_equal,
|
|
{
|
|
dispatch: 24,
|
|
file: 0,
|
|
isNotChrome: 25,
|
|
id: 26,
|
|
isContracted: 27,
|
|
inhibitExpand: 28,
|
|
bepis: 1
|
|
},
|
|
add_css6,
|
|
[-1, -1]
|
|
);
|
|
}
|
|
get dispatch() {
|
|
return this.$$.ctx[24];
|
|
}
|
|
get file() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set file(file) {
|
|
this.$$set({ file });
|
|
flush();
|
|
}
|
|
get isNotChrome() {
|
|
return this.$$.ctx[25];
|
|
}
|
|
get id() {
|
|
return this.$$.ctx[26];
|
|
}
|
|
set id(id) {
|
|
this.$$set({ id });
|
|
flush();
|
|
}
|
|
get isContracted() {
|
|
return this.$$.ctx[27];
|
|
}
|
|
get inhibitExpand() {
|
|
return this.$$.ctx[28];
|
|
}
|
|
set inhibitExpand(inhibitExpand) {
|
|
this.$$set({ inhibitExpand });
|
|
flush();
|
|
}
|
|
get bepis() {
|
|
return this.$$.ctx[1];
|
|
}
|
|
};
|
|
var Embedding_default = Embedding;
|
|
|
|
// src/Components/HydrusSearch.svelte
|
|
function add_css7(target) {
|
|
append_styles(target, "svelte-1qi3e99", ".results.svelte-1qi3e99.svelte-1qi3e99{display:flex;flex-wrap:wrap;max-height:30vh;gap:10px;overflow-y:auto;align-items:center;justify-content:center}.tagcont.svelte-1qi3e99.svelte-1qi3e99{display:flex;gap:5px}.cont.svelte-1qi3e99.svelte-1qi3e99{display:flex;flex-direction:column;gap:10px}details.svelte-1qi3e99.svelte-1qi3e99{border:1px solid #aaa;border-radius:4px;padding:0.5em 0.5em 0}summary.svelte-1qi3e99.svelte-1qi3e99{font-weight:bold;margin:-0.5em -0.5em 0;padding:0.5em;cursor:pointer}details[open].svelte-1qi3e99.svelte-1qi3e99{padding:0.5em}details[open].svelte-1qi3e99 summary.svelte-1qi3e99{border-bottom:1px solid #aaa;margin-bottom:0.5em}");
|
|
}
|
|
function get_each_context(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[10] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function get_each_context_1(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[13] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function create_each_block_1(ctx) {
|
|
let tag;
|
|
let current;
|
|
function toggle_handler() {
|
|
return ctx[7](ctx[13]);
|
|
}
|
|
tag = new Tag_default({ props: { tag: ctx[13] } });
|
|
tag.$on("toggle", toggle_handler);
|
|
return {
|
|
c() {
|
|
create_component(tag.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(tag, target, anchor);
|
|
current = true;
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
const tag_changes = {};
|
|
if (dirty & 1)
|
|
tag_changes.tag = ctx[13];
|
|
tag.$set(tag_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(tag.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(tag.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(tag, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_else_block(ctx) {
|
|
let div;
|
|
let each_blocks = [];
|
|
let each_1_lookup = /* @__PURE__ */ new Map();
|
|
let current;
|
|
let each_value = ctx[2];
|
|
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 key2 = get_key(child_ctx);
|
|
each_1_lookup.set(key2, each_blocks[i] = create_each_block(key2, child_ctx));
|
|
}
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(div, "class", "results svelte-1qi3e99");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div, null);
|
|
}
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty & 36) {
|
|
each_value = ctx2[2];
|
|
group_outros();
|
|
each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx2, each_value, each_1_lookup, div, outro_and_destroy_block, create_each_block, null, get_each_context);
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function create_if_block5(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("Loading...");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
p: noop,
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block(key_1, ctx) {
|
|
let first;
|
|
let embedding;
|
|
let current;
|
|
function click_handler2(...args) {
|
|
return ctx[8](ctx[10], ...args);
|
|
}
|
|
embedding = new Embedding_default({
|
|
props: {
|
|
inhibitExpand: true,
|
|
id: "only",
|
|
file: ctx[10][1]
|
|
}
|
|
});
|
|
embedding.$on("click", click_handler2);
|
|
return {
|
|
key: key_1,
|
|
first: null,
|
|
c() {
|
|
first = empty();
|
|
create_component(embedding.$$.fragment);
|
|
this.first = first;
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, first, anchor);
|
|
mount_component(embedding, target, anchor);
|
|
current = true;
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
const embedding_changes = {};
|
|
if (dirty & 4)
|
|
embedding_changes.file = ctx[10][1];
|
|
embedding.$set(embedding_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(embedding.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(embedding.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(first);
|
|
destroy_component(embedding, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment8(ctx) {
|
|
let div1;
|
|
let input;
|
|
let t0;
|
|
let details;
|
|
let t5;
|
|
let div0;
|
|
let t6;
|
|
let current_block_type_index;
|
|
let if_block;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
let each_value_1 = ctx[0];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value_1.length; i += 1) {
|
|
each_blocks[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i));
|
|
}
|
|
const out = (i) => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
const if_block_creators = [create_if_block5, create_else_block];
|
|
const if_blocks = [];
|
|
function select_block_type(ctx2, dirty) {
|
|
if (ctx2[1])
|
|
return 0;
|
|
return 1;
|
|
}
|
|
current_block_type_index = select_block_type(ctx, -1);
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
return {
|
|
c() {
|
|
div1 = element("div");
|
|
input = element("input");
|
|
t0 = space();
|
|
details = element("details");
|
|
details.innerHTML = `<summary class="svelte-1qi3e99">Tips</summary>
|
|
Press enter without entering a tag to refresh. <br/>
|
|
Files are picked randomly <br/>
|
|
Click on a file to embed it <br/>`;
|
|
t5 = space();
|
|
div0 = element("div");
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
t6 = space();
|
|
if_block.c();
|
|
attr(input, "type", "text");
|
|
attr(input, "placeholder", "Input a tag here, then press enter");
|
|
attr(details, "class", "svelte-1qi3e99");
|
|
attr(div0, "class", "tagcont svelte-1qi3e99");
|
|
attr(div1, "class", "cont svelte-1qi3e99");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, input);
|
|
append(div1, t0);
|
|
append(div1, details);
|
|
append(div1, t5);
|
|
append(div1, div0);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div0, null);
|
|
}
|
|
append(div1, t6);
|
|
if_blocks[current_block_type_index].m(div1, null);
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = listen(input, "keydown", ctx[6]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 9) {
|
|
each_value_1 = ctx2[0];
|
|
let i;
|
|
for (i = 0; i < each_value_1.length; i += 1) {
|
|
const child_ctx = get_each_context_1(ctx2, each_value_1, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block_1(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(div0, null);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value_1.length; i < each_blocks.length; i += 1) {
|
|
out(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
let previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type(ctx2, dirty);
|
|
if (current_block_type_index === previous_block_index) {
|
|
if_blocks[current_block_type_index].p(ctx2, dirty);
|
|
} else {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
if_block = if_blocks[current_block_type_index];
|
|
if (!if_block) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
|
|
if_block.c();
|
|
} else {
|
|
if_block.p(ctx2, dirty);
|
|
}
|
|
transition_in(if_block, 1);
|
|
if_block.m(div1, null);
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
for (let i = 0; i < each_value_1.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div1);
|
|
destroy_each(each_blocks, detaching);
|
|
if_blocks[current_block_type_index].d();
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function instance8($$self, $$props, $$invalidate) {
|
|
let $appState;
|
|
component_subscribe($$self, appState, ($$value) => $$invalidate(9, $appState = $$value));
|
|
let tags = [];
|
|
let loading = false;
|
|
function removeTag(t) {
|
|
$$invalidate(0, tags = tags.filter((e) => e != t));
|
|
update2();
|
|
}
|
|
let maps = [];
|
|
async function update2() {
|
|
$$invalidate(1, loading = true);
|
|
if ($appState.client) {
|
|
try {
|
|
if (tags.length == 0) {
|
|
$$invalidate(2, maps = []);
|
|
$$invalidate(1, loading = false);
|
|
return;
|
|
}
|
|
$$invalidate(2, maps = await getFileFromHydrus($appState.client, tags.concat(["system:limit=32"]), { file_sort_type: 4 }));
|
|
} catch {
|
|
}
|
|
}
|
|
$$invalidate(1, loading = false);
|
|
}
|
|
onMount(() => {
|
|
return update2();
|
|
});
|
|
const handleEv = (ev, ef) => {
|
|
if (ev.detail.button == 0) {
|
|
return addToEmbeds(ef);
|
|
}
|
|
};
|
|
const keydown_handler = (ev) => {
|
|
if (ev.key == "Enter") {
|
|
if (ev.currentTarget.value)
|
|
$$invalidate(0, tags = [...tags, ev.currentTarget.value]);
|
|
ev.currentTarget.value = "";
|
|
update2();
|
|
}
|
|
};
|
|
const toggle_handler = (tag) => removeTag(tag);
|
|
const click_handler2 = (map, ev) => handleEv(ev, map[1]);
|
|
return [
|
|
tags,
|
|
loading,
|
|
maps,
|
|
removeTag,
|
|
update2,
|
|
handleEv,
|
|
keydown_handler,
|
|
toggle_handler,
|
|
click_handler2
|
|
];
|
|
}
|
|
var HydrusSearch = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance8, create_fragment8, safe_not_equal, {}, add_css7);
|
|
}
|
|
};
|
|
var HydrusSearch_default = HydrusSearch;
|
|
|
|
// src/Components/App.svelte
|
|
function add_css8(target) {
|
|
append_styles(target, "svelte-15t7t1d", '.bepis.svelte-15t7t1d.svelte-15t7t1d{max-height:260px;overflow-y:auto}.tagcont.svelte-15t7t1d.svelte-15t7t1d{display:flex;gap:5px;margin-bottom:10px;flex-wrap:wrap}label.svelte-15t7t1d>input[type="text"].svelte-15t7t1d,label.svelte-15t7t1d>input[type="number"].svelte-15t7t1d{width:95%}.content.svelte-15t7t1d.svelte-15t7t1d{display:flex;flex-direction:column}.error.svelte-15t7t1d.svelte-15t7t1d{color:red}hr.svelte-15t7t1d.svelte-15t7t1d{width:100%}h1.svelte-15t7t1d.svelte-15t7t1d{text-align:center;margin-bottom:0}h4.svelte-15t7t1d.svelte-15t7t1d{text-align:center;margin:0}.form.svelte-15t7t1d.svelte-15t7t1d{display:flex;flex-direction:column;gap:20px;position:absolute;padding:15px;border:1px solid white;background-color:black;border-radius:10px}.form.svelte-15t7t1d>label.svelte-15t7t1d{display:flex;flex-direction:column;gap:10px}.newsbox.svelte-15t7t1d.svelte-15t7t1d{max-height:300px;overflow-y:scroll}.backpanel.svelte-15t7t1d.svelte-15t7t1d{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}.loading.svelte-15t7t1d.svelte-15t7t1d{position:absolute;right:32px;padding:10px;bottom:32px;border:1px solid;border-radius:10px;background-color:rgba(0, 0, 0, 0.8);pointer-events:all;backdrop-filter:blur(9px)}');
|
|
}
|
|
function get_each_context2(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[60] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function get_each_context_12(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[63] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function get_each_context_2(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[66] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function get_each_context_3(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[69] = list[i];
|
|
child_ctx[71] = i;
|
|
return child_ctx;
|
|
}
|
|
function get_each_context_4(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[72] = list[i];
|
|
child_ctx[71] = i;
|
|
return child_ctx;
|
|
}
|
|
function get_each_context_5(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[74] = list[i];
|
|
child_ctx[71] = i;
|
|
return child_ctx;
|
|
}
|
|
function create_if_block_13(ctx) {
|
|
let div;
|
|
let t0;
|
|
let t1_value = ctx[8].processed + "";
|
|
let t1;
|
|
let t2;
|
|
let t3_value = ctx[8].processing + "";
|
|
let t3;
|
|
let t4;
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
t0 = text("PEE Loading... (");
|
|
t1 = text(t1_value);
|
|
t2 = text(" / ");
|
|
t3 = text(t3_value);
|
|
t4 = text(")");
|
|
attr(div, "class", "loading svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, t0);
|
|
append(div, t1);
|
|
append(div, t2);
|
|
append(div, t3);
|
|
append(div, t4);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 256 && t1_value !== (t1_value = ctx2[8].processed + ""))
|
|
set_data(t1, t1_value);
|
|
if (dirty[0] & 256 && t3_value !== (t3_value = ctx2[8].processing + ""))
|
|
set_data(t3, t3_value);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block6(ctx) {
|
|
let div1;
|
|
let div0;
|
|
let h1;
|
|
let t0;
|
|
let t1;
|
|
let t2;
|
|
let h4;
|
|
let t4;
|
|
let hr;
|
|
let t5;
|
|
let tabs;
|
|
let div1_transition;
|
|
let current;
|
|
tabs = new Tabs_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
h1 = element("h1");
|
|
t0 = text("PEE Settings 0.");
|
|
t1 = text(ctx[0]);
|
|
t2 = space();
|
|
h4 = element("h4");
|
|
h4.innerHTML = `<a href="https://2chen.moe/tech/">Join us on 2chen!</a>`;
|
|
t4 = space();
|
|
hr = element("hr");
|
|
t5 = space();
|
|
create_component(tabs.$$.fragment);
|
|
attr(h1, "class", "svelte-15t7t1d");
|
|
attr(h4, "class", "svelte-15t7t1d");
|
|
attr(hr, "class", "svelte-15t7t1d");
|
|
attr(div0, "class", "content svelte-15t7t1d");
|
|
attr(div1, "class", "backpanel svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, div0);
|
|
append(div0, h1);
|
|
append(h1, t0);
|
|
append(h1, t1);
|
|
append(div0, t2);
|
|
append(div0, h4);
|
|
append(div0, t4);
|
|
append(div0, hr);
|
|
append(div0, t5);
|
|
mount_component(tabs, div0, null);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (!current || dirty[0] & 1)
|
|
set_data(t1, ctx2[0]);
|
|
const tabs_changes = {};
|
|
if (dirty[0] & 1006 | dirty[2] & 16384) {
|
|
tabs_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tabs.$set(tabs_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(tabs.$$.fragment, local);
|
|
add_render_callback(() => {
|
|
if (!div1_transition)
|
|
div1_transition = create_bidirectional_transition(div1, slide, {}, true);
|
|
div1_transition.run(1);
|
|
});
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(tabs.$$.fragment, local);
|
|
if (!div1_transition)
|
|
div1_transition = create_bidirectional_transition(div1, slide, {}, false);
|
|
div1_transition.run(0);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div1);
|
|
destroy_component(tabs);
|
|
if (detaching && div1_transition)
|
|
div1_transition.end();
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_16(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("General");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_15(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("External");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_14(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("File Host");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_13(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("Thread Watcher");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_12(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("Reminder");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_11(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("Advanced");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_12(ctx) {
|
|
let tab;
|
|
let current;
|
|
tab = new Tab_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_10] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(tab.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(tab, target, anchor);
|
|
current = true;
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(tab.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(tab.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(tab, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_10(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("Hydrus");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_9(ctx) {
|
|
let tab0;
|
|
let t0;
|
|
let tab1;
|
|
let t1;
|
|
let tab2;
|
|
let t2;
|
|
let tab3;
|
|
let t3;
|
|
let tab4;
|
|
let t4;
|
|
let tab5;
|
|
let t5;
|
|
let if_block_anchor;
|
|
let current;
|
|
tab0 = new Tab_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_16] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tab1 = new Tab_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_15] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tab2 = new Tab_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_14] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tab3 = new Tab_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_13] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tab3.$on("select", ctx[19]);
|
|
tab4 = new Tab_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_12] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tab4.$on("select", ctx[20]);
|
|
tab5 = new Tab_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_11] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
let if_block = ctx[8].akValid && create_if_block_12(ctx);
|
|
return {
|
|
c() {
|
|
create_component(tab0.$$.fragment);
|
|
t0 = space();
|
|
create_component(tab1.$$.fragment);
|
|
t1 = space();
|
|
create_component(tab2.$$.fragment);
|
|
t2 = space();
|
|
create_component(tab3.$$.fragment);
|
|
t3 = space();
|
|
create_component(tab4.$$.fragment);
|
|
t4 = space();
|
|
create_component(tab5.$$.fragment);
|
|
t5 = space();
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(tab0, target, anchor);
|
|
insert(target, t0, anchor);
|
|
mount_component(tab1, target, anchor);
|
|
insert(target, t1, anchor);
|
|
mount_component(tab2, target, anchor);
|
|
insert(target, t2, anchor);
|
|
mount_component(tab3, target, anchor);
|
|
insert(target, t3, anchor);
|
|
mount_component(tab4, target, anchor);
|
|
insert(target, t4, anchor);
|
|
mount_component(tab5, target, anchor);
|
|
insert(target, t5, anchor);
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const tab0_changes = {};
|
|
if (dirty[2] & 16384) {
|
|
tab0_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tab0.$set(tab0_changes);
|
|
const tab1_changes = {};
|
|
if (dirty[2] & 16384) {
|
|
tab1_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tab1.$set(tab1_changes);
|
|
const tab2_changes = {};
|
|
if (dirty[2] & 16384) {
|
|
tab2_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tab2.$set(tab2_changes);
|
|
const tab3_changes = {};
|
|
if (dirty[2] & 16384) {
|
|
tab3_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tab3.$set(tab3_changes);
|
|
const tab4_changes = {};
|
|
if (dirty[2] & 16384) {
|
|
tab4_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tab4.$set(tab4_changes);
|
|
const tab5_changes = {};
|
|
if (dirty[2] & 16384) {
|
|
tab5_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tab5.$set(tab5_changes);
|
|
if (ctx2[8].akValid) {
|
|
if (if_block) {
|
|
if (dirty[0] & 256) {
|
|
transition_in(if_block, 1);
|
|
}
|
|
} else {
|
|
if_block = create_if_block_12(ctx2);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(tab0.$$.fragment, local);
|
|
transition_in(tab1.$$.fragment, local);
|
|
transition_in(tab2.$$.fragment, local);
|
|
transition_in(tab3.$$.fragment, local);
|
|
transition_in(tab4.$$.fragment, local);
|
|
transition_in(tab5.$$.fragment, local);
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(tab0.$$.fragment, local);
|
|
transition_out(tab1.$$.fragment, local);
|
|
transition_out(tab2.$$.fragment, local);
|
|
transition_out(tab3.$$.fragment, local);
|
|
transition_out(tab4.$$.fragment, local);
|
|
transition_out(tab5.$$.fragment, local);
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(tab0, detaching);
|
|
if (detaching)
|
|
detach(t0);
|
|
destroy_component(tab1, detaching);
|
|
if (detaching)
|
|
detach(t1);
|
|
destroy_component(tab2, detaching);
|
|
if (detaching)
|
|
detach(t2);
|
|
destroy_component(tab3, detaching);
|
|
if (detaching)
|
|
detach(t3);
|
|
destroy_component(tab4, detaching);
|
|
if (detaching)
|
|
detach(t4);
|
|
destroy_component(tab5, detaching);
|
|
if (detaching)
|
|
detach(t5);
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_11(ctx) {
|
|
let label;
|
|
let input;
|
|
let t;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
label = element("label");
|
|
input = element("input");
|
|
t = text("\n Hide original content when hidden content is visible.");
|
|
attr(input, "type", "checkbox");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, label, anchor);
|
|
append(label, input);
|
|
input.checked = ctx[7].ho;
|
|
append(label, t);
|
|
if (!mounted) {
|
|
dispose = listen(input, "change", ctx[30]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 128) {
|
|
input.checked = ctx2[7].ho;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(label);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_8(ctx) {
|
|
let t0;
|
|
let label;
|
|
let t1;
|
|
let a;
|
|
let t3;
|
|
let input;
|
|
let t4;
|
|
let if_block1_anchor;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block0 = ctx[8].herror && create_if_block_10(ctx);
|
|
let if_block1 = ctx[8].akValid && create_if_block_9(ctx);
|
|
return {
|
|
c() {
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t0 = space();
|
|
label = element("label");
|
|
t1 = text("Hydrus Access Key\n \n ");
|
|
a = element("a");
|
|
a.textContent = "?";
|
|
t3 = space();
|
|
input = element("input");
|
|
t4 = space();
|
|
if (if_block1)
|
|
if_block1.c();
|
|
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-15t7t1d");
|
|
attr(label, "class", "svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block0)
|
|
if_block0.m(target, anchor);
|
|
insert(target, t0, anchor);
|
|
insert(target, label, anchor);
|
|
append(label, t1);
|
|
append(label, a);
|
|
append(label, t3);
|
|
append(label, input);
|
|
set_input_value(input, ctx[7].ak);
|
|
insert(target, t4, anchor);
|
|
if (if_block1)
|
|
if_block1.m(target, anchor);
|
|
insert(target, if_block1_anchor, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(input, "input", ctx[38]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (ctx2[8].herror) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx2, dirty);
|
|
} else {
|
|
if_block0 = create_if_block_10(ctx2);
|
|
if_block0.c();
|
|
if_block0.m(t0.parentNode, t0);
|
|
}
|
|
} else if (if_block0) {
|
|
if_block0.d(1);
|
|
if_block0 = null;
|
|
}
|
|
if (dirty[0] & 128 && input.value !== ctx2[7].ak) {
|
|
set_input_value(input, ctx2[7].ak);
|
|
}
|
|
if (ctx2[8].akValid) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx2, dirty);
|
|
} else {
|
|
if_block1 = create_if_block_9(ctx2);
|
|
if_block1.c();
|
|
if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
|
|
}
|
|
} else if (if_block1) {
|
|
if_block1.d(1);
|
|
if_block1 = null;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (if_block0)
|
|
if_block0.d(detaching);
|
|
if (detaching)
|
|
detach(t0);
|
|
if (detaching)
|
|
detach(label);
|
|
if (detaching)
|
|
detach(t4);
|
|
if (if_block1)
|
|
if_block1.d(detaching);
|
|
if (detaching)
|
|
detach(if_block1_anchor);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_10(ctx) {
|
|
let span;
|
|
let t_value = ctx[8].herror + "";
|
|
let t;
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
t = text(t_value);
|
|
attr(span, "class", "error svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
append(span, t);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 256 && t_value !== (t_value = ctx2[8].herror + ""))
|
|
set_data(t, t_value);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_9(ctx) {
|
|
let label0;
|
|
let t0;
|
|
let input0;
|
|
let t1;
|
|
let t2;
|
|
let label1;
|
|
let input1;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
label0 = element("label");
|
|
t0 = text("Auto-embed ");
|
|
input0 = element("input");
|
|
t1 = text("\n random files");
|
|
t2 = space();
|
|
label1 = element("label");
|
|
input1 = element("input");
|
|
set_style(input0, "width", "5ch");
|
|
attr(input0, "type", "number");
|
|
attr(input0, "class", "svelte-15t7t1d");
|
|
attr(label0, "class", "svelte-15t7t1d");
|
|
attr(input1, "placeholder", "Restrict to these tags (space to separate tags, _ to separate words)");
|
|
attr(input1, "type", "text");
|
|
attr(input1, "class", "svelte-15t7t1d");
|
|
attr(label1, "class", "svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, label0, anchor);
|
|
append(label0, t0);
|
|
append(label0, input0);
|
|
set_input_value(input0, ctx[7].auto_embed);
|
|
append(label0, t1);
|
|
insert(target, t2, anchor);
|
|
insert(target, label1, anchor);
|
|
append(label1, input1);
|
|
set_input_value(input1, ctx[7].auto_tags);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(input0, "input", ctx[39]),
|
|
listen(input1, "input", ctx[40])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 128 && to_number(input0.value) !== ctx2[7].auto_embed) {
|
|
set_input_value(input0, ctx2[7].auto_embed);
|
|
}
|
|
if (dirty[0] & 128 && input1.value !== ctx2[7].auto_tags) {
|
|
set_input_value(input1, ctx2[7].auto_tags);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(label0);
|
|
if (detaching)
|
|
detach(t2);
|
|
if (detaching)
|
|
detach(label1);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_8(ctx) {
|
|
let label0;
|
|
let input0;
|
|
let t0;
|
|
let t1;
|
|
let label1;
|
|
let input1;
|
|
let t2;
|
|
let t3;
|
|
let label2;
|
|
let input2;
|
|
let t4;
|
|
let t5;
|
|
let label3;
|
|
let input3;
|
|
let t6;
|
|
let t7;
|
|
let label4;
|
|
let input4;
|
|
let t8;
|
|
let t9;
|
|
let label5;
|
|
let input5;
|
|
let t10;
|
|
let t11;
|
|
let label6;
|
|
let input6;
|
|
let t12;
|
|
let t13;
|
|
let label7;
|
|
let input7;
|
|
let t14;
|
|
let t15;
|
|
let label8;
|
|
let input8;
|
|
let t16;
|
|
let t17;
|
|
let t18;
|
|
let label9;
|
|
let input9;
|
|
let t19;
|
|
let t20;
|
|
let label10;
|
|
let input10;
|
|
let t21;
|
|
let t22;
|
|
let label11;
|
|
let input11;
|
|
let t23;
|
|
let t24;
|
|
let label12;
|
|
let input12;
|
|
let t25;
|
|
let t26;
|
|
let label13;
|
|
let input13;
|
|
let t27;
|
|
let t28;
|
|
let label14;
|
|
let input14;
|
|
let t29;
|
|
let a;
|
|
let t31;
|
|
let label15;
|
|
let input15;
|
|
let t32;
|
|
let t33;
|
|
let if_block1_anchor;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block0 = ctx[7].eye && create_if_block_11(ctx);
|
|
let if_block1 = ctx[7].hyd && create_if_block_8(ctx);
|
|
return {
|
|
c() {
|
|
label0 = element("label");
|
|
input0 = element("input");
|
|
t0 = text("\n Disable loading on catalog");
|
|
t1 = space();
|
|
label1 = element("label");
|
|
input1 = element("input");
|
|
t2 = text("\n Try to load embeds from server cache");
|
|
t3 = space();
|
|
label2 = element("label");
|
|
input2 = element("input");
|
|
t4 = text("\n Display view counts");
|
|
t5 = space();
|
|
label3 = element("label");
|
|
input3 = element("input");
|
|
t6 = text("\n Check for new versions at startup.");
|
|
t7 = space();
|
|
label4 = element("label");
|
|
input4 = element("input");
|
|
t8 = text("\n Autoexpand Images on opening.");
|
|
t9 = space();
|
|
label5 = element("label");
|
|
input5 = element("input");
|
|
t10 = text("\n Autoexpand Videos on opening.");
|
|
t11 = space();
|
|
label6 = element("label");
|
|
input6 = element("input");
|
|
t12 = text("\n Loop media content.");
|
|
t13 = space();
|
|
label7 = element("label");
|
|
input7 = element("input");
|
|
t14 = text("\n Disable hover preview.");
|
|
t15 = space();
|
|
label8 = element("label");
|
|
input8 = element("input");
|
|
t16 = text("\n Hide embedded content behind an eye.");
|
|
t17 = space();
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t18 = space();
|
|
label9 = element("label");
|
|
input9 = element("input");
|
|
t19 = text("\n Preload external files.");
|
|
t20 = space();
|
|
label10 = element("label");
|
|
input10 = element("input");
|
|
t21 = text("\n Preload external files when they are in view.");
|
|
t22 = space();
|
|
label11 = element("label");
|
|
input11 = element("input");
|
|
t23 = text("\n Hotlink content.");
|
|
t24 = space();
|
|
label12 = element("label");
|
|
input12 = element("input");
|
|
t25 = text("\n Control audio on videos with mouse wheel.");
|
|
t26 = space();
|
|
label13 = element("label");
|
|
input13 = element("input");
|
|
t27 = text("\n Show Minimap");
|
|
t28 = space();
|
|
label14 = element("label");
|
|
input14 = element("input");
|
|
t29 = text("\n \n Disable embedded file preloading");
|
|
a = element("a");
|
|
a.textContent = "?";
|
|
t31 = space();
|
|
label15 = element("label");
|
|
input15 = element("input");
|
|
t32 = text("\n \n Enable Hydrus Integration");
|
|
t33 = space();
|
|
if (if_block1)
|
|
if_block1.c();
|
|
if_block1_anchor = empty();
|
|
attr(input0, "type", "checkbox");
|
|
attr(input1, "type", "checkbox");
|
|
attr(input2, "type", "checkbox");
|
|
attr(input3, "type", "checkbox");
|
|
attr(input4, "type", "checkbox");
|
|
attr(input5, "type", "checkbox");
|
|
attr(input6, "type", "checkbox");
|
|
attr(input7, "type", "checkbox");
|
|
attr(input8, "type", "checkbox");
|
|
attr(input9, "type", "checkbox");
|
|
attr(input10, "type", "checkbox");
|
|
attr(input11, "type", "checkbox");
|
|
attr(input12, "type", "checkbox");
|
|
attr(input13, "type", "checkbox");
|
|
attr(input14, "type", "checkbox");
|
|
attr(a, "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[7].notcata;
|
|
append(label0, t0);
|
|
insert(target, t1, anchor);
|
|
insert(target, label1, anchor);
|
|
append(label1, input1);
|
|
input1.checked = ctx[9];
|
|
append(label1, t2);
|
|
insert(target, t3, anchor);
|
|
insert(target, label2, anchor);
|
|
append(label2, input2);
|
|
input2.checked = ctx[7].dvc;
|
|
append(label2, t4);
|
|
insert(target, t5, anchor);
|
|
insert(target, label3, anchor);
|
|
append(label3, input3);
|
|
input3.checked = ctx[7].vercheck;
|
|
append(label3, t6);
|
|
insert(target, t7, anchor);
|
|
insert(target, label4, anchor);
|
|
append(label4, input4);
|
|
input4.checked = ctx[7].xpi;
|
|
append(label4, t8);
|
|
insert(target, t9, anchor);
|
|
insert(target, label5, anchor);
|
|
append(label5, input5);
|
|
input5.checked = ctx[7].xpv;
|
|
append(label5, t10);
|
|
insert(target, t11, anchor);
|
|
insert(target, label6, anchor);
|
|
append(label6, input6);
|
|
input6.checked = ctx[7].loop;
|
|
append(label6, t12);
|
|
insert(target, t13, anchor);
|
|
insert(target, label7, anchor);
|
|
append(label7, input7);
|
|
input7.checked = ctx[7].dh;
|
|
append(label7, t14);
|
|
insert(target, t15, anchor);
|
|
insert(target, label8, anchor);
|
|
append(label8, input8);
|
|
input8.checked = ctx[7].eye;
|
|
append(label8, t16);
|
|
insert(target, t17, anchor);
|
|
if (if_block0)
|
|
if_block0.m(target, anchor);
|
|
insert(target, t18, anchor);
|
|
insert(target, label9, anchor);
|
|
append(label9, input9);
|
|
input9.checked = ctx[7].pre;
|
|
append(label9, t19);
|
|
insert(target, t20, anchor);
|
|
insert(target, label10, anchor);
|
|
append(label10, input10);
|
|
input10.checked = ctx[7].prev;
|
|
append(label10, t21);
|
|
insert(target, t22, anchor);
|
|
insert(target, label11, anchor);
|
|
append(label11, input11);
|
|
input11.checked = ctx[7].hotlink;
|
|
append(label11, t23);
|
|
insert(target, t24, anchor);
|
|
insert(target, label12, anchor);
|
|
append(label12, input12);
|
|
input12.checked = ctx[7].ca;
|
|
append(label12, t25);
|
|
insert(target, t26, anchor);
|
|
insert(target, label13, anchor);
|
|
append(label13, input13);
|
|
input13.checked = ctx[7].sh;
|
|
append(label13, t27);
|
|
insert(target, t28, anchor);
|
|
insert(target, label14, anchor);
|
|
append(label14, input14);
|
|
input14.checked = ctx[7].ep;
|
|
append(label14, t29);
|
|
append(label14, a);
|
|
insert(target, t31, anchor);
|
|
insert(target, label15, anchor);
|
|
append(label15, input15);
|
|
input15.checked = ctx[7].hyd;
|
|
append(label15, t32);
|
|
insert(target, t33, anchor);
|
|
if (if_block1)
|
|
if_block1.m(target, anchor);
|
|
insert(target, if_block1_anchor, anchor);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(input0, "change", ctx[21]),
|
|
listen(input1, "change", ctx[22]),
|
|
listen(input2, "change", ctx[23]),
|
|
listen(input3, "change", ctx[24]),
|
|
listen(input4, "change", ctx[25]),
|
|
listen(input5, "change", ctx[26]),
|
|
listen(input6, "change", ctx[27]),
|
|
listen(input7, "change", ctx[28]),
|
|
listen(input8, "change", ctx[29]),
|
|
listen(input9, "change", ctx[31]),
|
|
listen(input10, "change", ctx[32]),
|
|
listen(input11, "change", ctx[33]),
|
|
listen(input12, "change", ctx[34]),
|
|
listen(input13, "change", ctx[35]),
|
|
listen(input14, "change", ctx[36]),
|
|
listen(input15, "change", ctx[37])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 128) {
|
|
input0.checked = ctx2[7].notcata;
|
|
}
|
|
if (dirty[0] & 512) {
|
|
input1.checked = ctx2[9];
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input2.checked = ctx2[7].dvc;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input3.checked = ctx2[7].vercheck;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input4.checked = ctx2[7].xpi;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input5.checked = ctx2[7].xpv;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input6.checked = ctx2[7].loop;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input7.checked = ctx2[7].dh;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input8.checked = ctx2[7].eye;
|
|
}
|
|
if (ctx2[7].eye) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx2, dirty);
|
|
} else {
|
|
if_block0 = create_if_block_11(ctx2);
|
|
if_block0.c();
|
|
if_block0.m(t18.parentNode, t18);
|
|
}
|
|
} else if (if_block0) {
|
|
if_block0.d(1);
|
|
if_block0 = null;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input9.checked = ctx2[7].pre;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input10.checked = ctx2[7].prev;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input11.checked = ctx2[7].hotlink;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input12.checked = ctx2[7].ca;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input13.checked = ctx2[7].sh;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input14.checked = ctx2[7].ep;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
input15.checked = ctx2[7].hyd;
|
|
}
|
|
if (ctx2[7].hyd) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx2, dirty);
|
|
} else {
|
|
if_block1 = create_if_block_8(ctx2);
|
|
if_block1.c();
|
|
if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
|
|
}
|
|
} else if (if_block1) {
|
|
if_block1.d(1);
|
|
if_block1 = null;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(label0);
|
|
if (detaching)
|
|
detach(t1);
|
|
if (detaching)
|
|
detach(label1);
|
|
if (detaching)
|
|
detach(t3);
|
|
if (detaching)
|
|
detach(label2);
|
|
if (detaching)
|
|
detach(t5);
|
|
if (detaching)
|
|
detach(label3);
|
|
if (detaching)
|
|
detach(t7);
|
|
if (detaching)
|
|
detach(label4);
|
|
if (detaching)
|
|
detach(t9);
|
|
if (detaching)
|
|
detach(label5);
|
|
if (detaching)
|
|
detach(t11);
|
|
if (detaching)
|
|
detach(label6);
|
|
if (detaching)
|
|
detach(t13);
|
|
if (detaching)
|
|
detach(label7);
|
|
if (detaching)
|
|
detach(t15);
|
|
if (detaching)
|
|
detach(label8);
|
|
if (detaching)
|
|
detach(t17);
|
|
if (if_block0)
|
|
if_block0.d(detaching);
|
|
if (detaching)
|
|
detach(t18);
|
|
if (detaching)
|
|
detach(label9);
|
|
if (detaching)
|
|
detach(t20);
|
|
if (detaching)
|
|
detach(label10);
|
|
if (detaching)
|
|
detach(t22);
|
|
if (detaching)
|
|
detach(label11);
|
|
if (detaching)
|
|
detach(t24);
|
|
if (detaching)
|
|
detach(label12);
|
|
if (detaching)
|
|
detach(t26);
|
|
if (detaching)
|
|
detach(label13);
|
|
if (detaching)
|
|
detach(t28);
|
|
if (detaching)
|
|
detach(label14);
|
|
if (detaching)
|
|
detach(t31);
|
|
if (detaching)
|
|
detach(label15);
|
|
if (detaching)
|
|
detach(t33);
|
|
if (if_block1)
|
|
if_block1.d(detaching);
|
|
if (detaching)
|
|
detach(if_block1_anchor);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_42(ctx) {
|
|
let label;
|
|
let input0;
|
|
let t0;
|
|
let t1;
|
|
let t2;
|
|
let h30;
|
|
let t4;
|
|
let t5;
|
|
let div0;
|
|
let t6;
|
|
let button;
|
|
let t8;
|
|
let t9;
|
|
let dialog;
|
|
let t10;
|
|
let hr;
|
|
let t11;
|
|
let h31;
|
|
let t13;
|
|
let div1;
|
|
let t14;
|
|
let input1;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block0 = ctx[7].phash && create_if_block_72(ctx);
|
|
let if_block1 = ctx[7].rsources.length == 0 && create_if_block_62(ctx);
|
|
let each_value_5 = ctx[7].rsources;
|
|
let each_blocks_1 = [];
|
|
for (let i = 0; i < each_value_5.length; i += 1) {
|
|
each_blocks_1[i] = create_each_block_5(get_each_context_5(ctx, each_value_5, i));
|
|
}
|
|
const out = (i) => transition_out(each_blocks_1[i], 1, 1, () => {
|
|
each_blocks_1[i] = null;
|
|
});
|
|
let if_block2 = ctx[7].rsources.length == 0 && create_if_block_52(ctx);
|
|
let dialog_props = {
|
|
$$slots: { default: [create_default_slot_7] },
|
|
$$scope: { ctx }
|
|
};
|
|
dialog = new Dialog_default({ props: dialog_props });
|
|
ctx[52](dialog);
|
|
let each_value_4 = ctx[7].blacklist;
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value_4.length; i += 1) {
|
|
each_blocks[i] = create_each_block_4(get_each_context_4(ctx, each_value_4, i));
|
|
}
|
|
const out_1 = (i) => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
return {
|
|
c() {
|
|
label = element("label");
|
|
input0 = element("input");
|
|
t0 = text("\n Enable perceptual hash-based filtering");
|
|
t1 = space();
|
|
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();
|
|
}
|
|
t6 = space();
|
|
button = element("button");
|
|
button.textContent = "Add a source";
|
|
t8 = space();
|
|
if (if_block2)
|
|
if_block2.c();
|
|
t9 = space();
|
|
create_component(dialog.$$.fragment);
|
|
t10 = space();
|
|
hr = element("hr");
|
|
t11 = space();
|
|
h31 = element("h3");
|
|
h31.textContent = "Blacklisted tags";
|
|
t13 = space();
|
|
div1 = element("div");
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
t14 = space();
|
|
input1 = element("input");
|
|
attr(input0, "type", "checkbox");
|
|
attr(div0, "class", "tagcont svelte-15t7t1d");
|
|
attr(hr, "class", "svelte-15t7t1d");
|
|
attr(div1, "class", "tagcont svelte-15t7t1d");
|
|
attr(input1, "placeholder", "Press enter after typing your tag");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, label, anchor);
|
|
append(label, input0);
|
|
input0.checked = ctx[7].phash;
|
|
append(label, t0);
|
|
insert(target, t1, 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, t6, anchor);
|
|
insert(target, button, anchor);
|
|
insert(target, t8, anchor);
|
|
if (if_block2)
|
|
if_block2.m(target, anchor);
|
|
insert(target, t9, anchor);
|
|
mount_component(dialog, target, anchor);
|
|
insert(target, t10, anchor);
|
|
insert(target, hr, anchor);
|
|
insert(target, t11, anchor);
|
|
insert(target, h31, anchor);
|
|
insert(target, t13, anchor);
|
|
insert(target, div1, anchor);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
insert(target, t14, anchor);
|
|
insert(target, input1, anchor);
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(input0, "change", ctx[42]),
|
|
listen(button, "click", ctx[47]),
|
|
listen(input1, "keydown", ctx[54])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 128) {
|
|
input0.checked = ctx2[7].phash;
|
|
}
|
|
if (ctx2[7].phash) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx2, dirty);
|
|
} else {
|
|
if_block0 = create_if_block_72(ctx2);
|
|
if_block0.c();
|
|
if_block0.m(t2.parentNode, t2);
|
|
}
|
|
} 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_62(ctx2);
|
|
if_block1.c();
|
|
if_block1.m(t5.parentNode, t5);
|
|
}
|
|
} else if (if_block1) {
|
|
if_block1.d(1);
|
|
if_block1 = null;
|
|
}
|
|
if (dirty[0] & 139392) {
|
|
each_value_5 = ctx2[7].rsources;
|
|
let i;
|
|
for (i = 0; i < each_value_5.length; i += 1) {
|
|
const child_ctx = get_each_context_5(ctx2, each_value_5, i);
|
|
if (each_blocks_1[i]) {
|
|
each_blocks_1[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks_1[i], 1);
|
|
} else {
|
|
each_blocks_1[i] = create_each_block_5(child_ctx);
|
|
each_blocks_1[i].c();
|
|
transition_in(each_blocks_1[i], 1);
|
|
each_blocks_1[i].m(div0, null);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value_5.length; i < each_blocks_1.length; i += 1) {
|
|
out(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
if (ctx2[7].rsources.length == 0) {
|
|
if (if_block2) {
|
|
if_block2.p(ctx2, dirty);
|
|
} else {
|
|
if_block2 = create_if_block_52(ctx2);
|
|
if_block2.c();
|
|
if_block2.m(t9.parentNode, t9);
|
|
}
|
|
} else if (if_block2) {
|
|
if_block2.d(1);
|
|
if_block2 = null;
|
|
}
|
|
const dialog_changes = {};
|
|
if (dirty[0] & 2 | dirty[2] & 16384) {
|
|
dialog_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
dialog.$set(dialog_changes);
|
|
if (dirty[0] & 4224) {
|
|
each_value_4 = ctx2[7].blacklist;
|
|
let i;
|
|
for (i = 0; i < each_value_4.length; i += 1) {
|
|
const child_ctx = get_each_context_4(ctx2, each_value_4, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block_4(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value_4.length; i < each_blocks.length; i += 1) {
|
|
out_1(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
for (let i = 0; i < each_value_5.length; i += 1) {
|
|
transition_in(each_blocks_1[i]);
|
|
}
|
|
transition_in(dialog.$$.fragment, local);
|
|
for (let i = 0; i < each_value_4.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
each_blocks_1 = each_blocks_1.filter(Boolean);
|
|
for (let i = 0; i < each_blocks_1.length; i += 1) {
|
|
transition_out(each_blocks_1[i]);
|
|
}
|
|
transition_out(dialog.$$.fragment, local);
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(label);
|
|
if (detaching)
|
|
detach(t1);
|
|
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(t6);
|
|
if (detaching)
|
|
detach(button);
|
|
if (detaching)
|
|
detach(t8);
|
|
if (if_block2)
|
|
if_block2.d(detaching);
|
|
if (detaching)
|
|
detach(t9);
|
|
ctx[52](null);
|
|
destroy_component(dialog, detaching);
|
|
if (detaching)
|
|
detach(t10);
|
|
if (detaching)
|
|
detach(hr);
|
|
if (detaching)
|
|
detach(t11);
|
|
if (detaching)
|
|
detach(h31);
|
|
if (detaching)
|
|
detach(t13);
|
|
if (detaching)
|
|
detach(div1);
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(t14);
|
|
if (detaching)
|
|
detach(input1);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_72(ctx) {
|
|
let label;
|
|
let input;
|
|
let t0;
|
|
let a;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
label = element("label");
|
|
input = element("input");
|
|
t0 = text("\n Minimum distance required (5 recommended)\n \n ");
|
|
a = element("a");
|
|
a.textContent = "?";
|
|
attr(input, "type", "number");
|
|
attr(input, "class", "svelte-15t7t1d");
|
|
attr(a, "title", "Higher will filter more potentially different images, lower will let more identical images through");
|
|
attr(label, "class", "svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, label, anchor);
|
|
append(label, input);
|
|
set_input_value(input, ctx[7].mdist);
|
|
append(label, t0);
|
|
append(label, a);
|
|
if (!mounted) {
|
|
dispose = listen(input, "input", ctx[43]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 128 && to_number(input.value) !== ctx2[7].mdist) {
|
|
set_input_value(input, ctx2[7].mdist);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(label);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_62(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_5(ctx) {
|
|
let tag;
|
|
let current;
|
|
function func(...args) {
|
|
return ctx[44](ctx[74], ...args);
|
|
}
|
|
function remove_handler() {
|
|
return ctx[45](ctx[74]);
|
|
}
|
|
function toggle_handler() {
|
|
return ctx[46](ctx[74]);
|
|
}
|
|
tag = new Tag_default({
|
|
props: {
|
|
tag: ctx[74].name,
|
|
toggleable: true,
|
|
toggled: !ctx[7].rsources.find(func)?.disabled
|
|
}
|
|
});
|
|
tag.$on("remove", remove_handler);
|
|
tag.$on("toggle", toggle_handler);
|
|
return {
|
|
c() {
|
|
create_component(tag.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(tag, target, anchor);
|
|
current = true;
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
const tag_changes = {};
|
|
if (dirty[0] & 128)
|
|
tag_changes.tag = ctx[74].name;
|
|
if (dirty[0] & 128)
|
|
tag_changes.toggled = !ctx[7].rsources.find(func)?.disabled;
|
|
tag.$set(tag_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(tag.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(tag.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(tag, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_52(ctx) {
|
|
let button;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
button = element("button");
|
|
button.textContent = "Import Bulk from clipboard";
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, button, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(button, "click", ctx[14]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(button);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_7(ctx) {
|
|
let div;
|
|
let label0;
|
|
let t0;
|
|
let input0;
|
|
let t1;
|
|
let label1;
|
|
let t2;
|
|
let input1;
|
|
let t3;
|
|
let label2;
|
|
let t4;
|
|
let input2;
|
|
let t5;
|
|
let label3;
|
|
let t6;
|
|
let input3;
|
|
let t7;
|
|
let button;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
label0 = element("label");
|
|
t0 = text("Name\n ");
|
|
input0 = element("input");
|
|
t1 = space();
|
|
label1 = element("label");
|
|
t2 = text("Domain\n ");
|
|
input1 = element("input");
|
|
t3 = space();
|
|
label2 = element("label");
|
|
t4 = text("API Endpoint\n ");
|
|
input2 = element("input");
|
|
t5 = space();
|
|
label3 = element("label");
|
|
t6 = text("Post page prefix (for sources)\n ");
|
|
input3 = element("input");
|
|
t7 = space();
|
|
button = element("button");
|
|
button.textContent = "Add";
|
|
attr(input0, "type", "text");
|
|
attr(input0, "placeholder", "Safebooru");
|
|
attr(input0, "class", "svelte-15t7t1d");
|
|
attr(label0, "class", "svelte-15t7t1d");
|
|
attr(input1, "type", "text");
|
|
attr(input1, "placeholder", "safebooru.com");
|
|
attr(input1, "class", "svelte-15t7t1d");
|
|
attr(label1, "class", "svelte-15t7t1d");
|
|
attr(input2, "type", "text");
|
|
attr(input2, "placeholder", "/post.json?tags=md5:");
|
|
attr(input2, "class", "svelte-15t7t1d");
|
|
attr(label2, "class", "svelte-15t7t1d");
|
|
attr(input3, "type", "text");
|
|
attr(input3, "placeholder", "https://safebooru.com/post/show/");
|
|
attr(input3, "class", "svelte-15t7t1d");
|
|
attr(label3, "class", "svelte-15t7t1d");
|
|
attr(div, "class", "form svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, label0);
|
|
append(label0, t0);
|
|
append(label0, input0);
|
|
set_input_value(input0, ctx[1].name);
|
|
append(div, t1);
|
|
append(div, label1);
|
|
append(label1, t2);
|
|
append(label1, input1);
|
|
set_input_value(input1, ctx[1].domain);
|
|
append(div, t3);
|
|
append(div, label2);
|
|
append(label2, t4);
|
|
append(label2, input2);
|
|
set_input_value(input2, ctx[1].endpoint);
|
|
append(div, t5);
|
|
append(div, label3);
|
|
append(label3, t6);
|
|
append(label3, input3);
|
|
set_input_value(input3, ctx[1].view);
|
|
append(div, t7);
|
|
append(div, button);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(input0, "input", ctx[48]),
|
|
listen(input1, "input", ctx[49]),
|
|
listen(input2, "input", ctx[50]),
|
|
listen(input3, "input", ctx[51]),
|
|
listen(button, "click", ctx[11])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 2 && input0.value !== ctx2[1].name) {
|
|
set_input_value(input0, ctx2[1].name);
|
|
}
|
|
if (dirty[0] & 2 && input1.value !== ctx2[1].domain) {
|
|
set_input_value(input1, ctx2[1].domain);
|
|
}
|
|
if (dirty[0] & 2 && input2.value !== ctx2[1].endpoint) {
|
|
set_input_value(input2, ctx2[1].endpoint);
|
|
}
|
|
if (dirty[0] & 2 && input3.value !== ctx2[1].view) {
|
|
set_input_value(input3, ctx2[1].view);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block_4(ctx) {
|
|
let tag;
|
|
let current;
|
|
function toggle_handler_1() {
|
|
return ctx[53](ctx[72]);
|
|
}
|
|
tag = new Tag_default({ props: { tag: ctx[72] } });
|
|
tag.$on("toggle", toggle_handler_1);
|
|
return {
|
|
c() {
|
|
create_component(tag.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(tag, target, anchor);
|
|
current = true;
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
const tag_changes = {};
|
|
if (dirty[0] & 128)
|
|
tag_changes.tag = ctx[72];
|
|
tag.$set(tag_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(tag.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(tag.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(tag, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_6(ctx) {
|
|
let label;
|
|
let input;
|
|
let t0;
|
|
let t1;
|
|
let if_block_anchor;
|
|
let current;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block = !ctx[7].te && create_if_block_42(ctx);
|
|
return {
|
|
c() {
|
|
label = element("label");
|
|
input = element("input");
|
|
t0 = text("\n Disable third-eye.");
|
|
t1 = space();
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
attr(input, "type", "checkbox");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, label, anchor);
|
|
append(label, input);
|
|
input.checked = ctx[7].te;
|
|
append(label, t0);
|
|
insert(target, t1, anchor);
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
if (!mounted) {
|
|
dispose = listen(input, "change", ctx[41]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 128) {
|
|
input.checked = ctx2[7].te;
|
|
}
|
|
if (!ctx2[7].te) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
if (dirty[0] & 128) {
|
|
transition_in(if_block, 1);
|
|
}
|
|
} else {
|
|
if_block = create_if_block_42(ctx2);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(label);
|
|
if (detaching)
|
|
detach(t1);
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_each_block_3(ctx) {
|
|
let option;
|
|
let t_value = ctx[69].domain + "";
|
|
let t;
|
|
let option_value_value;
|
|
return {
|
|
c() {
|
|
option = element("option");
|
|
t = text(t_value);
|
|
option.__value = option_value_value = ctx[71];
|
|
option.value = option.__value;
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, option, anchor);
|
|
append(option, t);
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(option);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_5(ctx) {
|
|
let p;
|
|
let t1;
|
|
let select;
|
|
let t2;
|
|
let label;
|
|
let t3;
|
|
let input;
|
|
let mounted;
|
|
let dispose;
|
|
let each_value_3 = filehosts;
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value_3.length; i += 1) {
|
|
each_blocks[i] = create_each_block_3(get_each_context_3(ctx, each_value_3, i));
|
|
}
|
|
return {
|
|
c() {
|
|
p = element("p");
|
|
p.textContent = "Host to use when uploading files (Only permanent hosts)";
|
|
t1 = space();
|
|
select = element("select");
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
t2 = space();
|
|
label = element("label");
|
|
t3 = text("Maximum number of embedded links to display\n ");
|
|
input = element("input");
|
|
if (ctx[7].fhost === void 0)
|
|
add_render_callback(() => ctx[55].call(select));
|
|
attr(input, "type", "number");
|
|
attr(input, "class", "svelte-15t7t1d");
|
|
attr(label, "class", "svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, p, anchor);
|
|
insert(target, t1, anchor);
|
|
insert(target, select, anchor);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(select, null);
|
|
}
|
|
select_option(select, ctx[7].fhost);
|
|
insert(target, t2, anchor);
|
|
insert(target, label, anchor);
|
|
append(label, t3);
|
|
append(label, input);
|
|
set_input_value(input, ctx[7].maxe);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(select, "change", ctx[55]),
|
|
listen(input, "input", ctx[56])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty & 0) {
|
|
each_value_3 = filehosts;
|
|
let i;
|
|
for (i = 0; i < each_value_3.length; i += 1) {
|
|
const child_ctx = get_each_context_3(ctx2, each_value_3, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
} else {
|
|
each_blocks[i] = create_each_block_3(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(select, null);
|
|
}
|
|
}
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value_3.length;
|
|
}
|
|
if (dirty[0] & 128) {
|
|
select_option(select, ctx2[7].fhost);
|
|
}
|
|
if (dirty[0] & 128 && to_number(input.value) !== ctx2[7].maxe) {
|
|
set_input_value(input, ctx2[7].maxe);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(p);
|
|
if (detaching)
|
|
detach(t1);
|
|
if (detaching)
|
|
detach(select);
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(t2);
|
|
if (detaching)
|
|
detach(label);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function create_else_block_1(ctx) {
|
|
let p;
|
|
return {
|
|
c() {
|
|
p = element("p");
|
|
p.textContent = "Loading...";
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, p, anchor);
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(p);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_32(ctx) {
|
|
let div;
|
|
let p;
|
|
let t1;
|
|
let each_value_2 = ctx[6];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value_2.length; i += 1) {
|
|
each_blocks[i] = create_each_block_2(get_each_context_2(ctx, each_value_2, i));
|
|
}
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
p = element("p");
|
|
p.textContent = "Format is (embedded links / link in filename)";
|
|
t1 = space();
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(div, "class", "bepis svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, p);
|
|
append(div, t1);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div, null);
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 32832) {
|
|
each_value_2 = ctx2[6];
|
|
let i;
|
|
for (i = 0; i < each_value_2.length; i += 1) {
|
|
const child_ctx = get_each_context_2(ctx2, each_value_2, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
} else {
|
|
each_blocks[i] = create_each_block_2(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(div, null);
|
|
}
|
|
}
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value_2.length;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block_2(ctx) {
|
|
let div;
|
|
let a;
|
|
let t0;
|
|
let t1_value = ctx[66].id + "";
|
|
let t1;
|
|
let a_href_value;
|
|
let t2;
|
|
let t3_value = ctx[66].pees + "";
|
|
let t3;
|
|
let t4;
|
|
let t5_value = ctx[66].eyes + ctx[66].other + "";
|
|
let t5;
|
|
let t6;
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
a = element("a");
|
|
t0 = text(">>");
|
|
t1 = text(t1_value);
|
|
t2 = text("\n (");
|
|
t3 = text(t3_value);
|
|
t4 = text(" / ");
|
|
t5 = text(t5_value);
|
|
t6 = text(")\n ");
|
|
attr(a, "href", a_href_value = "https://boards.4chan.org/" + ctx[15] + "/thread/" + ctx[66].id);
|
|
attr(div, "class", "mbepis");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, a);
|
|
append(a, t0);
|
|
append(a, t1);
|
|
append(div, t2);
|
|
append(div, t3);
|
|
append(div, t4);
|
|
append(div, t5);
|
|
append(div, t6);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 64 && t1_value !== (t1_value = ctx2[66].id + ""))
|
|
set_data(t1, t1_value);
|
|
if (dirty[0] & 64 && a_href_value !== (a_href_value = "https://boards.4chan.org/" + ctx2[15] + "/thread/" + ctx2[66].id)) {
|
|
attr(a, "href", a_href_value);
|
|
}
|
|
if (dirty[0] & 64 && t3_value !== (t3_value = ctx2[66].pees + ""))
|
|
set_data(t3, t3_value);
|
|
if (dirty[0] & 64 && t5_value !== (t5_value = ctx2[66].eyes + ctx2[66].other + ""))
|
|
set_data(t5, t5_value);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_4(ctx) {
|
|
let label;
|
|
let input;
|
|
let t0;
|
|
let a;
|
|
let t2;
|
|
let t3;
|
|
let if_block_anchor;
|
|
let mounted;
|
|
let dispose;
|
|
function select_block_type(ctx2, dirty) {
|
|
if (!ctx2[5])
|
|
return create_if_block_32;
|
|
return create_else_block_1;
|
|
}
|
|
let current_block_type = select_block_type(ctx, [-1, -1, -1]);
|
|
let if_block = current_block_type(ctx);
|
|
return {
|
|
c() {
|
|
label = element("label");
|
|
input = element("input");
|
|
t0 = text("\n \n Contribute to help keep this list up to date. [");
|
|
a = element("a");
|
|
a.textContent = "?";
|
|
t2 = text("]");
|
|
t3 = space();
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
attr(input, "type", "checkbox");
|
|
attr(a, "title", "This will make PEE automatically send the\n post number of posts you find with embedded content");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, label, anchor);
|
|
append(label, input);
|
|
input.checked = ctx[7].tm;
|
|
append(label, t0);
|
|
append(label, a);
|
|
append(label, t2);
|
|
insert(target, t3, anchor);
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(input, "change", ctx[57]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 128) {
|
|
input.checked = ctx2[7].tm;
|
|
}
|
|
if (current_block_type === (current_block_type = select_block_type(ctx2, dirty)) && if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block.d(1);
|
|
if_block = current_block_type(ctx2);
|
|
if (if_block) {
|
|
if_block.c();
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(label);
|
|
if (detaching)
|
|
detach(t3);
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_else_block2(ctx) {
|
|
let each_1_anchor;
|
|
let each_value_1 = ctx[3];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value_1.length; i += 1) {
|
|
each_blocks[i] = create_each_block_12(get_each_context_12(ctx, each_value_1, i));
|
|
}
|
|
return {
|
|
c() {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
each_1_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(target, anchor);
|
|
}
|
|
insert(target, each_1_anchor, anchor);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 8) {
|
|
each_value_1 = ctx2[3];
|
|
let i;
|
|
for (i = 0; i < each_value_1.length; i += 1) {
|
|
const child_ctx = get_each_context_12(ctx2, each_value_1, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
} else {
|
|
each_blocks[i] = create_each_block_12(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
|
|
}
|
|
}
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value_1.length;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(each_1_anchor);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_22(ctx) {
|
|
let p;
|
|
return {
|
|
c() {
|
|
p = element("p");
|
|
p.textContent = "There are no news yet.";
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, p, anchor);
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(p);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block_12(ctx) {
|
|
let h3;
|
|
let t0_value = ctx[63].title + "";
|
|
let t0;
|
|
let t1;
|
|
let p;
|
|
let t2_value = ctx[63].content + "";
|
|
let t2;
|
|
return {
|
|
c() {
|
|
h3 = element("h3");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
p = element("p");
|
|
t2 = text(t2_value);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, h3, anchor);
|
|
append(h3, t0);
|
|
insert(target, t1, anchor);
|
|
insert(target, p, anchor);
|
|
append(p, t2);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 8 && t0_value !== (t0_value = ctx2[63].title + ""))
|
|
set_data(t0, t0_value);
|
|
if (dirty[0] & 8 && t2_value !== (t2_value = ctx2[63].content + ""))
|
|
set_data(t2, t2_value);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(h3);
|
|
if (detaching)
|
|
detach(t1);
|
|
if (detaching)
|
|
detach(p);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_3(ctx) {
|
|
let p;
|
|
let t2;
|
|
let div;
|
|
function select_block_type_1(ctx2, dirty) {
|
|
if (ctx2[3].length == 0)
|
|
return create_if_block_22;
|
|
return create_else_block2;
|
|
}
|
|
let current_block_type = select_block_type_1(ctx, [-1, -1, -1]);
|
|
let if_block = current_block_type(ctx);
|
|
return {
|
|
c() {
|
|
p = element("p");
|
|
p.innerHTML = `Reminder to report issues to <a href="https://git.coom.tech/coomdev/PEE">the main repo</a>`;
|
|
t2 = space();
|
|
div = element("div");
|
|
if_block.c();
|
|
attr(div, "class", "newsbox svelte-15t7t1d");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, p, anchor);
|
|
insert(target, t2, anchor);
|
|
insert(target, div, anchor);
|
|
if_block.m(div, null);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (current_block_type === (current_block_type = select_block_type_1(ctx2, dirty)) && if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block.d(1);
|
|
if_block = current_block_type(ctx2);
|
|
if (if_block) {
|
|
if_block.c();
|
|
if_block.m(div, null);
|
|
}
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(p);
|
|
if (detaching)
|
|
detach(t2);
|
|
if (detaching)
|
|
detach(div);
|
|
if_block.d();
|
|
}
|
|
};
|
|
}
|
|
function create_each_block2(ctx) {
|
|
let option;
|
|
let t0;
|
|
let t1;
|
|
let option_value_value;
|
|
return {
|
|
c() {
|
|
option = element("option");
|
|
t0 = text("Method ");
|
|
t1 = text(ctx[60]);
|
|
option.__value = option_value_value = ctx[60];
|
|
option.value = option.__value;
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, option, anchor);
|
|
append(option, t0);
|
|
append(option, t1);
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(option);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_2(ctx) {
|
|
let label;
|
|
let t;
|
|
let select;
|
|
let mounted;
|
|
let dispose;
|
|
let each_value = [0, 1, 2, 3, 4, 5];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < 6; i += 1) {
|
|
each_blocks[i] = create_each_block2(get_each_context2(ctx, each_value, i));
|
|
}
|
|
return {
|
|
c() {
|
|
label = element("label");
|
|
t = text("PNG Embedding method\n ");
|
|
select = element("select");
|
|
for (let i = 0; i < 6; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
if (ctx[7].pmeth === void 0)
|
|
add_render_callback(() => ctx[58].call(select));
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, label, anchor);
|
|
append(label, t);
|
|
append(label, select);
|
|
for (let i = 0; i < 6; i += 1) {
|
|
each_blocks[i].m(select, null);
|
|
}
|
|
select_option(select, ctx[7].pmeth);
|
|
if (!mounted) {
|
|
dispose = listen(select, "change", ctx[58]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty[0] & 128) {
|
|
select_option(select, ctx2[7].pmeth);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(label);
|
|
destroy_each(each_blocks, detaching);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_14(ctx) {
|
|
let tabpanel;
|
|
let current;
|
|
tabpanel = new TabPanel_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_1] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
return {
|
|
c() {
|
|
create_component(tabpanel.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(tabpanel, target, anchor);
|
|
current = true;
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(tabpanel.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(tabpanel.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(tabpanel, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot_1(ctx) {
|
|
let hydrussearch;
|
|
let current;
|
|
hydrussearch = new HydrusSearch_default({});
|
|
return {
|
|
c() {
|
|
create_component(hydrussearch.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(hydrussearch, target, anchor);
|
|
current = true;
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(hydrussearch.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(hydrussearch.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(hydrussearch, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_default_slot(ctx) {
|
|
let tablist;
|
|
let t0;
|
|
let tabpanel0;
|
|
let t1;
|
|
let tabpanel1;
|
|
let t2;
|
|
let tabpanel2;
|
|
let t3;
|
|
let tabpanel3;
|
|
let t4;
|
|
let tabpanel4;
|
|
let t5;
|
|
let tabpanel5;
|
|
let t6;
|
|
let if_block_anchor;
|
|
let current;
|
|
tablist = new TabList_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_9] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tabpanel0 = new TabPanel_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_8] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tabpanel1 = new TabPanel_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_6] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tabpanel2 = new TabPanel_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_5] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tabpanel3 = new TabPanel_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_4] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tabpanel4 = new TabPanel_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_3] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
tabpanel5 = new TabPanel_default({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_2] },
|
|
$$scope: { ctx }
|
|
}
|
|
});
|
|
let if_block = ctx[8].akValid && create_if_block_14(ctx);
|
|
return {
|
|
c() {
|
|
create_component(tablist.$$.fragment);
|
|
t0 = space();
|
|
create_component(tabpanel0.$$.fragment);
|
|
t1 = space();
|
|
create_component(tabpanel1.$$.fragment);
|
|
t2 = space();
|
|
create_component(tabpanel2.$$.fragment);
|
|
t3 = space();
|
|
create_component(tabpanel3.$$.fragment);
|
|
t4 = space();
|
|
create_component(tabpanel4.$$.fragment);
|
|
t5 = space();
|
|
create_component(tabpanel5.$$.fragment);
|
|
t6 = space();
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(tablist, target, anchor);
|
|
insert(target, t0, anchor);
|
|
mount_component(tabpanel0, target, anchor);
|
|
insert(target, t1, anchor);
|
|
mount_component(tabpanel1, target, anchor);
|
|
insert(target, t2, anchor);
|
|
mount_component(tabpanel2, target, anchor);
|
|
insert(target, t3, anchor);
|
|
mount_component(tabpanel3, target, anchor);
|
|
insert(target, t4, anchor);
|
|
mount_component(tabpanel4, target, anchor);
|
|
insert(target, t5, anchor);
|
|
mount_component(tabpanel5, target, anchor);
|
|
insert(target, t6, anchor);
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
const tablist_changes = {};
|
|
if (dirty[0] & 256 | dirty[2] & 16384) {
|
|
tablist_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tablist.$set(tablist_changes);
|
|
const tabpanel0_changes = {};
|
|
if (dirty[0] & 896 | dirty[2] & 16384) {
|
|
tabpanel0_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tabpanel0.$set(tabpanel0_changes);
|
|
const tabpanel1_changes = {};
|
|
if (dirty[0] & 134 | dirty[2] & 16384) {
|
|
tabpanel1_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tabpanel1.$set(tabpanel1_changes);
|
|
const tabpanel2_changes = {};
|
|
if (dirty[0] & 128 | dirty[2] & 16384) {
|
|
tabpanel2_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tabpanel2.$set(tabpanel2_changes);
|
|
const tabpanel3_changes = {};
|
|
if (dirty[0] & 224 | dirty[2] & 16384) {
|
|
tabpanel3_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tabpanel3.$set(tabpanel3_changes);
|
|
const tabpanel4_changes = {};
|
|
if (dirty[0] & 8 | dirty[2] & 16384) {
|
|
tabpanel4_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tabpanel4.$set(tabpanel4_changes);
|
|
const tabpanel5_changes = {};
|
|
if (dirty[0] & 128 | dirty[2] & 16384) {
|
|
tabpanel5_changes.$$scope = { dirty, ctx: ctx2 };
|
|
}
|
|
tabpanel5.$set(tabpanel5_changes);
|
|
if (ctx2[8].akValid) {
|
|
if (if_block) {
|
|
if (dirty[0] & 256) {
|
|
transition_in(if_block, 1);
|
|
}
|
|
} else {
|
|
if_block = create_if_block_14(ctx2);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(tablist.$$.fragment, local);
|
|
transition_in(tabpanel0.$$.fragment, local);
|
|
transition_in(tabpanel1.$$.fragment, local);
|
|
transition_in(tabpanel2.$$.fragment, local);
|
|
transition_in(tabpanel3.$$.fragment, local);
|
|
transition_in(tabpanel4.$$.fragment, local);
|
|
transition_in(tabpanel5.$$.fragment, local);
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(tablist.$$.fragment, local);
|
|
transition_out(tabpanel0.$$.fragment, local);
|
|
transition_out(tabpanel1.$$.fragment, local);
|
|
transition_out(tabpanel2.$$.fragment, local);
|
|
transition_out(tabpanel3.$$.fragment, local);
|
|
transition_out(tabpanel4.$$.fragment, local);
|
|
transition_out(tabpanel5.$$.fragment, local);
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_component(tablist, detaching);
|
|
if (detaching)
|
|
detach(t0);
|
|
destroy_component(tabpanel0, detaching);
|
|
if (detaching)
|
|
detach(t1);
|
|
destroy_component(tabpanel1, detaching);
|
|
if (detaching)
|
|
detach(t2);
|
|
destroy_component(tabpanel2, detaching);
|
|
if (detaching)
|
|
detach(t3);
|
|
destroy_component(tabpanel3, detaching);
|
|
if (detaching)
|
|
detach(t4);
|
|
destroy_component(tabpanel4, detaching);
|
|
if (detaching)
|
|
detach(t5);
|
|
destroy_component(tabpanel5, detaching);
|
|
if (detaching)
|
|
detach(t6);
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment9(ctx) {
|
|
let t;
|
|
let if_block1_anchor;
|
|
let current;
|
|
let if_block0 = ctx[8].processing != ctx[8].processed && create_if_block_13(ctx);
|
|
let if_block1 = ctx[4] && create_if_block6(ctx);
|
|
return {
|
|
c() {
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t = space();
|
|
if (if_block1)
|
|
if_block1.c();
|
|
if_block1_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block0)
|
|
if_block0.m(target, anchor);
|
|
insert(target, t, anchor);
|
|
if (if_block1)
|
|
if_block1.m(target, anchor);
|
|
insert(target, if_block1_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (ctx2[8].processing != ctx2[8].processed) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx2, dirty);
|
|
} else {
|
|
if_block0 = create_if_block_13(ctx2);
|
|
if_block0.c();
|
|
if_block0.m(t.parentNode, t);
|
|
}
|
|
} else if (if_block0) {
|
|
if_block0.d(1);
|
|
if_block0 = null;
|
|
}
|
|
if (ctx2[4]) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx2, dirty);
|
|
if (dirty[0] & 16) {
|
|
transition_in(if_block1, 1);
|
|
}
|
|
} else {
|
|
if_block1 = create_if_block6(ctx2);
|
|
if_block1.c();
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
|
|
}
|
|
} else if (if_block1) {
|
|
group_outros();
|
|
transition_out(if_block1, 1, 1, () => {
|
|
if_block1 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(if_block1);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(if_block1);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
if (if_block0)
|
|
if_block0.d(detaching);
|
|
if (detaching)
|
|
detach(t);
|
|
if (if_block1)
|
|
if_block1.d(detaching);
|
|
if (detaching)
|
|
detach(if_block1_anchor);
|
|
}
|
|
};
|
|
}
|
|
function instance9($$self, $$props, $$invalidate) {
|
|
let $settings;
|
|
let $appState;
|
|
let $cached;
|
|
component_subscribe($$self, settings, ($$value) => $$invalidate(7, $settings = $$value));
|
|
component_subscribe($$self, appState, ($$value) => $$invalidate(8, $appState = $$value));
|
|
let newbooru = {};
|
|
let dial;
|
|
let { rev } = $$props;
|
|
let news = [];
|
|
const updateNews = async () => {
|
|
const res = await fetch("https://shoujo.coom.tech/news");
|
|
$$invalidate(3, news = await res.json());
|
|
};
|
|
function appendBooru() {
|
|
if (false) {
|
|
request(newbooru.domain);
|
|
}
|
|
set_store_value(settings, $settings.rsources = [...$settings.rsources, newbooru], $settings);
|
|
dial.toggle();
|
|
$$invalidate(1, newbooru = {});
|
|
}
|
|
let visible = false;
|
|
let penisEvent = () => {
|
|
$$invalidate(4, visible = !visible);
|
|
};
|
|
document.addEventListener("penis", penisEvent);
|
|
console.log("app loaded");
|
|
function removeTag(t) {
|
|
set_store_value(settings, $settings.blacklist = $settings.blacklist.filter((e) => e != t), $settings);
|
|
}
|
|
function removeBooru(t) {
|
|
const idx = $settings.rsources.findIndex((e) => e.domain == t);
|
|
const rep = prompt("You DO know what you're doing, right? (type 'y')");
|
|
if (!rep || rep != "y")
|
|
return;
|
|
if (idx >= 0)
|
|
$settings.rsources.splice(idx, 1);
|
|
settings.set($settings);
|
|
}
|
|
const setFromClip = async () => {
|
|
try {
|
|
const content = await navigator.clipboard.readText();
|
|
set_store_value(settings, $settings.rsources = JSON.parse(content), $settings);
|
|
} catch {
|
|
try {
|
|
const content = prompt("Paste it in here") || "";
|
|
let v = JSON.parse(content);
|
|
if (false)
|
|
v = cloneInto(v, window);
|
|
set_store_value(settings, $settings.rsources = v, $settings);
|
|
} catch (e) {
|
|
console.log(e);
|
|
alert("How can you fail so badly? pathetic...");
|
|
}
|
|
}
|
|
};
|
|
const boardname = location.pathname.match(/\/([^/]*)\//)[1];
|
|
let updating = false;
|
|
let threads = [];
|
|
async function updateThreads() {
|
|
$$invalidate(5, updating = true);
|
|
let params = "";
|
|
if ($settings.phash) {
|
|
params = "?mdist=" + $settings.mdist;
|
|
}
|
|
let res = await ifetch("https://shoujo.coom.tech/listing/" + boardname + params);
|
|
$$invalidate(6, threads = await res.json());
|
|
$$invalidate(5, updating = false);
|
|
}
|
|
function toggleBooru(t) {
|
|
const elem = $settings.rsources.find((e) => e.domain == t);
|
|
if (elem)
|
|
elem.disabled = !elem.disabled;
|
|
settings.set($settings);
|
|
}
|
|
onDestroy(() => {
|
|
document.removeEventListener("penis", penisEvent);
|
|
});
|
|
let cached = writable(false);
|
|
component_subscribe($$self, cached, (value) => $$invalidate(9, $cached = value));
|
|
settings.subscribe((val) => {
|
|
cached.set(typeof val.cache == "boolean" ? val.cache : location.host.includes("b4k"));
|
|
});
|
|
cached.subscribe((v) => {
|
|
set_store_value(settings, $settings.cache = v, $settings);
|
|
});
|
|
const select_handler = () => updateThreads();
|
|
const select_handler_1 = () => updateNews();
|
|
function input0_change_handler() {
|
|
$settings.notcata = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input1_change_handler() {
|
|
$cached = this.checked;
|
|
cached.set($cached);
|
|
}
|
|
function input2_change_handler() {
|
|
$settings.dvc = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input3_change_handler() {
|
|
$settings.vercheck = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input4_change_handler() {
|
|
$settings.xpi = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input5_change_handler() {
|
|
$settings.xpv = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input6_change_handler() {
|
|
$settings.loop = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input7_change_handler() {
|
|
$settings.dh = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input8_change_handler() {
|
|
$settings.eye = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input_change_handler() {
|
|
$settings.ho = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input9_change_handler() {
|
|
$settings.pre = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input10_change_handler() {
|
|
$settings.prev = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input11_change_handler() {
|
|
$settings.hotlink = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input12_change_handler() {
|
|
$settings.ca = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input13_change_handler() {
|
|
$settings.sh = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input14_change_handler() {
|
|
$settings.ep = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input15_change_handler() {
|
|
$settings.hyd = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input_input_handler() {
|
|
$settings.ak = this.value;
|
|
settings.set($settings);
|
|
}
|
|
function input0_input_handler() {
|
|
$settings.auto_embed = to_number(this.value);
|
|
settings.set($settings);
|
|
}
|
|
function input1_input_handler() {
|
|
$settings.auto_tags = this.value;
|
|
settings.set($settings);
|
|
}
|
|
function input_change_handler_1() {
|
|
$settings.te = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input0_change_handler_1() {
|
|
$settings.phash = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function input_input_handler_1() {
|
|
$settings.mdist = to_number(this.value);
|
|
settings.set($settings);
|
|
}
|
|
const func = (source, e) => e.domain == source.domain;
|
|
const remove_handler = (source) => removeBooru(source.domain);
|
|
const toggle_handler = (source) => toggleBooru(source.domain);
|
|
const click_handler2 = (ev) => {
|
|
dial.setPos([ev.clientX, ev.clientY]);
|
|
dial.toggle();
|
|
};
|
|
function input0_input_handler_1() {
|
|
newbooru.name = this.value;
|
|
$$invalidate(1, newbooru);
|
|
}
|
|
function input1_input_handler_1() {
|
|
newbooru.domain = this.value;
|
|
$$invalidate(1, newbooru);
|
|
}
|
|
function input2_input_handler() {
|
|
newbooru.endpoint = this.value;
|
|
$$invalidate(1, newbooru);
|
|
}
|
|
function input3_input_handler() {
|
|
newbooru.view = this.value;
|
|
$$invalidate(1, newbooru);
|
|
}
|
|
function dialog_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
dial = $$value;
|
|
$$invalidate(2, dial);
|
|
});
|
|
}
|
|
const toggle_handler_1 = (tag) => removeTag(tag);
|
|
const keydown_handler = (ev) => {
|
|
if (ev.key == "Enter") {
|
|
set_store_value(settings, $settings.blacklist = [...$settings.blacklist, ev.currentTarget.value], $settings);
|
|
ev.currentTarget.value = "";
|
|
}
|
|
};
|
|
function select_change_handler() {
|
|
$settings.fhost = select_value(this);
|
|
settings.set($settings);
|
|
}
|
|
function input_input_handler_2() {
|
|
$settings.maxe = to_number(this.value);
|
|
settings.set($settings);
|
|
}
|
|
function input_change_handler_2() {
|
|
$settings.tm = this.checked;
|
|
settings.set($settings);
|
|
}
|
|
function select_change_handler_1() {
|
|
$settings.pmeth = select_value(this);
|
|
settings.set($settings);
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("rev" in $$props2)
|
|
$$invalidate(0, rev = $$props2.rev);
|
|
};
|
|
return [
|
|
rev,
|
|
newbooru,
|
|
dial,
|
|
news,
|
|
visible,
|
|
updating,
|
|
threads,
|
|
$settings,
|
|
$appState,
|
|
$cached,
|
|
updateNews,
|
|
appendBooru,
|
|
removeTag,
|
|
removeBooru,
|
|
setFromClip,
|
|
boardname,
|
|
updateThreads,
|
|
toggleBooru,
|
|
cached,
|
|
select_handler,
|
|
select_handler_1,
|
|
input0_change_handler,
|
|
input1_change_handler,
|
|
input2_change_handler,
|
|
input3_change_handler,
|
|
input4_change_handler,
|
|
input5_change_handler,
|
|
input6_change_handler,
|
|
input7_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,
|
|
input_change_handler_1,
|
|
input0_change_handler_1,
|
|
input_input_handler_1,
|
|
func,
|
|
remove_handler,
|
|
toggle_handler,
|
|
click_handler2,
|
|
input0_input_handler_1,
|
|
input1_input_handler_1,
|
|
input2_input_handler,
|
|
input3_input_handler,
|
|
dialog_binding,
|
|
toggle_handler_1,
|
|
keydown_handler,
|
|
select_change_handler,
|
|
input_input_handler_2,
|
|
input_change_handler_2,
|
|
select_change_handler_1
|
|
];
|
|
}
|
|
var App = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance9, create_fragment9, safe_not_equal, { rev: 0 }, add_css8, [-1, -1, -1]);
|
|
}
|
|
get rev() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set rev(rev) {
|
|
this.$$set({ rev });
|
|
flush();
|
|
}
|
|
};
|
|
var App_default = App;
|
|
|
|
// src/Components/ScrollHighlighter.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css9(target) {
|
|
append_styles(target, "svelte-ausv8u", ".hint.svelte-ausv8u.svelte-ausv8u{background-color:rgb(222 222 222 / 80%);z-index:-1;pointer-events:none}.scroll-container.svelte-ausv8u.svelte-ausv8u{position:fixed;height:100%;width:12px;top:0;right:0;z-index:1000}.scroll-container.svelte-ausv8u span.svelte-ausv8u{position:absolute;right:0;width:33%;cursor:pointer;transition:width 200ms}.scroll-container.svelte-ausv8u:hover span.svelte-ausv8u{width:100%}");
|
|
}
|
|
function get_each_context3(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[14] = list[i];
|
|
child_ctx[16] = i;
|
|
return child_ctx;
|
|
}
|
|
function create_if_block7(ctx) {
|
|
let div;
|
|
let t;
|
|
let span;
|
|
let each_value = ctx[2].foundPosts;
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block3(get_each_context3(ctx, each_value, i));
|
|
}
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
t = space();
|
|
span = element("span");
|
|
attr(span, "class", "hint svelte-ausv8u");
|
|
attr(div, "class", "scroll-container svelte-ausv8u");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div, null);
|
|
}
|
|
append(div, t);
|
|
append(div, span);
|
|
ctx[5](span);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty & 5) {
|
|
each_value = ctx2[2].foundPosts;
|
|
let i;
|
|
for (i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context3(ctx2, each_value, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
} else {
|
|
each_blocks[i] = create_each_block3(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(div, t);
|
|
}
|
|
}
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
destroy_each(each_blocks, detaching);
|
|
ctx[5](null);
|
|
}
|
|
};
|
|
}
|
|
function create_each_block3(ctx) {
|
|
let span;
|
|
let mounted;
|
|
let dispose;
|
|
function click_handler2() {
|
|
return ctx[4](ctx[16]);
|
|
}
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
set_style(span, "top", ctx[0][ctx[16]][0] + "px");
|
|
set_style(span, "height", ctx[0][ctx[16]][1] + "px");
|
|
set_style(span, "background-color", ctx[0][ctx[16]][3]);
|
|
attr(span, "class", "marker svelte-ausv8u");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(span, "click", click_handler2);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
if (dirty & 1) {
|
|
set_style(span, "top", ctx[0][ctx[16]][0] + "px");
|
|
}
|
|
if (dirty & 1) {
|
|
set_style(span, "height", ctx[0][ctx[16]][1] + "px");
|
|
}
|
|
if (dirty & 1) {
|
|
set_style(span, "background-color", ctx[0][ctx[16]][3]);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_fragment10(ctx) {
|
|
let if_block_anchor;
|
|
let if_block = ctx[3].sh && create_if_block7(ctx);
|
|
return {
|
|
c() {
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (ctx2[3].sh) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block7(ctx2);
|
|
if_block.c();
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function getOffset(el) {
|
|
var _x = 0;
|
|
var _y = 0;
|
|
while (el && el instanceof HTMLElement) {
|
|
_x += el.offsetLeft - el.scrollLeft;
|
|
_y += el.offsetTop - el.scrollTop;
|
|
el = el.offsetParent;
|
|
}
|
|
return { top: _y, left: _x };
|
|
}
|
|
function instance10($$self, $$props, $$invalidate) {
|
|
let $appState;
|
|
let $settings;
|
|
component_subscribe($$self, appState, ($$value) => $$invalidate(2, $appState = $$value));
|
|
component_subscribe($$self, settings, ($$value) => $$invalidate(3, $settings = $$value));
|
|
let positions = [];
|
|
const getViewport = () => (typeof visualViewport != "undefined" ? () => [visualViewport.width, visualViewport.height] : () => [document.documentElement.clientWidth, document.documentElement.clientHeight])();
|
|
const getDistFromTop = () => (typeof visualViewport != "undefined" ? () => visualViewport.pageTop : () => document.documentElement.scrollTop)();
|
|
let viewhint;
|
|
const updatePositions = (v) => {
|
|
const [sw, sh] = getViewport();
|
|
const containerScrollHeight = document.documentElement.scrollHeight;
|
|
$$invalidate(0, positions = v.foundPosts.map((v2) => {
|
|
const coords = getOffset(v2);
|
|
const top = sh * (coords.top / containerScrollHeight);
|
|
const bot = sh * ((coords.top + v2.offsetHeight) / containerScrollHeight);
|
|
const hei = bot - top;
|
|
return [top, hei, coords.top, getComputedStyle(v2)["borderRightColor"]];
|
|
}));
|
|
};
|
|
const updateViewhint = () => {
|
|
if (!$settings.sh)
|
|
return;
|
|
const [sw, sh] = getViewport();
|
|
const fromtop = getDistFromTop();
|
|
const containerScrollHeight = document.documentElement.scrollHeight;
|
|
const top = sh * (fromtop / containerScrollHeight);
|
|
const bot = sh * ((fromtop + sh) / containerScrollHeight);
|
|
const hei = bot - top;
|
|
$$invalidate(1, viewhint.style.top = top + "px", viewhint);
|
|
$$invalidate(1, viewhint.style.height = hei + "px", viewhint);
|
|
};
|
|
appState.subscribe((v) => updatePositions(v));
|
|
const handleResize = () => {
|
|
updatePositions($appState);
|
|
};
|
|
let locked = false;
|
|
const handleScroll = async () => {
|
|
if (locked)
|
|
return;
|
|
locked = true;
|
|
updateViewhint();
|
|
await new Promise((_) => requestAnimationFrame(_));
|
|
locked = false;
|
|
};
|
|
const docRszObserver = new ResizeObserver((e) => {
|
|
updatePositions($appState);
|
|
updateViewhint();
|
|
});
|
|
onMount(() => {
|
|
window.addEventListener("resize", handleResize);
|
|
document.addEventListener("scroll", handleScroll);
|
|
updateViewhint();
|
|
docRszObserver.observe(document.documentElement);
|
|
});
|
|
onDestroy(() => {
|
|
window.removeEventListener("resize", handleResize);
|
|
document.addEventListener("scroll", handleScroll);
|
|
docRszObserver.unobserve(document.documentElement);
|
|
});
|
|
const click_handler2 = (i) => window.scrollTo(0, positions[i][2]);
|
|
function span_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
viewhint = $$value;
|
|
$$invalidate(1, viewhint);
|
|
});
|
|
}
|
|
return [positions, viewhint, $appState, $settings, click_handler2, span_binding];
|
|
}
|
|
var ScrollHighlighter = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance10, create_fragment10, safe_not_equal, {}, add_css9);
|
|
}
|
|
};
|
|
var ScrollHighlighter_default = ScrollHighlighter;
|
|
|
|
// src/Components/PostOptions.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css10(target) {
|
|
append_styles(target, "svelte-bgqqj3", "a.svelte-bgqqj3 i.svelte-bgqqj3{font-style:normal}a.svelte-bgqqj3.svelte-bgqqj3{cursor:pointer}.root.svelte-bgqqj3.svelte-bgqqj3{position:relative}.additionnal.svelte-bgqqj3.svelte-bgqqj3{display:none;position:absolute;flex-direction:column;gap:5px;outline:1px solid #ce3d08;padding:5px;background-color:#fffdee;border-radius:5px;left:50%;transform:translateX(-50%)}.root.svelte-bgqqj3:hover>.additionnal.svelte-bgqqj3{display:flex}");
|
|
}
|
|
function create_if_block8(ctx) {
|
|
let a;
|
|
let i;
|
|
let t_value = ctx[2].is4chanX ? "" : "\u274C";
|
|
let t;
|
|
let a_title_value;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
a = element("a");
|
|
i = element("i");
|
|
t = text(t_value);
|
|
attr(i, "class", "fa fa-times svelte-bgqqj3");
|
|
attr(a, "title", a_title_value = "Discard ALL " + ctx[0].length + " files");
|
|
attr(a, "class", "svelte-bgqqj3");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, a, anchor);
|
|
append(a, i);
|
|
append(i, t);
|
|
if (!mounted) {
|
|
dispose = listen(a, "click", ctx[8]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty & 4 && t_value !== (t_value = ctx2[2].is4chanX ? "" : "\u274C"))
|
|
set_data(t, t_value);
|
|
if (dirty & 1 && a_title_value !== (a_title_value = "Discard ALL " + ctx2[0].length + " files")) {
|
|
attr(a, "title", a_title_value);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(a);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_fragment11(ctx) {
|
|
let div1;
|
|
let a0;
|
|
let i0;
|
|
let t0_value = ctx[2].is4chanX ? "" : "\u{1F9F2}";
|
|
let t0;
|
|
let t1;
|
|
let div0;
|
|
let a1;
|
|
let i1;
|
|
let t2_value = ctx[2].is4chanX ? "" : "\u{1F589}";
|
|
let t2;
|
|
let t3;
|
|
let a2;
|
|
let i2;
|
|
let t4_value = ctx[2].is4chanX ? "" : "\u{1F4CB}";
|
|
let t4;
|
|
let t5;
|
|
let mounted;
|
|
let dispose;
|
|
let if_block = ctx[0].length && create_if_block8(ctx);
|
|
return {
|
|
c() {
|
|
div1 = element("div");
|
|
a0 = element("a");
|
|
i0 = element("i");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
div0 = element("div");
|
|
a1 = element("a");
|
|
i1 = element("i");
|
|
t2 = text(t2_value);
|
|
t3 = space();
|
|
a2 = element("a");
|
|
i2 = element("i");
|
|
t4 = text(t4_value);
|
|
t5 = space();
|
|
if (if_block)
|
|
if_block.c();
|
|
attr(i0, "class", "fa fa-magnet svelte-bgqqj3");
|
|
attr(a0, "title", "Add a file");
|
|
attr(a0, "class", "svelte-bgqqj3");
|
|
attr(i1, "class", "fa fa-pencil svelte-bgqqj3");
|
|
attr(a1, "title", "Add a message (this uses the content of the comment text box)");
|
|
attr(a1, "class", "svelte-bgqqj3");
|
|
attr(i2, "class", "fa fa-clipboard svelte-bgqqj3");
|
|
attr(a2, "title", "Add from clipboard (click this then CTRL+v)");
|
|
attr(a2, "class", "svelte-bgqqj3");
|
|
attr(div0, "class", "additionnal svelte-bgqqj3");
|
|
attr(div1, "class", "root svelte-bgqqj3");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, a0);
|
|
append(a0, i0);
|
|
append(i0, t0);
|
|
append(div1, t1);
|
|
append(div1, div0);
|
|
append(div0, a1);
|
|
append(a1, i1);
|
|
append(i1, t2);
|
|
append(div0, t3);
|
|
append(div0, a2);
|
|
append(a2, i2);
|
|
append(i2, t4);
|
|
append(div0, t5);
|
|
if (if_block)
|
|
if_block.m(div0, null);
|
|
ctx[9](div0);
|
|
if (!mounted) {
|
|
dispose = [
|
|
listen(a0, "click", ctx[5]),
|
|
listen(a1, "click", ctx[4])
|
|
];
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 4 && t0_value !== (t0_value = ctx2[2].is4chanX ? "" : "\u{1F9F2}"))
|
|
set_data(t0, t0_value);
|
|
if (dirty & 4 && t2_value !== (t2_value = ctx2[2].is4chanX ? "" : "\u{1F589}"))
|
|
set_data(t2, t2_value);
|
|
if (dirty & 4 && t4_value !== (t4_value = ctx2[2].is4chanX ? "" : "\u{1F4CB}"))
|
|
set_data(t4, t4_value);
|
|
if (ctx2[0].length) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block8(ctx2);
|
|
if_block.c();
|
|
if_block.m(div0, null);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div1);
|
|
if (if_block)
|
|
if_block.d();
|
|
ctx[9](null);
|
|
mounted = false;
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
function instance11($$self, $$props, $$invalidate) {
|
|
let $settings;
|
|
let $appState;
|
|
component_subscribe($$self, settings, ($$value) => $$invalidate(13, $settings = $$value));
|
|
component_subscribe($$self, appState, ($$value) => $$invalidate(2, $appState = $$value));
|
|
let { processors: processors2 = [] } = $$props;
|
|
let { textinput } = $$props;
|
|
let { links = [] } = $$props;
|
|
let floating;
|
|
const isParentOrSame = (p, ofe) => {
|
|
while (ofe && ofe != document.body) {
|
|
if (p == ofe)
|
|
return true;
|
|
ofe = ofe.parentElement;
|
|
}
|
|
return false;
|
|
};
|
|
const handleGlobalPaste = (e) => {
|
|
if (!e.clipboardData) {
|
|
return;
|
|
}
|
|
if (isParentOrSame(floating, e.target)) {
|
|
if (e.clipboardData.files.length == 0) {
|
|
if (e.clipboardData.types.includes("text/plain")) {
|
|
const data = e.clipboardData.getData("text/plain");
|
|
addContent(new File([new Blob([data], { type: "text/plain" })], `message${links.length}.txt`));
|
|
}
|
|
} else {
|
|
addContent(...[...e.clipboardData.files]);
|
|
}
|
|
e.stopImmediatePropagation();
|
|
e.stopPropagation();
|
|
return true;
|
|
}
|
|
};
|
|
onMount(() => {
|
|
document.addEventListener("paste", handleGlobalPaste, true);
|
|
});
|
|
const addContent = async (...newfiles) => {
|
|
$$invalidate(0, links = [...links, ...await uploadFiles(newfiles)]);
|
|
return embedContent({});
|
|
};
|
|
let original;
|
|
let currentEmbed;
|
|
function restore() {
|
|
externalDispatch("QRSetFile", { file: original });
|
|
}
|
|
let inhibit = false;
|
|
const isSame = (a, b) => {
|
|
if (a == null || b == null)
|
|
return false;
|
|
return ["size", "name", "lastModified"].every((e) => a[e] == b[e]);
|
|
};
|
|
document.addEventListener("PEEFile", async (e) => {
|
|
let file = e.detail;
|
|
if (!currentEmbed || !isSame(currentEmbed.file, file) && !inhibit) {
|
|
original = file;
|
|
if ($settings.auto_embed && $appState.client) {
|
|
const tags = $settings.auto_tags.split(" ").map((e2) => e2.replaceAll("_", " "));
|
|
const efs = await getFileFromHydrus($appState.client, tags.concat(["system:limit=" + $settings.auto_embed]), { file_sort_type: 4 });
|
|
const files = await embeddedToBlob(...efs.map((e2) => e2[1]));
|
|
const nlinks = await uploadFiles(files);
|
|
$$invalidate(0, links = [...links, ...nlinks]);
|
|
}
|
|
inhibit = true;
|
|
await embedContent(e);
|
|
setTimeout(() => inhibit = false, 500);
|
|
}
|
|
});
|
|
document.addEventListener("QRPostSuccessful", () => {
|
|
if (currentEmbed) {
|
|
$$invalidate(0, links = []);
|
|
currentEmbed = void 0;
|
|
original = void 0;
|
|
}
|
|
});
|
|
document.addEventListener("AddPEE", (e) => {
|
|
let link = e.detail;
|
|
$$invalidate(0, links = links.concat(link));
|
|
embedContent(e);
|
|
});
|
|
const embedText = async (e) => {
|
|
if (textinput.value == "")
|
|
return;
|
|
if (textinput.value.length > 2e3) {
|
|
fireNotification("error", "Message attachments are limited to 2000 characters");
|
|
return;
|
|
}
|
|
await addContent(new File([new Blob([textinput.value], { type: "text/plain" })], `message${links.length}.txt`));
|
|
$$invalidate(6, textinput.value = "", textinput);
|
|
};
|
|
const downloadFile = (f) => {
|
|
let file;
|
|
if ("file" in f)
|
|
file = f.file;
|
|
else
|
|
file = f;
|
|
var element2 = document.createElement("a");
|
|
element2.setAttribute("href", URL.createObjectURL(file));
|
|
element2.setAttribute("download", file.name);
|
|
element2.style.display = "none";
|
|
document.body.appendChild(element2);
|
|
element2.click();
|
|
document.body.removeChild(element2);
|
|
};
|
|
const embedContent = async (e) => {
|
|
let tfile = original;
|
|
if (!tfile)
|
|
return;
|
|
if (links.length == 0)
|
|
return;
|
|
const type = tfile.type;
|
|
let file;
|
|
if (!(tfile instanceof File)) {
|
|
const et = await fileTypeFromBuffer(await tfile.arrayBuffer());
|
|
if (!et)
|
|
throw new Error("Unsupported container type");
|
|
file = new File([tfile], `file.${et.ext}`);
|
|
} else {
|
|
file = tfile;
|
|
}
|
|
try {
|
|
const proc = processors2.filter((e2) => e2.inject).find((e2) => e2.match(file.name));
|
|
if (!proc)
|
|
throw new Error("Container filetype not supported");
|
|
const buff = await proc.inject(file, links.slice(0, $settings.maxe));
|
|
currentEmbed = {
|
|
file: new File([buff], file.name, { type })
|
|
};
|
|
externalDispatch("QRSetFile", currentEmbed);
|
|
fireNotification("success", `File${links.length > 1 ? "s" : ""} successfully embedded!`);
|
|
} catch (err) {
|
|
const e2 = err;
|
|
fireNotification("error", "Couldn't embed file: " + e2.message);
|
|
}
|
|
};
|
|
const embedFile = async (e) => {
|
|
const input = document.createElement("input");
|
|
input.setAttribute("type", "file");
|
|
input.multiple = true;
|
|
input.onchange = async (ev) => {
|
|
if (input.files) {
|
|
addContent(...input.files);
|
|
}
|
|
};
|
|
input.click();
|
|
};
|
|
const click_handler2 = () => ($$invalidate(0, links = []), restore());
|
|
function div0_binding($$value) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
floating = $$value;
|
|
$$invalidate(1, floating);
|
|
});
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("processors" in $$props2)
|
|
$$invalidate(7, processors2 = $$props2.processors);
|
|
if ("textinput" in $$props2)
|
|
$$invalidate(6, textinput = $$props2.textinput);
|
|
if ("links" in $$props2)
|
|
$$invalidate(0, links = $$props2.links);
|
|
};
|
|
return [
|
|
links,
|
|
floating,
|
|
$appState,
|
|
restore,
|
|
embedText,
|
|
embedFile,
|
|
textinput,
|
|
processors2,
|
|
click_handler2,
|
|
div0_binding
|
|
];
|
|
}
|
|
var PostOptions = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance11, create_fragment11, safe_not_equal, { processors: 7, textinput: 6, links: 0 }, add_css10);
|
|
}
|
|
get processors() {
|
|
return this.$$.ctx[7];
|
|
}
|
|
set processors(processors2) {
|
|
this.$$set({ processors: processors2 });
|
|
flush();
|
|
}
|
|
get textinput() {
|
|
return this.$$.ctx[6];
|
|
}
|
|
set textinput(textinput) {
|
|
this.$$set({ textinput });
|
|
flush();
|
|
}
|
|
get links() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set links(links) {
|
|
this.$$set({ links });
|
|
flush();
|
|
}
|
|
};
|
|
var PostOptions_default = PostOptions;
|
|
|
|
// src/Components/SettingsButton.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css11(target) {
|
|
append_styles(target, "svelte-55kf6x", ".glow.svelte-55kf6x{text-shadow:0 0 4px red}.clickable.svelte-55kf6x{cursor:pointer}.clickable.svelte-55kf6x:hover{text-shadow:0 0 4px palevioletred}");
|
|
}
|
|
function create_fragment12(ctx) {
|
|
let span;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
span.textContent = "[PEE Settings]";
|
|
attr(span, "class", "clickable svelte-55kf6x");
|
|
toggle_class(span, "glow", ctx[0]);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(span, "click", ctx[2]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 1) {
|
|
toggle_class(span, "glow", ctx2[0]);
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function instance12($$self, $$props, $$invalidate) {
|
|
"use strict";
|
|
let visible = false;
|
|
function opensettings() {
|
|
$$invalidate(0, visible = !visible);
|
|
document.dispatchEvent(new CustomEvent("penis"));
|
|
}
|
|
const click_handler2 = () => opensettings();
|
|
return [visible, opensettings, click_handler2];
|
|
}
|
|
var SettingsButton = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance12, create_fragment12, safe_not_equal, {}, add_css11);
|
|
}
|
|
};
|
|
var SettingsButton_default = SettingsButton;
|
|
|
|
// src/Components/Embeddings.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function get_each_context4(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[7] = list[i];
|
|
child_ctx[8] = list;
|
|
child_ctx[9] = i;
|
|
return child_ctx;
|
|
}
|
|
function create_each_block4(ctx) {
|
|
let embedding;
|
|
let i = ctx[9];
|
|
let current;
|
|
const assign_embedding = () => ctx[5](embedding, i);
|
|
const unassign_embedding = () => ctx[5](null, i);
|
|
let embedding_props = { id: ctx[1], file: ctx[7] };
|
|
embedding = new Embedding_default({ props: embedding_props });
|
|
assign_embedding();
|
|
embedding.$on("fileinfo", ctx[6]);
|
|
return {
|
|
c() {
|
|
create_component(embedding.$$.fragment);
|
|
},
|
|
m(target, anchor) {
|
|
mount_component(embedding, target, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (i !== ctx2[9]) {
|
|
unassign_embedding();
|
|
i = ctx2[9];
|
|
assign_embedding();
|
|
}
|
|
const embedding_changes = {};
|
|
if (dirty & 2)
|
|
embedding_changes.id = ctx2[1];
|
|
if (dirty & 1)
|
|
embedding_changes.file = ctx2[7];
|
|
embedding.$set(embedding_changes);
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
transition_in(embedding.$$.fragment, local);
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
transition_out(embedding.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
unassign_embedding();
|
|
destroy_component(embedding, detaching);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment13(ctx) {
|
|
let each_1_anchor;
|
|
let current;
|
|
let each_value = ctx[0];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block4(get_each_context4(ctx, each_value, i));
|
|
}
|
|
const out = (i) => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
return {
|
|
c() {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
each_1_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(target, anchor);
|
|
}
|
|
insert(target, each_1_anchor, anchor);
|
|
current = true;
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 7) {
|
|
each_value = ctx2[0];
|
|
let i;
|
|
for (i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context4(ctx2, each_value, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block4(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
|
|
}
|
|
}
|
|
group_outros();
|
|
for (i = each_value.length; i < each_blocks.length; i += 1) {
|
|
out(i);
|
|
}
|
|
check_outros();
|
|
}
|
|
},
|
|
i(local) {
|
|
if (current)
|
|
return;
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
transition_in(each_blocks[i]);
|
|
}
|
|
current = true;
|
|
},
|
|
o(local) {
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
transition_out(each_blocks[i]);
|
|
}
|
|
current = false;
|
|
},
|
|
d(detaching) {
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(each_1_anchor);
|
|
}
|
|
};
|
|
}
|
|
function instance13($$self, $$props, $$invalidate) {
|
|
const dispatch2 = createEventDispatcher();
|
|
let { files } = $$props;
|
|
let { id = "" } = $$props;
|
|
let children2 = {};
|
|
async function bepis(ev) {
|
|
for (let child of Object.values(children2))
|
|
child.bepis(ev);
|
|
}
|
|
function embedding_binding($$value, i) {
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
|
children2[i] = $$value;
|
|
$$invalidate(2, children2);
|
|
});
|
|
}
|
|
function fileinfo_handler(event) {
|
|
bubble.call(this, $$self, event);
|
|
}
|
|
$$self.$$set = ($$props2) => {
|
|
if ("files" in $$props2)
|
|
$$invalidate(0, files = $$props2.files);
|
|
if ("id" in $$props2)
|
|
$$invalidate(1, id = $$props2.id);
|
|
};
|
|
return [files, id, children2, dispatch2, bepis, embedding_binding, fileinfo_handler];
|
|
}
|
|
var Embeddings = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance13, create_fragment13, safe_not_equal, { dispatch: 3, files: 0, id: 1, bepis: 4 });
|
|
}
|
|
get dispatch() {
|
|
return this.$$.ctx[3];
|
|
}
|
|
get files() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set files(files) {
|
|
this.$$set({ files });
|
|
flush();
|
|
}
|
|
get id() {
|
|
return this.$$.ctx[1];
|
|
}
|
|
set id(id) {
|
|
this.$$set({ id });
|
|
flush();
|
|
}
|
|
get bepis() {
|
|
return this.$$.ctx[4];
|
|
}
|
|
};
|
|
var Embeddings_default = Embeddings;
|
|
|
|
// src/Components/EyeButton.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var import_buffer8 = __toESM(require_buffer(), 1);
|
|
function add_css12(target) {
|
|
append_styles(target, "svelte-64lw6s", ".clickable.svelte-64lw6s{cursor:pointer;margin-left:5px}.clickable.svelte-64lw6s:hover{text-shadow:0 0 4px palevioletred}");
|
|
}
|
|
function get_each_context5(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[12] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function create_if_block_33(ctx) {
|
|
let span;
|
|
let t_value = ctx[5].is4chanX ? "" : !ctx[3] ? "\u{1F441}" : "\u{1F926}";
|
|
let t;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
t = text(t_value);
|
|
attr(span, "class", "fa clickable svelte-64lw6s");
|
|
toggle_class(span, "fa-eye", !ctx[3]);
|
|
toggle_class(span, "fa-eye-slash", ctx[3]);
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
append(span, t);
|
|
if (!mounted) {
|
|
dispose = listen(span, "click", ctx[6]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty & 40 && t_value !== (t_value = ctx2[5].is4chanX ? "" : !ctx2[3] ? "\u{1F441}" : "\u{1F926}"))
|
|
set_data(t, t_value);
|
|
if (dirty & 8) {
|
|
toggle_class(span, "fa-eye", !ctx2[3]);
|
|
}
|
|
if (dirty & 8) {
|
|
toggle_class(span, "fa-eye-slash", ctx2[3]);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_23(ctx) {
|
|
let a;
|
|
let t;
|
|
let a_href_value;
|
|
return {
|
|
c() {
|
|
a = element("a");
|
|
t = text("Source");
|
|
attr(a, "href", a_href_value = ctx[12].source);
|
|
attr(a, "target", "_blank");
|
|
attr(a, "class", "clickable svelte-64lw6s");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, a, anchor);
|
|
append(a, t);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty & 1 && a_href_value !== (a_href_value = ctx2[12].source)) {
|
|
attr(a, "href", a_href_value);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(a);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_15(ctx) {
|
|
let a;
|
|
let t_value = ctx[12].page.title + "";
|
|
let t;
|
|
let a_href_value;
|
|
return {
|
|
c() {
|
|
a = element("a");
|
|
t = text(t_value);
|
|
attr(a, "href", a_href_value = ctx[12].page.url);
|
|
attr(a, "target", "_blank");
|
|
attr(a, "class", "clickable svelte-64lw6s");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, a, anchor);
|
|
append(a, t);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty & 1 && t_value !== (t_value = ctx2[12].page.title + ""))
|
|
set_data(t, t_value);
|
|
if (dirty & 1 && a_href_value !== (a_href_value = ctx2[12].page.url)) {
|
|
attr(a, "href", a_href_value);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(a);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block9(ctx) {
|
|
let a;
|
|
let mounted;
|
|
let dispose;
|
|
return {
|
|
c() {
|
|
a = element("a");
|
|
a.textContent = "[PEE contract]";
|
|
attr(a, "alt", "By clicking this you agree to stay hydrated");
|
|
attr(a, "class", "clickable svelte-64lw6s");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, a, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(a, "click", ctx[11]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(a);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_each_block5(ctx) {
|
|
let span;
|
|
let t0_value = ctx[5].is4chanX ? "" : "\u{1F5AB}";
|
|
let t0;
|
|
let span_title_value;
|
|
let t1;
|
|
let t2;
|
|
let t3;
|
|
let if_block2_anchor;
|
|
let mounted;
|
|
let dispose;
|
|
function click_handler2() {
|
|
return ctx[10](ctx[12]);
|
|
}
|
|
let if_block0 = ctx[12].source && create_if_block_23(ctx);
|
|
let if_block1 = ctx[12].page && create_if_block_15(ctx);
|
|
let if_block2 = ctx[7] && ctx[2] && create_if_block9(ctx);
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
if (if_block0)
|
|
if_block0.c();
|
|
t2 = space();
|
|
if (if_block1)
|
|
if_block1.c();
|
|
t3 = space();
|
|
if (if_block2)
|
|
if_block2.c();
|
|
if_block2_anchor = empty();
|
|
attr(span, "title", span_title_value = ctx[12].filename);
|
|
attr(span, "class", "fa fa-download clickable svelte-64lw6s");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
append(span, t0);
|
|
insert(target, t1, anchor);
|
|
if (if_block0)
|
|
if_block0.m(target, anchor);
|
|
insert(target, t2, anchor);
|
|
if (if_block1)
|
|
if_block1.m(target, anchor);
|
|
insert(target, t3, anchor);
|
|
if (if_block2)
|
|
if_block2.m(target, anchor);
|
|
insert(target, if_block2_anchor, anchor);
|
|
if (!mounted) {
|
|
dispose = listen(span, "click", click_handler2);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
if (dirty & 32 && t0_value !== (t0_value = ctx[5].is4chanX ? "" : "\u{1F5AB}"))
|
|
set_data(t0, t0_value);
|
|
if (dirty & 1 && span_title_value !== (span_title_value = ctx[12].filename)) {
|
|
attr(span, "title", span_title_value);
|
|
}
|
|
if (ctx[12].source) {
|
|
if (if_block0) {
|
|
if_block0.p(ctx, dirty);
|
|
} else {
|
|
if_block0 = create_if_block_23(ctx);
|
|
if_block0.c();
|
|
if_block0.m(t2.parentNode, t2);
|
|
}
|
|
} else if (if_block0) {
|
|
if_block0.d(1);
|
|
if_block0 = null;
|
|
}
|
|
if (ctx[12].page) {
|
|
if (if_block1) {
|
|
if_block1.p(ctx, dirty);
|
|
} else {
|
|
if_block1 = create_if_block_15(ctx);
|
|
if_block1.c();
|
|
if_block1.m(t3.parentNode, t3);
|
|
}
|
|
} else if (if_block1) {
|
|
if_block1.d(1);
|
|
if_block1 = null;
|
|
}
|
|
if (ctx[7] && ctx[2]) {
|
|
if (if_block2) {
|
|
if_block2.p(ctx, dirty);
|
|
} else {
|
|
if_block2 = create_if_block9(ctx);
|
|
if_block2.c();
|
|
if_block2.m(if_block2_anchor.parentNode, if_block2_anchor);
|
|
}
|
|
} else if (if_block2) {
|
|
if_block2.d(1);
|
|
if_block2 = null;
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
if (detaching)
|
|
detach(t1);
|
|
if (if_block0)
|
|
if_block0.d(detaching);
|
|
if (detaching)
|
|
detach(t2);
|
|
if (if_block1)
|
|
if_block1.d(detaching);
|
|
if (detaching)
|
|
detach(t3);
|
|
if (if_block2)
|
|
if_block2.d(detaching);
|
|
if (detaching)
|
|
detach(if_block2_anchor);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_fragment14(ctx) {
|
|
let t;
|
|
let each_1_anchor;
|
|
let if_block = ctx[4].eye && create_if_block_33(ctx);
|
|
let each_value = ctx[0];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block5(get_each_context5(ctx, each_value, i));
|
|
}
|
|
return {
|
|
c() {
|
|
if (if_block)
|
|
if_block.c();
|
|
t = space();
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
each_1_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, t, anchor);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(target, anchor);
|
|
}
|
|
insert(target, each_1_anchor, anchor);
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (ctx2[4].eye) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block_33(ctx2);
|
|
if_block.c();
|
|
if_block.m(t.parentNode, t);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
if (dirty & 423) {
|
|
each_value = ctx2[0];
|
|
let i;
|
|
for (i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context5(ctx2, each_value, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
} else {
|
|
each_blocks[i] = create_each_block5(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
|
|
}
|
|
}
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(t);
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(each_1_anchor);
|
|
}
|
|
};
|
|
}
|
|
function instance14($$self, $$props, $$invalidate) {
|
|
let $settings;
|
|
let $appState;
|
|
component_subscribe($$self, settings, ($$value) => $$invalidate(4, $settings = $$value));
|
|
component_subscribe($$self, appState, ($$value) => $$invalidate(5, $appState = $$value));
|
|
let { id = "" } = $$props;
|
|
let { files } = $$props;
|
|
let { inst } = $$props;
|
|
let isVideo = false;
|
|
inst.$on("fileinfo", (info) => {
|
|
$$invalidate(2, isVideo = isVideo || info.detail.type.mime.startsWith("video/"));
|
|
});
|
|
let visible = false;
|
|
function reveal() {
|
|
$$invalidate(3, visible = !visible);
|
|
document.dispatchEvent(new CustomEvent("reveal", { detail: { id } }));
|
|
}
|
|
const isNotChrome = !navigator.userAgent.includes("Chrome/");
|
|
async function downloadFile(file) {
|
|
const a = document.createElement("a");
|
|
document.body.appendChild(a);
|
|
a.style.display = "none";
|
|
let url;
|
|
if (typeof file.data != "string") {
|
|
const thumb = file.data instanceof Uint8Array ? file.data : await file.data();
|
|
const type = await fileTypeFromBuffer(thumb);
|
|
url = URL.createObjectURL(new Blob([thumb], { type: type?.mime }));
|
|
} else
|
|
url = file.data;
|
|
a.href = url;
|
|
a.download = file.filename;
|
|
a.click();
|
|
window.URL.revokeObjectURL(url);
|
|
}
|
|
const click_handler2 = (file) => downloadFile(file);
|
|
const click_handler_1 = (ev) => {
|
|
inst.bepis(ev);
|
|
};
|
|
$$self.$$set = ($$props2) => {
|
|
if ("id" in $$props2)
|
|
$$invalidate(9, id = $$props2.id);
|
|
if ("files" in $$props2)
|
|
$$invalidate(0, files = $$props2.files);
|
|
if ("inst" in $$props2)
|
|
$$invalidate(1, inst = $$props2.inst);
|
|
};
|
|
return [
|
|
files,
|
|
inst,
|
|
isVideo,
|
|
visible,
|
|
$settings,
|
|
$appState,
|
|
reveal,
|
|
isNotChrome,
|
|
downloadFile,
|
|
id,
|
|
click_handler2,
|
|
click_handler_1
|
|
];
|
|
}
|
|
var EyeButton = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance14, create_fragment14, safe_not_equal, { id: 9, files: 0, inst: 1 }, add_css12);
|
|
}
|
|
get id() {
|
|
return this.$$.ctx[9];
|
|
}
|
|
set id(id) {
|
|
this.$$set({ id });
|
|
flush();
|
|
}
|
|
get files() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set files(files) {
|
|
this.$$set({ files });
|
|
flush();
|
|
}
|
|
get inst() {
|
|
return this.$$.ctx[1];
|
|
}
|
|
set inst(inst) {
|
|
this.$$set({ inst });
|
|
flush();
|
|
}
|
|
};
|
|
var EyeButton_default = EyeButton;
|
|
|
|
// src/Components/NotificationsHandler.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css13(target) {
|
|
append_styles(target, "svelte-5t4r47", ".clickable.svelte-5t4r47.svelte-5t4r47{cursor:pointer;float:right}.root.svelte-5t4r47>span.svelte-5t4r47{display:flex;gap:10px;border:1px solid;padding:10px;border-radius:5px;font-weight:bolder;color:white;min-width:45vw}.root.svelte-5t4r47.svelte-5t4r47{position:fixed;top:0;left:50%;transform:translateX(-50%);display:flex;flex-direction:column;gap:10px}.error.svelte-5t4r47.svelte-5t4r47{background-color:crimson}.info.svelte-5t4r47.svelte-5t4r47{background-color:cornflowerblue}.warning.svelte-5t4r47.svelte-5t4r47{background-color:darkgoldenrod}.success.svelte-5t4r47.svelte-5t4r47{background-color:green}");
|
|
}
|
|
function get_each_context6(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[4] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function create_each_block6(key_1, ctx) {
|
|
let span1;
|
|
let t0_value = ctx[4].content + "";
|
|
let t0;
|
|
let span0;
|
|
let span1_class_value;
|
|
let mounted;
|
|
let dispose;
|
|
function click_handler2() {
|
|
return ctx[2](ctx[4]);
|
|
}
|
|
return {
|
|
key: key_1,
|
|
first: null,
|
|
c() {
|
|
span1 = element("span");
|
|
t0 = text(t0_value);
|
|
span0 = element("span");
|
|
span0.textContent = "X";
|
|
attr(span0, "class", "clickable svelte-5t4r47");
|
|
attr(span1, "class", span1_class_value = null_to_empty(ctx[4].type) + " svelte-5t4r47");
|
|
this.first = span1;
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span1, anchor);
|
|
append(span1, t0);
|
|
append(span1, span0);
|
|
if (!mounted) {
|
|
dispose = listen(span0, "click", click_handler2);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(new_ctx, dirty) {
|
|
ctx = new_ctx;
|
|
if (dirty & 1 && t0_value !== (t0_value = ctx[4].content + ""))
|
|
set_data(t0, t0_value);
|
|
if (dirty & 1 && span1_class_value !== (span1_class_value = null_to_empty(ctx[4].type) + " svelte-5t4r47")) {
|
|
attr(span1, "class", span1_class_value);
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span1);
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_fragment15(ctx) {
|
|
let div;
|
|
let each_blocks = [];
|
|
let each_1_lookup = /* @__PURE__ */ new Map();
|
|
let each_value = ctx[0];
|
|
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 key2 = get_key(child_ctx);
|
|
each_1_lookup.set(key2, each_blocks[i] = create_each_block6(key2, child_ctx));
|
|
}
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(div, "class", "root svelte-5t4r47");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div, null);
|
|
}
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 3) {
|
|
each_value = ctx2[0];
|
|
each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx2, each_value, each_1_lookup, div, destroy_block, create_each_block6, null, get_each_context6);
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function instance15($$self, $$props, $$invalidate) {
|
|
let { nots = [] } = $$props;
|
|
const removeId = (id) => $$invalidate(0, nots = nots.filter((e) => e.id != id));
|
|
let gid2 = 0;
|
|
document.addEventListener("CreateNotification", (e) => {
|
|
const id = gid2++;
|
|
$$invalidate(0, nots = [...nots, { ...e.detail, id }]);
|
|
setTimeout(() => removeId(id), (e.detail.lifetime || 3) * 1e3);
|
|
});
|
|
const click_handler2 = (not) => removeId(not.id);
|
|
$$self.$$set = ($$props2) => {
|
|
if ("nots" in $$props2)
|
|
$$invalidate(0, nots = $$props2.nots);
|
|
};
|
|
return [nots, removeId, click_handler2];
|
|
}
|
|
var NotificationsHandler = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance15, create_fragment15, safe_not_equal, { nots: 0 }, add_css13);
|
|
}
|
|
get nots() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set nots(nots) {
|
|
this.$$set({ nots });
|
|
flush();
|
|
}
|
|
};
|
|
var NotificationsHandler_default = NotificationsHandler;
|
|
|
|
// src/websites/index.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var V4chan = {
|
|
getFileThumbnail: (post) => post.querySelector("div.file"),
|
|
getPost: (post) => post.classList.contains("post") ? post : post.querySelector(".post"),
|
|
postsWithFiles: (h) => [...(h || document).querySelectorAll(".file")].map((e) => e.closest(".postContainer")),
|
|
settingsHost: () => document.getElementById("navtopright"),
|
|
catalogControlHost: () => document.getElementById("settings"),
|
|
getImageLink: async function* (post) {
|
|
let href = post.querySelector('a[target="_blank"]')?.getAttribute("href");
|
|
if (href)
|
|
href += `?${Date.now()}`;
|
|
yield href || "";
|
|
},
|
|
getFilename: (post) => {
|
|
const a = post.querySelector('a[target="_blank"]');
|
|
if (a && a.title)
|
|
return a.title;
|
|
return a?.textContent || "";
|
|
},
|
|
getMD5: (post) => post.querySelector("img[data-md5]")?.getAttribute("data-md5") || "",
|
|
getThumbnailLink: (post) => post.querySelector("img[data-md5]")?.getAttribute("src") || "",
|
|
getInfoBox: (post) => post.querySelector("div.fileText"),
|
|
getPostIdPrefix: () => "p",
|
|
getTextBox: (post) => post.querySelector("blockquote"),
|
|
getCurrentBoard: () => location.pathname.split("/")[1],
|
|
getCurrentThread: () => +location.pathname.split("/")[3]
|
|
};
|
|
var X4chan = {
|
|
getFileThumbnail: (post) => post.querySelector("div.file"),
|
|
getPost: (post) => V4chan.getPost(post),
|
|
postsWithFiles: (h) => [...(h || document).querySelectorAll('.postContainer:not([class*="noFile"])')],
|
|
settingsHost: () => document.getElementById("shortcuts"),
|
|
catalogControlHost: () => document.getElementById("index-options"),
|
|
getImageLink: async function* (post) {
|
|
let href = post.querySelector('a[target="_blank"]')?.getAttribute("href");
|
|
if (href)
|
|
href += `?${Date.now()}`;
|
|
yield href || "";
|
|
},
|
|
getFilename: (post) => {
|
|
const a = post.querySelector('a[target="_blank"]');
|
|
const origlink = post.querySelector('.file-info > a[target*="_blank"]');
|
|
return (origlink?.querySelector(".fnfull") || origlink)?.textContent || V4chan.getFilename(post) || "";
|
|
},
|
|
getMD5: (post) => post.querySelector("img[data-md5]")?.getAttribute("data-md5") || "",
|
|
getThumbnailLink: (post) => post.querySelector("img[data-md5]")?.getAttribute("src") || "",
|
|
getInfoBox: (post) => post.querySelector("span.file-info") || V4chan.getInfoBox(post),
|
|
getPostIdPrefix: V4chan.getPostIdPrefix,
|
|
getTextBox: V4chan.getTextBox,
|
|
getCurrentBoard: V4chan.getCurrentBoard,
|
|
getCurrentThread: V4chan.getCurrentThread
|
|
};
|
|
var FoolFuuka = {
|
|
getFileThumbnail: (post) => post.classList.contains("post_is_op") ? post.querySelector(".thread_image_link") : post.querySelector(".thread_image_box"),
|
|
getPost: (post) => post.querySelector(".post_wrapper") || post,
|
|
postsWithFiles: (h) => [...(h || document).querySelectorAll('article[class*="thread"], article[class*="has_image"]')],
|
|
settingsHost: () => document.querySelector(".letters"),
|
|
catalogControlHost: () => document.getElementById("index-options"),
|
|
getImageLink: async function* (post) {
|
|
if (location.host == "arch.b4k.co") {
|
|
return;
|
|
}
|
|
yield post.querySelector("a[rel]")?.getAttribute("href") || "";
|
|
},
|
|
getFilename: (post) => {
|
|
const opfn = post.querySelector(".post_file_filename")?.textContent;
|
|
if (opfn)
|
|
return opfn;
|
|
const a = post.querySelector("a[rel]");
|
|
return a?.title || "";
|
|
},
|
|
getMD5: (post) => post.querySelector("img[data-md5]")?.getAttribute("data-md5") || "",
|
|
getThumbnailLink: (post) => {
|
|
const e = post.querySelector("img[data-md5]");
|
|
return e?.getAttribute("src") || e?.getAttribute("data-src") || "";
|
|
},
|
|
getInfoBox: (post) => post.querySelector("span.post_controls"),
|
|
getPostIdPrefix: () => "",
|
|
getTextBox: (post) => post.querySelector(".text"),
|
|
getCurrentBoard: V4chan.getCurrentBoard,
|
|
getCurrentThread: V4chan.getCurrentThread
|
|
};
|
|
var KChan = {
|
|
getFileThumbnail: (post) => post.querySelector("figure.uploadCell"),
|
|
getPost: (post) => post.querySelector(".innerPost"),
|
|
postsWithFiles: (h) => [...(h || document).querySelectorAll(".postCell")].filter((p) => p.querySelector("figure")),
|
|
settingsHost: () => document.getElementById("navOptionsSpanThread") || document.getElementById("navOptionsSpan") || document.getElementById("navOptionsSpanCatalog"),
|
|
catalogControlHost: () => document.getElementById("divTools"),
|
|
getImageLink: async function* (post) {
|
|
yield post.querySelector('a.imgLink[target="_blank"]')?.href || "";
|
|
},
|
|
getFilename: (post) => {
|
|
const a = post.querySelector(".imgLink > img");
|
|
if (a && a.title)
|
|
return a.title;
|
|
return a?.textContent || "";
|
|
},
|
|
getMD5: (post) => "",
|
|
getThumbnailLink: (post) => post.querySelector(".imgLink > img")?.getAttribute("src") || "",
|
|
getInfoBox: (post) => post.querySelector("div.uploadDetails"),
|
|
getPostIdPrefix: () => "",
|
|
getTextBox: (post) => post.querySelector(".divMessage"),
|
|
getCurrentBoard: () => location.pathname.split("/")[1],
|
|
getCurrentThread: () => +location.pathname.split("/")[3]
|
|
};
|
|
var getQueryProcessor = (is4chanX) => {
|
|
if (["boards.4chan.org", "boards.4channel.org"].includes(location.host))
|
|
return is4chanX ? X4chan : V4chan;
|
|
if (["kohlchan.net", "nocsp.kohlchan.net"].includes(location.host)) {
|
|
return KChan;
|
|
}
|
|
if (document.querySelector('meta[name="generator"]')?.getAttribute("content")?.startsWith("FoolFuuka"))
|
|
return FoolFuuka;
|
|
};
|
|
var altdomains = [
|
|
"kohlchan.net",
|
|
"nocsp.kohlchan.net"
|
|
];
|
|
function supportedAltDomain(s) {
|
|
return altdomains.includes(s);
|
|
}
|
|
function supportedMainDomain(s) {
|
|
return ["boards.4channel.org", "boards.4chan.org"].includes(s);
|
|
}
|
|
|
|
// src/Components/TextEmbeddings.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/linkify-string/dist/linkify-string.es.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// node_modules/linkifyjs/dist/linkify.es.js
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var tlds = "aaa aarp abarth abb abbott abbvie abc able abogado abudhabi ac academy accenture accountant accountants aco actor ad adac ads adult ae aeg aero aetna af afl africa ag agakhan agency ai aig airbus airforce airtel akdn al alfaromeo alibaba alipay allfinanz allstate ally alsace alstom am amazon americanexpress americanfamily amex amfam amica amsterdam analytics android anquan anz ao aol apartments app apple aq aquarelle ar arab aramco archi army arpa art arte as asda asia associates at athleta attorney au auction audi audible audio auspost author auto autos avianca aw aws ax axa az azure ba baby baidu banamex bananarepublic band bank bar barcelona barclaycard barclays barefoot bargains baseball basketball bauhaus bayern bb bbc bbt bbva bcg bcn bd be beats beauty beer bentley berlin best bestbuy bet bf bg bh bharti bi bible bid bike bing bingo bio biz bj black blackfriday blockbuster blog bloomberg blue bm bms bmw bn bnpparibas bo boats boehringer bofa bom bond boo book booking bosch bostik boston bot boutique box br bradesco bridgestone broadway broker brother brussels bs bt bugatti build builders business buy buzz bv bw by bz bzh ca cab cafe cal call calvinklein cam camera camp cancerresearch canon capetown capital capitalone car caravan cards care career careers cars casa case cash casino cat catering catholic cba cbn cbre cbs cc cd center ceo cern cf cfa cfd cg ch chanel channel charity chase chat cheap chintai christmas chrome church ci cipriani circle cisco citadel citi citic city cityeats ck cl claims cleaning click clinic clinique clothing cloud club clubmed cm cn co coach codes coffee college cologne com comcast commbank community company compare computer comsec condos construction consulting contact contractors cooking cookingchannel cool coop corsica country coupon coupons courses cpa cr credit creditcard creditunion cricket crown crs cruise cruises cu cuisinella cv cw cx cy cymru cyou cz dabur dad dance data date dating datsun day dclk dds de deal dealer deals degree delivery dell deloitte delta democrat dental dentist desi design dev dhl diamonds diet digital direct directory discount discover dish diy dj dk dm dnp do docs doctor dog domains dot download drive dtv dubai dunlop dupont durban dvag dvr dz earth eat ec eco edeka edu education ee eg email emerck energy engineer engineering enterprises epson equipment er ericsson erni es esq estate et etisalat eu eurovision eus events exchange expert exposed express extraspace fage fail fairwinds faith family fan fans farm farmers fashion fast fedex feedback ferrari ferrero fi fiat fidelity fido film final finance financial fire firestone firmdale fish fishing fit fitness fj fk flickr flights flir florist flowers fly fm fo foo food foodnetwork football ford forex forsale forum foundation fox fr free fresenius frl frogans frontdoor frontier ftr fujitsu fun fund furniture futbol fyi ga gal gallery gallo gallup game games gap garden gay gb gbiz gd gdn ge gea gent genting george gf gg ggee gh gi gift gifts gives giving gl glass gle global globo gm gmail gmbh gmo gmx gn godaddy gold goldpoint golf goo goodyear goog google gop got gov gp gq gr grainger graphics gratis green gripe grocery group gs gt gu guardian gucci guge guide guitars guru gw gy hair hamburg hangout haus hbo hdfc hdfcbank health healthcare help helsinki here hermes hgtv hiphop hisamitsu hitachi hiv hk hkt hm hn hockey holdings holiday homedepot homegoods homes homesense honda horse hospital host hosting hot hoteles hotels hotmail house how hr hsbc ht hu hughes hyatt hyundai ibm icbc ice icu id ie ieee ifm ikano il im imamat imdb immo immobilien in inc industries infiniti info ing ink institute insurance insure int international intuit investments io ipiranga iq ir irish is ismaili ist istanbul it itau itv jaguar java jcb je jeep jetzt jewelry jio jll jm jmp jnj jo jobs joburg jot joy jp jpmorgan jprs juegos juniper kaufen kddi ke kerryhotels kerrylogistics kerryproperties kfh kg kh ki kia kids kim kinder kindle kitchen kiwi km kn koeln komatsu kosher kp kpmg kpn kr krd kred kuokgroup kw ky kyoto kz la lacaixa lamborghini lamer lancaster lancia land landrover lanxess lasalle lat latino latrobe law lawyer lb lc lds lease leclerc lefrak legal lego lexus lgbt li lidl life lifeinsurance lifestyle lighting like lilly limited limo lincoln linde link lipsy live living lk llc llp loan loans locker locus loft lol london lotte lotto love lpl lplfinancial lr ls lt ltd ltda lu lundbeck luxe luxury lv ly ma macys madrid maif maison makeup man management mango map market marketing markets marriott marshalls maserati mattel mba mc mckinsey md me med media meet melbourne meme memorial men menu merckmsd mg mh miami microsoft mil mini mint mit mitsubishi mk ml mlb mls mm mma mn mo mobi mobile moda moe moi mom monash money monster mormon mortgage moscow moto motorcycles mov movie mp mq mr ms msd mt mtn mtr mu museum music mutual mv mw mx my mz na nab nagoya name natura navy nba nc ne nec net netbank netflix network neustar new news next nextdirect nexus nf nfl ng ngo nhk ni nico nike nikon ninja nissan nissay nl no nokia northwesternmutual norton now nowruz nowtv np nr nra nrw ntt nu nyc nz obi observer office okinawa olayan olayangroup oldnavy ollo om omega one ong onl online ooo open oracle orange org organic origins osaka otsuka ott ovh pa page panasonic paris pars partners parts party passagens pay pccw pe pet pf pfizer pg ph pharmacy phd philips phone photo photography photos physio pics pictet pictures pid pin ping pink pioneer pizza pk pl place play playstation plumbing plus pm pn pnc pohl poker politie porn post pr pramerica praxi press prime pro prod productions prof progressive promo properties property protection pru prudential ps pt pub pw pwc py qa qpon quebec quest racing radio re read realestate realtor realty recipes red redstone redumbrella rehab reise reisen reit reliance ren rent rentals repair report republican rest restaurant review reviews rexroth rich richardli ricoh ril rio rip ro rocher rocks rodeo rogers room rs rsvp ru rugby ruhr run rw rwe ryukyu sa saarland safe safety sakura sale salon samsclub samsung sandvik sandvikcoromant sanofi sap sarl sas save saxo sb sbi sbs sc sca scb schaeffler schmidt scholarships school schule schwarz science scot sd se search seat secure security seek select sener services ses seven sew sex sexy sfr sg sh shangrila sharp shaw shell shia shiksha shoes shop shopping shouji show showtime si silk sina singles site sj sk ski skin sky skype sl sling sm smart smile sn sncf so soccer social softbank software sohu solar solutions song sony soy spa space sport spot sr srl ss st stada staples star statebank statefarm stc stcgroup stockholm storage store stream studio study style su sucks supplies supply support surf surgery suzuki sv swatch swiss sx sy sydney systems sz tab taipei talk taobao target tatamotors tatar tattoo tax taxi tc tci td tdk team tech technology tel temasek tennis teva tf tg th thd theater theatre tiaa tickets tienda tiffany tips tires tirol tj tjmaxx tjx tk tkmaxx tl tm tmall tn to today tokyo tools top toray toshiba total tours town toyota toys tr trade trading training travel travelchannel travelers travelersinsurance trust trv tt tube tui tunes tushu tv tvs tw tz ua ubank ubs ug uk unicom university uno uol ups us uy uz va vacations vana vanguard vc ve vegas ventures verisign verm\xF6gensberater verm\xF6gensberatung versicherung vet vg vi viajes video vig viking villas vin vip virgin visa vision viva vivo vlaanderen vn vodka volkswagen volvo vote voting voto voyage vu vuelos wales walmart walter wang wanggou watch watches weather weatherchannel webcam weber website wed wedding weibo weir wf whoswho wien wiki williamhill win windows wine winners wme wolterskluwer woodside work works world wow ws wtc wtf xbox xerox xfinity xihuan xin xxx xyz yachts yahoo yamaxun yandex ye yodobashi yoga yokohama you youtube yt yun za zappos zara zero zip zm zone zuerich zw".split(" ");
|
|
var utlds = "\u03B5\u03BB \u03B5\u03C5 \u0431\u0433 \u0431\u0435\u043B \u0434\u0435\u0442\u0438 \u0435\u044E \u043A\u0430\u0442\u043E\u043B\u0438\u043A \u043A\u043E\u043C \u043C\u043A\u0434 \u043C\u043E\u043D \u043C\u043E\u0441\u043A\u0432\u0430 \u043E\u043D\u043B\u0430\u0439\u043D \u043E\u0440\u0433 \u0440\u0443\u0441 \u0440\u0444 \u0441\u0430\u0439\u0442 \u0441\u0440\u0431 \u0443\u043A\u0440 \u049B\u0430\u0437 \u0570\u0561\u0575 \u05D9\u05E9\u05E8\u05D0\u05DC \u05E7\u05D5\u05DD \u0627\u0628\u0648\u0638\u0628\u064A \u0627\u062A\u0635\u0627\u0644\u0627\u062A \u0627\u0631\u0627\u0645\u0643\u0648 \u0627\u0644\u0627\u0631\u062F\u0646 \u0627\u0644\u0628\u062D\u0631\u064A\u0646 \u0627\u0644\u062C\u0632\u0627\u0626\u0631 \u0627\u0644\u0633\u0639\u0648\u062F\u064A\u0629 \u0627\u0644\u0639\u0644\u064A\u0627\u0646 \u0627\u0644\u0645\u063A\u0631\u0628 \u0627\u0645\u0627\u0631\u0627\u062A \u0627\u06CC\u0631\u0627\u0646 \u0628\u0627\u0631\u062A \u0628\u0627\u0632\u0627\u0631 \u0628\u064A\u062A\u0643 \u0628\u06BE\u0627\u0631\u062A \u062A\u0648\u0646\u0633 \u0633\u0648\u062F\u0627\u0646 \u0633\u0648\u0631\u064A\u0629 \u0634\u0628\u0643\u0629 \u0639\u0631\u0627\u0642 \u0639\u0631\u0628 \u0639\u0645\u0627\u0646 \u0641\u0644\u0633\u0637\u064A\u0646 \u0642\u0637\u0631 \u0643\u0627\u062B\u0648\u0644\u064A\u0643 \u0643\u0648\u0645 \u0645\u0635\u0631 \u0645\u0644\u064A\u0633\u064A\u0627 \u0645\u0648\u0631\u064A\u062A\u0627\u0646\u064A\u0627 \u0645\u0648\u0642\u0639 \u0647\u0645\u0631\u0627\u0647 \u067E\u0627\u06A9\u0633\u062A\u0627\u0646 \u0680\u0627\u0631\u062A \u0915\u0949\u092E \u0928\u0947\u091F \u092D\u093E\u0930\u0924 \u092D\u093E\u0930\u0924\u092E\u094D \u092D\u093E\u0930\u094B\u0924 \u0938\u0902\u0917\u0920\u0928 \u09AC\u09BE\u0982\u09B2\u09BE \u09AD\u09BE\u09B0\u09A4 \u09AD\u09BE\u09F0\u09A4 \u0A2D\u0A3E\u0A30\u0A24 \u0AAD\u0ABE\u0AB0\u0AA4 \u0B2D\u0B3E\u0B30\u0B24 \u0B87\u0BA8\u0BCD\u0BA4\u0BBF\u0BAF\u0BBE \u0B87\u0BB2\u0B99\u0BCD\u0B95\u0BC8 \u0B9A\u0BBF\u0B99\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0BC2\u0BB0\u0BCD \u0C2D\u0C3E\u0C30\u0C24\u0C4D \u0CAD\u0CBE\u0CB0\u0CA4 \u0D2D\u0D3E\u0D30\u0D24\u0D02 \u0DBD\u0D82\u0D9A\u0DCF \u0E04\u0E2D\u0E21 \u0E44\u0E17\u0E22 \u0EA5\u0EB2\u0EA7 \u10D2\u10D4 \u307F\u3093\u306A \u30A2\u30DE\u30BE\u30F3 \u30AF\u30E9\u30A6\u30C9 \u30B0\u30FC\u30B0\u30EB \u30B3\u30E0 \u30B9\u30C8\u30A2 \u30BB\u30FC\u30EB \u30D5\u30A1\u30C3\u30B7\u30E7\u30F3 \u30DD\u30A4\u30F3\u30C8 \u4E16\u754C \u4E2D\u4FE1 \u4E2D\u56FD \u4E2D\u570B \u4E2D\u6587\u7F51 \u4E9A\u9A6C\u900A \u4F01\u4E1A \u4F5B\u5C71 \u4FE1\u606F \u5065\u5EB7 \u516B\u5366 \u516C\u53F8 \u516C\u76CA \u53F0\u6E7E \u53F0\u7063 \u5546\u57CE \u5546\u5E97 \u5546\u6807 \u5609\u91CC \u5609\u91CC\u5927\u9152\u5E97 \u5728\u7EBF \u5927\u62FF \u5929\u4E3B\u6559 \u5A31\u4E50 \u5BB6\u96FB \u5E7F\u4E1C \u5FAE\u535A \u6148\u5584 \u6211\u7231\u4F60 \u624B\u673A \u62DB\u8058 \u653F\u52A1 \u653F\u5E9C \u65B0\u52A0\u5761 \u65B0\u95FB \u65F6\u5C1A \u66F8\u7C4D \u673A\u6784 \u6DE1\u9A6C\u9521 \u6E38\u620F \u6FB3\u9580 \u70B9\u770B \u79FB\u52A8 \u7EC4\u7EC7\u673A\u6784 \u7F51\u5740 \u7F51\u5E97 \u7F51\u7AD9 \u7F51\u7EDC \u8054\u901A \u8BFA\u57FA\u4E9A \u8C37\u6B4C \u8D2D\u7269 \u901A\u8CA9 \u96C6\u56E2 \u96FB\u8A0A\u76C8\u79D1 \u98DE\u5229\u6D66 \u98DF\u54C1 \u9910\u5385 \u9999\u683C\u91CC\u62C9 \u9999\u6E2F \uB2F7\uB137 \uB2F7\uCEF4 \uC0BC\uC131 \uD55C\uAD6D".split(" ");
|
|
var assign2 = function assign3(target, properties) {
|
|
for (var key2 in properties) {
|
|
target[key2] = properties[key2];
|
|
}
|
|
return target;
|
|
};
|
|
var numeric = "numeric";
|
|
var ascii = "ascii";
|
|
var alpha = "alpha";
|
|
var asciinumeric = "asciinumeric";
|
|
var alphanumeric = "alphanumeric";
|
|
var domain = "domain";
|
|
var emoji = "emoji";
|
|
var scheme = "scheme";
|
|
var slashscheme = "slashscheme";
|
|
var whitespace = "whitespace";
|
|
function registerGroup(name, groups) {
|
|
if (!(name in groups)) {
|
|
groups[name] = [];
|
|
}
|
|
return groups[name];
|
|
}
|
|
function addToGroups(t, flags, groups) {
|
|
if (flags[numeric]) {
|
|
flags[asciinumeric] = true;
|
|
flags[alphanumeric] = true;
|
|
}
|
|
if (flags[ascii]) {
|
|
flags[asciinumeric] = true;
|
|
flags[alpha] = true;
|
|
}
|
|
if (flags[asciinumeric]) {
|
|
flags[alphanumeric] = true;
|
|
}
|
|
if (flags[alpha]) {
|
|
flags[alphanumeric] = true;
|
|
}
|
|
if (flags[alphanumeric]) {
|
|
flags[domain] = true;
|
|
}
|
|
if (flags[emoji]) {
|
|
flags[domain] = true;
|
|
}
|
|
for (var k in flags) {
|
|
var group = registerGroup(k, groups);
|
|
if (group.indexOf(t) < 0) {
|
|
group.push(t);
|
|
}
|
|
}
|
|
}
|
|
function flagsForToken(t, groups) {
|
|
var result = {};
|
|
for (var c in groups) {
|
|
if (groups[c].indexOf(t) >= 0) {
|
|
result[c] = true;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function State(token) {
|
|
if (token === void 0) {
|
|
token = null;
|
|
}
|
|
this.j = {};
|
|
this.jr = [];
|
|
this.jd = null;
|
|
this.t = token;
|
|
}
|
|
State.groups = {};
|
|
State.prototype = {
|
|
accepts: function accepts() {
|
|
return !!this.t;
|
|
},
|
|
go: function go(input) {
|
|
var state = this;
|
|
var nextState = state.j[input];
|
|
if (nextState) {
|
|
return nextState;
|
|
}
|
|
for (var i = 0; i < state.jr.length; i++) {
|
|
var regex = state.jr[i][0];
|
|
var _nextState = state.jr[i][1];
|
|
if (_nextState && regex.test(input)) {
|
|
return _nextState;
|
|
}
|
|
}
|
|
return state.jd;
|
|
},
|
|
has: function has(input, exactOnly) {
|
|
if (exactOnly === void 0) {
|
|
exactOnly = false;
|
|
}
|
|
return exactOnly ? input in this.j : !!this.go(input);
|
|
},
|
|
ta: function ta(inputs, next, flags, groups) {
|
|
for (var i = 0; i < inputs.length; i++) {
|
|
this.tt(inputs[i], next, flags, groups);
|
|
}
|
|
},
|
|
tr: function tr(regexp, next, flags, groups) {
|
|
groups = groups || State.groups;
|
|
var nextState;
|
|
if (next && next.j) {
|
|
nextState = next;
|
|
} else {
|
|
nextState = new State(next);
|
|
if (flags && groups) {
|
|
addToGroups(next, flags, groups);
|
|
}
|
|
}
|
|
this.jr.push([regexp, nextState]);
|
|
return nextState;
|
|
},
|
|
ts: function ts(input, next, flags, groups) {
|
|
var state = this;
|
|
var len = input.length;
|
|
if (!len) {
|
|
return state;
|
|
}
|
|
for (var i = 0; i < len - 1; i++) {
|
|
state = state.tt(input[i]);
|
|
}
|
|
return state.tt(input[len - 1], next, flags, groups);
|
|
},
|
|
tt: function tt(input, next, flags, groups) {
|
|
groups = groups || State.groups;
|
|
var state = this;
|
|
if (next && next.j) {
|
|
state.j[input] = next;
|
|
return next;
|
|
}
|
|
var t = next;
|
|
var nextState, templateState = state.go(input);
|
|
if (templateState) {
|
|
nextState = new State();
|
|
assign2(nextState.j, templateState.j);
|
|
nextState.jr.push.apply(nextState.jr, templateState.jr);
|
|
nextState.jd = templateState.jd;
|
|
nextState.t = templateState.t;
|
|
} else {
|
|
nextState = new State();
|
|
}
|
|
if (t) {
|
|
if (groups) {
|
|
if (nextState.t && typeof nextState.t === "string") {
|
|
var allFlags = assign2(flagsForToken(nextState.t, groups), flags);
|
|
addToGroups(t, allFlags, groups);
|
|
} else if (flags) {
|
|
addToGroups(t, flags, groups);
|
|
}
|
|
}
|
|
nextState.t = t;
|
|
}
|
|
state.j[input] = nextState;
|
|
return nextState;
|
|
}
|
|
};
|
|
var ta2 = function ta3(state, input, next, flags, groups) {
|
|
return state.ta(input, next, flags, groups);
|
|
};
|
|
var tr2 = function tr3(state, regexp, next, flags, groups) {
|
|
return state.tr(regexp, next, flags, groups);
|
|
};
|
|
var ts2 = function ts3(state, input, next, flags, groups) {
|
|
return state.ts(input, next, flags, groups);
|
|
};
|
|
var tt2 = function tt3(state, input, next, flags, groups) {
|
|
return state.tt(input, next, flags, groups);
|
|
};
|
|
var WORD = "WORD";
|
|
var UWORD = "UWORD";
|
|
var LOCALHOST = "LOCALHOST";
|
|
var TLD = "TLD";
|
|
var UTLD = "UTLD";
|
|
var SCHEME = "SCHEME";
|
|
var SLASH_SCHEME = "SLASH_SCHEME";
|
|
var NUM = "NUM";
|
|
var WS = "WS";
|
|
var NL$1 = "NL";
|
|
var OPENBRACE = "OPENBRACE";
|
|
var OPENBRACKET = "OPENBRACKET";
|
|
var OPENANGLEBRACKET = "OPENANGLEBRACKET";
|
|
var OPENPAREN = "OPENPAREN";
|
|
var CLOSEBRACE = "CLOSEBRACE";
|
|
var CLOSEBRACKET = "CLOSEBRACKET";
|
|
var CLOSEANGLEBRACKET = "CLOSEANGLEBRACKET";
|
|
var CLOSEPAREN = "CLOSEPAREN";
|
|
var AMPERSAND = "AMPERSAND";
|
|
var APOSTROPHE = "APOSTROPHE";
|
|
var ASTERISK = "ASTERISK";
|
|
var AT = "AT";
|
|
var BACKSLASH = "BACKSLASH";
|
|
var BACKTICK = "BACKTICK";
|
|
var CARET = "CARET";
|
|
var COLON = "COLON";
|
|
var COMMA = "COMMA";
|
|
var DOLLAR = "DOLLAR";
|
|
var DOT = "DOT";
|
|
var EQUALS = "EQUALS";
|
|
var EXCLAMATION = "EXCLAMATION";
|
|
var HYPHEN = "HYPHEN";
|
|
var PERCENT = "PERCENT";
|
|
var PIPE = "PIPE";
|
|
var PLUS = "PLUS";
|
|
var POUND = "POUND";
|
|
var QUERY = "QUERY";
|
|
var QUOTE = "QUOTE";
|
|
var SEMI = "SEMI";
|
|
var SLASH = "SLASH";
|
|
var TILDE = "TILDE";
|
|
var UNDERSCORE = "UNDERSCORE";
|
|
var EMOJI$1 = "EMOJI";
|
|
var SYM = "SYM";
|
|
var tk = /* @__PURE__ */ Object.freeze({
|
|
__proto__: null,
|
|
WORD,
|
|
UWORD,
|
|
LOCALHOST,
|
|
TLD,
|
|
UTLD,
|
|
SCHEME,
|
|
SLASH_SCHEME,
|
|
NUM,
|
|
WS,
|
|
NL: NL$1,
|
|
OPENBRACE,
|
|
OPENBRACKET,
|
|
OPENANGLEBRACKET,
|
|
OPENPAREN,
|
|
CLOSEBRACE,
|
|
CLOSEBRACKET,
|
|
CLOSEANGLEBRACKET,
|
|
CLOSEPAREN,
|
|
AMPERSAND,
|
|
APOSTROPHE,
|
|
ASTERISK,
|
|
AT,
|
|
BACKSLASH,
|
|
BACKTICK,
|
|
CARET,
|
|
COLON,
|
|
COMMA,
|
|
DOLLAR,
|
|
DOT,
|
|
EQUALS,
|
|
EXCLAMATION,
|
|
HYPHEN,
|
|
PERCENT,
|
|
PIPE,
|
|
PLUS,
|
|
POUND,
|
|
QUERY,
|
|
QUOTE,
|
|
SEMI,
|
|
SLASH,
|
|
TILDE,
|
|
UNDERSCORE,
|
|
EMOJI: EMOJI$1,
|
|
SYM
|
|
});
|
|
var ASCII_LETTER = /[a-z]/;
|
|
var LETTER = /(?:[A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDF70-\uDF81\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE70-\uDEBE\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD837[\uDF00-\uDF1E]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB]|\uD839[\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF38\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])/;
|
|
var EMOJI = /(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26A7\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5-\uDED7\uDEDD-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDDFF\uDE70-\uDE74\uDE78-\uDE7C\uDE80-\uDE86\uDE90-\uDEAC\uDEB0-\uDEBA\uDEC0-\uDEC5\uDED0-\uDED9\uDEE0-\uDEE7\uDEF0-\uDEF6])/;
|
|
var DIGIT = /\d/;
|
|
var SPACE = /\s/;
|
|
var NL = "\n";
|
|
var EMOJI_VARIATION = "\uFE0F";
|
|
var EMOJI_JOINER = "\u200D";
|
|
function init$2(customSchemes) {
|
|
var _tr, _tr2, _tr3, _tr4, _tt, _tr5;
|
|
if (customSchemes === void 0) {
|
|
customSchemes = [];
|
|
}
|
|
var groups = {};
|
|
State.groups = groups;
|
|
var Start = new State();
|
|
tt2(Start, "'", APOSTROPHE);
|
|
tt2(Start, "{", OPENBRACE);
|
|
tt2(Start, "[", OPENBRACKET);
|
|
tt2(Start, "<", OPENANGLEBRACKET);
|
|
tt2(Start, "(", OPENPAREN);
|
|
tt2(Start, "}", CLOSEBRACE);
|
|
tt2(Start, "]", CLOSEBRACKET);
|
|
tt2(Start, ">", CLOSEANGLEBRACKET);
|
|
tt2(Start, ")", CLOSEPAREN);
|
|
tt2(Start, "&", AMPERSAND);
|
|
tt2(Start, "*", ASTERISK);
|
|
tt2(Start, "@", AT);
|
|
tt2(Start, "`", BACKTICK);
|
|
tt2(Start, "^", CARET);
|
|
tt2(Start, ":", COLON);
|
|
tt2(Start, ",", COMMA);
|
|
tt2(Start, "$", DOLLAR);
|
|
tt2(Start, ".", DOT);
|
|
tt2(Start, "=", EQUALS);
|
|
tt2(Start, "!", EXCLAMATION);
|
|
tt2(Start, "-", HYPHEN);
|
|
tt2(Start, "%", PERCENT);
|
|
tt2(Start, "|", PIPE);
|
|
tt2(Start, "+", PLUS);
|
|
tt2(Start, "#", POUND);
|
|
tt2(Start, "?", QUERY);
|
|
tt2(Start, '"', QUOTE);
|
|
tt2(Start, "/", SLASH);
|
|
tt2(Start, ";", SEMI);
|
|
tt2(Start, "~", TILDE);
|
|
tt2(Start, "_", UNDERSCORE);
|
|
tt2(Start, "\\", BACKSLASH);
|
|
var Num = tr2(Start, DIGIT, NUM, (_tr = {}, _tr[numeric] = true, _tr));
|
|
tr2(Num, DIGIT, Num);
|
|
var Word = tr2(Start, ASCII_LETTER, WORD, (_tr2 = {}, _tr2[ascii] = true, _tr2));
|
|
tr2(Word, ASCII_LETTER, Word);
|
|
var UWord = tr2(Start, LETTER, UWORD, (_tr3 = {}, _tr3[alpha] = true, _tr3));
|
|
tr2(UWord, ASCII_LETTER);
|
|
tr2(UWord, LETTER, UWord);
|
|
var Ws = tr2(Start, SPACE, WS, (_tr4 = {}, _tr4[whitespace] = true, _tr4));
|
|
tt2(Start, NL, NL$1, (_tt = {}, _tt[whitespace] = true, _tt));
|
|
tt2(Ws, NL);
|
|
tr2(Ws, SPACE, Ws);
|
|
var Emoji = tr2(Start, EMOJI, EMOJI$1, (_tr5 = {}, _tr5[emoji] = true, _tr5));
|
|
tr2(Emoji, EMOJI, Emoji);
|
|
tt2(Emoji, EMOJI_VARIATION, Emoji);
|
|
var EmojiJoiner = tt2(Emoji, EMOJI_JOINER);
|
|
tr2(EmojiJoiner, EMOJI, Emoji);
|
|
var wordjr = [[ASCII_LETTER, Word]];
|
|
var uwordjr = [[ASCII_LETTER, null], [LETTER, UWord]];
|
|
for (var i = 0; i < tlds.length; i++) {
|
|
fastts(Start, tlds[i], TLD, WORD, wordjr);
|
|
}
|
|
for (var _i = 0; _i < utlds.length; _i++) {
|
|
fastts(Start, utlds[_i], UTLD, UWORD, uwordjr);
|
|
}
|
|
addToGroups(TLD, {
|
|
tld: true,
|
|
ascii: true
|
|
}, groups);
|
|
addToGroups(UTLD, {
|
|
utld: true,
|
|
alpha: true
|
|
}, groups);
|
|
fastts(Start, "file", SCHEME, WORD, wordjr);
|
|
fastts(Start, "mailto", SCHEME, WORD, wordjr);
|
|
fastts(Start, "http", SLASH_SCHEME, WORD, wordjr);
|
|
fastts(Start, "https", SLASH_SCHEME, WORD, wordjr);
|
|
fastts(Start, "ftp", SLASH_SCHEME, WORD, wordjr);
|
|
fastts(Start, "ftps", SLASH_SCHEME, WORD, wordjr);
|
|
addToGroups(SCHEME, {
|
|
scheme: true,
|
|
ascii: true
|
|
}, groups);
|
|
addToGroups(SLASH_SCHEME, {
|
|
slashscheme: true,
|
|
ascii: true
|
|
}, groups);
|
|
customSchemes = customSchemes.sort(function(a, b) {
|
|
return a[0] > b[0] ? 1 : -1;
|
|
});
|
|
for (var _i2 = 0; _i2 < customSchemes.length; _i2++) {
|
|
var _ref, _ref2;
|
|
var sch = customSchemes[_i2][0];
|
|
var optionalSlashSlash = customSchemes[_i2][1];
|
|
var flags = optionalSlashSlash ? (_ref = {}, _ref[scheme] = true, _ref) : (_ref2 = {}, _ref2[slashscheme] = true, _ref2);
|
|
if (sch.indexOf("-") >= 0) {
|
|
flags[domain] = true;
|
|
} else if (!ASCII_LETTER.test(sch)) {
|
|
flags[numeric] = true;
|
|
} else if (DIGIT.test(sch)) {
|
|
flags[asciinumeric] = true;
|
|
} else {
|
|
flags[ascii] = true;
|
|
}
|
|
ts2(Start, sch, sch, flags);
|
|
}
|
|
ts2(Start, "localhost", LOCALHOST, {
|
|
ascii: true
|
|
});
|
|
Start.jd = new State(SYM);
|
|
return {
|
|
start: Start,
|
|
tokens: assign2({
|
|
groups
|
|
}, tk)
|
|
};
|
|
}
|
|
function run$1(start, str) {
|
|
var iterable = stringToArray(str.replace(/[A-Z]/g, function(c) {
|
|
return c.toLowerCase();
|
|
}));
|
|
var charCount = iterable.length;
|
|
var tokens = [];
|
|
var cursor = 0;
|
|
var charCursor = 0;
|
|
while (charCursor < charCount) {
|
|
var state = start;
|
|
var nextState = null;
|
|
var tokenLength = 0;
|
|
var latestAccepting = null;
|
|
var sinceAccepts = -1;
|
|
var charsSinceAccepts = -1;
|
|
while (charCursor < charCount && (nextState = state.go(iterable[charCursor]))) {
|
|
state = nextState;
|
|
if (state.accepts()) {
|
|
sinceAccepts = 0;
|
|
charsSinceAccepts = 0;
|
|
latestAccepting = state;
|
|
} else if (sinceAccepts >= 0) {
|
|
sinceAccepts += iterable[charCursor].length;
|
|
charsSinceAccepts++;
|
|
}
|
|
tokenLength += iterable[charCursor].length;
|
|
cursor += iterable[charCursor].length;
|
|
charCursor++;
|
|
}
|
|
cursor -= sinceAccepts;
|
|
charCursor -= charsSinceAccepts;
|
|
tokenLength -= sinceAccepts;
|
|
tokens.push({
|
|
t: latestAccepting.t,
|
|
v: str.slice(cursor - tokenLength, cursor),
|
|
s: cursor - tokenLength,
|
|
e: cursor
|
|
});
|
|
}
|
|
return tokens;
|
|
}
|
|
function stringToArray(str) {
|
|
var result = [];
|
|
var len = str.length;
|
|
var index = 0;
|
|
while (index < len) {
|
|
var first = str.charCodeAt(index);
|
|
var second = void 0;
|
|
var char = first < 55296 || first > 56319 || index + 1 === len || (second = str.charCodeAt(index + 1)) < 56320 || second > 57343 ? str[index] : str.slice(index, index + 2);
|
|
result.push(char);
|
|
index += char.length;
|
|
}
|
|
return result;
|
|
}
|
|
function fastts(state, input, t, defaultt, jr) {
|
|
var next;
|
|
var len = input.length;
|
|
for (var i = 0; i < len - 1; i++) {
|
|
var char = input[i];
|
|
if (state.j[char]) {
|
|
next = state.j[char];
|
|
} else {
|
|
next = new State(defaultt);
|
|
next.jr = jr.slice();
|
|
state.j[char] = next;
|
|
}
|
|
state = next;
|
|
}
|
|
next = new State(t);
|
|
next.jr = jr.slice();
|
|
state.j[input[len - 1]] = next;
|
|
return next;
|
|
}
|
|
function _inheritsLoose(subClass, superClass) {
|
|
subClass.prototype = Object.create(superClass.prototype);
|
|
subClass.prototype.constructor = subClass;
|
|
_setPrototypeOf(subClass, superClass);
|
|
}
|
|
function _setPrototypeOf(o, p) {
|
|
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
|
|
o2.__proto__ = p2;
|
|
return o2;
|
|
};
|
|
return _setPrototypeOf(o, p);
|
|
}
|
|
var defaults = {
|
|
defaultProtocol: "http",
|
|
events: null,
|
|
format: noop2,
|
|
formatHref: noop2,
|
|
nl2br: false,
|
|
tagName: "a",
|
|
target: null,
|
|
rel: null,
|
|
validate: true,
|
|
truncate: Infinity,
|
|
className: null,
|
|
attributes: null,
|
|
ignoreTags: [],
|
|
render: null
|
|
};
|
|
function Options(opts, defaultRender3) {
|
|
if (defaultRender3 === void 0) {
|
|
defaultRender3 = null;
|
|
}
|
|
var o = assign2({}, defaults);
|
|
if (opts) {
|
|
o = assign2(o, opts instanceof Options ? opts.o : opts);
|
|
}
|
|
var ignoredTags = o.ignoreTags;
|
|
var uppercaseIgnoredTags = [];
|
|
for (var i = 0; i < ignoredTags.length; i++) {
|
|
uppercaseIgnoredTags.push(ignoredTags[i].toUpperCase());
|
|
}
|
|
this.o = o;
|
|
if (defaultRender3) {
|
|
this.defaultRender = defaultRender3;
|
|
}
|
|
this.ignoreTags = uppercaseIgnoredTags;
|
|
}
|
|
Options.prototype = {
|
|
o: defaults,
|
|
ignoreTags: [],
|
|
defaultRender: function defaultRender(ir) {
|
|
return ir;
|
|
},
|
|
check: function check(token) {
|
|
return this.get("validate", token.toString(), token);
|
|
},
|
|
get: function get(key2, operator, token) {
|
|
var isCallable = operator != null;
|
|
var option = this.o[key2];
|
|
if (!option) {
|
|
return option;
|
|
}
|
|
if (typeof option === "object") {
|
|
option = token.t in option ? option[token.t] : defaults[key2];
|
|
if (typeof option === "function" && isCallable) {
|
|
option = option(operator, token);
|
|
}
|
|
} else if (typeof option === "function" && isCallable) {
|
|
option = option(operator, token.t, token);
|
|
}
|
|
return option;
|
|
},
|
|
getObj: function getObj(key2, operator, token) {
|
|
var obj = this.o[key2];
|
|
if (typeof obj === "function" && operator != null) {
|
|
obj = obj(operator, token.t, token);
|
|
}
|
|
return obj;
|
|
},
|
|
render: function render(token) {
|
|
var ir = token.render(this);
|
|
var renderFn = this.get("render", null, token) || this.defaultRender;
|
|
return renderFn(ir, token.t, token);
|
|
}
|
|
};
|
|
function noop2(val) {
|
|
return val;
|
|
}
|
|
function MultiToken(value, tokens) {
|
|
this.t = "token";
|
|
this.v = value;
|
|
this.tk = tokens;
|
|
}
|
|
MultiToken.prototype = {
|
|
isLink: false,
|
|
toString: function toString() {
|
|
return this.v;
|
|
},
|
|
toHref: function toHref(scheme2) {
|
|
return this.toString();
|
|
},
|
|
toFormattedString: function toFormattedString(options) {
|
|
var val = this.toString();
|
|
var truncate = options.get("truncate", val, this);
|
|
var formatted = options.get("format", val, this);
|
|
return truncate && formatted.length > truncate ? formatted.substring(0, truncate) + "\u2026" : formatted;
|
|
},
|
|
toFormattedHref: function toFormattedHref(options) {
|
|
return options.get("formatHref", this.toHref(options.get("defaultProtocol")), this);
|
|
},
|
|
startIndex: function startIndex() {
|
|
return this.tk[0].s;
|
|
},
|
|
endIndex: function endIndex() {
|
|
return this.tk[this.tk.length - 1].e;
|
|
},
|
|
toObject: function toObject(protocol) {
|
|
if (protocol === void 0) {
|
|
protocol = defaults.defaultProtocol;
|
|
}
|
|
return {
|
|
type: this.t,
|
|
value: this.toString(),
|
|
isLink: this.isLink,
|
|
href: this.toHref(protocol),
|
|
start: this.startIndex(),
|
|
end: this.endIndex()
|
|
};
|
|
},
|
|
toFormattedObject: function toFormattedObject(options) {
|
|
return {
|
|
type: this.t,
|
|
value: this.toFormattedString(options),
|
|
isLink: this.isLink,
|
|
href: this.toFormattedHref(options),
|
|
start: this.startIndex(),
|
|
end: this.endIndex()
|
|
};
|
|
},
|
|
validate: function validate(options) {
|
|
return options.get("validate", this.toString(), this);
|
|
},
|
|
render: function render2(options) {
|
|
var token = this;
|
|
var href = this.toFormattedHref(options);
|
|
var tagName = options.get("tagName", href, token);
|
|
var content = this.toFormattedString(options);
|
|
var attributes = {};
|
|
var className = options.get("className", href, token);
|
|
var target = options.get("target", href, token);
|
|
var rel = options.get("rel", href, token);
|
|
var attrs = options.getObj("attributes", href, token);
|
|
var eventListeners = options.getObj("events", href, token);
|
|
attributes.href = href;
|
|
if (className) {
|
|
attributes.class = className;
|
|
}
|
|
if (target) {
|
|
attributes.target = target;
|
|
}
|
|
if (rel) {
|
|
attributes.rel = rel;
|
|
}
|
|
if (attrs) {
|
|
assign2(attributes, attrs);
|
|
}
|
|
return {
|
|
tagName,
|
|
attributes,
|
|
content,
|
|
eventListeners
|
|
};
|
|
}
|
|
};
|
|
function createTokenClass(type, props) {
|
|
var Token = /* @__PURE__ */ function(_MultiToken) {
|
|
_inheritsLoose(Token2, _MultiToken);
|
|
function Token2(value, tokens) {
|
|
var _this;
|
|
_this = _MultiToken.call(this, value, tokens) || this;
|
|
_this.t = type;
|
|
return _this;
|
|
}
|
|
return Token2;
|
|
}(MultiToken);
|
|
for (var p in props) {
|
|
Token.prototype[p] = props[p];
|
|
}
|
|
Token.t = type;
|
|
return Token;
|
|
}
|
|
var Email = createTokenClass("email", {
|
|
isLink: true,
|
|
toHref: function toHref2() {
|
|
return "mailto:" + this.toString();
|
|
}
|
|
});
|
|
var Text = createTokenClass("text");
|
|
var Nl = createTokenClass("nl");
|
|
var Url = createTokenClass("url", {
|
|
isLink: true,
|
|
toHref: function toHref3(scheme2) {
|
|
if (scheme2 === void 0) {
|
|
scheme2 = defaults.defaultProtocol;
|
|
}
|
|
return this.hasProtocol() ? this.v : scheme2 + "://" + this.v;
|
|
},
|
|
hasProtocol: function hasProtocol() {
|
|
var tokens = this.tk;
|
|
return tokens.length >= 2 && tokens[0].t !== LOCALHOST && tokens[1].t === COLON;
|
|
}
|
|
});
|
|
var makeState = function makeState2(arg) {
|
|
return new State(arg);
|
|
};
|
|
function init$1(_ref) {
|
|
var groups = _ref.groups;
|
|
var qsAccepting = groups.domain.concat([AMPERSAND, ASTERISK, AT, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, NUM, PERCENT, PIPE, PLUS, POUND, SLASH, SYM, TILDE, UNDERSCORE]);
|
|
var qsNonAccepting = [APOSTROPHE, CLOSEANGLEBRACKET, CLOSEBRACE, CLOSEBRACKET, CLOSEPAREN, COLON, COMMA, DOT, EXCLAMATION, OPENANGLEBRACKET, OPENBRACE, OPENBRACKET, OPENPAREN, QUERY, QUOTE, SEMI];
|
|
var localpartAccepting = [AMPERSAND, APOSTROPHE, ASTERISK, BACKSLASH, BACKTICK, CARET, CLOSEBRACE, DOLLAR, EQUALS, HYPHEN, NUM, OPENBRACE, PERCENT, PIPE, PLUS, POUND, QUERY, SLASH, SYM, TILDE, UNDERSCORE];
|
|
var Start = makeState();
|
|
var Localpart = tt2(Start, TILDE);
|
|
ta2(Localpart, localpartAccepting, Localpart);
|
|
ta2(Localpart, groups.domain, Localpart);
|
|
var Domain = makeState(), Scheme = makeState(), SlashScheme = makeState();
|
|
ta2(Start, groups.domain, Domain);
|
|
ta2(Start, groups.scheme, Scheme);
|
|
ta2(Start, groups.slashscheme, SlashScheme);
|
|
ta2(Domain, localpartAccepting, Localpart);
|
|
ta2(Domain, groups.domain, Domain);
|
|
var LocalpartAt = tt2(Domain, AT);
|
|
tt2(Localpart, AT, LocalpartAt);
|
|
var LocalpartDot = tt2(Localpart, DOT);
|
|
ta2(LocalpartDot, localpartAccepting, Localpart);
|
|
ta2(LocalpartDot, groups.domain, Localpart);
|
|
var EmailDomain = makeState();
|
|
ta2(LocalpartAt, groups.domain, EmailDomain);
|
|
ta2(EmailDomain, groups.domain, EmailDomain);
|
|
var EmailDomainDot = tt2(EmailDomain, DOT);
|
|
ta2(EmailDomainDot, groups.domain, EmailDomain);
|
|
var Email$1 = makeState(Email);
|
|
ta2(EmailDomainDot, groups.tld, Email$1);
|
|
ta2(EmailDomainDot, groups.utld, Email$1);
|
|
tt2(LocalpartAt, LOCALHOST, Email$1);
|
|
var EmailDomainHyphen = tt2(EmailDomain, HYPHEN);
|
|
ta2(EmailDomainHyphen, groups.domain, EmailDomain);
|
|
ta2(Email$1, groups.domain, EmailDomain);
|
|
tt2(Email$1, DOT, EmailDomainDot);
|
|
tt2(Email$1, HYPHEN, EmailDomainHyphen);
|
|
var EmailColon = tt2(Email$1, COLON);
|
|
ta2(EmailColon, groups.numeric, Email);
|
|
var DomainHyphen = tt2(Domain, HYPHEN);
|
|
var DomainDot = tt2(Domain, DOT);
|
|
ta2(DomainHyphen, groups.domain, Domain);
|
|
ta2(DomainDot, localpartAccepting, Localpart);
|
|
ta2(DomainDot, groups.domain, Domain);
|
|
var DomainDotTld = makeState(Url);
|
|
ta2(DomainDot, groups.tld, DomainDotTld);
|
|
ta2(DomainDot, groups.utld, DomainDotTld);
|
|
ta2(DomainDotTld, groups.domain, Domain);
|
|
ta2(DomainDotTld, localpartAccepting, Localpart);
|
|
tt2(DomainDotTld, DOT, DomainDot);
|
|
tt2(DomainDotTld, HYPHEN, DomainHyphen);
|
|
tt2(DomainDotTld, AT, LocalpartAt);
|
|
var DomainDotTldColon = tt2(DomainDotTld, COLON);
|
|
var DomainDotTldColonPort = makeState(Url);
|
|
ta2(DomainDotTldColon, groups.numeric, DomainDotTldColonPort);
|
|
var Url$1 = makeState(Url);
|
|
var UrlNonaccept = makeState();
|
|
ta2(Url$1, qsAccepting, Url$1);
|
|
ta2(Url$1, qsNonAccepting, UrlNonaccept);
|
|
ta2(UrlNonaccept, qsAccepting, Url$1);
|
|
ta2(UrlNonaccept, qsNonAccepting, UrlNonaccept);
|
|
tt2(DomainDotTld, SLASH, Url$1);
|
|
tt2(DomainDotTldColonPort, SLASH, Url$1);
|
|
var UriPrefix = tt2(Scheme, COLON);
|
|
var SlashSchemeColon = tt2(SlashScheme, COLON);
|
|
var SlashSchemeColonSlash = tt2(SlashSchemeColon, SLASH);
|
|
tt2(SlashSchemeColonSlash, SLASH, UriPrefix);
|
|
ta2(Scheme, groups.domain, Domain);
|
|
tt2(Scheme, DOT, DomainDot);
|
|
tt2(Scheme, HYPHEN, DomainHyphen);
|
|
ta2(SlashScheme, groups.domain, Domain);
|
|
tt2(SlashScheme, DOT, DomainDot);
|
|
tt2(SlashScheme, HYPHEN, DomainHyphen);
|
|
ta2(UriPrefix, groups.domain, Url$1);
|
|
tt2(UriPrefix, SLASH, Url$1);
|
|
var UrlOpenbrace = tt2(Url$1, OPENBRACE);
|
|
var UrlOpenbracket = tt2(Url$1, OPENBRACKET);
|
|
var UrlOpenanglebracket = tt2(Url$1, OPENANGLEBRACKET);
|
|
var UrlOpenparen = tt2(Url$1, OPENPAREN);
|
|
tt2(UrlNonaccept, OPENBRACE, UrlOpenbrace);
|
|
tt2(UrlNonaccept, OPENBRACKET, UrlOpenbracket);
|
|
tt2(UrlNonaccept, OPENANGLEBRACKET, UrlOpenanglebracket);
|
|
tt2(UrlNonaccept, OPENPAREN, UrlOpenparen);
|
|
tt2(UrlOpenbrace, CLOSEBRACE, Url$1);
|
|
tt2(UrlOpenbracket, CLOSEBRACKET, Url$1);
|
|
tt2(UrlOpenanglebracket, CLOSEANGLEBRACKET, Url$1);
|
|
tt2(UrlOpenparen, CLOSEPAREN, Url$1);
|
|
tt2(UrlOpenbrace, CLOSEBRACE, Url$1);
|
|
var UrlOpenbraceQ = makeState(Url);
|
|
var UrlOpenbracketQ = makeState(Url);
|
|
var UrlOpenanglebracketQ = makeState(Url);
|
|
var UrlOpenparenQ = makeState(Url);
|
|
ta2(UrlOpenbrace, qsAccepting, UrlOpenbraceQ);
|
|
ta2(UrlOpenbracket, qsAccepting, UrlOpenbracketQ);
|
|
ta2(UrlOpenanglebracket, qsAccepting, UrlOpenanglebracketQ);
|
|
ta2(UrlOpenparen, qsAccepting, UrlOpenparenQ);
|
|
var UrlOpenbraceSyms = makeState();
|
|
var UrlOpenbracketSyms = makeState();
|
|
var UrlOpenanglebracketSyms = makeState();
|
|
var UrlOpenparenSyms = makeState();
|
|
ta2(UrlOpenbrace, qsNonAccepting);
|
|
ta2(UrlOpenbracket, qsNonAccepting);
|
|
ta2(UrlOpenanglebracket, qsNonAccepting);
|
|
ta2(UrlOpenparen, qsNonAccepting);
|
|
ta2(UrlOpenbraceQ, qsAccepting, UrlOpenbraceQ);
|
|
ta2(UrlOpenbracketQ, qsAccepting, UrlOpenbracketQ);
|
|
ta2(UrlOpenanglebracketQ, qsAccepting, UrlOpenanglebracketQ);
|
|
ta2(UrlOpenparenQ, qsAccepting, UrlOpenparenQ);
|
|
ta2(UrlOpenbraceQ, qsNonAccepting, UrlOpenbraceQ);
|
|
ta2(UrlOpenbracketQ, qsNonAccepting, UrlOpenbracketQ);
|
|
ta2(UrlOpenanglebracketQ, qsNonAccepting, UrlOpenanglebracketQ);
|
|
ta2(UrlOpenparenQ, qsNonAccepting, UrlOpenparenQ);
|
|
ta2(UrlOpenbraceSyms, qsAccepting, UrlOpenbraceSyms);
|
|
ta2(UrlOpenbracketSyms, qsAccepting, UrlOpenbracketQ);
|
|
ta2(UrlOpenanglebracketSyms, qsAccepting, UrlOpenanglebracketQ);
|
|
ta2(UrlOpenparenSyms, qsAccepting, UrlOpenparenQ);
|
|
ta2(UrlOpenbraceSyms, qsNonAccepting, UrlOpenbraceSyms);
|
|
ta2(UrlOpenbracketSyms, qsNonAccepting, UrlOpenbracketSyms);
|
|
ta2(UrlOpenanglebracketSyms, qsNonAccepting, UrlOpenanglebracketSyms);
|
|
ta2(UrlOpenparenSyms, qsNonAccepting, UrlOpenparenSyms);
|
|
tt2(UrlOpenbracketQ, CLOSEBRACKET, Url$1);
|
|
tt2(UrlOpenanglebracketQ, CLOSEANGLEBRACKET, Url$1);
|
|
tt2(UrlOpenparenQ, CLOSEPAREN, Url$1);
|
|
tt2(UrlOpenbraceQ, CLOSEBRACE, Url$1);
|
|
tt2(UrlOpenbracketSyms, CLOSEBRACKET, Url$1);
|
|
tt2(UrlOpenanglebracketSyms, CLOSEANGLEBRACKET, Url$1);
|
|
tt2(UrlOpenparenSyms, CLOSEPAREN, Url$1);
|
|
tt2(UrlOpenbraceSyms, CLOSEPAREN, Url$1);
|
|
tt2(Start, LOCALHOST, DomainDotTld);
|
|
tt2(Start, NL$1, Nl);
|
|
return {
|
|
start: Start,
|
|
tokens: tk
|
|
};
|
|
}
|
|
function run2(start, input, tokens) {
|
|
var len = tokens.length;
|
|
var cursor = 0;
|
|
var multis = [];
|
|
var textTokens = [];
|
|
while (cursor < len) {
|
|
var state = start;
|
|
var secondState = null;
|
|
var nextState = null;
|
|
var multiLength = 0;
|
|
var latestAccepting = null;
|
|
var sinceAccepts = -1;
|
|
while (cursor < len && !(secondState = state.go(tokens[cursor].t))) {
|
|
textTokens.push(tokens[cursor++]);
|
|
}
|
|
while (cursor < len && (nextState = secondState || state.go(tokens[cursor].t))) {
|
|
secondState = null;
|
|
state = nextState;
|
|
if (state.accepts()) {
|
|
sinceAccepts = 0;
|
|
latestAccepting = state;
|
|
} else if (sinceAccepts >= 0) {
|
|
sinceAccepts++;
|
|
}
|
|
cursor++;
|
|
multiLength++;
|
|
}
|
|
if (sinceAccepts < 0) {
|
|
cursor -= multiLength;
|
|
if (cursor < len) {
|
|
textTokens.push(tokens[cursor]);
|
|
cursor++;
|
|
}
|
|
} else {
|
|
if (textTokens.length > 0) {
|
|
multis.push(initMultiToken(Text, input, textTokens));
|
|
textTokens = [];
|
|
}
|
|
cursor -= sinceAccepts;
|
|
multiLength -= sinceAccepts;
|
|
var Multi = latestAccepting.t;
|
|
var subtokens = tokens.slice(cursor - multiLength, cursor);
|
|
multis.push(initMultiToken(Multi, input, subtokens));
|
|
}
|
|
}
|
|
if (textTokens.length > 0) {
|
|
multis.push(initMultiToken(Text, input, textTokens));
|
|
}
|
|
return multis;
|
|
}
|
|
function initMultiToken(Multi, input, tokens) {
|
|
var startIdx = tokens[0].s;
|
|
var endIdx = tokens[tokens.length - 1].e;
|
|
var value = input.slice(startIdx, endIdx);
|
|
return new Multi(value, tokens);
|
|
}
|
|
var warn = typeof console !== "undefined" && console && console.warn || function() {
|
|
};
|
|
var warnAdvice = "To avoid this warning, please register all custom schemes before invoking linkify the first time.";
|
|
var INIT = {
|
|
scanner: null,
|
|
parser: null,
|
|
tokenQueue: [],
|
|
pluginQueue: [],
|
|
customSchemes: [],
|
|
initialized: false
|
|
};
|
|
function registerPlugin(name, plugin) {
|
|
if (typeof plugin !== "function") {
|
|
throw new Error("linkifyjs: Invalid plugin " + plugin + " (expects function)");
|
|
}
|
|
for (var i = 0; i < INIT.pluginQueue.length; i++) {
|
|
if (name === INIT.pluginQueue[i][0]) {
|
|
warn('linkifyjs: plugin "' + name + '" already registered - will be overwritten');
|
|
INIT.pluginQueue[i] = [name, plugin];
|
|
return;
|
|
}
|
|
}
|
|
INIT.pluginQueue.push([name, plugin]);
|
|
if (INIT.initialized) {
|
|
warn('linkifyjs: already initialized - will not register plugin "' + name + '" until you manually call linkify.init(). ' + warnAdvice);
|
|
}
|
|
}
|
|
function init3() {
|
|
INIT.scanner = init$2(INIT.customSchemes);
|
|
for (var i = 0; i < INIT.tokenQueue.length; i++) {
|
|
INIT.tokenQueue[i][1]({
|
|
scanner: INIT.scanner
|
|
});
|
|
}
|
|
INIT.parser = init$1(INIT.scanner.tokens);
|
|
for (var _i = 0; _i < INIT.pluginQueue.length; _i++) {
|
|
INIT.pluginQueue[_i][1]({
|
|
scanner: INIT.scanner,
|
|
parser: INIT.parser
|
|
});
|
|
}
|
|
INIT.initialized = true;
|
|
}
|
|
function tokenize(str) {
|
|
if (!INIT.initialized) {
|
|
init3();
|
|
}
|
|
return run2(INIT.parser.start, str, run$1(INIT.scanner.start, str));
|
|
}
|
|
|
|
// node_modules/linkify-string/dist/linkify-string.es.js
|
|
function escapeText(text2) {
|
|
return text2.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
|
}
|
|
function escapeAttr(href) {
|
|
return href.replace(/"/g, """);
|
|
}
|
|
function attributesToString(attributes) {
|
|
var result = [];
|
|
for (var attr2 in attributes) {
|
|
var val = attributes[attr2] + "";
|
|
result.push(attr2 + '="' + escapeAttr(val) + '"');
|
|
}
|
|
return result.join(" ");
|
|
}
|
|
function defaultRender2(_ref) {
|
|
var tagName = _ref.tagName, attributes = _ref.attributes, content = _ref.content;
|
|
return "<" + tagName + " " + attributesToString(attributes) + ">" + escapeText(content) + "</" + tagName + ">";
|
|
}
|
|
function linkifyStr(str, opts) {
|
|
if (opts === void 0) {
|
|
opts = {};
|
|
}
|
|
opts = new Options(opts, defaultRender2);
|
|
var tokens = tokenize(str);
|
|
var result = [];
|
|
for (var i = 0; i < tokens.length; i++) {
|
|
var token = tokens[i];
|
|
if (token.t === "nl" && opts.get("nl2br")) {
|
|
result.push("<br>\n");
|
|
} else if (!token.isLink || !opts.check(token)) {
|
|
result.push(escapeText(token.toString()));
|
|
} else {
|
|
result.push(opts.render(token));
|
|
}
|
|
}
|
|
return result.join("");
|
|
}
|
|
if (!String.prototype.linkify) {
|
|
Object.defineProperty(String.prototype, "linkify", {
|
|
writable: false,
|
|
value: function linkify(options) {
|
|
return linkifyStr(this, options);
|
|
}
|
|
});
|
|
}
|
|
|
|
// src/Components/TextEmbeddings.svelte
|
|
function add_css14(target) {
|
|
append_styles(target, "svelte-nv2bo1", ".additionnal.svelte-nv2bo1{border-top:2px dashed;clear:both;margin-top:10px;padding-top:10px;white-space:pre-wrap}");
|
|
}
|
|
function get_each_context7(ctx, list, i) {
|
|
const child_ctx = ctx.slice();
|
|
child_ctx[3] = list[i];
|
|
return child_ctx;
|
|
}
|
|
function create_each_block7(ctx) {
|
|
let div;
|
|
let html_tag;
|
|
let raw_value = ctx[1](ctx[3]) + "";
|
|
let t;
|
|
return {
|
|
c() {
|
|
div = element("div");
|
|
html_tag = new HtmlTag(false);
|
|
t = space();
|
|
html_tag.a = t;
|
|
attr(div, "class", "additionnal svelte-nv2bo1");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, div, anchor);
|
|
html_tag.m(raw_value, div);
|
|
append(div, t);
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(div);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment16(ctx) {
|
|
let each_1_anchor;
|
|
let each_value = ctx[0];
|
|
let each_blocks = [];
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block7(get_each_context7(ctx, each_value, i));
|
|
}
|
|
return {
|
|
c() {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
each_1_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(target, anchor);
|
|
}
|
|
insert(target, each_1_anchor, anchor);
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (dirty & 3) {
|
|
each_value = ctx2[0];
|
|
let i;
|
|
for (i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context7(ctx2, each_value, i);
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(child_ctx, dirty);
|
|
} else {
|
|
each_blocks[i] = create_each_block7(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
|
|
}
|
|
}
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
destroy_each(each_blocks, detaching);
|
|
if (detaching)
|
|
detach(each_1_anchor);
|
|
}
|
|
};
|
|
}
|
|
function instance16($$self, $$props, $$invalidate) {
|
|
let { files } = $$props;
|
|
let contents = files.map((e) => e.data.toString());
|
|
const san = (s) => linkifyStr(s).split("\n").map((m) => m.trim().startsWith(">") ? `<span style="color: #b5bd68">${m.trim()}</span>` : m.trim()).join("\n");
|
|
$$self.$$set = ($$props2) => {
|
|
if ("files" in $$props2)
|
|
$$invalidate(2, files = $$props2.files);
|
|
};
|
|
return [contents, san, files];
|
|
}
|
|
var TextEmbeddings = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance16, create_fragment16, safe_not_equal, { files: 2 }, add_css14);
|
|
}
|
|
get files() {
|
|
return this.$$.ctx[2];
|
|
}
|
|
set files(files) {
|
|
this.$$set({ files });
|
|
flush();
|
|
}
|
|
};
|
|
var TextEmbeddings_default = TextEmbeddings;
|
|
|
|
// src/hydrus.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
var HydrusClient = class {
|
|
constructor(ak, origin = "http://127.0.0.1", port = 45869) {
|
|
this.ak = ak;
|
|
this.origin = origin;
|
|
this.port = port;
|
|
}
|
|
get baseUrl() {
|
|
return `${this.origin}:${this.port}`;
|
|
}
|
|
async get(params) {
|
|
return await ifetch(this.baseUrl + params, {
|
|
headers: {
|
|
"Hydrus-Client-API-Access-Key": this.ak
|
|
}
|
|
});
|
|
}
|
|
async verify() {
|
|
try {
|
|
const ret = await this.get("/verify_access_key");
|
|
return !!await ret.json();
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
async idsByTags(taglist, args) {
|
|
const req = await this.get("/get_files/search_files?tags=" + encodeURIComponent(JSON.stringify(taglist)) + (args ? "&" + Object.entries(args).map((e) => `${e[0]}=${encodeURIComponent(e[1])}`).join("&") : ""));
|
|
return await req.json();
|
|
}
|
|
async getMetaDataByIds(ids) {
|
|
const req = await this.get("/get_files/file_metadata?file_ids=" + encodeURIComponent(JSON.stringify(ids)));
|
|
return await req.json();
|
|
}
|
|
async getFile(id) {
|
|
const req = await this.get("/get_files/file?file_id=" + id);
|
|
return await req.arrayBuffer();
|
|
}
|
|
async getThumbnail(id) {
|
|
const req = await this.get("/get_files/thumbnail?file_id=" + id);
|
|
return await req.arrayBuffer();
|
|
}
|
|
};
|
|
|
|
// src/Components/ViewCount.svelte
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function add_css15(target) {
|
|
append_styles(target, "svelte-15vwgmz", ".tag.svelte-15vwgmz{padding:5px;border:1px solid;border-radius:55px;cursor:pointer;display:inline-flex}");
|
|
}
|
|
function create_if_block10(ctx) {
|
|
let span;
|
|
let mounted;
|
|
let dispose;
|
|
function select_block_type(ctx2, dirty) {
|
|
if (ctx2[1])
|
|
return create_if_block_16;
|
|
if ((ctx2[3] || {})[ctx2[0]])
|
|
return create_if_block_24;
|
|
return create_else_block3;
|
|
}
|
|
let current_block_type = select_block_type(ctx, -1);
|
|
let if_block = current_block_type(ctx);
|
|
return {
|
|
c() {
|
|
span = element("span");
|
|
if_block.c();
|
|
attr(span, "title", "click to refresh");
|
|
attr(span, "class", "tag svelte-15vwgmz");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, span, anchor);
|
|
if_block.m(span, null);
|
|
if (!mounted) {
|
|
dispose = listen(span, "click", ctx[7]);
|
|
mounted = true;
|
|
}
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (current_block_type === (current_block_type = select_block_type(ctx2, dirty)) && if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block.d(1);
|
|
if_block = current_block_type(ctx2);
|
|
if (if_block) {
|
|
if_block.c();
|
|
if_block.m(span, null);
|
|
}
|
|
}
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(span);
|
|
if_block.d();
|
|
mounted = false;
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
function create_else_block3(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("smth wrong...");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_24(ctx) {
|
|
let t0_value = (ctx[3] || {})[ctx[0]].cnt + "";
|
|
let t0;
|
|
let t1;
|
|
return {
|
|
c() {
|
|
t0 = text(t0_value);
|
|
t1 = text(" views");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t0, anchor);
|
|
insert(target, t1, anchor);
|
|
},
|
|
p(ctx2, dirty) {
|
|
if (dirty & 9 && t0_value !== (t0_value = (ctx2[3] || {})[ctx2[0]].cnt + ""))
|
|
set_data(t0, t0_value);
|
|
},
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t0);
|
|
if (detaching)
|
|
detach(t1);
|
|
}
|
|
};
|
|
}
|
|
function create_if_block_16(ctx) {
|
|
let t;
|
|
return {
|
|
c() {
|
|
t = text("...");
|
|
},
|
|
m(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
p: noop,
|
|
d(detaching) {
|
|
if (detaching)
|
|
detach(t);
|
|
}
|
|
};
|
|
}
|
|
function create_fragment17(ctx) {
|
|
let if_block_anchor;
|
|
let if_block = ctx[2].dvc && create_if_block10(ctx);
|
|
return {
|
|
c() {
|
|
if (if_block)
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
m(target, anchor) {
|
|
if (if_block)
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
},
|
|
p(ctx2, [dirty]) {
|
|
if (ctx2[2].dvc) {
|
|
if (if_block) {
|
|
if_block.p(ctx2, dirty);
|
|
} else {
|
|
if_block = create_if_block10(ctx2);
|
|
if_block.c();
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
},
|
|
i: noop,
|
|
o: noop,
|
|
d(detaching) {
|
|
if (if_block)
|
|
if_block.d(detaching);
|
|
if (detaching)
|
|
detach(if_block_anchor);
|
|
}
|
|
};
|
|
}
|
|
function instance17($$self, $$props, $$invalidate) {
|
|
let $settings;
|
|
let $threadDataCache;
|
|
component_subscribe($$self, settings, ($$value) => $$invalidate(2, $settings = $$value));
|
|
component_subscribe($$self, threadDataCache, ($$value) => $$invalidate(3, $threadDataCache = $$value));
|
|
let { board } = $$props;
|
|
let { op } = $$props;
|
|
let loading = false;
|
|
let { pid } = $$props;
|
|
const snooze = (n) => new Promise((_) => setTimeout(_, n));
|
|
const execRefresh = async (trueRefresh) => {
|
|
$$invalidate(1, loading = true);
|
|
let p = [];
|
|
if (trueRefresh) {
|
|
p.push(snooze(250));
|
|
p.push(refreshThreadDataCache(board, op));
|
|
} else
|
|
p.push((async () => {
|
|
await getThreadDataCache(board, op);
|
|
})());
|
|
await Promise.all(p);
|
|
$$invalidate(1, loading = false);
|
|
};
|
|
settings.subscribe((newsetting) => {
|
|
if (newsetting.dvc)
|
|
execRefresh(false);
|
|
});
|
|
const click_handler2 = () => execRefresh(true);
|
|
$$self.$$set = ($$props2) => {
|
|
if ("board" in $$props2)
|
|
$$invalidate(5, board = $$props2.board);
|
|
if ("op" in $$props2)
|
|
$$invalidate(6, op = $$props2.op);
|
|
if ("pid" in $$props2)
|
|
$$invalidate(0, pid = $$props2.pid);
|
|
};
|
|
return [
|
|
pid,
|
|
loading,
|
|
$settings,
|
|
$threadDataCache,
|
|
execRefresh,
|
|
board,
|
|
op,
|
|
click_handler2
|
|
];
|
|
}
|
|
var ViewCount = class extends SvelteComponent {
|
|
constructor(options) {
|
|
super();
|
|
init(this, options, instance17, create_fragment17, safe_not_equal, { board: 5, op: 6, pid: 0 }, add_css15);
|
|
}
|
|
get board() {
|
|
return this.$$.ctx[5];
|
|
}
|
|
set board(board) {
|
|
this.$$set({ board });
|
|
flush();
|
|
}
|
|
get op() {
|
|
return this.$$.ctx[6];
|
|
}
|
|
set op(op) {
|
|
this.$$set({ op });
|
|
flush();
|
|
}
|
|
get pid() {
|
|
return this.$$.ctx[0];
|
|
}
|
|
set pid(pid) {
|
|
this.$$set({ pid });
|
|
flush();
|
|
}
|
|
};
|
|
var ViewCount_default = ViewCount;
|
|
|
|
// src/processor.worker.ts
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
|
|
// inline-worker:__inline-worker
|
|
init_define_BUILD_VERSION();
|
|
init_esbuild_inject();
|
|
function inlineWorker(scriptText) {
|
|
let blob = new Blob([scriptText], { type: "text/javascript" });
|
|
let url = URL.createObjectURL(blob);
|
|
let worker = new Worker(url);
|
|
URL.revokeObjectURL(url);
|
|
return worker;
|
|
}
|
|
|
|
// src/processor.worker.ts
|
|
function Worker2() {
|
|
return inlineWorker('var __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;\nvar __esm = (fn, res) => function __init() {\n return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;\n};\nvar __commonJS = (cb, mod) => function __require() {\n return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __export = (target, all) => {\n for (var name in all)\n __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n if (from && typeof from === "object" || typeof from === "function") {\n for (let key2 of __getOwnPropNames(from))\n if (!__hasOwnProp.call(to, key2) && key2 !== except)\n __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });\n }\n return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,\n mod\n));\nvar __decorateClass = (decorators, target, key2, kind) => {\n var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key2) : target;\n for (var i = decorators.length - 1, decorator; i >= 0; i--)\n if (decorator = decorators[i])\n result = (kind ? decorator(target, key2, result) : decorator(result)) || result;\n if (kind && result)\n __defProp(target, key2, result);\n return result;\n};\nvar __publicField = (obj, key2, value) => {\n __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);\n return value;\n};\nvar __accessCheck = (obj, member, msg) => {\n if (!member.has(obj))\n throw TypeError("Cannot " + msg);\n};\nvar __privateGet = (obj, member, getter) => {\n __accessCheck(obj, member, "read from private field");\n return getter ? getter.call(obj) : member.get(obj);\n};\nvar __privateAdd = (obj, member, value) => {\n if (member.has(obj))\n throw TypeError("Cannot add the same private member more than once");\n member instanceof WeakSet ? member.add(obj) : member.set(obj, value);\n};\nvar __privateSet = (obj, member, value, setter) => {\n __accessCheck(obj, member, "write to private field");\n setter ? setter.call(obj, value) : member.set(obj, value);\n return value;\n};\nvar __privateMethod = (obj, member, method) => {\n __accessCheck(obj, member, "access private method");\n return method;\n};\nvar __toBinary = /* @__PURE__ */ (() => {\n var table = new Uint8Array(128);\n for (var i = 0; i < 64; i++)\n table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;\n return (base64) => {\n var n = base64.length, bytes = new Uint8Array((n - (base64[n - 1] == "=") - (base64[n - 2] == "=")) * 3 / 4 | 0);\n for (var i2 = 0, j = 0; i2 < n; ) {\n var c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)];\n var c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)];\n bytes[j++] = c0 << 2 | c1 >> 4;\n bytes[j++] = c1 << 4 | c2 >> 2;\n bytes[j++] = c2 << 6 | c3;\n }\n return bytes;\n };\n})();\n\n// <define:BUILD_VERSION>\nvar init_define_BUILD_VERSION = __esm({\n "<define:BUILD_VERSION>"() {\n }\n});\n\n// node_modules/base64-js/index.js\nvar require_base64_js = __commonJS({\n "node_modules/base64-js/index.js"(exports) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n exports.byteLength = byteLength;\n exports.toByteArray = toByteArray;\n exports.fromByteArray = fromByteArray;\n var lookup = [];\n var revLookup = [];\n var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;\n var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";\n for (i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i];\n revLookup[code.charCodeAt(i)] = i;\n }\n var i;\n var len;\n revLookup["-".charCodeAt(0)] = 62;\n revLookup["_".charCodeAt(0)] = 63;\n function getLens(b64) {\n var len2 = b64.length;\n if (len2 % 4 > 0) {\n throw new Error("Invalid string. Length must be a multiple of 4");\n }\n var validLen = b64.indexOf("=");\n if (validLen === -1)\n validLen = len2;\n var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;\n return [validLen, placeHoldersLen];\n }\n function byteLength(b64) {\n var lens = getLens(b64);\n var validLen = lens[0];\n var placeHoldersLen = lens[1];\n return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n }\n function _byteLength(b64, validLen, placeHoldersLen) {\n return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n }\n function toByteArray(b64) {\n var tmp;\n var lens = getLens(b64);\n var validLen = lens[0];\n var placeHoldersLen = lens[1];\n var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n var curByte = 0;\n var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;\n var i2;\n for (i2 = 0; i2 < len2; i2 += 4) {\n tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];\n arr[curByte++] = tmp >> 16 & 255;\n arr[curByte++] = tmp >> 8 & 255;\n arr[curByte++] = tmp & 255;\n }\n if (placeHoldersLen === 2) {\n tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;\n arr[curByte++] = tmp & 255;\n }\n if (placeHoldersLen === 1) {\n tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;\n arr[curByte++] = tmp >> 8 & 255;\n arr[curByte++] = tmp & 255;\n }\n return arr;\n }\n function tripletToBase64(num) {\n return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];\n }\n function encodeChunk(uint8, start, end) {\n var tmp;\n var output = [];\n for (var i2 = start; i2 < end; i2 += 3) {\n tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);\n output.push(tripletToBase64(tmp));\n }\n return output.join("");\n }\n function fromByteArray(uint8) {\n var tmp;\n var len2 = uint8.length;\n var extraBytes = len2 % 3;\n var parts = [];\n var maxChunkLength = 16383;\n for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {\n parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));\n }\n if (extraBytes === 1) {\n tmp = uint8[len2 - 1];\n parts.push(\n lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="\n );\n } else if (extraBytes === 2) {\n tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];\n parts.push(\n lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="\n );\n }\n return parts.join("");\n }\n }\n});\n\n// node_modules/ieee754/index.js\nvar require_ieee754 = __commonJS({\n "node_modules/ieee754/index.js"(exports) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n exports.read = function(buffer, offset, isLE, mLen, nBytes) {\n var e, m;\n var eLen = nBytes * 8 - mLen - 1;\n var eMax = (1 << eLen) - 1;\n var eBias = eMax >> 1;\n var nBits = -7;\n var i = isLE ? nBytes - 1 : 0;\n var d = isLE ? -1 : 1;\n var s = buffer[offset + i];\n i += d;\n e = s & (1 << -nBits) - 1;\n s >>= -nBits;\n nBits += eLen;\n for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {\n }\n m = e & (1 << -nBits) - 1;\n e >>= -nBits;\n nBits += mLen;\n for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {\n }\n if (e === 0) {\n e = 1 - eBias;\n } else if (e === eMax) {\n return m ? NaN : (s ? -1 : 1) * Infinity;\n } else {\n m = m + Math.pow(2, mLen);\n e = e - eBias;\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n };\n exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c;\n var eLen = nBytes * 8 - mLen - 1;\n var eMax = (1 << eLen) - 1;\n var eBias = eMax >> 1;\n var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;\n var i = isLE ? 0 : nBytes - 1;\n var d = isLE ? 1 : -1;\n var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n value = Math.abs(value);\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0;\n e = eMax;\n } else {\n e = Math.floor(Math.log(value) / Math.LN2);\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--;\n c *= 2;\n }\n if (e + eBias >= 1) {\n value += rt / c;\n } else {\n value += rt * Math.pow(2, 1 - eBias);\n }\n if (value * c >= 2) {\n e++;\n c /= 2;\n }\n if (e + eBias >= eMax) {\n m = 0;\n e = eMax;\n } else if (e + eBias >= 1) {\n m = (value * c - 1) * Math.pow(2, mLen);\n e = e + eBias;\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n e = 0;\n }\n }\n for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {\n }\n e = e << mLen | m;\n eLen += mLen;\n for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {\n }\n buffer[offset + i - d] |= s * 128;\n };\n }\n});\n\n// node_modules/buffer/index.js\nvar require_buffer = __commonJS({\n "node_modules/buffer/index.js"(exports) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var base64 = require_base64_js();\n var ieee7542 = require_ieee754();\n var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;\n exports.Buffer = Buffer13;\n exports.SlowBuffer = SlowBuffer;\n exports.INSPECT_MAX_BYTES = 50;\n var K_MAX_LENGTH = 2147483647;\n exports.kMaxLength = K_MAX_LENGTH;\n Buffer13.TYPED_ARRAY_SUPPORT = typedArraySupport();\n if (!Buffer13.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {\n console.error(\n "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."\n );\n }\n function typedArraySupport() {\n try {\n const arr = new Uint8Array(1);\n const proto = { foo: function() {\n return 42;\n } };\n Object.setPrototypeOf(proto, Uint8Array.prototype);\n Object.setPrototypeOf(arr, proto);\n return arr.foo() === 42;\n } catch (e) {\n return false;\n }\n }\n Object.defineProperty(Buffer13.prototype, "parent", {\n enumerable: true,\n get: function() {\n if (!Buffer13.isBuffer(this))\n return void 0;\n return this.buffer;\n }\n });\n Object.defineProperty(Buffer13.prototype, "offset", {\n enumerable: true,\n get: function() {\n if (!Buffer13.isBuffer(this))\n return void 0;\n return this.byteOffset;\n }\n });\n function createBuffer(length) {\n if (length > K_MAX_LENGTH) {\n throw new RangeError(\'The value "\' + length + \'" is invalid for option "size"\');\n }\n const buf2 = new Uint8Array(length);\n Object.setPrototypeOf(buf2, Buffer13.prototype);\n return buf2;\n }\n function Buffer13(arg, encodingOrOffset, length) {\n if (typeof arg === "number") {\n if (typeof encodingOrOffset === "string") {\n throw new TypeError(\n \'The "string" argument must be of type string. Received type number\'\n );\n }\n return allocUnsafe(arg);\n }\n return from(arg, encodingOrOffset, length);\n }\n Buffer13.poolSize = 8192;\n function from(value, encodingOrOffset, length) {\n if (typeof value === "string") {\n return fromString(value, encodingOrOffset);\n }\n if (ArrayBuffer.isView(value)) {\n return fromArrayView(value);\n }\n if (value == null) {\n throw new TypeError(\n "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value\n );\n }\n if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {\n return fromArrayBuffer(value, encodingOrOffset, length);\n }\n if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {\n return fromArrayBuffer(value, encodingOrOffset, length);\n }\n if (typeof value === "number") {\n throw new TypeError(\n \'The "value" argument must not be of type number. Received type number\'\n );\n }\n const valueOf = value.valueOf && value.valueOf();\n if (valueOf != null && valueOf !== value) {\n return Buffer13.from(valueOf, encodingOrOffset, length);\n }\n const b = fromObject(value);\n if (b)\n return b;\n if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {\n return Buffer13.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);\n }\n throw new TypeError(\n "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value\n );\n }\n Buffer13.from = function(value, encodingOrOffset, length) {\n return from(value, encodingOrOffset, length);\n };\n Object.setPrototypeOf(Buffer13.prototype, Uint8Array.prototype);\n Object.setPrototypeOf(Buffer13, Uint8Array);\n function assertSize(size) {\n if (typeof size !== "number") {\n throw new TypeError(\'"size" argument must be of type number\');\n } else if (size < 0) {\n throw new RangeError(\'The value "\' + size + \'" is invalid for option "size"\');\n }\n }\n function alloc(size, fill, encoding) {\n assertSize(size);\n if (size <= 0) {\n return createBuffer(size);\n }\n if (fill !== void 0) {\n return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);\n }\n return createBuffer(size);\n }\n Buffer13.alloc = function(size, fill, encoding) {\n return alloc(size, fill, encoding);\n };\n function allocUnsafe(size) {\n assertSize(size);\n return createBuffer(size < 0 ? 0 : checked(size) | 0);\n }\n Buffer13.allocUnsafe = function(size) {\n return allocUnsafe(size);\n };\n Buffer13.allocUnsafeSlow = function(size) {\n return allocUnsafe(size);\n };\n function fromString(string, encoding) {\n if (typeof encoding !== "string" || encoding === "") {\n encoding = "utf8";\n }\n if (!Buffer13.isEncoding(encoding)) {\n throw new TypeError("Unknown encoding: " + encoding);\n }\n const length = byteLength(string, encoding) | 0;\n let buf2 = createBuffer(length);\n const actual = buf2.write(string, encoding);\n if (actual !== length) {\n buf2 = buf2.slice(0, actual);\n }\n return buf2;\n }\n function fromArrayLike(array) {\n const length = array.length < 0 ? 0 : checked(array.length) | 0;\n const buf2 = createBuffer(length);\n for (let i = 0; i < length; i += 1) {\n buf2[i] = array[i] & 255;\n }\n return buf2;\n }\n function fromArrayView(arrayView) {\n if (isInstance(arrayView, Uint8Array)) {\n const copy = new Uint8Array(arrayView);\n return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);\n }\n return fromArrayLike(arrayView);\n }\n function fromArrayBuffer(array, byteOffset, length) {\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError(\'"offset" is outside of buffer bounds\');\n }\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError(\'"length" is outside of buffer bounds\');\n }\n let buf2;\n if (byteOffset === void 0 && length === void 0) {\n buf2 = new Uint8Array(array);\n } else if (length === void 0) {\n buf2 = new Uint8Array(array, byteOffset);\n } else {\n buf2 = new Uint8Array(array, byteOffset, length);\n }\n Object.setPrototypeOf(buf2, Buffer13.prototype);\n return buf2;\n }\n function fromObject(obj) {\n if (Buffer13.isBuffer(obj)) {\n const len = checked(obj.length) | 0;\n const buf2 = createBuffer(len);\n if (buf2.length === 0) {\n return buf2;\n }\n obj.copy(buf2, 0, 0, len);\n return buf2;\n }\n if (obj.length !== void 0) {\n if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {\n return createBuffer(0);\n }\n return fromArrayLike(obj);\n }\n if (obj.type === "Buffer" && Array.isArray(obj.data)) {\n return fromArrayLike(obj.data);\n }\n }\n function checked(length) {\n if (length >= K_MAX_LENGTH) {\n throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");\n }\n return length | 0;\n }\n function SlowBuffer(length) {\n if (+length != length) {\n length = 0;\n }\n return Buffer13.alloc(+length);\n }\n Buffer13.isBuffer = function isBuffer(b) {\n return b != null && b._isBuffer === true && b !== Buffer13.prototype;\n };\n Buffer13.compare = function compare(a, b) {\n if (isInstance(a, Uint8Array))\n a = Buffer13.from(a, a.offset, a.byteLength);\n if (isInstance(b, Uint8Array))\n b = Buffer13.from(b, b.offset, b.byteLength);\n if (!Buffer13.isBuffer(a) || !Buffer13.isBuffer(b)) {\n throw new TypeError(\n \'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array\'\n );\n }\n if (a === b)\n return 0;\n let x = a.length;\n let y = b.length;\n for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i];\n y = b[i];\n break;\n }\n }\n if (x < y)\n return -1;\n if (y < x)\n return 1;\n return 0;\n };\n Buffer13.isEncoding = function isEncoding(encoding) {\n switch (String(encoding).toLowerCase()) {\n case "hex":\n case "utf8":\n case "utf-8":\n case "ascii":\n case "latin1":\n case "binary":\n case "base64":\n case "ucs2":\n case "ucs-2":\n case "utf16le":\n case "utf-16le":\n return true;\n default:\n return false;\n }\n };\n Buffer13.concat = function concat(list, length) {\n if (!Array.isArray(list)) {\n throw new TypeError(\'"list" argument must be an Array of Buffers\');\n }\n if (list.length === 0) {\n return Buffer13.alloc(0);\n }\n let i;\n if (length === void 0) {\n length = 0;\n for (i = 0; i < list.length; ++i) {\n length += list[i].length;\n }\n }\n const buffer = Buffer13.allocUnsafe(length);\n let pos = 0;\n for (i = 0; i < list.length; ++i) {\n let buf2 = list[i];\n if (isInstance(buf2, Uint8Array)) {\n if (pos + buf2.length > buffer.length) {\n if (!Buffer13.isBuffer(buf2))\n buf2 = Buffer13.from(buf2);\n buf2.copy(buffer, pos);\n } else {\n Uint8Array.prototype.set.call(\n buffer,\n buf2,\n pos\n );\n }\n } else if (!Buffer13.isBuffer(buf2)) {\n throw new TypeError(\'"list" argument must be an Array of Buffers\');\n } else {\n buf2.copy(buffer, pos);\n }\n pos += buf2.length;\n }\n return buffer;\n };\n function byteLength(string, encoding) {\n if (Buffer13.isBuffer(string)) {\n return string.length;\n }\n if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n return string.byteLength;\n }\n if (typeof string !== "string") {\n throw new TypeError(\n \'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type \' + typeof string\n );\n }\n const len = string.length;\n const mustMatch = arguments.length > 2 && arguments[2] === true;\n if (!mustMatch && len === 0)\n return 0;\n let loweredCase = false;\n for (; ; ) {\n switch (encoding) {\n case "ascii":\n case "latin1":\n case "binary":\n return len;\n case "utf8":\n case "utf-8":\n return utf8ToBytes(string).length;\n case "ucs2":\n case "ucs-2":\n case "utf16le":\n case "utf-16le":\n return len * 2;\n case "hex":\n return len >>> 1;\n case "base64":\n return base64ToBytes(string).length;\n default:\n if (loweredCase) {\n return mustMatch ? -1 : utf8ToBytes(string).length;\n }\n encoding = ("" + encoding).toLowerCase();\n loweredCase = true;\n }\n }\n }\n Buffer13.byteLength = byteLength;\n function slowToString(encoding, start, end) {\n let loweredCase = false;\n if (start === void 0 || start < 0) {\n start = 0;\n }\n if (start > this.length) {\n return "";\n }\n if (end === void 0 || end > this.length) {\n end = this.length;\n }\n if (end <= 0) {\n return "";\n }\n end >>>= 0;\n start >>>= 0;\n if (end <= start) {\n return "";\n }\n if (!encoding)\n encoding = "utf8";\n while (true) {\n switch (encoding) {\n case "hex":\n return hexSlice(this, start, end);\n case "utf8":\n case "utf-8":\n return utf8Slice(this, start, end);\n case "ascii":\n return asciiSlice(this, start, end);\n case "latin1":\n case "binary":\n return latin1Slice(this, start, end);\n case "base64":\n return base64Slice(this, start, end);\n case "ucs2":\n case "ucs-2":\n case "utf16le":\n case "utf-16le":\n return utf16leSlice(this, start, end);\n default:\n if (loweredCase)\n throw new TypeError("Unknown encoding: " + encoding);\n encoding = (encoding + "").toLowerCase();\n loweredCase = true;\n }\n }\n }\n Buffer13.prototype._isBuffer = true;\n function swap(b, n, m) {\n const i = b[n];\n b[n] = b[m];\n b[m] = i;\n }\n Buffer13.prototype.swap16 = function swap16() {\n const len = this.length;\n if (len % 2 !== 0) {\n throw new RangeError("Buffer size must be a multiple of 16-bits");\n }\n for (let i = 0; i < len; i += 2) {\n swap(this, i, i + 1);\n }\n return this;\n };\n Buffer13.prototype.swap32 = function swap32() {\n const len = this.length;\n if (len % 4 !== 0) {\n throw new RangeError("Buffer size must be a multiple of 32-bits");\n }\n for (let i = 0; i < len; i += 4) {\n swap(this, i, i + 3);\n swap(this, i + 1, i + 2);\n }\n return this;\n };\n Buffer13.prototype.swap64 = function swap64() {\n const len = this.length;\n if (len % 8 !== 0) {\n throw new RangeError("Buffer size must be a multiple of 64-bits");\n }\n for (let i = 0; i < len; i += 8) {\n swap(this, i, i + 7);\n swap(this, i + 1, i + 6);\n swap(this, i + 2, i + 5);\n swap(this, i + 3, i + 4);\n }\n return this;\n };\n Buffer13.prototype.toString = function toString() {\n const length = this.length;\n if (length === 0)\n return "";\n if (arguments.length === 0)\n return utf8Slice(this, 0, length);\n return slowToString.apply(this, arguments);\n };\n Buffer13.prototype.toLocaleString = Buffer13.prototype.toString;\n Buffer13.prototype.equals = function equals(b) {\n if (!Buffer13.isBuffer(b))\n throw new TypeError("Argument must be a Buffer");\n if (this === b)\n return true;\n return Buffer13.compare(this, b) === 0;\n };\n Buffer13.prototype.inspect = function inspect() {\n let str = "";\n const max = exports.INSPECT_MAX_BYTES;\n str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();\n if (this.length > max)\n str += " ... ";\n return "<Buffer " + str + ">";\n };\n if (customInspectSymbol) {\n Buffer13.prototype[customInspectSymbol] = Buffer13.prototype.inspect;\n }\n Buffer13.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n if (isInstance(target, Uint8Array)) {\n target = Buffer13.from(target, target.offset, target.byteLength);\n }\n if (!Buffer13.isBuffer(target)) {\n throw new TypeError(\n \'The "target" argument must be one of type Buffer or Uint8Array. Received type \' + typeof target\n );\n }\n if (start === void 0) {\n start = 0;\n }\n if (end === void 0) {\n end = target ? target.length : 0;\n }\n if (thisStart === void 0) {\n thisStart = 0;\n }\n if (thisEnd === void 0) {\n thisEnd = this.length;\n }\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError("out of range index");\n }\n if (thisStart >= thisEnd && start >= end) {\n return 0;\n }\n if (thisStart >= thisEnd) {\n return -1;\n }\n if (start >= end) {\n return 1;\n }\n start >>>= 0;\n end >>>= 0;\n thisStart >>>= 0;\n thisEnd >>>= 0;\n if (this === target)\n return 0;\n let x = thisEnd - thisStart;\n let y = end - start;\n const len = Math.min(x, y);\n const thisCopy = this.slice(thisStart, thisEnd);\n const targetCopy = target.slice(start, end);\n for (let i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i];\n y = targetCopy[i];\n break;\n }\n }\n if (x < y)\n return -1;\n if (y < x)\n return 1;\n return 0;\n };\n function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n if (buffer.length === 0)\n return -1;\n if (typeof byteOffset === "string") {\n encoding = byteOffset;\n byteOffset = 0;\n } else if (byteOffset > 2147483647) {\n byteOffset = 2147483647;\n } else if (byteOffset < -2147483648) {\n byteOffset = -2147483648;\n }\n byteOffset = +byteOffset;\n if (numberIsNaN(byteOffset)) {\n byteOffset = dir ? 0 : buffer.length - 1;\n }\n if (byteOffset < 0)\n byteOffset = buffer.length + byteOffset;\n if (byteOffset >= buffer.length) {\n if (dir)\n return -1;\n else\n byteOffset = buffer.length - 1;\n } else if (byteOffset < 0) {\n if (dir)\n byteOffset = 0;\n else\n return -1;\n }\n if (typeof val === "string") {\n val = Buffer13.from(val, encoding);\n }\n if (Buffer13.isBuffer(val)) {\n if (val.length === 0) {\n return -1;\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir);\n } else if (typeof val === "number") {\n val = val & 255;\n if (typeof Uint8Array.prototype.indexOf === "function") {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);\n }\n }\n return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);\n }\n throw new TypeError("val must be string, number or Buffer");\n }\n function arrayIndexOf(arr, val, byteOffset, encoding, dir) {\n let indexSize = 1;\n let arrLength = arr.length;\n let valLength = val.length;\n if (encoding !== void 0) {\n encoding = String(encoding).toLowerCase();\n if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {\n if (arr.length < 2 || val.length < 2) {\n return -1;\n }\n indexSize = 2;\n arrLength /= 2;\n valLength /= 2;\n byteOffset /= 2;\n }\n }\n function read2(buf2, i2) {\n if (indexSize === 1) {\n return buf2[i2];\n } else {\n return buf2.readUInt16BE(i2 * indexSize);\n }\n }\n let i;\n if (dir) {\n let foundIndex = -1;\n for (i = byteOffset; i < arrLength; i++) {\n if (read2(arr, i) === read2(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1)\n foundIndex = i;\n if (i - foundIndex + 1 === valLength)\n return foundIndex * indexSize;\n } else {\n if (foundIndex !== -1)\n i -= i - foundIndex;\n foundIndex = -1;\n }\n }\n } else {\n if (byteOffset + valLength > arrLength)\n byteOffset = arrLength - valLength;\n for (i = byteOffset; i >= 0; i--) {\n let found = true;\n for (let j = 0; j < valLength; j++) {\n if (read2(arr, i + j) !== read2(val, j)) {\n found = false;\n break;\n }\n }\n if (found)\n return i;\n }\n }\n return -1;\n }\n Buffer13.prototype.includes = function includes(val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1;\n };\n Buffer13.prototype.indexOf = function indexOf(val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true);\n };\n Buffer13.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false);\n };\n function hexWrite(buf2, string, offset, length) {\n offset = Number(offset) || 0;\n const remaining = buf2.length - offset;\n if (!length) {\n length = remaining;\n } else {\n length = Number(length);\n if (length > remaining) {\n length = remaining;\n }\n }\n const strLen = string.length;\n if (length > strLen / 2) {\n length = strLen / 2;\n }\n let i;\n for (i = 0; i < length; ++i) {\n const parsed = parseInt(string.substr(i * 2, 2), 16);\n if (numberIsNaN(parsed))\n return i;\n buf2[offset + i] = parsed;\n }\n return i;\n }\n function utf8Write(buf2, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf2.length - offset), buf2, offset, length);\n }\n function asciiWrite(buf2, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf2, offset, length);\n }\n function base64Write(buf2, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf2, offset, length);\n }\n function ucs2Write(buf2, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf2.length - offset), buf2, offset, length);\n }\n Buffer13.prototype.write = function write2(string, offset, length, encoding) {\n if (offset === void 0) {\n encoding = "utf8";\n length = this.length;\n offset = 0;\n } else if (length === void 0 && typeof offset === "string") {\n encoding = offset;\n length = this.length;\n offset = 0;\n } else if (isFinite(offset)) {\n offset = offset >>> 0;\n if (isFinite(length)) {\n length = length >>> 0;\n if (encoding === void 0)\n encoding = "utf8";\n } else {\n encoding = length;\n length = void 0;\n }\n } else {\n throw new Error(\n "Buffer.write(string, encoding, offset[, length]) is no longer supported"\n );\n }\n const remaining = this.length - offset;\n if (length === void 0 || length > remaining)\n length = remaining;\n if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {\n throw new RangeError("Attempt to write outside buffer bounds");\n }\n if (!encoding)\n encoding = "utf8";\n let loweredCase = false;\n for (; ; ) {\n switch (encoding) {\n case "hex":\n return hexWrite(this, string, offset, length);\n case "utf8":\n case "utf-8":\n return utf8Write(this, string, offset, length);\n case "ascii":\n case "latin1":\n case "binary":\n return asciiWrite(this, string, offset, length);\n case "base64":\n return base64Write(this, string, offset, length);\n case "ucs2":\n case "ucs-2":\n case "utf16le":\n case "utf-16le":\n return ucs2Write(this, string, offset, length);\n default:\n if (loweredCase)\n throw new TypeError("Unknown encoding: " + encoding);\n encoding = ("" + encoding).toLowerCase();\n loweredCase = true;\n }\n }\n };\n Buffer13.prototype.toJSON = function toJSON() {\n return {\n type: "Buffer",\n data: Array.prototype.slice.call(this._arr || this, 0)\n };\n };\n function base64Slice(buf2, start, end) {\n if (start === 0 && end === buf2.length) {\n return base64.fromByteArray(buf2);\n } else {\n return base64.fromByteArray(buf2.slice(start, end));\n }\n }\n function utf8Slice(buf2, start, end) {\n end = Math.min(buf2.length, end);\n const res = [];\n let i = start;\n while (i < end) {\n const firstByte = buf2[i];\n let codePoint = null;\n let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;\n if (i + bytesPerSequence <= end) {\n let secondByte, thirdByte, fourthByte, tempCodePoint;\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 128) {\n codePoint = firstByte;\n }\n break;\n case 2:\n secondByte = buf2[i + 1];\n if ((secondByte & 192) === 128) {\n tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;\n if (tempCodePoint > 127) {\n codePoint = tempCodePoint;\n }\n }\n break;\n case 3:\n secondByte = buf2[i + 1];\n thirdByte = buf2[i + 2];\n if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {\n tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;\n if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {\n codePoint = tempCodePoint;\n }\n }\n break;\n case 4:\n secondByte = buf2[i + 1];\n thirdByte = buf2[i + 2];\n fourthByte = buf2[i + 3];\n if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {\n tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;\n if (tempCodePoint > 65535 && tempCodePoint < 1114112) {\n codePoint = tempCodePoint;\n }\n }\n }\n }\n if (codePoint === null) {\n codePoint = 65533;\n bytesPerSequence = 1;\n } else if (codePoint > 65535) {\n codePoint -= 65536;\n res.push(codePoint >>> 10 & 1023 | 55296);\n codePoint = 56320 | codePoint & 1023;\n }\n res.push(codePoint);\n i += bytesPerSequence;\n }\n return decodeCodePointsArray(res);\n }\n var MAX_ARGUMENTS_LENGTH = 4096;\n function decodeCodePointsArray(codePoints) {\n const len = codePoints.length;\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints);\n }\n let res = "";\n let i = 0;\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n );\n }\n return res;\n }\n function asciiSlice(buf2, start, end) {\n let ret = "";\n end = Math.min(buf2.length, end);\n for (let i = start; i < end; ++i) {\n ret += String.fromCharCode(buf2[i] & 127);\n }\n return ret;\n }\n function latin1Slice(buf2, start, end) {\n let ret = "";\n end = Math.min(buf2.length, end);\n for (let i = start; i < end; ++i) {\n ret += String.fromCharCode(buf2[i]);\n }\n return ret;\n }\n function hexSlice(buf2, start, end) {\n const len = buf2.length;\n if (!start || start < 0)\n start = 0;\n if (!end || end < 0 || end > len)\n end = len;\n let out = "";\n for (let i = start; i < end; ++i) {\n out += hexSliceLookupTable[buf2[i]];\n }\n return out;\n }\n function utf16leSlice(buf2, start, end) {\n const bytes = buf2.slice(start, end);\n let res = "";\n for (let i = 0; i < bytes.length - 1; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n }\n return res;\n }\n Buffer13.prototype.slice = function slice(start, end) {\n const len = this.length;\n start = ~~start;\n end = end === void 0 ? len : ~~end;\n if (start < 0) {\n start += len;\n if (start < 0)\n start = 0;\n } else if (start > len) {\n start = len;\n }\n if (end < 0) {\n end += len;\n if (end < 0)\n end = 0;\n } else if (end > len) {\n end = len;\n }\n if (end < start)\n end = start;\n const newBuf = this.subarray(start, end);\n Object.setPrototypeOf(newBuf, Buffer13.prototype);\n return newBuf;\n };\n function checkOffset(offset, ext, length) {\n if (offset % 1 !== 0 || offset < 0)\n throw new RangeError("offset is not uint");\n if (offset + ext > length)\n throw new RangeError("Trying to access beyond buffer length");\n }\n Buffer13.prototype.readUintLE = Buffer13.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {\n offset = offset >>> 0;\n byteLength2 = byteLength2 >>> 0;\n if (!noAssert)\n checkOffset(offset, byteLength2, this.length);\n let val = this[offset];\n let mul = 1;\n let i = 0;\n while (++i < byteLength2 && (mul *= 256)) {\n val += this[offset + i] * mul;\n }\n return val;\n };\n Buffer13.prototype.readUintBE = Buffer13.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {\n offset = offset >>> 0;\n byteLength2 = byteLength2 >>> 0;\n if (!noAssert) {\n checkOffset(offset, byteLength2, this.length);\n }\n let val = this[offset + --byteLength2];\n let mul = 1;\n while (byteLength2 > 0 && (mul *= 256)) {\n val += this[offset + --byteLength2] * mul;\n }\n return val;\n };\n Buffer13.prototype.readUint8 = Buffer13.prototype.readUInt8 = function readUInt8(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 1, this.length);\n return this[offset];\n };\n Buffer13.prototype.readUint16LE = Buffer13.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 2, this.length);\n return this[offset] | this[offset + 1] << 8;\n };\n Buffer13.prototype.readUint16BE = Buffer13.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 2, this.length);\n return this[offset] << 8 | this[offset + 1];\n };\n Buffer13.prototype.readUint32LE = Buffer13.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 4, this.length);\n return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;\n };\n Buffer13.prototype.readUint32BE = Buffer13.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 4, this.length);\n return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);\n };\n Buffer13.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {\n offset = offset >>> 0;\n validateNumber(offset, "offset");\n const first = this[offset];\n const last = this[offset + 7];\n if (first === void 0 || last === void 0) {\n boundsError(offset, this.length - 8);\n }\n const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;\n const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;\n return BigInt(lo) + (BigInt(hi) << BigInt(32));\n });\n Buffer13.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {\n offset = offset >>> 0;\n validateNumber(offset, "offset");\n const first = this[offset];\n const last = this[offset + 7];\n if (first === void 0 || last === void 0) {\n boundsError(offset, this.length - 8);\n }\n const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];\n const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;\n return (BigInt(hi) << BigInt(32)) + BigInt(lo);\n });\n Buffer13.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {\n offset = offset >>> 0;\n byteLength2 = byteLength2 >>> 0;\n if (!noAssert)\n checkOffset(offset, byteLength2, this.length);\n let val = this[offset];\n let mul = 1;\n let i = 0;\n while (++i < byteLength2 && (mul *= 256)) {\n val += this[offset + i] * mul;\n }\n mul *= 128;\n if (val >= mul)\n val -= Math.pow(2, 8 * byteLength2);\n return val;\n };\n Buffer13.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {\n offset = offset >>> 0;\n byteLength2 = byteLength2 >>> 0;\n if (!noAssert)\n checkOffset(offset, byteLength2, this.length);\n let i = byteLength2;\n let mul = 1;\n let val = this[offset + --i];\n while (i > 0 && (mul *= 256)) {\n val += this[offset + --i] * mul;\n }\n mul *= 128;\n if (val >= mul)\n val -= Math.pow(2, 8 * byteLength2);\n return val;\n };\n Buffer13.prototype.readInt8 = function readInt8(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 1, this.length);\n if (!(this[offset] & 128))\n return this[offset];\n return (255 - this[offset] + 1) * -1;\n };\n Buffer13.prototype.readInt16LE = function readInt16LE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 2, this.length);\n const val = this[offset] | this[offset + 1] << 8;\n return val & 32768 ? val | 4294901760 : val;\n };\n Buffer13.prototype.readInt16BE = function readInt16BE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 2, this.length);\n const val = this[offset + 1] | this[offset] << 8;\n return val & 32768 ? val | 4294901760 : val;\n };\n Buffer13.prototype.readInt32LE = function readInt32LE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 4, this.length);\n return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n };\n Buffer13.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 4, this.length);\n return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];\n };\n Buffer13.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {\n offset = offset >>> 0;\n validateNumber(offset, "offset");\n const first = this[offset];\n const last = this[offset + 7];\n if (first === void 0 || last === void 0) {\n boundsError(offset, this.length - 8);\n }\n const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);\n return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);\n });\n Buffer13.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {\n offset = offset >>> 0;\n validateNumber(offset, "offset");\n const first = this[offset];\n const last = this[offset + 7];\n if (first === void 0 || last === void 0) {\n boundsError(offset, this.length - 8);\n }\n const val = (first << 24) + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];\n return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);\n });\n Buffer13.prototype.readFloatLE = function readFloatLE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 4, this.length);\n return ieee7542.read(this, offset, true, 23, 4);\n };\n Buffer13.prototype.readFloatBE = function readFloatBE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 4, this.length);\n return ieee7542.read(this, offset, false, 23, 4);\n };\n Buffer13.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 8, this.length);\n return ieee7542.read(this, offset, true, 52, 8);\n };\n Buffer13.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {\n offset = offset >>> 0;\n if (!noAssert)\n checkOffset(offset, 8, this.length);\n return ieee7542.read(this, offset, false, 52, 8);\n };\n function checkInt(buf2, value, offset, ext, max, min) {\n if (!Buffer13.isBuffer(buf2))\n throw new TypeError(\'"buffer" argument must be a Buffer instance\');\n if (value > max || value < min)\n throw new RangeError(\'"value" argument is out of bounds\');\n if (offset + ext > buf2.length)\n throw new RangeError("Index out of range");\n }\n Buffer13.prototype.writeUintLE = Buffer13.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {\n value = +value;\n offset = offset >>> 0;\n byteLength2 = byteLength2 >>> 0;\n if (!noAssert) {\n const maxBytes = Math.pow(2, 8 * byteLength2) - 1;\n checkInt(this, value, offset, byteLength2, maxBytes, 0);\n }\n let mul = 1;\n let i = 0;\n this[offset] = value & 255;\n while (++i < byteLength2 && (mul *= 256)) {\n this[offset + i] = value / mul & 255;\n }\n return offset + byteLength2;\n };\n Buffer13.prototype.writeUintBE = Buffer13.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {\n value = +value;\n offset = offset >>> 0;\n byteLength2 = byteLength2 >>> 0;\n if (!noAssert) {\n const maxBytes = Math.pow(2, 8 * byteLength2) - 1;\n checkInt(this, value, offset, byteLength2, maxBytes, 0);\n }\n let i = byteLength2 - 1;\n let mul = 1;\n this[offset + i] = value & 255;\n while (--i >= 0 && (mul *= 256)) {\n this[offset + i] = value / mul & 255;\n }\n return offset + byteLength2;\n };\n Buffer13.prototype.writeUint8 = Buffer13.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 1, 255, 0);\n this[offset] = value & 255;\n return offset + 1;\n };\n Buffer13.prototype.writeUint16LE = Buffer13.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 2, 65535, 0);\n this[offset] = value & 255;\n this[offset + 1] = value >>> 8;\n return offset + 2;\n };\n Buffer13.prototype.writeUint16BE = Buffer13.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 2, 65535, 0);\n this[offset] = value >>> 8;\n this[offset + 1] = value & 255;\n return offset + 2;\n };\n Buffer13.prototype.writeUint32LE = Buffer13.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 4, 4294967295, 0);\n this[offset + 3] = value >>> 24;\n this[offset + 2] = value >>> 16;\n this[offset + 1] = value >>> 8;\n this[offset] = value & 255;\n return offset + 4;\n };\n Buffer13.prototype.writeUint32BE = Buffer13.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 4, 4294967295, 0);\n this[offset] = value >>> 24;\n this[offset + 1] = value >>> 16;\n this[offset + 2] = value >>> 8;\n this[offset + 3] = value & 255;\n return offset + 4;\n };\n function wrtBigUInt64LE(buf2, value, offset, min, max) {\n checkIntBI(value, min, max, buf2, offset, 7);\n let lo = Number(value & BigInt(4294967295));\n buf2[offset++] = lo;\n lo = lo >> 8;\n buf2[offset++] = lo;\n lo = lo >> 8;\n buf2[offset++] = lo;\n lo = lo >> 8;\n buf2[offset++] = lo;\n let hi = Number(value >> BigInt(32) & BigInt(4294967295));\n buf2[offset++] = hi;\n hi = hi >> 8;\n buf2[offset++] = hi;\n hi = hi >> 8;\n buf2[offset++] = hi;\n hi = hi >> 8;\n buf2[offset++] = hi;\n return offset;\n }\n function wrtBigUInt64BE(buf2, value, offset, min, max) {\n checkIntBI(value, min, max, buf2, offset, 7);\n let lo = Number(value & BigInt(4294967295));\n buf2[offset + 7] = lo;\n lo = lo >> 8;\n buf2[offset + 6] = lo;\n lo = lo >> 8;\n buf2[offset + 5] = lo;\n lo = lo >> 8;\n buf2[offset + 4] = lo;\n let hi = Number(value >> BigInt(32) & BigInt(4294967295));\n buf2[offset + 3] = hi;\n hi = hi >> 8;\n buf2[offset + 2] = hi;\n hi = hi >> 8;\n buf2[offset + 1] = hi;\n hi = hi >> 8;\n buf2[offset] = hi;\n return offset + 8;\n }\n Buffer13.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {\n return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));\n });\n Buffer13.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {\n return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));\n });\n Buffer13.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert) {\n const limit = Math.pow(2, 8 * byteLength2 - 1);\n checkInt(this, value, offset, byteLength2, limit - 1, -limit);\n }\n let i = 0;\n let mul = 1;\n let sub = 0;\n this[offset] = value & 255;\n while (++i < byteLength2 && (mul *= 256)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1;\n }\n this[offset + i] = (value / mul >> 0) - sub & 255;\n }\n return offset + byteLength2;\n };\n Buffer13.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert) {\n const limit = Math.pow(2, 8 * byteLength2 - 1);\n checkInt(this, value, offset, byteLength2, limit - 1, -limit);\n }\n let i = byteLength2 - 1;\n let mul = 1;\n let sub = 0;\n this[offset + i] = value & 255;\n while (--i >= 0 && (mul *= 256)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1;\n }\n this[offset + i] = (value / mul >> 0) - sub & 255;\n }\n return offset + byteLength2;\n };\n Buffer13.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 1, 127, -128);\n if (value < 0)\n value = 255 + value + 1;\n this[offset] = value & 255;\n return offset + 1;\n };\n Buffer13.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 2, 32767, -32768);\n this[offset] = value & 255;\n this[offset + 1] = value >>> 8;\n return offset + 2;\n };\n Buffer13.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 2, 32767, -32768);\n this[offset] = value >>> 8;\n this[offset + 1] = value & 255;\n return offset + 2;\n };\n Buffer13.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 4, 2147483647, -2147483648);\n this[offset] = value & 255;\n this[offset + 1] = value >>> 8;\n this[offset + 2] = value >>> 16;\n this[offset + 3] = value >>> 24;\n return offset + 4;\n };\n Buffer13.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert)\n checkInt(this, value, offset, 4, 2147483647, -2147483648);\n if (value < 0)\n value = 4294967295 + value + 1;\n this[offset] = value >>> 24;\n this[offset + 1] = value >>> 16;\n this[offset + 2] = value >>> 8;\n this[offset + 3] = value & 255;\n return offset + 4;\n };\n Buffer13.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {\n return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));\n });\n Buffer13.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {\n return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));\n });\n function checkIEEE754(buf2, value, offset, ext, max, min) {\n if (offset + ext > buf2.length)\n throw new RangeError("Index out of range");\n if (offset < 0)\n throw new RangeError("Index out of range");\n }\n function writeFloat(buf2, value, offset, littleEndian, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert) {\n checkIEEE754(buf2, value, offset, 4, 34028234663852886e22, -34028234663852886e22);\n }\n ieee7542.write(buf2, value, offset, littleEndian, 23, 4);\n return offset + 4;\n }\n Buffer13.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert);\n };\n Buffer13.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert);\n };\n function writeDouble(buf2, value, offset, littleEndian, noAssert) {\n value = +value;\n offset = offset >>> 0;\n if (!noAssert) {\n checkIEEE754(buf2, value, offset, 8, 17976931348623157e292, -17976931348623157e292);\n }\n ieee7542.write(buf2, value, offset, littleEndian, 52, 8);\n return offset + 8;\n }\n Buffer13.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert);\n };\n Buffer13.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert);\n };\n Buffer13.prototype.copy = function copy(target, targetStart, start, end) {\n if (!Buffer13.isBuffer(target))\n throw new TypeError("argument should be a Buffer");\n if (!start)\n start = 0;\n if (!end && end !== 0)\n end = this.length;\n if (targetStart >= target.length)\n targetStart = target.length;\n if (!targetStart)\n targetStart = 0;\n if (end > 0 && end < start)\n end = start;\n if (end === start)\n return 0;\n if (target.length === 0 || this.length === 0)\n return 0;\n if (targetStart < 0) {\n throw new RangeError("targetStart out of bounds");\n }\n if (start < 0 || start >= this.length)\n throw new RangeError("Index out of range");\n if (end < 0)\n throw new RangeError("sourceEnd out of bounds");\n if (end > this.length)\n end = this.length;\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start;\n }\n const len = end - start;\n if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {\n this.copyWithin(targetStart, start, end);\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, end),\n targetStart\n );\n }\n return len;\n };\n Buffer13.prototype.fill = function fill(val, start, end, encoding) {\n if (typeof val === "string") {\n if (typeof start === "string") {\n encoding = start;\n start = 0;\n end = this.length;\n } else if (typeof end === "string") {\n encoding = end;\n end = this.length;\n }\n if (encoding !== void 0 && typeof encoding !== "string") {\n throw new TypeError("encoding must be a string");\n }\n if (typeof encoding === "string" && !Buffer13.isEncoding(encoding)) {\n throw new TypeError("Unknown encoding: " + encoding);\n }\n if (val.length === 1) {\n const code = val.charCodeAt(0);\n if (encoding === "utf8" && code < 128 || encoding === "latin1") {\n val = code;\n }\n }\n } else if (typeof val === "number") {\n val = val & 255;\n } else if (typeof val === "boolean") {\n val = Number(val);\n }\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError("Out of range index");\n }\n if (end <= start) {\n return this;\n }\n start = start >>> 0;\n end = end === void 0 ? this.length : end >>> 0;\n if (!val)\n val = 0;\n let i;\n if (typeof val === "number") {\n for (i = start; i < end; ++i) {\n this[i] = val;\n }\n } else {\n const bytes = Buffer13.isBuffer(val) ? val : Buffer13.from(val, encoding);\n const len = bytes.length;\n if (len === 0) {\n throw new TypeError(\'The value "\' + val + \'" is invalid for argument "value"\');\n }\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len];\n }\n }\n return this;\n };\n var errors = {};\n function E(sym, getMessage, Base) {\n errors[sym] = class NodeError extends Base {\n constructor() {\n super();\n Object.defineProperty(this, "message", {\n value: getMessage.apply(this, arguments),\n writable: true,\n configurable: true\n });\n this.name = `${this.name} [${sym}]`;\n this.stack;\n delete this.name;\n }\n get code() {\n return sym;\n }\n set code(value) {\n Object.defineProperty(this, "code", {\n configurable: true,\n enumerable: true,\n value,\n writable: true\n });\n }\n toString() {\n return `${this.name} [${sym}]: ${this.message}`;\n }\n };\n }\n E(\n "ERR_BUFFER_OUT_OF_BOUNDS",\n function(name) {\n if (name) {\n return `${name} is outside of buffer bounds`;\n }\n return "Attempt to access memory outside buffer bounds";\n },\n RangeError\n );\n E(\n "ERR_INVALID_ARG_TYPE",\n function(name, actual) {\n return `The "${name}" argument must be of type number. Received type ${typeof actual}`;\n },\n TypeError\n );\n E(\n "ERR_OUT_OF_RANGE",\n function(str, range, input) {\n let msg = `The value of "${str}" is out of range.`;\n let received = input;\n if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n received = addNumericalSeparator(String(input));\n } else if (typeof input === "bigint") {\n received = String(input);\n if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n received = addNumericalSeparator(received);\n }\n received += "n";\n }\n msg += ` It must be ${range}. Received ${received}`;\n return msg;\n },\n RangeError\n );\n function addNumericalSeparator(val) {\n let res = "";\n let i = val.length;\n const start = val[0] === "-" ? 1 : 0;\n for (; i >= start + 4; i -= 3) {\n res = `_${val.slice(i - 3, i)}${res}`;\n }\n return `${val.slice(0, i)}${res}`;\n }\n function checkBounds(buf2, offset, byteLength2) {\n validateNumber(offset, "offset");\n if (buf2[offset] === void 0 || buf2[offset + byteLength2] === void 0) {\n boundsError(offset, buf2.length - (byteLength2 + 1));\n }\n }\n function checkIntBI(value, min, max, buf2, offset, byteLength2) {\n if (value > max || value < min) {\n const n = typeof min === "bigint" ? "n" : "";\n let range;\n if (byteLength2 > 3) {\n if (min === 0 || min === BigInt(0)) {\n range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;\n } else {\n range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;\n }\n } else {\n range = `>= ${min}${n} and <= ${max}${n}`;\n }\n throw new errors.ERR_OUT_OF_RANGE("value", range, value);\n }\n checkBounds(buf2, offset, byteLength2);\n }\n function validateNumber(value, name) {\n if (typeof value !== "number") {\n throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);\n }\n }\n function boundsError(value, length, type) {\n if (Math.floor(value) !== value) {\n validateNumber(value, type);\n throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);\n }\n if (length < 0) {\n throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();\n }\n throw new errors.ERR_OUT_OF_RANGE(\n type || "offset",\n `>= ${type ? 1 : 0} and <= ${length}`,\n value\n );\n }\n var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;\n function base64clean(str) {\n str = str.split("=")[0];\n str = str.trim().replace(INVALID_BASE64_RE, "");\n if (str.length < 2)\n return "";\n while (str.length % 4 !== 0) {\n str = str + "=";\n }\n return str;\n }\n function utf8ToBytes(string, units) {\n units = units || Infinity;\n let codePoint;\n const length = string.length;\n let leadSurrogate = null;\n const bytes = [];\n for (let i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i);\n if (codePoint > 55295 && codePoint < 57344) {\n if (!leadSurrogate) {\n if (codePoint > 56319) {\n if ((units -= 3) > -1)\n bytes.push(239, 191, 189);\n continue;\n } else if (i + 1 === length) {\n if ((units -= 3) > -1)\n bytes.push(239, 191, 189);\n continue;\n }\n leadSurrogate = codePoint;\n continue;\n }\n if (codePoint < 56320) {\n if ((units -= 3) > -1)\n bytes.push(239, 191, 189);\n leadSurrogate = codePoint;\n continue;\n }\n codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;\n } else if (leadSurrogate) {\n if ((units -= 3) > -1)\n bytes.push(239, 191, 189);\n }\n leadSurrogate = null;\n if (codePoint < 128) {\n if ((units -= 1) < 0)\n break;\n bytes.push(codePoint);\n } else if (codePoint < 2048) {\n if ((units -= 2) < 0)\n break;\n bytes.push(\n codePoint >> 6 | 192,\n codePoint & 63 | 128\n );\n } else if (codePoint < 65536) {\n if ((units -= 3) < 0)\n break;\n bytes.push(\n codePoint >> 12 | 224,\n codePoint >> 6 & 63 | 128,\n codePoint & 63 | 128\n );\n } else if (codePoint < 1114112) {\n if ((units -= 4) < 0)\n break;\n bytes.push(\n codePoint >> 18 | 240,\n codePoint >> 12 & 63 | 128,\n codePoint >> 6 & 63 | 128,\n codePoint & 63 | 128\n );\n } else {\n throw new Error("Invalid code point");\n }\n }\n return bytes;\n }\n function asciiToBytes(str) {\n const byteArray = [];\n for (let i = 0; i < str.length; ++i) {\n byteArray.push(str.charCodeAt(i) & 255);\n }\n return byteArray;\n }\n function utf16leToBytes(str, units) {\n let c, hi, lo;\n const byteArray = [];\n for (let i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0)\n break;\n c = str.charCodeAt(i);\n hi = c >> 8;\n lo = c % 256;\n byteArray.push(lo);\n byteArray.push(hi);\n }\n return byteArray;\n }\n function base64ToBytes(str) {\n return base64.toByteArray(base64clean(str));\n }\n function blitBuffer(src, dst, offset, length) {\n let i;\n for (i = 0; i < length; ++i) {\n if (i + offset >= dst.length || i >= src.length)\n break;\n dst[i + offset] = src[i];\n }\n return i;\n }\n function isInstance(obj, type) {\n return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;\n }\n function numberIsNaN(obj) {\n return obj !== obj;\n }\n var hexSliceLookupTable = function() {\n const alphabet = "0123456789abcdef";\n const table = new Array(256);\n for (let i = 0; i < 16; ++i) {\n const i16 = i * 16;\n for (let j = 0; j < 16; ++j) {\n table[i16 + j] = alphabet[i] + alphabet[j];\n }\n }\n return table;\n }();\n function defineBigIntMethod(fn) {\n return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;\n }\n function BufferBigIntNotDefined() {\n throw new Error("BigInt not supported");\n }\n }\n});\n\n// esbuild.inject.js\nvar Buffer2;\nvar init_esbuild_inject = __esm({\n "esbuild.inject.js"() {\n "use strict";\n Buffer2 = require_buffer().Buffer;\n if (true) {\n if (false) {\n const ocreate = unsafeWindow.document.createElement.bind(document);\n unsafeWindow.document.createElement = (tag) => {\n if (tag != "meta")\n return ocreate(tag);\n unsafeWindow.document.createElement = ocreate;\n return unsafeWindow.document.createElement("link");\n };\n }\n if (false) {\n if (typeof cloneInto != "undefined")\n console.log("CLONE INTO DEFINED");\n else\n console.log("CLONE INTO NOT DEFINED");\n let a = 1;\n console.log(a++);\n const unsafeWindow2 = window;\n console.log(a++);\n const ocreate = unsafeWindow2.document.createElement.bind(document);\n console.log(a++);\n exportFunction((tag) => {\n if (tag != "meta")\n return ocreate(tag);\n unsafeWindow2.document.createElement = ocreate;\n return unsafeWindow2.document.createElement("link");\n }, window.document, { defineAs: "createElement" });\n console.log(a++);\n }\n }\n }\n});\n\n// node_modules/crc-32/crc32.js\nvar require_crc32 = __commonJS({\n "node_modules/crc-32/crc32.js"(exports) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var CRC32;\n (function(factory) {\n if (typeof DO_NOT_EXPORT_CRC === "undefined") {\n if ("object" === typeof exports) {\n factory(exports);\n } else if ("function" === typeof define && define.amd) {\n define(function() {\n var module2 = {};\n factory(module2);\n return module2;\n });\n } else {\n factory(CRC32 = {});\n }\n } else {\n factory(CRC32 = {});\n }\n })(function(CRC322) {\n CRC322.version = "1.2.2";\n function signed_crc_table() {\n var c = 0, table = new Array(256);\n for (var n = 0; n != 256; ++n) {\n c = n;\n c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;\n c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;\n c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;\n c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;\n c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;\n c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;\n c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;\n c = c & 1 ? -306674912 ^ c >>> 1 : c >>> 1;\n table[n] = c;\n }\n return typeof Int32Array !== "undefined" ? new Int32Array(table) : table;\n }\n var T0 = signed_crc_table();\n function slice_by_16_tables(T) {\n var c = 0, v = 0, n = 0, table = typeof Int32Array !== "undefined" ? new Int32Array(4096) : new Array(4096);\n for (n = 0; n != 256; ++n)\n table[n] = T[n];\n for (n = 0; n != 256; ++n) {\n v = T[n];\n for (c = 256 + n; c < 4096; c += 256)\n v = table[c] = v >>> 8 ^ T[v & 255];\n }\n var out = [];\n for (n = 1; n != 16; ++n)\n out[n - 1] = typeof Int32Array !== "undefined" ? table.subarray(n * 256, n * 256 + 256) : table.slice(n * 256, n * 256 + 256);\n return out;\n }\n var TT = slice_by_16_tables(T0);\n var T1 = TT[0], T2 = TT[1], T3 = TT[2], T4 = TT[3], T5 = TT[4];\n var T6 = TT[5], T7 = TT[6], T8 = TT[7], T9 = TT[8], Ta = TT[9];\n var Tb = TT[10], Tc = TT[11], Td = TT[12], Te = TT[13], Tf = TT[14];\n function crc32_bstr(bstr, seed) {\n var C = seed ^ -1;\n for (var i = 0, L = bstr.length; i < L; )\n C = C >>> 8 ^ T0[(C ^ bstr.charCodeAt(i++)) & 255];\n return ~C;\n }\n function crc32_buf(B, seed) {\n var C = seed ^ -1, L = B.length - 15, i = 0;\n for (; i < L; )\n C = Tf[B[i++] ^ C & 255] ^ Te[B[i++] ^ C >> 8 & 255] ^ Td[B[i++] ^ C >> 16 & 255] ^ Tc[B[i++] ^ C >>> 24] ^ Tb[B[i++]] ^ Ta[B[i++]] ^ T9[B[i++]] ^ T8[B[i++]] ^ T7[B[i++]] ^ T6[B[i++]] ^ T5[B[i++]] ^ T4[B[i++]] ^ T3[B[i++]] ^ T2[B[i++]] ^ T1[B[i++]] ^ T0[B[i++]];\n L += 15;\n while (i < L)\n C = C >>> 8 ^ T0[(C ^ B[i++]) & 255];\n return ~C;\n }\n function crc32_str(str, seed) {\n var C = seed ^ -1;\n for (var i = 0, L = str.length, c = 0, d = 0; i < L; ) {\n c = str.charCodeAt(i++);\n if (c < 128) {\n C = C >>> 8 ^ T0[(C ^ c) & 255];\n } else if (c < 2048) {\n C = C >>> 8 ^ T0[(C ^ (192 | c >> 6 & 31)) & 255];\n C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];\n } else if (c >= 55296 && c < 57344) {\n c = (c & 1023) + 64;\n d = str.charCodeAt(i++) & 1023;\n C = C >>> 8 ^ T0[(C ^ (240 | c >> 8 & 7)) & 255];\n C = C >>> 8 ^ T0[(C ^ (128 | c >> 2 & 63)) & 255];\n C = C >>> 8 ^ T0[(C ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255];\n C = C >>> 8 ^ T0[(C ^ (128 | d & 63)) & 255];\n } else {\n C = C >>> 8 ^ T0[(C ^ (224 | c >> 12 & 15)) & 255];\n C = C >>> 8 ^ T0[(C ^ (128 | c >> 6 & 63)) & 255];\n C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];\n }\n }\n return ~C;\n }\n CRC322.table = T0;\n CRC322.bstr = crc32_bstr;\n CRC322.buf = crc32_buf;\n CRC322.str = crc32_str;\n });\n }\n});\n\n// node_modules/events/events.js\nvar require_events = __commonJS({\n "node_modules/events/events.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var R = typeof Reflect === "object" ? Reflect : null;\n var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {\n return Function.prototype.apply.call(target, receiver, args);\n };\n var ReflectOwnKeys;\n if (R && typeof R.ownKeys === "function") {\n ReflectOwnKeys = R.ownKeys;\n } else if (Object.getOwnPropertySymbols) {\n ReflectOwnKeys = function ReflectOwnKeys2(target) {\n return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));\n };\n } else {\n ReflectOwnKeys = function ReflectOwnKeys2(target) {\n return Object.getOwnPropertyNames(target);\n };\n }\n function ProcessEmitWarning(warning) {\n if (console && console.warn)\n console.warn(warning);\n }\n var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {\n return value !== value;\n };\n function EventEmitter() {\n EventEmitter.init.call(this);\n }\n module.exports = EventEmitter;\n module.exports.once = once;\n EventEmitter.EventEmitter = EventEmitter;\n EventEmitter.prototype._events = void 0;\n EventEmitter.prototype._eventsCount = 0;\n EventEmitter.prototype._maxListeners = void 0;\n var defaultMaxListeners = 10;\n function checkListener(listener) {\n if (typeof listener !== "function") {\n throw new TypeError(\'The "listener" argument must be of type Function. Received type \' + typeof listener);\n }\n }\n Object.defineProperty(EventEmitter, "defaultMaxListeners", {\n enumerable: true,\n get: function() {\n return defaultMaxListeners;\n },\n set: function(arg) {\n if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {\n throw new RangeError(\'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received \' + arg + ".");\n }\n defaultMaxListeners = arg;\n }\n });\n EventEmitter.init = function() {\n if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {\n this._events = /* @__PURE__ */ Object.create(null);\n this._eventsCount = 0;\n }\n this._maxListeners = this._maxListeners || void 0;\n };\n EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {\n throw new RangeError(\'The value of "n" is out of range. It must be a non-negative number. Received \' + n + ".");\n }\n this._maxListeners = n;\n return this;\n };\n function _getMaxListeners(that) {\n if (that._maxListeners === void 0)\n return EventEmitter.defaultMaxListeners;\n return that._maxListeners;\n }\n EventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n return _getMaxListeners(this);\n };\n EventEmitter.prototype.emit = function emit(type) {\n var args = [];\n for (var i = 1; i < arguments.length; i++)\n args.push(arguments[i]);\n var doError = type === "error";\n var events = this._events;\n if (events !== void 0)\n doError = doError && events.error === void 0;\n else if (!doError)\n return false;\n if (doError) {\n var er;\n if (args.length > 0)\n er = args[0];\n if (er instanceof Error) {\n throw er;\n }\n var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));\n err.context = er;\n throw err;\n }\n var handler = events[type];\n if (handler === void 0)\n return false;\n if (typeof handler === "function") {\n ReflectApply(handler, this, args);\n } else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n ReflectApply(listeners[i], this, args);\n }\n return true;\n };\n function _addListener(target, type, listener, prepend) {\n var m;\n var events;\n var existing;\n checkListener(listener);\n events = target._events;\n if (events === void 0) {\n events = target._events = /* @__PURE__ */ Object.create(null);\n target._eventsCount = 0;\n } else {\n if (events.newListener !== void 0) {\n target.emit(\n "newListener",\n type,\n listener.listener ? listener.listener : listener\n );\n events = target._events;\n }\n existing = events[type];\n }\n if (existing === void 0) {\n existing = events[type] = listener;\n ++target._eventsCount;\n } else {\n if (typeof existing === "function") {\n existing = events[type] = prepend ? [listener, existing] : [existing, listener];\n } else if (prepend) {\n existing.unshift(listener);\n } else {\n existing.push(listener);\n }\n m = _getMaxListeners(target);\n if (m > 0 && existing.length > m && !existing.warned) {\n existing.warned = true;\n var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");\n w.name = "MaxListenersExceededWarning";\n w.emitter = target;\n w.type = type;\n w.count = existing.length;\n ProcessEmitWarning(w);\n }\n }\n return target;\n }\n EventEmitter.prototype.addListener = function addListener(type, listener) {\n return _addListener(this, type, listener, false);\n };\n EventEmitter.prototype.on = EventEmitter.prototype.addListener;\n EventEmitter.prototype.prependListener = function prependListener(type, listener) {\n return _addListener(this, type, listener, true);\n };\n function onceWrapper() {\n if (!this.fired) {\n this.target.removeListener(this.type, this.wrapFn);\n this.fired = true;\n if (arguments.length === 0)\n return this.listener.call(this.target);\n return this.listener.apply(this.target, arguments);\n }\n }\n function _onceWrap(target, type, listener) {\n var state = { fired: false, wrapFn: void 0, target, type, listener };\n var wrapped = onceWrapper.bind(state);\n wrapped.listener = listener;\n state.wrapFn = wrapped;\n return wrapped;\n }\n EventEmitter.prototype.once = function once2(type, listener) {\n checkListener(listener);\n this.on(type, _onceWrap(this, type, listener));\n return this;\n };\n EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {\n checkListener(listener);\n this.prependListener(type, _onceWrap(this, type, listener));\n return this;\n };\n EventEmitter.prototype.removeListener = function removeListener(type, listener) {\n var list, events, position, i, originalListener;\n checkListener(listener);\n events = this._events;\n if (events === void 0)\n return this;\n list = events[type];\n if (list === void 0)\n return this;\n if (list === listener || list.listener === listener) {\n if (--this._eventsCount === 0)\n this._events = /* @__PURE__ */ Object.create(null);\n else {\n delete events[type];\n if (events.removeListener)\n this.emit("removeListener", type, list.listener || listener);\n }\n } else if (typeof list !== "function") {\n position = -1;\n for (i = list.length - 1; i >= 0; i--) {\n if (list[i] === listener || list[i].listener === listener) {\n originalListener = list[i].listener;\n position = i;\n break;\n }\n }\n if (position < 0)\n return this;\n if (position === 0)\n list.shift();\n else {\n spliceOne(list, position);\n }\n if (list.length === 1)\n events[type] = list[0];\n if (events.removeListener !== void 0)\n this.emit("removeListener", type, originalListener || listener);\n }\n return this;\n };\n EventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {\n var listeners, events, i;\n events = this._events;\n if (events === void 0)\n return this;\n if (events.removeListener === void 0) {\n if (arguments.length === 0) {\n this._events = /* @__PURE__ */ Object.create(null);\n this._eventsCount = 0;\n } else if (events[type] !== void 0) {\n if (--this._eventsCount === 0)\n this._events = /* @__PURE__ */ Object.create(null);\n else\n delete events[type];\n }\n return this;\n }\n if (arguments.length === 0) {\n var keys = Object.keys(events);\n var key2;\n for (i = 0; i < keys.length; ++i) {\n key2 = keys[i];\n if (key2 === "removeListener")\n continue;\n this.removeAllListeners(key2);\n }\n this.removeAllListeners("removeListener");\n this._events = /* @__PURE__ */ Object.create(null);\n this._eventsCount = 0;\n return this;\n }\n listeners = events[type];\n if (typeof listeners === "function") {\n this.removeListener(type, listeners);\n } else if (listeners !== void 0) {\n for (i = listeners.length - 1; i >= 0; i--) {\n this.removeListener(type, listeners[i]);\n }\n }\n return this;\n };\n function _listeners(target, type, unwrap) {\n var events = target._events;\n if (events === void 0)\n return [];\n var evlistener = events[type];\n if (evlistener === void 0)\n return [];\n if (typeof evlistener === "function")\n return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n }\n EventEmitter.prototype.listeners = function listeners(type) {\n return _listeners(this, type, true);\n };\n EventEmitter.prototype.rawListeners = function rawListeners(type) {\n return _listeners(this, type, false);\n };\n EventEmitter.listenerCount = function(emitter, type) {\n if (typeof emitter.listenerCount === "function") {\n return emitter.listenerCount(type);\n } else {\n return listenerCount.call(emitter, type);\n }\n };\n EventEmitter.prototype.listenerCount = listenerCount;\n function listenerCount(type) {\n var events = this._events;\n if (events !== void 0) {\n var evlistener = events[type];\n if (typeof evlistener === "function") {\n return 1;\n } else if (evlistener !== void 0) {\n return evlistener.length;\n }\n }\n return 0;\n }\n EventEmitter.prototype.eventNames = function eventNames() {\n return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n };\n function arrayClone(arr, n) {\n var copy = new Array(n);\n for (var i = 0; i < n; ++i)\n copy[i] = arr[i];\n return copy;\n }\n function spliceOne(list, index) {\n for (; index + 1 < list.length; index++)\n list[index] = list[index + 1];\n list.pop();\n }\n function unwrapListeners(arr) {\n var ret = new Array(arr.length);\n for (var i = 0; i < ret.length; ++i) {\n ret[i] = arr[i].listener || arr[i];\n }\n return ret;\n }\n function once(emitter, name) {\n return new Promise(function(resolve, reject) {\n function errorListener(err) {\n emitter.removeListener(name, resolver);\n reject(err);\n }\n function resolver() {\n if (typeof emitter.removeListener === "function") {\n emitter.removeListener("error", errorListener);\n }\n resolve([].slice.call(arguments));\n }\n ;\n eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n if (name !== "error") {\n addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n }\n });\n }\n function addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n if (typeof emitter.on === "function") {\n eventTargetAgnosticAddListener(emitter, "error", handler, flags);\n }\n }\n function eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n if (typeof emitter.on === "function") {\n if (flags.once) {\n emitter.once(name, listener);\n } else {\n emitter.on(name, listener);\n }\n } else if (typeof emitter.addEventListener === "function") {\n emitter.addEventListener(name, function wrapListener(arg) {\n if (flags.once) {\n emitter.removeEventListener(name, wrapListener);\n }\n listener(arg);\n });\n } else {\n throw new TypeError(\'The "emitter" argument must be of type EventEmitter. Received type \' + typeof emitter);\n }\n }\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/stream-browser.js\nvar require_stream_browser = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/stream-browser.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n module.exports = require_events().EventEmitter;\n }\n});\n\n// (disabled):node_modules/util/util.js\nvar require_util = __commonJS({\n "(disabled):node_modules/util/util.js"() {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/buffer_list.js\nvar require_buffer_list = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n function ownKeys(object, enumerableOnly) {\n var keys = Object.keys(object);\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(object);\n if (enumerableOnly)\n symbols = symbols.filter(function(sym) {\n return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n });\n keys.push.apply(keys, symbols);\n }\n return keys;\n }\n function _objectSpread(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i] != null ? arguments[i] : {};\n if (i % 2) {\n ownKeys(Object(source), true).forEach(function(key2) {\n _defineProperty(target, key2, source[key2]);\n });\n } else if (Object.getOwnPropertyDescriptors) {\n Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n } else {\n ownKeys(Object(source)).forEach(function(key2) {\n Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2));\n });\n }\n }\n return target;\n }\n function _defineProperty(obj, key2, value) {\n if (key2 in obj) {\n Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });\n } else {\n obj[key2] = value;\n }\n return obj;\n }\n function _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError("Cannot call a class as a function");\n }\n }\n function _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if ("value" in descriptor)\n descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n }\n function _createClass(Constructor, protoProps, staticProps) {\n if (protoProps)\n _defineProperties(Constructor.prototype, protoProps);\n if (staticProps)\n _defineProperties(Constructor, staticProps);\n return Constructor;\n }\n var _require = require_buffer();\n var Buffer13 = _require.Buffer;\n var _require2 = require_util();\n var inspect = _require2.inspect;\n var custom = inspect && inspect.custom || "inspect";\n function copyBuffer(src, target, offset) {\n Buffer13.prototype.copy.call(src, target, offset);\n }\n module.exports = /* @__PURE__ */ function() {\n function BufferList() {\n _classCallCheck(this, BufferList);\n this.head = null;\n this.tail = null;\n this.length = 0;\n }\n _createClass(BufferList, [{\n key: "push",\n value: function push(v) {\n var entry = {\n data: v,\n next: null\n };\n if (this.length > 0)\n this.tail.next = entry;\n else\n this.head = entry;\n this.tail = entry;\n ++this.length;\n }\n }, {\n key: "unshift",\n value: function unshift(v) {\n var entry = {\n data: v,\n next: this.head\n };\n if (this.length === 0)\n this.tail = entry;\n this.head = entry;\n ++this.length;\n }\n }, {\n key: "shift",\n value: function shift() {\n if (this.length === 0)\n return;\n var ret = this.head.data;\n if (this.length === 1)\n this.head = this.tail = null;\n else\n this.head = this.head.next;\n --this.length;\n return ret;\n }\n }, {\n key: "clear",\n value: function clear() {\n this.head = this.tail = null;\n this.length = 0;\n }\n }, {\n key: "join",\n value: function join(s) {\n if (this.length === 0)\n return "";\n var p = this.head;\n var ret = "" + p.data;\n while (p = p.next) {\n ret += s + p.data;\n }\n return ret;\n }\n }, {\n key: "concat",\n value: function concat(n) {\n if (this.length === 0)\n return Buffer13.alloc(0);\n var ret = Buffer13.allocUnsafe(n >>> 0);\n var p = this.head;\n var i = 0;\n while (p) {\n copyBuffer(p.data, ret, i);\n i += p.data.length;\n p = p.next;\n }\n return ret;\n }\n }, {\n key: "consume",\n value: function consume(n, hasStrings) {\n var ret;\n if (n < this.head.data.length) {\n ret = this.head.data.slice(0, n);\n this.head.data = this.head.data.slice(n);\n } else if (n === this.head.data.length) {\n ret = this.shift();\n } else {\n ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n }\n return ret;\n }\n }, {\n key: "first",\n value: function first() {\n return this.head.data;\n }\n }, {\n key: "_getString",\n value: function _getString(n) {\n var p = this.head;\n var c = 1;\n var ret = p.data;\n n -= ret.length;\n while (p = p.next) {\n var str = p.data;\n var nb = n > str.length ? str.length : n;\n if (nb === str.length)\n ret += str;\n else\n ret += str.slice(0, n);\n n -= nb;\n if (n === 0) {\n if (nb === str.length) {\n ++c;\n if (p.next)\n this.head = p.next;\n else\n this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = str.slice(nb);\n }\n break;\n }\n ++c;\n }\n this.length -= c;\n return ret;\n }\n }, {\n key: "_getBuffer",\n value: function _getBuffer(n) {\n var ret = Buffer13.allocUnsafe(n);\n var p = this.head;\n var c = 1;\n p.data.copy(ret);\n n -= p.data.length;\n while (p = p.next) {\n var buf2 = p.data;\n var nb = n > buf2.length ? buf2.length : n;\n buf2.copy(ret, ret.length - n, 0, nb);\n n -= nb;\n if (n === 0) {\n if (nb === buf2.length) {\n ++c;\n if (p.next)\n this.head = p.next;\n else\n this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = buf2.slice(nb);\n }\n break;\n }\n ++c;\n }\n this.length -= c;\n return ret;\n }\n }, {\n key: custom,\n value: function value(_, options) {\n return inspect(this, _objectSpread({}, options, {\n depth: 0,\n customInspect: false\n }));\n }\n }]);\n return BufferList;\n }();\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/destroy.js\nvar require_destroy = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n function destroy(err, cb) {\n var _this = this;\n var readableDestroyed = this._readableState && this._readableState.destroyed;\n var writableDestroyed = this._writableState && this._writableState.destroyed;\n if (readableDestroyed || writableDestroyed) {\n if (cb) {\n cb(err);\n } else if (err) {\n if (!this._writableState) {\n process.nextTick(emitErrorNT, this, err);\n } else if (!this._writableState.errorEmitted) {\n this._writableState.errorEmitted = true;\n process.nextTick(emitErrorNT, this, err);\n }\n }\n return this;\n }\n if (this._readableState) {\n this._readableState.destroyed = true;\n }\n if (this._writableState) {\n this._writableState.destroyed = true;\n }\n this._destroy(err || null, function(err2) {\n if (!cb && err2) {\n if (!_this._writableState) {\n process.nextTick(emitErrorAndCloseNT, _this, err2);\n } else if (!_this._writableState.errorEmitted) {\n _this._writableState.errorEmitted = true;\n process.nextTick(emitErrorAndCloseNT, _this, err2);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n } else if (cb) {\n process.nextTick(emitCloseNT, _this);\n cb(err2);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n });\n return this;\n }\n function emitErrorAndCloseNT(self2, err) {\n emitErrorNT(self2, err);\n emitCloseNT(self2);\n }\n function emitCloseNT(self2) {\n if (self2._writableState && !self2._writableState.emitClose)\n return;\n if (self2._readableState && !self2._readableState.emitClose)\n return;\n self2.emit("close");\n }\n function undestroy() {\n if (this._readableState) {\n this._readableState.destroyed = false;\n this._readableState.reading = false;\n this._readableState.ended = false;\n this._readableState.endEmitted = false;\n }\n if (this._writableState) {\n this._writableState.destroyed = false;\n this._writableState.ended = false;\n this._writableState.ending = false;\n this._writableState.finalCalled = false;\n this._writableState.prefinished = false;\n this._writableState.finished = false;\n this._writableState.errorEmitted = false;\n }\n }\n function emitErrorNT(self2, err) {\n self2.emit("error", err);\n }\n function errorOrDestroy(stream, err) {\n var rState = stream._readableState;\n var wState = stream._writableState;\n if (rState && rState.autoDestroy || wState && wState.autoDestroy)\n stream.destroy(err);\n else\n stream.emit("error", err);\n }\n module.exports = {\n destroy,\n undestroy,\n errorOrDestroy\n };\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/errors-browser.js\nvar require_errors_browser = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/errors-browser.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n function _inheritsLoose(subClass, superClass) {\n subClass.prototype = Object.create(superClass.prototype);\n subClass.prototype.constructor = subClass;\n subClass.__proto__ = superClass;\n }\n var codes = {};\n function createErrorType(code, message, Base) {\n if (!Base) {\n Base = Error;\n }\n function getMessage(arg1, arg2, arg3) {\n if (typeof message === "string") {\n return message;\n } else {\n return message(arg1, arg2, arg3);\n }\n }\n var NodeError = /* @__PURE__ */ function(_Base) {\n _inheritsLoose(NodeError2, _Base);\n function NodeError2(arg1, arg2, arg3) {\n return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n }\n return NodeError2;\n }(Base);\n NodeError.prototype.name = Base.name;\n NodeError.prototype.code = code;\n codes[code] = NodeError;\n }\n function oneOf(expected, thing) {\n if (Array.isArray(expected)) {\n var len = expected.length;\n expected = expected.map(function(i) {\n return String(i);\n });\n if (len > 2) {\n return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];\n } else if (len === 2) {\n return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);\n } else {\n return "of ".concat(thing, " ").concat(expected[0]);\n }\n } else {\n return "of ".concat(thing, " ").concat(String(expected));\n }\n }\n function startsWith(str, search, pos) {\n return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n }\n function endsWith(str, search, this_len) {\n if (this_len === void 0 || this_len > str.length) {\n this_len = str.length;\n }\n return str.substring(this_len - search.length, this_len) === search;\n }\n function includes(str, search, start) {\n if (typeof start !== "number") {\n start = 0;\n }\n if (start + search.length > str.length) {\n return false;\n } else {\n return str.indexOf(search, start) !== -1;\n }\n }\n createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {\n return \'The value "\' + value + \'" is invalid for option "\' + name + \'"\';\n }, TypeError);\n createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {\n var determiner;\n if (typeof expected === "string" && startsWith(expected, "not ")) {\n determiner = "must not be";\n expected = expected.replace(/^not /, "");\n } else {\n determiner = "must be";\n }\n var msg;\n if (endsWith(name, " argument")) {\n msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));\n } else {\n var type = includes(name, ".") ? "property" : "argument";\n msg = \'The "\'.concat(name, \'" \').concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));\n }\n msg += ". Received type ".concat(typeof actual);\n return msg;\n }, TypeError);\n createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");\n createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) {\n return "The " + name + " method is not implemented";\n });\n createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");\n createErrorType("ERR_STREAM_DESTROYED", function(name) {\n return "Cannot call " + name + " after a stream was destroyed";\n });\n createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");\n createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");\n createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");\n createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);\n createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {\n return "Unknown encoding: " + arg;\n }, TypeError);\n createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");\n module.exports.codes = codes;\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/state.js\nvar require_state = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/state.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var ERR_INVALID_OPT_VALUE = require_errors_browser().codes.ERR_INVALID_OPT_VALUE;\n function highWaterMarkFrom(options, isDuplex, duplexKey) {\n return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n }\n function getHighWaterMark(state, options, duplexKey, isDuplex) {\n var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n if (hwm != null) {\n if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n var name = isDuplex ? duplexKey : "highWaterMark";\n throw new ERR_INVALID_OPT_VALUE(name, hwm);\n }\n return Math.floor(hwm);\n }\n return state.objectMode ? 16 : 16 * 1024;\n }\n module.exports = {\n getHighWaterMark\n };\n }\n});\n\n// node_modules/inherits/inherits_browser.js\nvar require_inherits_browser = __commonJS({\n "node_modules/inherits/inherits_browser.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n if (typeof Object.create === "function") {\n module.exports = function inherits(ctor, superCtor) {\n if (superCtor) {\n ctor.super_ = superCtor;\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n }\n };\n } else {\n module.exports = function inherits(ctor, superCtor) {\n if (superCtor) {\n ctor.super_ = superCtor;\n var TempCtor = function() {\n };\n TempCtor.prototype = superCtor.prototype;\n ctor.prototype = new TempCtor();\n ctor.prototype.constructor = ctor;\n }\n };\n }\n }\n});\n\n// node_modules/util-deprecate/browser.js\nvar require_browser = __commonJS({\n "node_modules/util-deprecate/browser.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n module.exports = deprecate;\n function deprecate(fn, msg) {\n if (config("noDeprecation")) {\n return fn;\n }\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (config("throwDeprecation")) {\n throw new Error(msg);\n } else if (config("traceDeprecation")) {\n console.trace(msg);\n } else {\n console.warn(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n return deprecated;\n }\n function config(name) {\n try {\n if (!self.localStorage)\n return false;\n } catch (_) {\n return false;\n }\n var val = self.localStorage[name];\n if (null == val)\n return false;\n return String(val).toLowerCase() === "true";\n }\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_writable.js\nvar require_stream_writable = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_writable.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n module.exports = Writable;\n function CorkedRequest(state) {\n var _this = this;\n this.next = null;\n this.entry = null;\n this.finish = function() {\n onCorkedFinish(_this, state);\n };\n }\n var Duplex;\n Writable.WritableState = WritableState;\n var internalUtil = {\n deprecate: require_browser()\n };\n var Stream = require_stream_browser();\n var Buffer13 = require_buffer().Buffer;\n var OurUint8Array = self.Uint8Array || function() {\n };\n function _uint8ArrayToBuffer(chunk) {\n return Buffer13.from(chunk);\n }\n function _isUint8Array(obj) {\n return Buffer13.isBuffer(obj) || obj instanceof OurUint8Array;\n }\n var destroyImpl = require_destroy();\n var _require = require_state();\n var getHighWaterMark = _require.getHighWaterMark;\n var _require$codes = require_errors_browser().codes;\n var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;\n var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;\n var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;\n var ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE;\n var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n var ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES;\n var ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END;\n var ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n var errorOrDestroy = destroyImpl.errorOrDestroy;\n require_inherits_browser()(Writable, Stream);\n function nop() {\n }\n function WritableState(options, stream, isDuplex) {\n Duplex = Duplex || require_stream_duplex();\n options = options || {};\n if (typeof isDuplex !== "boolean")\n isDuplex = stream instanceof Duplex;\n this.objectMode = !!options.objectMode;\n if (isDuplex)\n this.objectMode = this.objectMode || !!options.writableObjectMode;\n this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);\n this.finalCalled = false;\n this.needDrain = false;\n this.ending = false;\n this.ended = false;\n this.finished = false;\n this.destroyed = false;\n var noDecode = options.decodeStrings === false;\n this.decodeStrings = !noDecode;\n this.defaultEncoding = options.defaultEncoding || "utf8";\n this.length = 0;\n this.writing = false;\n this.corked = 0;\n this.sync = true;\n this.bufferProcessing = false;\n this.onwrite = function(er) {\n onwrite(stream, er);\n };\n this.writecb = null;\n this.writelen = 0;\n this.bufferedRequest = null;\n this.lastBufferedRequest = null;\n this.pendingcb = 0;\n this.prefinished = false;\n this.errorEmitted = false;\n this.emitClose = options.emitClose !== false;\n this.autoDestroy = !!options.autoDestroy;\n this.bufferedRequestCount = 0;\n this.corkedRequestsFree = new CorkedRequest(this);\n }\n WritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n while (current) {\n out.push(current);\n current = current.next;\n }\n return out;\n };\n (function() {\n try {\n Object.defineProperty(WritableState.prototype, "buffer", {\n get: internalUtil.deprecate(function writableStateBufferGetter() {\n return this.getBuffer();\n }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")\n });\n } catch (_) {\n }\n })();\n var realHasInstance;\n if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {\n realHasInstance = Function.prototype[Symbol.hasInstance];\n Object.defineProperty(Writable, Symbol.hasInstance, {\n value: function value(object) {\n if (realHasInstance.call(this, object))\n return true;\n if (this !== Writable)\n return false;\n return object && object._writableState instanceof WritableState;\n }\n });\n } else {\n realHasInstance = function realHasInstance2(object) {\n return object instanceof this;\n };\n }\n function Writable(options) {\n Duplex = Duplex || require_stream_duplex();\n var isDuplex = this instanceof Duplex;\n if (!isDuplex && !realHasInstance.call(Writable, this))\n return new Writable(options);\n this._writableState = new WritableState(options, this, isDuplex);\n this.writable = true;\n if (options) {\n if (typeof options.write === "function")\n this._write = options.write;\n if (typeof options.writev === "function")\n this._writev = options.writev;\n if (typeof options.destroy === "function")\n this._destroy = options.destroy;\n if (typeof options.final === "function")\n this._final = options.final;\n }\n Stream.call(this);\n }\n Writable.prototype.pipe = function() {\n errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n };\n function writeAfterEnd(stream, cb) {\n var er = new ERR_STREAM_WRITE_AFTER_END();\n errorOrDestroy(stream, er);\n process.nextTick(cb, er);\n }\n function validChunk(stream, state, chunk, cb) {\n var er;\n if (chunk === null) {\n er = new ERR_STREAM_NULL_VALUES();\n } else if (typeof chunk !== "string" && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);\n }\n if (er) {\n errorOrDestroy(stream, er);\n process.nextTick(cb, er);\n return false;\n }\n return true;\n }\n Writable.prototype.write = function(chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\n var isBuf = !state.objectMode && _isUint8Array(chunk);\n if (isBuf && !Buffer13.isBuffer(chunk)) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n if (typeof encoding === "function") {\n cb = encoding;\n encoding = null;\n }\n if (isBuf)\n encoding = "buffer";\n else if (!encoding)\n encoding = state.defaultEncoding;\n if (typeof cb !== "function")\n cb = nop;\n if (state.ending)\n writeAfterEnd(this, cb);\n else if (isBuf || validChunk(this, state, chunk, cb)) {\n state.pendingcb++;\n ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n }\n return ret;\n };\n Writable.prototype.cork = function() {\n this._writableState.corked++;\n };\n Writable.prototype.uncork = function() {\n var state = this._writableState;\n if (state.corked) {\n state.corked--;\n if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest)\n clearBuffer(this, state);\n }\n };\n Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n if (typeof encoding === "string")\n encoding = encoding.toLowerCase();\n if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1))\n throw new ERR_UNKNOWN_ENCODING(encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\n };\n Object.defineProperty(Writable.prototype, "writableBuffer", {\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n });\n function decodeChunk(state, chunk, encoding) {\n if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {\n chunk = Buffer13.from(chunk, encoding);\n }\n return chunk;\n }\n Object.defineProperty(Writable.prototype, "writableHighWaterMark", {\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n });\n function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = "buffer";\n chunk = newChunk;\n }\n }\n var len = state.objectMode ? 1 : chunk.length;\n state.length += len;\n var ret = state.length < state.highWaterMark;\n if (!ret)\n state.needDrain = true;\n if (state.writing || state.corked) {\n var last = state.lastBufferedRequest;\n state.lastBufferedRequest = {\n chunk,\n encoding,\n isBuf,\n callback: cb,\n next: null\n };\n if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\n }\n state.bufferedRequestCount += 1;\n } else {\n doWrite(stream, state, false, len, chunk, encoding, cb);\n }\n return ret;\n }\n function doWrite(stream, state, writev, len, chunk, encoding, cb) {\n state.writelen = len;\n state.writecb = cb;\n state.writing = true;\n state.sync = true;\n if (state.destroyed)\n state.onwrite(new ERR_STREAM_DESTROYED("write"));\n else if (writev)\n stream._writev(chunk, state.onwrite);\n else\n stream._write(chunk, encoding, state.onwrite);\n state.sync = false;\n }\n function onwriteError(stream, state, sync, er, cb) {\n --state.pendingcb;\n if (sync) {\n process.nextTick(cb, er);\n process.nextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n errorOrDestroy(stream, er);\n } else {\n cb(er);\n stream._writableState.errorEmitted = true;\n errorOrDestroy(stream, er);\n finishMaybe(stream, state);\n }\n }\n function onwriteStateUpdate(state) {\n state.writing = false;\n state.writecb = null;\n state.length -= state.writelen;\n state.writelen = 0;\n }\n function onwrite(stream, er) {\n var state = stream._writableState;\n var sync = state.sync;\n var cb = state.writecb;\n if (typeof cb !== "function")\n throw new ERR_MULTIPLE_CALLBACK();\n onwriteStateUpdate(state);\n if (er)\n onwriteError(stream, state, sync, er, cb);\n else {\n var finished = needFinish(state) || stream.destroyed;\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n if (sync) {\n process.nextTick(afterWrite, stream, state, finished, cb);\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n }\n function afterWrite(stream, state, finished, cb) {\n if (!finished)\n onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n }\n function onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit("drain");\n }\n }\n function clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n if (stream._writev && entry && entry.next) {\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n var count = 0;\n var allBuffers = true;\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf)\n allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n buffer.allBuffers = allBuffers;\n doWrite(stream, state, true, state.length, buffer, "", holder.finish);\n state.pendingcb++;\n state.lastBufferedRequest = null;\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n state.bufferedRequestCount = 0;\n } else {\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n state.bufferedRequestCount--;\n if (state.writing) {\n break;\n }\n }\n if (entry === null)\n state.lastBufferedRequest = null;\n }\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n }\n Writable.prototype._write = function(chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));\n };\n Writable.prototype._writev = null;\n Writable.prototype.end = function(chunk, encoding, cb) {\n var state = this._writableState;\n if (typeof chunk === "function") {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === "function") {\n cb = encoding;\n encoding = null;\n }\n if (chunk !== null && chunk !== void 0)\n this.write(chunk, encoding);\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n }\n if (!state.ending)\n endWritable(this, state, cb);\n return this;\n };\n Object.defineProperty(Writable.prototype, "writableLength", {\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n });\n function needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n }\n function callFinal(stream, state) {\n stream._final(function(err) {\n state.pendingcb--;\n if (err) {\n errorOrDestroy(stream, err);\n }\n state.prefinished = true;\n stream.emit("prefinish");\n finishMaybe(stream, state);\n });\n }\n function prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === "function" && !state.destroyed) {\n state.pendingcb++;\n state.finalCalled = true;\n process.nextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit("prefinish");\n }\n }\n }\n function finishMaybe(stream, state) {\n var need = needFinish(state);\n if (need) {\n prefinish(stream, state);\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit("finish");\n if (state.autoDestroy) {\n var rState = stream._readableState;\n if (!rState || rState.autoDestroy && rState.endEmitted) {\n stream.destroy();\n }\n }\n }\n }\n return need;\n }\n function endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n if (cb) {\n if (state.finished)\n process.nextTick(cb);\n else\n stream.once("finish", cb);\n }\n state.ended = true;\n stream.writable = false;\n }\n function onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n }\n state.corkedRequestsFree.next = corkReq;\n }\n Object.defineProperty(Writable.prototype, "destroyed", {\n enumerable: false,\n get: function get() {\n if (this._writableState === void 0) {\n return false;\n }\n return this._writableState.destroyed;\n },\n set: function set(value) {\n if (!this._writableState) {\n return;\n }\n this._writableState.destroyed = value;\n }\n });\n Writable.prototype.destroy = destroyImpl.destroy;\n Writable.prototype._undestroy = destroyImpl.undestroy;\n Writable.prototype._destroy = function(err, cb) {\n cb(err);\n };\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_duplex.js\nvar require_stream_duplex = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var objectKeys = Object.keys || function(obj) {\n var keys2 = [];\n for (var key2 in obj) {\n keys2.push(key2);\n }\n return keys2;\n };\n module.exports = Duplex;\n var Readable = require_stream_readable();\n var Writable = require_stream_writable();\n require_inherits_browser()(Duplex, Readable);\n {\n keys = objectKeys(Writable.prototype);\n for (v = 0; v < keys.length; v++) {\n method = keys[v];\n if (!Duplex.prototype[method])\n Duplex.prototype[method] = Writable.prototype[method];\n }\n }\n var keys;\n var method;\n var v;\n function Duplex(options) {\n if (!(this instanceof Duplex))\n return new Duplex(options);\n Readable.call(this, options);\n Writable.call(this, options);\n this.allowHalfOpen = true;\n if (options) {\n if (options.readable === false)\n this.readable = false;\n if (options.writable === false)\n this.writable = false;\n if (options.allowHalfOpen === false) {\n this.allowHalfOpen = false;\n this.once("end", onend);\n }\n }\n }\n Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n });\n Object.defineProperty(Duplex.prototype, "writableBuffer", {\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n });\n Object.defineProperty(Duplex.prototype, "writableLength", {\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n });\n function onend() {\n if (this._writableState.ended)\n return;\n process.nextTick(onEndNT, this);\n }\n function onEndNT(self2) {\n self2.end();\n }\n Object.defineProperty(Duplex.prototype, "destroyed", {\n enumerable: false,\n get: function get() {\n if (this._readableState === void 0 || this._writableState === void 0) {\n return false;\n }\n return this._readableState.destroyed && this._writableState.destroyed;\n },\n set: function set(value) {\n if (this._readableState === void 0 || this._writableState === void 0) {\n return;\n }\n this._readableState.destroyed = value;\n this._writableState.destroyed = value;\n }\n });\n }\n});\n\n// node_modules/safe-buffer/index.js\nvar require_safe_buffer = __commonJS({\n "node_modules/safe-buffer/index.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var buffer = require_buffer();\n var Buffer13 = buffer.Buffer;\n function copyProps(src, dst) {\n for (var key2 in src) {\n dst[key2] = src[key2];\n }\n }\n if (Buffer13.from && Buffer13.alloc && Buffer13.allocUnsafe && Buffer13.allocUnsafeSlow) {\n module.exports = buffer;\n } else {\n copyProps(buffer, exports);\n exports.Buffer = SafeBuffer;\n }\n function SafeBuffer(arg, encodingOrOffset, length) {\n return Buffer13(arg, encodingOrOffset, length);\n }\n SafeBuffer.prototype = Object.create(Buffer13.prototype);\n copyProps(Buffer13, SafeBuffer);\n SafeBuffer.from = function(arg, encodingOrOffset, length) {\n if (typeof arg === "number") {\n throw new TypeError("Argument must not be a number");\n }\n return Buffer13(arg, encodingOrOffset, length);\n };\n SafeBuffer.alloc = function(size, fill, encoding) {\n if (typeof size !== "number") {\n throw new TypeError("Argument must be a number");\n }\n var buf2 = Buffer13(size);\n if (fill !== void 0) {\n if (typeof encoding === "string") {\n buf2.fill(fill, encoding);\n } else {\n buf2.fill(fill);\n }\n } else {\n buf2.fill(0);\n }\n return buf2;\n };\n SafeBuffer.allocUnsafe = function(size) {\n if (typeof size !== "number") {\n throw new TypeError("Argument must be a number");\n }\n return Buffer13(size);\n };\n SafeBuffer.allocUnsafeSlow = function(size) {\n if (typeof size !== "number") {\n throw new TypeError("Argument must be a number");\n }\n return buffer.SlowBuffer(size);\n };\n }\n});\n\n// node_modules/string_decoder/lib/string_decoder.js\nvar require_string_decoder = __commonJS({\n "node_modules/string_decoder/lib/string_decoder.js"(exports) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var Buffer13 = require_safe_buffer().Buffer;\n var isEncoding = Buffer13.isEncoding || function(encoding) {\n encoding = "" + encoding;\n switch (encoding && encoding.toLowerCase()) {\n case "hex":\n case "utf8":\n case "utf-8":\n case "ascii":\n case "binary":\n case "base64":\n case "ucs2":\n case "ucs-2":\n case "utf16le":\n case "utf-16le":\n case "raw":\n return true;\n default:\n return false;\n }\n };\n function _normalizeEncoding(enc) {\n if (!enc)\n return "utf8";\n var retried;\n while (true) {\n switch (enc) {\n case "utf8":\n case "utf-8":\n return "utf8";\n case "ucs2":\n case "ucs-2":\n case "utf16le":\n case "utf-16le":\n return "utf16le";\n case "latin1":\n case "binary":\n return "latin1";\n case "base64":\n case "ascii":\n case "hex":\n return enc;\n default:\n if (retried)\n return;\n enc = ("" + enc).toLowerCase();\n retried = true;\n }\n }\n }\n function normalizeEncoding(enc) {\n var nenc = _normalizeEncoding(enc);\n if (typeof nenc !== "string" && (Buffer13.isEncoding === isEncoding || !isEncoding(enc)))\n throw new Error("Unknown encoding: " + enc);\n return nenc || enc;\n }\n exports.StringDecoder = StringDecoder;\n function StringDecoder(encoding) {\n this.encoding = normalizeEncoding(encoding);\n var nb;\n switch (this.encoding) {\n case "utf16le":\n this.text = utf16Text;\n this.end = utf16End;\n nb = 4;\n break;\n case "utf8":\n this.fillLast = utf8FillLast;\n nb = 4;\n break;\n case "base64":\n this.text = base64Text;\n this.end = base64End;\n nb = 3;\n break;\n default:\n this.write = simpleWrite;\n this.end = simpleEnd;\n return;\n }\n this.lastNeed = 0;\n this.lastTotal = 0;\n this.lastChar = Buffer13.allocUnsafe(nb);\n }\n StringDecoder.prototype.write = function(buf2) {\n if (buf2.length === 0)\n return "";\n var r;\n var i;\n if (this.lastNeed) {\n r = this.fillLast(buf2);\n if (r === void 0)\n return "";\n i = this.lastNeed;\n this.lastNeed = 0;\n } else {\n i = 0;\n }\n if (i < buf2.length)\n return r ? r + this.text(buf2, i) : this.text(buf2, i);\n return r || "";\n };\n StringDecoder.prototype.end = utf8End;\n StringDecoder.prototype.text = utf8Text;\n StringDecoder.prototype.fillLast = function(buf2) {\n if (this.lastNeed <= buf2.length) {\n buf2.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf2.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf2.length);\n this.lastNeed -= buf2.length;\n };\n function utf8CheckByte(byte) {\n if (byte <= 127)\n return 0;\n else if (byte >> 5 === 6)\n return 2;\n else if (byte >> 4 === 14)\n return 3;\n else if (byte >> 3 === 30)\n return 4;\n return byte >> 6 === 2 ? -1 : -2;\n }\n function utf8CheckIncomplete(self2, buf2, i) {\n var j = buf2.length - 1;\n if (j < i)\n return 0;\n var nb = utf8CheckByte(buf2[j]);\n if (nb >= 0) {\n if (nb > 0)\n self2.lastNeed = nb - 1;\n return nb;\n }\n if (--j < i || nb === -2)\n return 0;\n nb = utf8CheckByte(buf2[j]);\n if (nb >= 0) {\n if (nb > 0)\n self2.lastNeed = nb - 2;\n return nb;\n }\n if (--j < i || nb === -2)\n return 0;\n nb = utf8CheckByte(buf2[j]);\n if (nb >= 0) {\n if (nb > 0) {\n if (nb === 2)\n nb = 0;\n else\n self2.lastNeed = nb - 3;\n }\n return nb;\n }\n return 0;\n }\n function utf8CheckExtraBytes(self2, buf2, p) {\n if ((buf2[0] & 192) !== 128) {\n self2.lastNeed = 0;\n return "\\uFFFD";\n }\n if (self2.lastNeed > 1 && buf2.length > 1) {\n if ((buf2[1] & 192) !== 128) {\n self2.lastNeed = 1;\n return "\\uFFFD";\n }\n if (self2.lastNeed > 2 && buf2.length > 2) {\n if ((buf2[2] & 192) !== 128) {\n self2.lastNeed = 2;\n return "\\uFFFD";\n }\n }\n }\n }\n function utf8FillLast(buf2) {\n var p = this.lastTotal - this.lastNeed;\n var r = utf8CheckExtraBytes(this, buf2, p);\n if (r !== void 0)\n return r;\n if (this.lastNeed <= buf2.length) {\n buf2.copy(this.lastChar, p, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf2.copy(this.lastChar, p, 0, buf2.length);\n this.lastNeed -= buf2.length;\n }\n function utf8Text(buf2, i) {\n var total = utf8CheckIncomplete(this, buf2, i);\n if (!this.lastNeed)\n return buf2.toString("utf8", i);\n this.lastTotal = total;\n var end = buf2.length - (total - this.lastNeed);\n buf2.copy(this.lastChar, 0, end);\n return buf2.toString("utf8", i, end);\n }\n function utf8End(buf2) {\n var r = buf2 && buf2.length ? this.write(buf2) : "";\n if (this.lastNeed)\n return r + "\\uFFFD";\n return r;\n }\n function utf16Text(buf2, i) {\n if ((buf2.length - i) % 2 === 0) {\n var r = buf2.toString("utf16le", i);\n if (r) {\n var c = r.charCodeAt(r.length - 1);\n if (c >= 55296 && c <= 56319) {\n this.lastNeed = 2;\n this.lastTotal = 4;\n this.lastChar[0] = buf2[buf2.length - 2];\n this.lastChar[1] = buf2[buf2.length - 1];\n return r.slice(0, -1);\n }\n }\n return r;\n }\n this.lastNeed = 1;\n this.lastTotal = 2;\n this.lastChar[0] = buf2[buf2.length - 1];\n return buf2.toString("utf16le", i, buf2.length - 1);\n }\n function utf16End(buf2) {\n var r = buf2 && buf2.length ? this.write(buf2) : "";\n if (this.lastNeed) {\n var end = this.lastTotal - this.lastNeed;\n return r + this.lastChar.toString("utf16le", 0, end);\n }\n return r;\n }\n function base64Text(buf2, i) {\n var n = (buf2.length - i) % 3;\n if (n === 0)\n return buf2.toString("base64", i);\n this.lastNeed = 3 - n;\n this.lastTotal = 3;\n if (n === 1) {\n this.lastChar[0] = buf2[buf2.length - 1];\n } else {\n this.lastChar[0] = buf2[buf2.length - 2];\n this.lastChar[1] = buf2[buf2.length - 1];\n }\n return buf2.toString("base64", i, buf2.length - n);\n }\n function base64End(buf2) {\n var r = buf2 && buf2.length ? this.write(buf2) : "";\n if (this.lastNeed)\n return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);\n return r;\n }\n function simpleWrite(buf2) {\n return buf2.toString(this.encoding);\n }\n function simpleEnd(buf2) {\n return buf2 && buf2.length ? this.write(buf2) : "";\n }\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/end-of-stream.js\nvar require_end_of_stream = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var ERR_STREAM_PREMATURE_CLOSE = require_errors_browser().codes.ERR_STREAM_PREMATURE_CLOSE;\n function once(callback) {\n var called = false;\n return function() {\n if (called)\n return;\n called = true;\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n callback.apply(this, args);\n };\n }\n function noop2() {\n }\n function isRequest(stream) {\n return stream.setHeader && typeof stream.abort === "function";\n }\n function eos(stream, opts, callback) {\n if (typeof opts === "function")\n return eos(stream, null, opts);\n if (!opts)\n opts = {};\n callback = once(callback || noop2);\n var readable = opts.readable || opts.readable !== false && stream.readable;\n var writable2 = opts.writable || opts.writable !== false && stream.writable;\n var onlegacyfinish = function onlegacyfinish2() {\n if (!stream.writable)\n onfinish();\n };\n var writableEnded = stream._writableState && stream._writableState.finished;\n var onfinish = function onfinish2() {\n writable2 = false;\n writableEnded = true;\n if (!readable)\n callback.call(stream);\n };\n var readableEnded = stream._readableState && stream._readableState.endEmitted;\n var onend = function onend2() {\n readable = false;\n readableEnded = true;\n if (!writable2)\n callback.call(stream);\n };\n var onerror = function onerror2(err) {\n callback.call(stream, err);\n };\n var onclose = function onclose2() {\n var err;\n if (readable && !readableEnded) {\n if (!stream._readableState || !stream._readableState.ended)\n err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n if (writable2 && !writableEnded) {\n if (!stream._writableState || !stream._writableState.ended)\n err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n };\n var onrequest = function onrequest2() {\n stream.req.on("finish", onfinish);\n };\n if (isRequest(stream)) {\n stream.on("complete", onfinish);\n stream.on("abort", onclose);\n if (stream.req)\n onrequest();\n else\n stream.on("request", onrequest);\n } else if (writable2 && !stream._writableState) {\n stream.on("end", onlegacyfinish);\n stream.on("close", onlegacyfinish);\n }\n stream.on("end", onend);\n stream.on("finish", onfinish);\n if (opts.error !== false)\n stream.on("error", onerror);\n stream.on("close", onclose);\n return function() {\n stream.removeListener("complete", onfinish);\n stream.removeListener("abort", onclose);\n stream.removeListener("request", onrequest);\n if (stream.req)\n stream.req.removeListener("finish", onfinish);\n stream.removeListener("end", onlegacyfinish);\n stream.removeListener("close", onlegacyfinish);\n stream.removeListener("finish", onfinish);\n stream.removeListener("end", onend);\n stream.removeListener("error", onerror);\n stream.removeListener("close", onclose);\n };\n }\n module.exports = eos;\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/async_iterator.js\nvar require_async_iterator = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/async_iterator.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var _Object$setPrototypeO;\n function _defineProperty(obj, key2, value) {\n if (key2 in obj) {\n Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });\n } else {\n obj[key2] = value;\n }\n return obj;\n }\n var finished = require_end_of_stream();\n var kLastResolve = Symbol("lastResolve");\n var kLastReject = Symbol("lastReject");\n var kError = Symbol("error");\n var kEnded = Symbol("ended");\n var kLastPromise = Symbol("lastPromise");\n var kHandlePromise = Symbol("handlePromise");\n var kStream = Symbol("stream");\n function createIterResult(value, done) {\n return {\n value,\n done\n };\n }\n function readAndResolve(iter) {\n var resolve = iter[kLastResolve];\n if (resolve !== null) {\n var data = iter[kStream].read();\n if (data !== null) {\n iter[kLastPromise] = null;\n iter[kLastResolve] = null;\n iter[kLastReject] = null;\n resolve(createIterResult(data, false));\n }\n }\n }\n function onReadable(iter) {\n process.nextTick(readAndResolve, iter);\n }\n function wrapForNext(lastPromise, iter) {\n return function(resolve, reject) {\n lastPromise.then(function() {\n if (iter[kEnded]) {\n resolve(createIterResult(void 0, true));\n return;\n }\n iter[kHandlePromise](resolve, reject);\n }, reject);\n };\n }\n var AsyncIteratorPrototype = Object.getPrototypeOf(function() {\n });\n var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n get stream() {\n return this[kStream];\n },\n next: function next() {\n var _this = this;\n var error = this[kError];\n if (error !== null) {\n return Promise.reject(error);\n }\n if (this[kEnded]) {\n return Promise.resolve(createIterResult(void 0, true));\n }\n if (this[kStream].destroyed) {\n return new Promise(function(resolve, reject) {\n process.nextTick(function() {\n if (_this[kError]) {\n reject(_this[kError]);\n } else {\n resolve(createIterResult(void 0, true));\n }\n });\n });\n }\n var lastPromise = this[kLastPromise];\n var promise;\n if (lastPromise) {\n promise = new Promise(wrapForNext(lastPromise, this));\n } else {\n var data = this[kStream].read();\n if (data !== null) {\n return Promise.resolve(createIterResult(data, false));\n }\n promise = new Promise(this[kHandlePromise]);\n }\n this[kLastPromise] = promise;\n return promise;\n }\n }, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function() {\n return this;\n }), _defineProperty(_Object$setPrototypeO, "return", function _return() {\n var _this2 = this;\n return new Promise(function(resolve, reject) {\n _this2[kStream].destroy(null, function(err) {\n if (err) {\n reject(err);\n return;\n }\n resolve(createIterResult(void 0, true));\n });\n });\n }), _Object$setPrototypeO), AsyncIteratorPrototype);\n var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator2(stream) {\n var _Object$create;\n var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n value: stream,\n writable: true\n }), _defineProperty(_Object$create, kLastResolve, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kLastReject, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kError, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kEnded, {\n value: stream._readableState.endEmitted,\n writable: true\n }), _defineProperty(_Object$create, kHandlePromise, {\n value: function value(resolve, reject) {\n var data = iterator[kStream].read();\n if (data) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(data, false));\n } else {\n iterator[kLastResolve] = resolve;\n iterator[kLastReject] = reject;\n }\n },\n writable: true\n }), _Object$create));\n iterator[kLastPromise] = null;\n finished(stream, function(err) {\n if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {\n var reject = iterator[kLastReject];\n if (reject !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n reject(err);\n }\n iterator[kError] = err;\n return;\n }\n var resolve = iterator[kLastResolve];\n if (resolve !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(void 0, true));\n }\n iterator[kEnded] = true;\n });\n stream.on("readable", onReadable.bind(null, iterator));\n return iterator;\n };\n module.exports = createReadableStreamAsyncIterator;\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/from-browser.js\nvar require_from_browser = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/from-browser.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n module.exports = function() {\n throw new Error("Readable.from is not available in the browser");\n };\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_readable.js\nvar require_stream_readable = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_readable.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n module.exports = Readable;\n var Duplex;\n Readable.ReadableState = ReadableState;\n var EE = require_events().EventEmitter;\n var EElistenerCount = function EElistenerCount2(emitter, type) {\n return emitter.listeners(type).length;\n };\n var Stream = require_stream_browser();\n var Buffer13 = require_buffer().Buffer;\n var OurUint8Array = self.Uint8Array || function() {\n };\n function _uint8ArrayToBuffer(chunk) {\n return Buffer13.from(chunk);\n }\n function _isUint8Array(obj) {\n return Buffer13.isBuffer(obj) || obj instanceof OurUint8Array;\n }\n var debugUtil = require_util();\n var debug;\n if (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog("stream");\n } else {\n debug = function debug2() {\n };\n }\n var BufferList = require_buffer_list();\n var destroyImpl = require_destroy();\n var _require = require_state();\n var getHighWaterMark = _require.getHighWaterMark;\n var _require$codes = require_errors_browser().codes;\n var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;\n var ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF;\n var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;\n var ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n var StringDecoder;\n var createReadableStreamAsyncIterator;\n var from;\n require_inherits_browser()(Readable, Stream);\n var errorOrDestroy = destroyImpl.errorOrDestroy;\n var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];\n function prependListener(emitter, event, fn) {\n if (typeof emitter.prependListener === "function")\n return emitter.prependListener(event, fn);\n if (!emitter._events || !emitter._events[event])\n emitter.on(event, fn);\n else if (Array.isArray(emitter._events[event]))\n emitter._events[event].unshift(fn);\n else\n emitter._events[event] = [fn, emitter._events[event]];\n }\n function ReadableState(options, stream, isDuplex) {\n Duplex = Duplex || require_stream_duplex();\n options = options || {};\n if (typeof isDuplex !== "boolean")\n isDuplex = stream instanceof Duplex;\n this.objectMode = !!options.objectMode;\n if (isDuplex)\n this.objectMode = this.objectMode || !!options.readableObjectMode;\n this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex);\n this.buffer = new BufferList();\n this.length = 0;\n this.pipes = null;\n this.pipesCount = 0;\n this.flowing = null;\n this.ended = false;\n this.endEmitted = false;\n this.reading = false;\n this.sync = true;\n this.needReadable = false;\n this.emittedReadable = false;\n this.readableListening = false;\n this.resumeScheduled = false;\n this.paused = true;\n this.emitClose = options.emitClose !== false;\n this.autoDestroy = !!options.autoDestroy;\n this.destroyed = false;\n this.defaultEncoding = options.defaultEncoding || "utf8";\n this.awaitDrain = 0;\n this.readingMore = false;\n this.decoder = null;\n this.encoding = null;\n if (options.encoding) {\n if (!StringDecoder)\n StringDecoder = require_string_decoder().StringDecoder;\n this.decoder = new StringDecoder(options.encoding);\n this.encoding = options.encoding;\n }\n }\n function Readable(options) {\n Duplex = Duplex || require_stream_duplex();\n if (!(this instanceof Readable))\n return new Readable(options);\n var isDuplex = this instanceof Duplex;\n this._readableState = new ReadableState(options, this, isDuplex);\n this.readable = true;\n if (options) {\n if (typeof options.read === "function")\n this._read = options.read;\n if (typeof options.destroy === "function")\n this._destroy = options.destroy;\n }\n Stream.call(this);\n }\n Object.defineProperty(Readable.prototype, "destroyed", {\n enumerable: false,\n get: function get() {\n if (this._readableState === void 0) {\n return false;\n }\n return this._readableState.destroyed;\n },\n set: function set(value) {\n if (!this._readableState) {\n return;\n }\n this._readableState.destroyed = value;\n }\n });\n Readable.prototype.destroy = destroyImpl.destroy;\n Readable.prototype._undestroy = destroyImpl.undestroy;\n Readable.prototype._destroy = function(err, cb) {\n cb(err);\n };\n Readable.prototype.push = function(chunk, encoding) {\n var state = this._readableState;\n var skipChunkCheck;\n if (!state.objectMode) {\n if (typeof chunk === "string") {\n encoding = encoding || state.defaultEncoding;\n if (encoding !== state.encoding) {\n chunk = Buffer13.from(chunk, encoding);\n encoding = "";\n }\n skipChunkCheck = true;\n }\n } else {\n skipChunkCheck = true;\n }\n return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n };\n Readable.prototype.unshift = function(chunk) {\n return readableAddChunk(this, chunk, null, true, false);\n };\n function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n debug("readableAddChunk", chunk);\n var state = stream._readableState;\n if (chunk === null) {\n state.reading = false;\n onEofChunk(stream, state);\n } else {\n var er;\n if (!skipChunkCheck)\n er = chunkInvalid(state, chunk);\n if (er) {\n errorOrDestroy(stream, er);\n } else if (state.objectMode || chunk && chunk.length > 0) {\n if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer13.prototype) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n if (addToFront) {\n if (state.endEmitted)\n errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());\n else\n addChunk(stream, state, chunk, true);\n } else if (state.ended) {\n errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n } else if (state.destroyed) {\n return false;\n } else {\n state.reading = false;\n if (state.decoder && !encoding) {\n chunk = state.decoder.write(chunk);\n if (state.objectMode || chunk.length !== 0)\n addChunk(stream, state, chunk, false);\n else\n maybeReadMore(stream, state);\n } else {\n addChunk(stream, state, chunk, false);\n }\n }\n } else if (!addToFront) {\n state.reading = false;\n maybeReadMore(stream, state);\n }\n }\n return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n }\n function addChunk(stream, state, chunk, addToFront) {\n if (state.flowing && state.length === 0 && !state.sync) {\n state.awaitDrain = 0;\n stream.emit("data", chunk);\n } else {\n state.length += state.objectMode ? 1 : chunk.length;\n if (addToFront)\n state.buffer.unshift(chunk);\n else\n state.buffer.push(chunk);\n if (state.needReadable)\n emitReadable(stream);\n }\n maybeReadMore(stream, state);\n }\n function chunkInvalid(state, chunk) {\n var er;\n if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);\n }\n return er;\n }\n Readable.prototype.isPaused = function() {\n return this._readableState.flowing === false;\n };\n Readable.prototype.setEncoding = function(enc) {\n if (!StringDecoder)\n StringDecoder = require_string_decoder().StringDecoder;\n var decoder = new StringDecoder(enc);\n this._readableState.decoder = decoder;\n this._readableState.encoding = this._readableState.decoder.encoding;\n var p = this._readableState.buffer.head;\n var content = "";\n while (p !== null) {\n content += decoder.write(p.data);\n p = p.next;\n }\n this._readableState.buffer.clear();\n if (content !== "")\n this._readableState.buffer.push(content);\n this._readableState.length = content.length;\n return this;\n };\n var MAX_HWM = 1073741824;\n function computeNewHighWaterMark(n) {\n if (n >= MAX_HWM) {\n n = MAX_HWM;\n } else {\n n--;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n n++;\n }\n return n;\n }\n function howMuchToRead(n, state) {\n if (n <= 0 || state.length === 0 && state.ended)\n return 0;\n if (state.objectMode)\n return 1;\n if (n !== n) {\n if (state.flowing && state.length)\n return state.buffer.head.data.length;\n else\n return state.length;\n }\n if (n > state.highWaterMark)\n state.highWaterMark = computeNewHighWaterMark(n);\n if (n <= state.length)\n return n;\n if (!state.ended) {\n state.needReadable = true;\n return 0;\n }\n return state.length;\n }\n Readable.prototype.read = function(n) {\n debug("read", n);\n n = parseInt(n, 10);\n var state = this._readableState;\n var nOrig = n;\n if (n !== 0)\n state.emittedReadable = false;\n if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n debug("read: emitReadable", state.length, state.ended);\n if (state.length === 0 && state.ended)\n endReadable(this);\n else\n emitReadable(this);\n return null;\n }\n n = howMuchToRead(n, state);\n if (n === 0 && state.ended) {\n if (state.length === 0)\n endReadable(this);\n return null;\n }\n var doRead = state.needReadable;\n debug("need readable", doRead);\n if (state.length === 0 || state.length - n < state.highWaterMark) {\n doRead = true;\n debug("length less than watermark", doRead);\n }\n if (state.ended || state.reading) {\n doRead = false;\n debug("reading or ended", doRead);\n } else if (doRead) {\n debug("do read");\n state.reading = true;\n state.sync = true;\n if (state.length === 0)\n state.needReadable = true;\n this._read(state.highWaterMark);\n state.sync = false;\n if (!state.reading)\n n = howMuchToRead(nOrig, state);\n }\n var ret;\n if (n > 0)\n ret = fromList(n, state);\n else\n ret = null;\n if (ret === null) {\n state.needReadable = state.length <= state.highWaterMark;\n n = 0;\n } else {\n state.length -= n;\n state.awaitDrain = 0;\n }\n if (state.length === 0) {\n if (!state.ended)\n state.needReadable = true;\n if (nOrig !== n && state.ended)\n endReadable(this);\n }\n if (ret !== null)\n this.emit("data", ret);\n return ret;\n };\n function onEofChunk(stream, state) {\n debug("onEofChunk");\n if (state.ended)\n return;\n if (state.decoder) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) {\n state.buffer.push(chunk);\n state.length += state.objectMode ? 1 : chunk.length;\n }\n }\n state.ended = true;\n if (state.sync) {\n emitReadable(stream);\n } else {\n state.needReadable = false;\n if (!state.emittedReadable) {\n state.emittedReadable = true;\n emitReadable_(stream);\n }\n }\n }\n function emitReadable(stream) {\n var state = stream._readableState;\n debug("emitReadable", state.needReadable, state.emittedReadable);\n state.needReadable = false;\n if (!state.emittedReadable) {\n debug("emitReadable", state.flowing);\n state.emittedReadable = true;\n process.nextTick(emitReadable_, stream);\n }\n }\n function emitReadable_(stream) {\n var state = stream._readableState;\n debug("emitReadable_", state.destroyed, state.length, state.ended);\n if (!state.destroyed && (state.length || state.ended)) {\n stream.emit("readable");\n state.emittedReadable = false;\n }\n state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n flow(stream);\n }\n function maybeReadMore(stream, state) {\n if (!state.readingMore) {\n state.readingMore = true;\n process.nextTick(maybeReadMore_, stream, state);\n }\n }\n function maybeReadMore_(stream, state) {\n while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n var len = state.length;\n debug("maybeReadMore read 0");\n stream.read(0);\n if (len === state.length)\n break;\n }\n state.readingMore = false;\n }\n Readable.prototype._read = function(n) {\n errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));\n };\n Readable.prototype.pipe = function(dest, pipeOpts) {\n var src = this;\n var state = this._readableState;\n switch (state.pipesCount) {\n case 0:\n state.pipes = dest;\n break;\n case 1:\n state.pipes = [state.pipes, dest];\n break;\n default:\n state.pipes.push(dest);\n break;\n }\n state.pipesCount += 1;\n debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);\n var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n var endFn = doEnd ? onend : unpipe;\n if (state.endEmitted)\n process.nextTick(endFn);\n else\n src.once("end", endFn);\n dest.on("unpipe", onunpipe);\n function onunpipe(readable, unpipeInfo) {\n debug("onunpipe");\n if (readable === src) {\n if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n unpipeInfo.hasUnpiped = true;\n cleanup();\n }\n }\n }\n function onend() {\n debug("onend");\n dest.end();\n }\n var ondrain = pipeOnDrain(src);\n dest.on("drain", ondrain);\n var cleanedUp = false;\n function cleanup() {\n debug("cleanup");\n dest.removeListener("close", onclose);\n dest.removeListener("finish", onfinish);\n dest.removeListener("drain", ondrain);\n dest.removeListener("error", onerror);\n dest.removeListener("unpipe", onunpipe);\n src.removeListener("end", onend);\n src.removeListener("end", unpipe);\n src.removeListener("data", ondata);\n cleanedUp = true;\n if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain))\n ondrain();\n }\n src.on("data", ondata);\n function ondata(chunk) {\n debug("ondata");\n var ret = dest.write(chunk);\n debug("dest.write", ret);\n if (ret === false) {\n if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n debug("false write response, pause", state.awaitDrain);\n state.awaitDrain++;\n }\n src.pause();\n }\n }\n function onerror(er) {\n debug("onerror", er);\n unpipe();\n dest.removeListener("error", onerror);\n if (EElistenerCount(dest, "error") === 0)\n errorOrDestroy(dest, er);\n }\n prependListener(dest, "error", onerror);\n function onclose() {\n dest.removeListener("finish", onfinish);\n unpipe();\n }\n dest.once("close", onclose);\n function onfinish() {\n debug("onfinish");\n dest.removeListener("close", onclose);\n unpipe();\n }\n dest.once("finish", onfinish);\n function unpipe() {\n debug("unpipe");\n src.unpipe(dest);\n }\n dest.emit("pipe", src);\n if (!state.flowing) {\n debug("pipe resume");\n src.resume();\n }\n return dest;\n };\n function pipeOnDrain(src) {\n return function pipeOnDrainFunctionResult() {\n var state = src._readableState;\n debug("pipeOnDrain", state.awaitDrain);\n if (state.awaitDrain)\n state.awaitDrain--;\n if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {\n state.flowing = true;\n flow(src);\n }\n };\n }\n Readable.prototype.unpipe = function(dest) {\n var state = this._readableState;\n var unpipeInfo = {\n hasUnpiped: false\n };\n if (state.pipesCount === 0)\n return this;\n if (state.pipesCount === 1) {\n if (dest && dest !== state.pipes)\n return this;\n if (!dest)\n dest = state.pipes;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n if (dest)\n dest.emit("unpipe", this, unpipeInfo);\n return this;\n }\n if (!dest) {\n var dests = state.pipes;\n var len = state.pipesCount;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n for (var i = 0; i < len; i++) {\n dests[i].emit("unpipe", this, {\n hasUnpiped: false\n });\n }\n return this;\n }\n var index = indexOf(state.pipes, dest);\n if (index === -1)\n return this;\n state.pipes.splice(index, 1);\n state.pipesCount -= 1;\n if (state.pipesCount === 1)\n state.pipes = state.pipes[0];\n dest.emit("unpipe", this, unpipeInfo);\n return this;\n };\n Readable.prototype.on = function(ev, fn) {\n var res = Stream.prototype.on.call(this, ev, fn);\n var state = this._readableState;\n if (ev === "data") {\n state.readableListening = this.listenerCount("readable") > 0;\n if (state.flowing !== false)\n this.resume();\n } else if (ev === "readable") {\n if (!state.endEmitted && !state.readableListening) {\n state.readableListening = state.needReadable = true;\n state.flowing = false;\n state.emittedReadable = false;\n debug("on readable", state.length, state.reading);\n if (state.length) {\n emitReadable(this);\n } else if (!state.reading) {\n process.nextTick(nReadingNextTick, this);\n }\n }\n }\n return res;\n };\n Readable.prototype.addListener = Readable.prototype.on;\n Readable.prototype.removeListener = function(ev, fn) {\n var res = Stream.prototype.removeListener.call(this, ev, fn);\n if (ev === "readable") {\n process.nextTick(updateReadableListening, this);\n }\n return res;\n };\n Readable.prototype.removeAllListeners = function(ev) {\n var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n if (ev === "readable" || ev === void 0) {\n process.nextTick(updateReadableListening, this);\n }\n return res;\n };\n function updateReadableListening(self2) {\n var state = self2._readableState;\n state.readableListening = self2.listenerCount("readable") > 0;\n if (state.resumeScheduled && !state.paused) {\n state.flowing = true;\n } else if (self2.listenerCount("data") > 0) {\n self2.resume();\n }\n }\n function nReadingNextTick(self2) {\n debug("readable nexttick read 0");\n self2.read(0);\n }\n Readable.prototype.resume = function() {\n var state = this._readableState;\n if (!state.flowing) {\n debug("resume");\n state.flowing = !state.readableListening;\n resume(this, state);\n }\n state.paused = false;\n return this;\n };\n function resume(stream, state) {\n if (!state.resumeScheduled) {\n state.resumeScheduled = true;\n process.nextTick(resume_, stream, state);\n }\n }\n function resume_(stream, state) {\n debug("resume", state.reading);\n if (!state.reading) {\n stream.read(0);\n }\n state.resumeScheduled = false;\n stream.emit("resume");\n flow(stream);\n if (state.flowing && !state.reading)\n stream.read(0);\n }\n Readable.prototype.pause = function() {\n debug("call pause flowing=%j", this._readableState.flowing);\n if (this._readableState.flowing !== false) {\n debug("pause");\n this._readableState.flowing = false;\n this.emit("pause");\n }\n this._readableState.paused = true;\n return this;\n };\n function flow(stream) {\n var state = stream._readableState;\n debug("flow", state.flowing);\n while (state.flowing && stream.read() !== null) {\n ;\n }\n }\n Readable.prototype.wrap = function(stream) {\n var _this = this;\n var state = this._readableState;\n var paused = false;\n stream.on("end", function() {\n debug("wrapped end");\n if (state.decoder && !state.ended) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length)\n _this.push(chunk);\n }\n _this.push(null);\n });\n stream.on("data", function(chunk) {\n debug("wrapped data");\n if (state.decoder)\n chunk = state.decoder.write(chunk);\n if (state.objectMode && (chunk === null || chunk === void 0))\n return;\n else if (!state.objectMode && (!chunk || !chunk.length))\n return;\n var ret = _this.push(chunk);\n if (!ret) {\n paused = true;\n stream.pause();\n }\n });\n for (var i in stream) {\n if (this[i] === void 0 && typeof stream[i] === "function") {\n this[i] = function methodWrap(method) {\n return function methodWrapReturnFunction() {\n return stream[method].apply(stream, arguments);\n };\n }(i);\n }\n }\n for (var n = 0; n < kProxyEvents.length; n++) {\n stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n }\n this._read = function(n2) {\n debug("wrapped _read", n2);\n if (paused) {\n paused = false;\n stream.resume();\n }\n };\n return this;\n };\n if (typeof Symbol === "function") {\n Readable.prototype[Symbol.asyncIterator] = function() {\n if (createReadableStreamAsyncIterator === void 0) {\n createReadableStreamAsyncIterator = require_async_iterator();\n }\n return createReadableStreamAsyncIterator(this);\n };\n }\n Object.defineProperty(Readable.prototype, "readableHighWaterMark", {\n enumerable: false,\n get: function get() {\n return this._readableState.highWaterMark;\n }\n });\n Object.defineProperty(Readable.prototype, "readableBuffer", {\n enumerable: false,\n get: function get() {\n return this._readableState && this._readableState.buffer;\n }\n });\n Object.defineProperty(Readable.prototype, "readableFlowing", {\n enumerable: false,\n get: function get() {\n return this._readableState.flowing;\n },\n set: function set(state) {\n if (this._readableState) {\n this._readableState.flowing = state;\n }\n }\n });\n Readable._fromList = fromList;\n Object.defineProperty(Readable.prototype, "readableLength", {\n enumerable: false,\n get: function get() {\n return this._readableState.length;\n }\n });\n function fromList(n, state) {\n if (state.length === 0)\n return null;\n var ret;\n if (state.objectMode)\n ret = state.buffer.shift();\n else if (!n || n >= state.length) {\n if (state.decoder)\n ret = state.buffer.join("");\n else if (state.buffer.length === 1)\n ret = state.buffer.first();\n else\n ret = state.buffer.concat(state.length);\n state.buffer.clear();\n } else {\n ret = state.buffer.consume(n, state.decoder);\n }\n return ret;\n }\n function endReadable(stream) {\n var state = stream._readableState;\n debug("endReadable", state.endEmitted);\n if (!state.endEmitted) {\n state.ended = true;\n process.nextTick(endReadableNT, state, stream);\n }\n }\n function endReadableNT(state, stream) {\n debug("endReadableNT", state.endEmitted, state.length);\n if (!state.endEmitted && state.length === 0) {\n state.endEmitted = true;\n stream.readable = false;\n stream.emit("end");\n if (state.autoDestroy) {\n var wState = stream._writableState;\n if (!wState || wState.autoDestroy && wState.finished) {\n stream.destroy();\n }\n }\n }\n }\n if (typeof Symbol === "function") {\n Readable.from = function(iterable, opts) {\n if (from === void 0) {\n from = require_from_browser();\n }\n return from(Readable, iterable, opts);\n };\n }\n function indexOf(xs, x) {\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x)\n return i;\n }\n return -1;\n }\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_transform.js\nvar require_stream_transform = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_transform.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n module.exports = Transform;\n var _require$codes = require_errors_browser().codes;\n var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;\n var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;\n var ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING;\n var ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n var Duplex = require_stream_duplex();\n require_inherits_browser()(Transform, Duplex);\n function afterTransform(er, data) {\n var ts = this._transformState;\n ts.transforming = false;\n var cb = ts.writecb;\n if (cb === null) {\n return this.emit("error", new ERR_MULTIPLE_CALLBACK());\n }\n ts.writechunk = null;\n ts.writecb = null;\n if (data != null)\n this.push(data);\n cb(er);\n var rs = this._readableState;\n rs.reading = false;\n if (rs.needReadable || rs.length < rs.highWaterMark) {\n this._read(rs.highWaterMark);\n }\n }\n function Transform(options) {\n if (!(this instanceof Transform))\n return new Transform(options);\n Duplex.call(this, options);\n this._transformState = {\n afterTransform: afterTransform.bind(this),\n needTransform: false,\n transforming: false,\n writecb: null,\n writechunk: null,\n writeencoding: null\n };\n this._readableState.needReadable = true;\n this._readableState.sync = false;\n if (options) {\n if (typeof options.transform === "function")\n this._transform = options.transform;\n if (typeof options.flush === "function")\n this._flush = options.flush;\n }\n this.on("prefinish", prefinish);\n }\n function prefinish() {\n var _this = this;\n if (typeof this._flush === "function" && !this._readableState.destroyed) {\n this._flush(function(er, data) {\n done(_this, er, data);\n });\n } else {\n done(this, null, null);\n }\n }\n Transform.prototype.push = function(chunk, encoding) {\n this._transformState.needTransform = false;\n return Duplex.prototype.push.call(this, chunk, encoding);\n };\n Transform.prototype._transform = function(chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED("_transform()"));\n };\n Transform.prototype._write = function(chunk, encoding, cb) {\n var ts = this._transformState;\n ts.writecb = cb;\n ts.writechunk = chunk;\n ts.writeencoding = encoding;\n if (!ts.transforming) {\n var rs = this._readableState;\n if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark)\n this._read(rs.highWaterMark);\n }\n };\n Transform.prototype._read = function(n) {\n var ts = this._transformState;\n if (ts.writechunk !== null && !ts.transforming) {\n ts.transforming = true;\n this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n } else {\n ts.needTransform = true;\n }\n };\n Transform.prototype._destroy = function(err, cb) {\n Duplex.prototype._destroy.call(this, err, function(err2) {\n cb(err2);\n });\n };\n function done(stream, er, data) {\n if (er)\n return stream.emit("error", er);\n if (data != null)\n stream.push(data);\n if (stream._writableState.length)\n throw new ERR_TRANSFORM_WITH_LENGTH_0();\n if (stream._transformState.transforming)\n throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n return stream.push(null);\n }\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_passthrough.js\nvar require_stream_passthrough = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/_stream_passthrough.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n module.exports = PassThrough;\n var Transform = require_stream_transform();\n require_inherits_browser()(PassThrough, Transform);\n function PassThrough(options) {\n if (!(this instanceof PassThrough))\n return new PassThrough(options);\n Transform.call(this, options);\n }\n PassThrough.prototype._transform = function(chunk, encoding, cb) {\n cb(null, chunk);\n };\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/pipeline.js\nvar require_pipeline = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/lib/internal/streams/pipeline.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var eos;\n function once(callback) {\n var called = false;\n return function() {\n if (called)\n return;\n called = true;\n callback.apply(void 0, arguments);\n };\n }\n var _require$codes = require_errors_browser().codes;\n var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;\n var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n function noop2(err) {\n if (err)\n throw err;\n }\n function isRequest(stream) {\n return stream.setHeader && typeof stream.abort === "function";\n }\n function destroyer(stream, reading, writing, callback) {\n callback = once(callback);\n var closed = false;\n stream.on("close", function() {\n closed = true;\n });\n if (eos === void 0)\n eos = require_end_of_stream();\n eos(stream, {\n readable: reading,\n writable: writing\n }, function(err) {\n if (err)\n return callback(err);\n closed = true;\n callback();\n });\n var destroyed = false;\n return function(err) {\n if (closed)\n return;\n if (destroyed)\n return;\n destroyed = true;\n if (isRequest(stream))\n return stream.abort();\n if (typeof stream.destroy === "function")\n return stream.destroy();\n callback(err || new ERR_STREAM_DESTROYED("pipe"));\n };\n }\n function call(fn) {\n fn();\n }\n function pipe(from, to) {\n return from.pipe(to);\n }\n function popCallback(streams) {\n if (!streams.length)\n return noop2;\n if (typeof streams[streams.length - 1] !== "function")\n return noop2;\n return streams.pop();\n }\n function pipeline() {\n for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n streams[_key] = arguments[_key];\n }\n var callback = popCallback(streams);\n if (Array.isArray(streams[0]))\n streams = streams[0];\n if (streams.length < 2) {\n throw new ERR_MISSING_ARGS("streams");\n }\n var error;\n var destroys = streams.map(function(stream, i) {\n var reading = i < streams.length - 1;\n var writing = i > 0;\n return destroyer(stream, reading, writing, function(err) {\n if (!error)\n error = err;\n if (err)\n destroys.forEach(call);\n if (reading)\n return;\n destroys.forEach(call);\n callback(error);\n });\n });\n return streams.reduce(pipe);\n }\n module.exports = pipeline;\n }\n});\n\n// node_modules/readable-web-to-node-stream/node_modules/readable-stream/readable-browser.js\nvar require_readable_browser = __commonJS({\n "node_modules/readable-web-to-node-stream/node_modules/readable-stream/readable-browser.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n exports = module.exports = require_stream_readable();\n exports.Stream = exports;\n exports.Readable = exports;\n exports.Writable = require_stream_writable();\n exports.Duplex = require_stream_duplex();\n exports.Transform = require_stream_transform();\n exports.PassThrough = require_stream_passthrough();\n exports.finished = require_end_of_stream();\n exports.pipeline = require_pipeline();\n }\n});\n\n// node_modules/readable-web-to-node-stream/lib/index.js\nvar require_lib = __commonJS({\n "node_modules/readable-web-to-node-stream/lib/index.js"(exports) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n Object.defineProperty(exports, "__esModule", { value: true });\n exports.ReadableWebToNodeStream = void 0;\n var readable_stream_1 = require_readable_browser();\n var ReadableWebToNodeStream2 = class extends readable_stream_1.Readable {\n constructor(stream) {\n super();\n this.bytesRead = 0;\n this.released = false;\n this.reader = stream.getReader();\n }\n async _read() {\n if (this.released) {\n this.push(null);\n return;\n }\n this.pendingRead = this.reader.read();\n const data = await this.pendingRead;\n delete this.pendingRead;\n if (data.done || this.released) {\n this.push(null);\n } else {\n this.bytesRead += data.value.length;\n this.push(data.value);\n }\n }\n async waitForReadToComplete() {\n if (this.pendingRead) {\n await this.pendingRead;\n }\n }\n async close() {\n await this.syncAndRelease();\n }\n async syncAndRelease() {\n this.released = true;\n await this.waitForReadToComplete();\n await this.reader.releaseLock();\n }\n };\n exports.ReadableWebToNodeStream = ReadableWebToNodeStream2;\n }\n});\n\n// node_modules/base-x/src/index.js\nvar require_src = __commonJS({\n "node_modules/base-x/src/index.js"(exports, module) {\n "use strict";\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n function base(ALPHABET) {\n if (ALPHABET.length >= 255) {\n throw new TypeError("Alphabet too long");\n }\n var BASE_MAP = new Uint8Array(256);\n for (var j = 0; j < BASE_MAP.length; j++) {\n BASE_MAP[j] = 255;\n }\n for (var i = 0; i < ALPHABET.length; i++) {\n var x = ALPHABET.charAt(i);\n var xc = x.charCodeAt(0);\n if (BASE_MAP[xc] !== 255) {\n throw new TypeError(x + " is ambiguous");\n }\n BASE_MAP[xc] = i;\n }\n var BASE = ALPHABET.length;\n var LEADER = ALPHABET.charAt(0);\n var FACTOR = Math.log(BASE) / Math.log(256);\n var iFACTOR = Math.log(256) / Math.log(BASE);\n function encode2(source) {\n if (source instanceof Uint8Array) {\n } else if (ArrayBuffer.isView(source)) {\n source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);\n } else if (Array.isArray(source)) {\n source = Uint8Array.from(source);\n }\n if (!(source instanceof Uint8Array)) {\n throw new TypeError("Expected Uint8Array");\n }\n if (source.length === 0) {\n return "";\n }\n var zeroes = 0;\n var length = 0;\n var pbegin = 0;\n var pend = source.length;\n while (pbegin !== pend && source[pbegin] === 0) {\n pbegin++;\n zeroes++;\n }\n var size = (pend - pbegin) * iFACTOR + 1 >>> 0;\n var b58 = new Uint8Array(size);\n while (pbegin !== pend) {\n var carry = source[pbegin];\n var i2 = 0;\n for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {\n carry += 256 * b58[it1] >>> 0;\n b58[it1] = carry % BASE >>> 0;\n carry = carry / BASE >>> 0;\n }\n if (carry !== 0) {\n throw new Error("Non-zero carry");\n }\n length = i2;\n pbegin++;\n }\n var it2 = size - length;\n while (it2 !== size && b58[it2] === 0) {\n it2++;\n }\n var str = LEADER.repeat(zeroes);\n for (; it2 < size; ++it2) {\n str += ALPHABET.charAt(b58[it2]);\n }\n return str;\n }\n function decodeUnsafe(source) {\n if (typeof source !== "string") {\n throw new TypeError("Expected String");\n }\n if (source.length === 0) {\n return new Uint8Array();\n }\n var psz = 0;\n var zeroes = 0;\n var length = 0;\n while (source[psz] === LEADER) {\n zeroes++;\n psz++;\n }\n var size = (source.length - psz) * FACTOR + 1 >>> 0;\n var b256 = new Uint8Array(size);\n while (source[psz]) {\n var carry = BASE_MAP[source.charCodeAt(psz)];\n if (carry === 255) {\n return;\n }\n var i2 = 0;\n for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {\n carry += BASE * b256[it3] >>> 0;\n b256[it3] = carry % 256 >>> 0;\n carry = carry / 256 >>> 0;\n }\n if (carry !== 0) {\n throw new Error("Non-zero carry");\n }\n length = i2;\n psz++;\n }\n var it4 = size - length;\n while (it4 !== size && b256[it4] === 0) {\n it4++;\n }\n var vch = new Uint8Array(zeroes + (size - it4));\n var j2 = zeroes;\n while (it4 !== size) {\n vch[j2++] = b256[it4++];\n }\n return vch;\n }\n function decode3(string) {\n var buffer = decodeUnsafe(string);\n if (buffer) {\n return buffer;\n }\n throw new Error("Non-base" + BASE + " character");\n }\n return {\n encode: encode2,\n decodeUnsafe,\n decode: decode3\n };\n }\n module.exports = base;\n }\n});\n\n// node_modules/bs58/index.js\nvar require_bs58 = __commonJS({\n "node_modules/bs58/index.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var basex = require_src();\n var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";\n module.exports = basex(ALPHABET);\n }\n});\n\n// node_modules/jpeg-js/lib/encoder.js\nvar require_encoder = __commonJS({\n "node_modules/jpeg-js/lib/encoder.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var btoa = btoa || function(buf2) {\n return Buffer2.from(buf2).toString("base64");\n };\n function JPEGEncoder(quality) {\n var self2 = this;\n var fround = Math.round;\n var ffloor = Math.floor;\n var YTable = new Array(64);\n var UVTable = new Array(64);\n var fdtbl_Y = new Array(64);\n var fdtbl_UV = new Array(64);\n var YDC_HT2;\n var UVDC_HT2;\n var YAC_HT2;\n var UVAC_HT2;\n var bitcode2 = new Array(65535);\n var category2 = new Array(65535);\n var outputfDCTQuant = new Array(64);\n var DU = new Array(64);\n var byteout = [];\n var bytenew = 0;\n var bytepos = 7;\n var YDU = new Array(64);\n var UDU = new Array(64);\n var VDU = new Array(64);\n var clt = new Array(256);\n var RGB_YUV_TABLE = new Array(2048);\n var currentQuality;\n var ZigZag = [\n 0,\n 1,\n 5,\n 6,\n 14,\n 15,\n 27,\n 28,\n 2,\n 4,\n 7,\n 13,\n 16,\n 26,\n 29,\n 42,\n 3,\n 8,\n 12,\n 17,\n 25,\n 30,\n 41,\n 43,\n 9,\n 11,\n 18,\n 24,\n 31,\n 40,\n 44,\n 53,\n 10,\n 19,\n 23,\n 32,\n 39,\n 45,\n 52,\n 54,\n 20,\n 22,\n 33,\n 38,\n 46,\n 51,\n 55,\n 60,\n 21,\n 34,\n 37,\n 47,\n 50,\n 56,\n 59,\n 61,\n 35,\n 36,\n 48,\n 49,\n 57,\n 58,\n 62,\n 63\n ];\n var std_dc_luminance_nrcodes2 = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];\n var std_dc_luminance_values2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];\n var std_ac_luminance_nrcodes2 = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125];\n var std_ac_luminance_values2 = [\n 1,\n 2,\n 3,\n 0,\n 4,\n 17,\n 5,\n 18,\n 33,\n 49,\n 65,\n 6,\n 19,\n 81,\n 97,\n 7,\n 34,\n 113,\n 20,\n 50,\n 129,\n 145,\n 161,\n 8,\n 35,\n 66,\n 177,\n 193,\n 21,\n 82,\n 209,\n 240,\n 36,\n 51,\n 98,\n 114,\n 130,\n 9,\n 10,\n 22,\n 23,\n 24,\n 25,\n 26,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 83,\n 84,\n 85,\n 86,\n 87,\n 88,\n 89,\n 90,\n 99,\n 100,\n 101,\n 102,\n 103,\n 104,\n 105,\n 106,\n 115,\n 116,\n 117,\n 118,\n 119,\n 120,\n 121,\n 122,\n 131,\n 132,\n 133,\n 134,\n 135,\n 136,\n 137,\n 138,\n 146,\n 147,\n 148,\n 149,\n 150,\n 151,\n 152,\n 153,\n 154,\n 162,\n 163,\n 164,\n 165,\n 166,\n 167,\n 168,\n 169,\n 170,\n 178,\n 179,\n 180,\n 181,\n 182,\n 183,\n 184,\n 185,\n 186,\n 194,\n 195,\n 196,\n 197,\n 198,\n 199,\n 200,\n 201,\n 202,\n 210,\n 211,\n 212,\n 213,\n 214,\n 215,\n 216,\n 217,\n 218,\n 225,\n 226,\n 227,\n 228,\n 229,\n 230,\n 231,\n 232,\n 233,\n 234,\n 241,\n 242,\n 243,\n 244,\n 245,\n 246,\n 247,\n 248,\n 249,\n 250\n ];\n var std_dc_chrominance_nrcodes2 = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];\n var std_dc_chrominance_values2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];\n var std_ac_chrominance_nrcodes2 = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119];\n var std_ac_chrominance_values2 = [\n 0,\n 1,\n 2,\n 3,\n 17,\n 4,\n 5,\n 33,\n 49,\n 6,\n 18,\n 65,\n 81,\n 7,\n 97,\n 113,\n 19,\n 34,\n 50,\n 129,\n 8,\n 20,\n 66,\n 145,\n 161,\n 177,\n 193,\n 9,\n 35,\n 51,\n 82,\n 240,\n 21,\n 98,\n 114,\n 209,\n 10,\n 22,\n 36,\n 52,\n 225,\n 37,\n 241,\n 23,\n 24,\n 25,\n 26,\n 38,\n 39,\n 40,\n 41,\n 42,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 83,\n 84,\n 85,\n 86,\n 87,\n 88,\n 89,\n 90,\n 99,\n 100,\n 101,\n 102,\n 103,\n 104,\n 105,\n 106,\n 115,\n 116,\n 117,\n 118,\n 119,\n 120,\n 121,\n 122,\n 130,\n 131,\n 132,\n 133,\n 134,\n 135,\n 136,\n 137,\n 138,\n 146,\n 147,\n 148,\n 149,\n 150,\n 151,\n 152,\n 153,\n 154,\n 162,\n 163,\n 164,\n 165,\n 166,\n 167,\n 168,\n 169,\n 170,\n 178,\n 179,\n 180,\n 181,\n 182,\n 183,\n 184,\n 185,\n 186,\n 194,\n 195,\n 196,\n 197,\n 198,\n 199,\n 200,\n 201,\n 202,\n 210,\n 211,\n 212,\n 213,\n 214,\n 215,\n 216,\n 217,\n 218,\n 226,\n 227,\n 228,\n 229,\n 230,\n 231,\n 232,\n 233,\n 234,\n 242,\n 243,\n 244,\n 245,\n 246,\n 247,\n 248,\n 249,\n 250\n ];\n function initQuantTables(sf) {\n var YQT = [\n 16,\n 11,\n 10,\n 16,\n 24,\n 40,\n 51,\n 61,\n 12,\n 12,\n 14,\n 19,\n 26,\n 58,\n 60,\n 55,\n 14,\n 13,\n 16,\n 24,\n 40,\n 57,\n 69,\n 56,\n 14,\n 17,\n 22,\n 29,\n 51,\n 87,\n 80,\n 62,\n 18,\n 22,\n 37,\n 56,\n 68,\n 109,\n 103,\n 77,\n 24,\n 35,\n 55,\n 64,\n 81,\n 104,\n 113,\n 92,\n 49,\n 64,\n 78,\n 87,\n 103,\n 121,\n 120,\n 101,\n 72,\n 92,\n 95,\n 98,\n 112,\n 100,\n 103,\n 99\n ];\n for (var i = 0; i < 64; i++) {\n var t = ffloor((YQT[i] * sf + 50) / 100);\n if (t < 1) {\n t = 1;\n } else if (t > 255) {\n t = 255;\n }\n YTable[ZigZag[i]] = t;\n }\n var UVQT = [\n 17,\n 18,\n 24,\n 47,\n 99,\n 99,\n 99,\n 99,\n 18,\n 21,\n 26,\n 66,\n 99,\n 99,\n 99,\n 99,\n 24,\n 26,\n 56,\n 99,\n 99,\n 99,\n 99,\n 99,\n 47,\n 66,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99,\n 99\n ];\n for (var j = 0; j < 64; j++) {\n var u = ffloor((UVQT[j] * sf + 50) / 100);\n if (u < 1) {\n u = 1;\n } else if (u > 255) {\n u = 255;\n }\n UVTable[ZigZag[j]] = u;\n }\n var aasf = [\n 1,\n 1.387039845,\n 1.306562965,\n 1.175875602,\n 1,\n 0.785694958,\n 0.5411961,\n 0.275899379\n ];\n var k = 0;\n for (var row = 0; row < 8; row++) {\n for (var col = 0; col < 8; col++) {\n fdtbl_Y[k] = 1 / (YTable[ZigZag[k]] * aasf[row] * aasf[col] * 8);\n fdtbl_UV[k] = 1 / (UVTable[ZigZag[k]] * aasf[row] * aasf[col] * 8);\n k++;\n }\n }\n }\n function computeHuffmanTbl(nrcodes, std_table) {\n var codevalue = 0;\n var pos_in_table = 0;\n var HT = new Array();\n for (var k = 1; k <= 16; k++) {\n for (var j = 1; j <= nrcodes[k]; j++) {\n HT[std_table[pos_in_table]] = [];\n HT[std_table[pos_in_table]][0] = codevalue;\n HT[std_table[pos_in_table]][1] = k;\n pos_in_table++;\n codevalue++;\n }\n codevalue *= 2;\n }\n return HT;\n }\n function initHuffmanTbl() {\n YDC_HT2 = computeHuffmanTbl(std_dc_luminance_nrcodes2, std_dc_luminance_values2);\n UVDC_HT2 = computeHuffmanTbl(std_dc_chrominance_nrcodes2, std_dc_chrominance_values2);\n YAC_HT2 = computeHuffmanTbl(std_ac_luminance_nrcodes2, std_ac_luminance_values2);\n UVAC_HT2 = computeHuffmanTbl(std_ac_chrominance_nrcodes2, std_ac_chrominance_values2);\n }\n function initCategoryNumber() {\n var nrlower = 1;\n var nrupper = 2;\n for (var cat = 1; cat <= 15; cat++) {\n for (var nr = nrlower; nr < nrupper; nr++) {\n category2[32767 + nr] = cat;\n bitcode2[32767 + nr] = [];\n bitcode2[32767 + nr][1] = cat;\n bitcode2[32767 + nr][0] = nr;\n }\n for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {\n category2[32767 + nrneg] = cat;\n bitcode2[32767 + nrneg] = [];\n bitcode2[32767 + nrneg][1] = cat;\n bitcode2[32767 + nrneg][0] = nrupper - 1 + nrneg;\n }\n nrlower <<= 1;\n nrupper <<= 1;\n }\n }\n function initRGBYUVTable() {\n for (var i = 0; i < 256; i++) {\n RGB_YUV_TABLE[i] = 19595 * i;\n RGB_YUV_TABLE[i + 256 >> 0] = 38470 * i;\n RGB_YUV_TABLE[i + 512 >> 0] = 7471 * i + 32768;\n RGB_YUV_TABLE[i + 768 >> 0] = -11059 * i;\n RGB_YUV_TABLE[i + 1024 >> 0] = -21709 * i;\n RGB_YUV_TABLE[i + 1280 >> 0] = 32768 * i + 8421375;\n RGB_YUV_TABLE[i + 1536 >> 0] = -27439 * i;\n RGB_YUV_TABLE[i + 1792 >> 0] = -5329 * i;\n }\n }\n function writeBits(bs) {\n var value = bs[0];\n var posval = bs[1] - 1;\n while (posval >= 0) {\n if (value & 1 << posval) {\n bytenew |= 1 << bytepos;\n }\n posval--;\n bytepos--;\n if (bytepos < 0) {\n if (bytenew == 255) {\n writeByte(255);\n writeByte(0);\n } else {\n writeByte(bytenew);\n }\n bytepos = 7;\n bytenew = 0;\n }\n }\n }\n function writeByte(value) {\n byteout.push(value);\n }\n function writeWord(value) {\n writeByte(value >> 8 & 255);\n writeByte(value & 255);\n }\n function fDCTQuant(data, fdtbl) {\n var d0, d1, d2, d3, d4, d5, d6, d7;\n var dataOff = 0;\n var i;\n var I8 = 8;\n var I64 = 64;\n for (i = 0; i < I8; ++i) {\n d0 = data[dataOff];\n d1 = data[dataOff + 1];\n d2 = data[dataOff + 2];\n d3 = data[dataOff + 3];\n d4 = data[dataOff + 4];\n d5 = data[dataOff + 5];\n d6 = data[dataOff + 6];\n d7 = data[dataOff + 7];\n var tmp0 = d0 + d7;\n var tmp7 = d0 - d7;\n var tmp1 = d1 + d6;\n var tmp6 = d1 - d6;\n var tmp2 = d2 + d5;\n var tmp5 = d2 - d5;\n var tmp3 = d3 + d4;\n var tmp4 = d3 - d4;\n var tmp10 = tmp0 + tmp3;\n var tmp13 = tmp0 - tmp3;\n var tmp11 = tmp1 + tmp2;\n var tmp12 = tmp1 - tmp2;\n data[dataOff] = tmp10 + tmp11;\n data[dataOff + 4] = tmp10 - tmp11;\n var z1 = (tmp12 + tmp13) * 0.707106781;\n data[dataOff + 2] = tmp13 + z1;\n data[dataOff + 6] = tmp13 - z1;\n tmp10 = tmp4 + tmp5;\n tmp11 = tmp5 + tmp6;\n tmp12 = tmp6 + tmp7;\n var z5 = (tmp10 - tmp12) * 0.382683433;\n var z2 = 0.5411961 * tmp10 + z5;\n var z4 = 1.306562965 * tmp12 + z5;\n var z3 = tmp11 * 0.707106781;\n var z11 = tmp7 + z3;\n var z13 = tmp7 - z3;\n data[dataOff + 5] = z13 + z2;\n data[dataOff + 3] = z13 - z2;\n data[dataOff + 1] = z11 + z4;\n data[dataOff + 7] = z11 - z4;\n dataOff += 8;\n }\n dataOff = 0;\n for (i = 0; i < I8; ++i) {\n d0 = data[dataOff];\n d1 = data[dataOff + 8];\n d2 = data[dataOff + 16];\n d3 = data[dataOff + 24];\n d4 = data[dataOff + 32];\n d5 = data[dataOff + 40];\n d6 = data[dataOff + 48];\n d7 = data[dataOff + 56];\n var tmp0p2 = d0 + d7;\n var tmp7p2 = d0 - d7;\n var tmp1p2 = d1 + d6;\n var tmp6p2 = d1 - d6;\n var tmp2p2 = d2 + d5;\n var tmp5p2 = d2 - d5;\n var tmp3p2 = d3 + d4;\n var tmp4p2 = d3 - d4;\n var tmp10p2 = tmp0p2 + tmp3p2;\n var tmp13p2 = tmp0p2 - tmp3p2;\n var tmp11p2 = tmp1p2 + tmp2p2;\n var tmp12p2 = tmp1p2 - tmp2p2;\n data[dataOff] = tmp10p2 + tmp11p2;\n data[dataOff + 32] = tmp10p2 - tmp11p2;\n var z1p2 = (tmp12p2 + tmp13p2) * 0.707106781;\n data[dataOff + 16] = tmp13p2 + z1p2;\n data[dataOff + 48] = tmp13p2 - z1p2;\n tmp10p2 = tmp4p2 + tmp5p2;\n tmp11p2 = tmp5p2 + tmp6p2;\n tmp12p2 = tmp6p2 + tmp7p2;\n var z5p2 = (tmp10p2 - tmp12p2) * 0.382683433;\n var z2p2 = 0.5411961 * tmp10p2 + z5p2;\n var z4p2 = 1.306562965 * tmp12p2 + z5p2;\n var z3p2 = tmp11p2 * 0.707106781;\n var z11p2 = tmp7p2 + z3p2;\n var z13p2 = tmp7p2 - z3p2;\n data[dataOff + 40] = z13p2 + z2p2;\n data[dataOff + 24] = z13p2 - z2p2;\n data[dataOff + 8] = z11p2 + z4p2;\n data[dataOff + 56] = z11p2 - z4p2;\n dataOff++;\n }\n var fDCTQuant2;\n for (i = 0; i < I64; ++i) {\n fDCTQuant2 = data[i] * fdtbl[i];\n outputfDCTQuant[i] = fDCTQuant2 > 0 ? fDCTQuant2 + 0.5 | 0 : fDCTQuant2 - 0.5 | 0;\n }\n return outputfDCTQuant;\n }\n function writeAPP0() {\n writeWord(65504);\n writeWord(16);\n writeByte(74);\n writeByte(70);\n writeByte(73);\n writeByte(70);\n writeByte(0);\n writeByte(1);\n writeByte(1);\n writeByte(0);\n writeWord(1);\n writeWord(1);\n writeByte(0);\n writeByte(0);\n }\n function writeAPP1(exifBuffer) {\n if (!exifBuffer)\n return;\n writeWord(65505);\n if (exifBuffer[0] === 69 && exifBuffer[1] === 120 && exifBuffer[2] === 105 && exifBuffer[3] === 102) {\n writeWord(exifBuffer.length + 2);\n } else {\n writeWord(exifBuffer.length + 5 + 2);\n writeByte(69);\n writeByte(120);\n writeByte(105);\n writeByte(102);\n writeByte(0);\n }\n for (var i = 0; i < exifBuffer.length; i++) {\n writeByte(exifBuffer[i]);\n }\n }\n function writeSOF0(width, height) {\n writeWord(65472);\n writeWord(17);\n writeByte(8);\n writeWord(height);\n writeWord(width);\n writeByte(3);\n writeByte(1);\n writeByte(17);\n writeByte(0);\n writeByte(2);\n writeByte(17);\n writeByte(1);\n writeByte(3);\n writeByte(17);\n writeByte(1);\n }\n function writeDQT() {\n writeWord(65499);\n writeWord(132);\n writeByte(0);\n for (var i = 0; i < 64; i++) {\n writeByte(YTable[i]);\n }\n writeByte(1);\n for (var j = 0; j < 64; j++) {\n writeByte(UVTable[j]);\n }\n }\n function writeDHT() {\n writeWord(65476);\n writeWord(418);\n writeByte(0);\n for (var i = 0; i < 16; i++) {\n writeByte(std_dc_luminance_nrcodes2[i + 1]);\n }\n for (var j = 0; j <= 11; j++) {\n writeByte(std_dc_luminance_values2[j]);\n }\n writeByte(16);\n for (var k = 0; k < 16; k++) {\n writeByte(std_ac_luminance_nrcodes2[k + 1]);\n }\n for (var l = 0; l <= 161; l++) {\n writeByte(std_ac_luminance_values2[l]);\n }\n writeByte(1);\n for (var m = 0; m < 16; m++) {\n writeByte(std_dc_chrominance_nrcodes2[m + 1]);\n }\n for (var n = 0; n <= 11; n++) {\n writeByte(std_dc_chrominance_values2[n]);\n }\n writeByte(17);\n for (var o = 0; o < 16; o++) {\n writeByte(std_ac_chrominance_nrcodes2[o + 1]);\n }\n for (var p = 0; p <= 161; p++) {\n writeByte(std_ac_chrominance_values2[p]);\n }\n }\n function writeCOM(comments) {\n if (typeof comments === "undefined" || comments.constructor !== Array)\n return;\n comments.forEach((e) => {\n if (typeof e !== "string")\n return;\n writeWord(65534);\n var l = e.length;\n writeWord(l + 2);\n var i;\n for (i = 0; i < l; i++)\n writeByte(e.charCodeAt(i));\n });\n }\n function writeSOS() {\n writeWord(65498);\n writeWord(12);\n writeByte(3);\n writeByte(1);\n writeByte(0);\n writeByte(2);\n writeByte(17);\n writeByte(3);\n writeByte(17);\n writeByte(0);\n writeByte(63);\n writeByte(0);\n }\n function processDU(CDU, fdtbl, DC, HTDC, HTAC) {\n var EOB = HTAC[0];\n var M16zeroes = HTAC[240];\n var pos;\n var I16 = 16;\n var I63 = 63;\n var I64 = 64;\n var DU_DCT = fDCTQuant(CDU, fdtbl);\n for (var j = 0; j < I64; ++j) {\n DU[ZigZag[j]] = DU_DCT[j];\n }\n var Diff = DU[0] - DC;\n DC = DU[0];\n if (Diff == 0) {\n writeBits(HTDC[0]);\n } else {\n pos = 32767 + Diff;\n writeBits(HTDC[category2[pos]]);\n writeBits(bitcode2[pos]);\n }\n var end0pos = 63;\n for (; end0pos > 0 && DU[end0pos] == 0; end0pos--) {\n }\n ;\n if (end0pos == 0) {\n writeBits(EOB);\n return DC;\n }\n var i = 1;\n var lng;\n while (i <= end0pos) {\n var startpos = i;\n for (; DU[i] == 0 && i <= end0pos; ++i) {\n }\n var nrzeroes = i - startpos;\n if (nrzeroes >= I16) {\n lng = nrzeroes >> 4;\n for (var nrmarker = 1; nrmarker <= lng; ++nrmarker)\n writeBits(M16zeroes);\n nrzeroes = nrzeroes & 15;\n }\n pos = 32767 + DU[i];\n writeBits(HTAC[(nrzeroes << 4) + category2[pos]]);\n writeBits(bitcode2[pos]);\n i++;\n }\n if (end0pos != I63) {\n writeBits(EOB);\n }\n return DC;\n }\n function initCharLookupTable() {\n var sfcc = String.fromCharCode;\n for (var i = 0; i < 256; i++) {\n clt[i] = sfcc(i);\n }\n }\n this.encode = function(image, quality2) {\n var time_start = new Date().getTime();\n if (quality2)\n setQuality(quality2);\n byteout = new Array();\n bytenew = 0;\n bytepos = 7;\n writeWord(65496);\n writeAPP0();\n writeCOM(image.comments);\n writeAPP1(image.exifBuffer);\n writeDQT();\n writeSOF0(image.width, image.height);\n writeDHT();\n writeSOS();\n var DCY = 0;\n var DCU = 0;\n var DCV = 0;\n bytenew = 0;\n bytepos = 7;\n this.encode.displayName = "_encode_";\n var imageData = image.data;\n var width = image.width;\n var height = image.height;\n var quadWidth = width * 4;\n var tripleWidth = width * 3;\n var x, y = 0;\n var r, g, b;\n var start, p, col, row, pos;\n while (y < height) {\n x = 0;\n while (x < quadWidth) {\n start = quadWidth * y + x;\n p = start;\n col = -1;\n row = 0;\n for (pos = 0; pos < 64; pos++) {\n row = pos >> 3;\n col = (pos & 7) * 4;\n p = start + row * quadWidth + col;\n if (y + row >= height) {\n p -= quadWidth * (y + 1 + row - height);\n }\n if (x + col >= quadWidth) {\n p -= x + col - quadWidth + 4;\n }\n r = imageData[p++];\n g = imageData[p++];\n b = imageData[p++];\n YDU[pos] = (RGB_YUV_TABLE[r] + RGB_YUV_TABLE[g + 256 >> 0] + RGB_YUV_TABLE[b + 512 >> 0] >> 16) - 128;\n UDU[pos] = (RGB_YUV_TABLE[r + 768 >> 0] + RGB_YUV_TABLE[g + 1024 >> 0] + RGB_YUV_TABLE[b + 1280 >> 0] >> 16) - 128;\n VDU[pos] = (RGB_YUV_TABLE[r + 1280 >> 0] + RGB_YUV_TABLE[g + 1536 >> 0] + RGB_YUV_TABLE[b + 1792 >> 0] >> 16) - 128;\n }\n DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT2, YAC_HT2);\n DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT2, UVAC_HT2);\n DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT2, UVAC_HT2);\n x += 32;\n }\n y += 8;\n }\n if (bytepos >= 0) {\n var fillbits = [];\n fillbits[1] = bytepos + 1;\n fillbits[0] = (1 << bytepos + 1) - 1;\n writeBits(fillbits);\n }\n writeWord(65497);\n if (typeof module === "undefined")\n return new Uint8Array(byteout);\n return Buffer2.from(byteout);\n var jpegDataUri = "data:image/jpeg;base64," + btoa(byteout.join(""));\n byteout = [];\n var duration = new Date().getTime() - time_start;\n return jpegDataUri;\n };\n function setQuality(quality2) {\n if (quality2 <= 0) {\n quality2 = 1;\n }\n if (quality2 > 100) {\n quality2 = 100;\n }\n if (currentQuality == quality2)\n return;\n var sf = 0;\n if (quality2 < 50) {\n sf = Math.floor(5e3 / quality2);\n } else {\n sf = Math.floor(200 - quality2 * 2);\n }\n initQuantTables(sf);\n currentQuality = quality2;\n }\n function init3() {\n var time_start = new Date().getTime();\n if (!quality)\n quality = 50;\n initCharLookupTable();\n initHuffmanTbl();\n initCategoryNumber();\n initRGBYUVTable();\n setQuality(quality);\n var duration = new Date().getTime() - time_start;\n }\n init3();\n }\n if (typeof module !== "undefined") {\n module.exports = encode2;\n } else if (typeof window !== "undefined") {\n window["jpeg-js"] = window["jpeg-js"] || {};\n window["jpeg-js"].encode = encode2;\n }\n function encode2(imgData, qu) {\n if (typeof qu === "undefined")\n qu = 50;\n var encoder = new JPEGEncoder(qu);\n var data = encoder.encode(imgData, qu);\n return {\n data,\n width: imgData.width,\n height: imgData.height\n };\n }\n }\n});\n\n// node_modules/jpeg-js/lib/decoder.js\nvar require_decoder = __commonJS({\n "node_modules/jpeg-js/lib/decoder.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var JpegImage = function jpegImage() {\n "use strict";\n var dctZigZag = new Int32Array([\n 0,\n 1,\n 8,\n 16,\n 9,\n 2,\n 3,\n 10,\n 17,\n 24,\n 32,\n 25,\n 18,\n 11,\n 4,\n 5,\n 12,\n 19,\n 26,\n 33,\n 40,\n 48,\n 41,\n 34,\n 27,\n 20,\n 13,\n 6,\n 7,\n 14,\n 21,\n 28,\n 35,\n 42,\n 49,\n 56,\n 57,\n 50,\n 43,\n 36,\n 29,\n 22,\n 15,\n 23,\n 30,\n 37,\n 44,\n 51,\n 58,\n 59,\n 52,\n 45,\n 38,\n 31,\n 39,\n 46,\n 53,\n 60,\n 61,\n 54,\n 47,\n 55,\n 62,\n 63\n ]);\n var dctCos1 = 4017;\n var dctSin1 = 799;\n var dctCos3 = 3406;\n var dctSin3 = 2276;\n var dctCos6 = 1567;\n var dctSin6 = 3784;\n var dctSqrt2 = 5793;\n var dctSqrt1d2 = 2896;\n function constructor() {\n }\n function buildHuffmanTable2(codeLengths, values) {\n var k = 0, code = [], i, j, length = 16;\n while (length > 0 && !codeLengths[length - 1])\n length--;\n code.push({ children: [], index: 0 });\n var p = code[0], q;\n for (i = 0; i < length; i++) {\n for (j = 0; j < codeLengths[i]; j++) {\n p = code.pop();\n p.children[p.index] = values[k];\n while (p.index > 0) {\n if (code.length === 0)\n throw new Error("Could not recreate Huffman Table");\n p = code.pop();\n }\n p.index++;\n code.push(p);\n while (code.length <= i) {\n code.push(q = { children: [], index: 0 });\n p.children[p.index] = q.children;\n p = q;\n }\n k++;\n }\n if (i + 1 < length) {\n code.push(q = { children: [], index: 0 });\n p.children[p.index] = q.children;\n p = q;\n }\n }\n return code[0].children;\n }\n function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, opts) {\n var precision = frame.precision;\n var samplesPerLine = frame.samplesPerLine;\n var scanLines = frame.scanLines;\n var mcusPerLine = frame.mcusPerLine;\n var progressive = frame.progressive;\n var maxH = frame.maxH, maxV = frame.maxV;\n var startOffset = offset, bitsData = 0, bitsCount = 0;\n function readBit() {\n if (bitsCount > 0) {\n bitsCount--;\n return bitsData >> bitsCount & 1;\n }\n bitsData = data[offset++];\n if (bitsData == 255) {\n var nextByte = data[offset++];\n if (nextByte) {\n throw new Error("unexpected marker: " + (bitsData << 8 | nextByte).toString(16));\n }\n }\n bitsCount = 7;\n return bitsData >>> 7;\n }\n function decodeHuffman(tree) {\n var node = tree, bit;\n while ((bit = readBit()) !== null) {\n node = node[bit];\n if (typeof node === "number")\n return node;\n if (typeof node !== "object")\n throw new Error("invalid huffman sequence");\n }\n return null;\n }\n function receive(length) {\n var n2 = 0;\n while (length > 0) {\n var bit = readBit();\n if (bit === null)\n return;\n n2 = n2 << 1 | bit;\n length--;\n }\n return n2;\n }\n function receiveAndExtend(length) {\n var n2 = receive(length);\n if (n2 >= 1 << length - 1)\n return n2;\n return n2 + (-1 << length) + 1;\n }\n function decodeBaseline(component2, zz) {\n var t = decodeHuffman(component2.huffmanTableDC);\n var diff = t === 0 ? 0 : receiveAndExtend(t);\n zz[0] = component2.pred += diff;\n var k2 = 1;\n while (k2 < 64) {\n var rs = decodeHuffman(component2.huffmanTableAC);\n var s = rs & 15, r = rs >> 4;\n if (s === 0) {\n if (r < 15)\n break;\n k2 += 16;\n continue;\n }\n k2 += r;\n var z = dctZigZag[k2];\n zz[z] = receiveAndExtend(s);\n k2++;\n }\n }\n function decodeDCFirst(component2, zz) {\n var t = decodeHuffman(component2.huffmanTableDC);\n var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;\n zz[0] = component2.pred += diff;\n }\n function decodeDCSuccessive(component2, zz) {\n zz[0] |= readBit() << successive;\n }\n var eobrun = 0;\n function decodeACFirst(component2, zz) {\n if (eobrun > 0) {\n eobrun--;\n return;\n }\n var k2 = spectralStart, e = spectralEnd;\n while (k2 <= e) {\n var rs = decodeHuffman(component2.huffmanTableAC);\n var s = rs & 15, r = rs >> 4;\n if (s === 0) {\n if (r < 15) {\n eobrun = receive(r) + (1 << r) - 1;\n break;\n }\n k2 += 16;\n continue;\n }\n k2 += r;\n var z = dctZigZag[k2];\n zz[z] = receiveAndExtend(s) * (1 << successive);\n k2++;\n }\n }\n var successiveACState = 0, successiveACNextValue;\n function decodeACSuccessive(component2, zz) {\n var k2 = spectralStart, e = spectralEnd, r = 0;\n while (k2 <= e) {\n var z = dctZigZag[k2];\n var direction = zz[z] < 0 ? -1 : 1;\n switch (successiveACState) {\n case 0:\n var rs = decodeHuffman(component2.huffmanTableAC);\n var s = rs & 15, r = rs >> 4;\n if (s === 0) {\n if (r < 15) {\n eobrun = receive(r) + (1 << r);\n successiveACState = 4;\n } else {\n r = 16;\n successiveACState = 1;\n }\n } else {\n if (s !== 1)\n throw new Error("invalid ACn encoding");\n successiveACNextValue = receiveAndExtend(s);\n successiveACState = r ? 2 : 3;\n }\n continue;\n case 1:\n case 2:\n if (zz[z])\n zz[z] += (readBit() << successive) * direction;\n else {\n r--;\n if (r === 0)\n successiveACState = successiveACState == 2 ? 3 : 0;\n }\n break;\n case 3:\n if (zz[z])\n zz[z] += (readBit() << successive) * direction;\n else {\n zz[z] = successiveACNextValue << successive;\n successiveACState = 0;\n }\n break;\n case 4:\n if (zz[z])\n zz[z] += (readBit() << successive) * direction;\n break;\n }\n k2++;\n }\n if (successiveACState === 4) {\n eobrun--;\n if (eobrun === 0)\n successiveACState = 0;\n }\n }\n function decodeMcu(component2, decode4, mcu2, row, col) {\n var mcuRow = mcu2 / mcusPerLine | 0;\n var mcuCol = mcu2 % mcusPerLine;\n var blockRow = mcuRow * component2.v + row;\n var blockCol = mcuCol * component2.h + col;\n if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)\n return;\n decode4(component2, component2.blocks[blockRow][blockCol]);\n }\n function decodeBlock(component2, decode4, mcu2) {\n var blockRow = mcu2 / component2.blocksPerLine | 0;\n var blockCol = mcu2 % component2.blocksPerLine;\n if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)\n return;\n decode4(component2, component2.blocks[blockRow][blockCol]);\n }\n var componentsLength = components.length;\n var component, i, j, k, n;\n var decodeFn;\n if (progressive) {\n if (spectralStart === 0)\n decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;\n else\n decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;\n } else {\n decodeFn = decodeBaseline;\n }\n var mcu = 0, marker;\n var mcuExpected;\n if (componentsLength == 1) {\n mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;\n } else {\n mcuExpected = mcusPerLine * frame.mcusPerColumn;\n }\n if (!resetInterval)\n resetInterval = mcuExpected;\n var h, v;\n while (mcu < mcuExpected) {\n for (i = 0; i < componentsLength; i++)\n components[i].pred = 0;\n eobrun = 0;\n if (componentsLength == 1) {\n component = components[0];\n for (n = 0; n < resetInterval; n++) {\n decodeBlock(component, decodeFn, mcu);\n mcu++;\n }\n } else {\n for (n = 0; n < resetInterval; n++) {\n for (i = 0; i < componentsLength; i++) {\n component = components[i];\n h = component.h;\n v = component.v;\n for (j = 0; j < v; j++) {\n for (k = 0; k < h; k++) {\n decodeMcu(component, decodeFn, mcu, j, k);\n }\n }\n }\n mcu++;\n if (mcu === mcuExpected)\n break;\n }\n }\n if (mcu === mcuExpected) {\n do {\n if (data[offset] === 255) {\n if (data[offset + 1] !== 0) {\n break;\n }\n }\n offset += 1;\n } while (offset < data.length - 2);\n }\n bitsCount = 0;\n marker = data[offset] << 8 | data[offset + 1];\n if (marker < 65280) {\n throw new Error("marker was not found");\n }\n if (marker >= 65488 && marker <= 65495) {\n offset += 2;\n } else\n break;\n }\n return offset - startOffset;\n }\n function buildComponentData(frame, component) {\n var lines = [];\n var blocksPerLine = component.blocksPerLine;\n var blocksPerColumn = component.blocksPerColumn;\n var samplesPerLine = blocksPerLine << 3;\n var R = new Int32Array(64), r = new Uint8Array(64);\n function quantizeAndInverse(zz, dataOut, dataIn) {\n var qt = component.quantizationTable;\n var v0, v1, v2, v3, v4, v5, v6, v7, t;\n var p = dataIn;\n var i2;\n for (i2 = 0; i2 < 64; i2++)\n p[i2] = zz[i2] * qt[i2];\n for (i2 = 0; i2 < 8; ++i2) {\n var row = 8 * i2;\n if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 && p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 && p[7 + row] == 0) {\n t = dctSqrt2 * p[0 + row] + 512 >> 10;\n p[0 + row] = t;\n p[1 + row] = t;\n p[2 + row] = t;\n p[3 + row] = t;\n p[4 + row] = t;\n p[5 + row] = t;\n p[6 + row] = t;\n p[7 + row] = t;\n continue;\n }\n v0 = dctSqrt2 * p[0 + row] + 128 >> 8;\n v1 = dctSqrt2 * p[4 + row] + 128 >> 8;\n v2 = p[2 + row];\n v3 = p[6 + row];\n v4 = dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128 >> 8;\n v7 = dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128 >> 8;\n v5 = p[3 + row] << 4;\n v6 = p[5 + row] << 4;\n t = v0 - v1 + 1 >> 1;\n v0 = v0 + v1 + 1 >> 1;\n v1 = t;\n t = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8;\n v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8;\n v3 = t;\n t = v4 - v6 + 1 >> 1;\n v4 = v4 + v6 + 1 >> 1;\n v6 = t;\n t = v7 + v5 + 1 >> 1;\n v5 = v7 - v5 + 1 >> 1;\n v7 = t;\n t = v0 - v3 + 1 >> 1;\n v0 = v0 + v3 + 1 >> 1;\n v3 = t;\n t = v1 - v2 + 1 >> 1;\n v1 = v1 + v2 + 1 >> 1;\n v2 = t;\n t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;\n v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;\n v7 = t;\n t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;\n v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;\n v6 = t;\n p[0 + row] = v0 + v7;\n p[7 + row] = v0 - v7;\n p[1 + row] = v1 + v6;\n p[6 + row] = v1 - v6;\n p[2 + row] = v2 + v5;\n p[5 + row] = v2 - v5;\n p[3 + row] = v3 + v4;\n p[4 + row] = v3 - v4;\n }\n for (i2 = 0; i2 < 8; ++i2) {\n var col = i2;\n if (p[1 * 8 + col] == 0 && p[2 * 8 + col] == 0 && p[3 * 8 + col] == 0 && p[4 * 8 + col] == 0 && p[5 * 8 + col] == 0 && p[6 * 8 + col] == 0 && p[7 * 8 + col] == 0) {\n t = dctSqrt2 * dataIn[i2 + 0] + 8192 >> 14;\n p[0 * 8 + col] = t;\n p[1 * 8 + col] = t;\n p[2 * 8 + col] = t;\n p[3 * 8 + col] = t;\n p[4 * 8 + col] = t;\n p[5 * 8 + col] = t;\n p[6 * 8 + col] = t;\n p[7 * 8 + col] = t;\n continue;\n }\n v0 = dctSqrt2 * p[0 * 8 + col] + 2048 >> 12;\n v1 = dctSqrt2 * p[4 * 8 + col] + 2048 >> 12;\n v2 = p[2 * 8 + col];\n v3 = p[6 * 8 + col];\n v4 = dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048 >> 12;\n v7 = dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048 >> 12;\n v5 = p[3 * 8 + col];\n v6 = p[5 * 8 + col];\n t = v0 - v1 + 1 >> 1;\n v0 = v0 + v1 + 1 >> 1;\n v1 = t;\n t = v2 * dctSin6 + v3 * dctCos6 + 2048 >> 12;\n v2 = v2 * dctCos6 - v3 * dctSin6 + 2048 >> 12;\n v3 = t;\n t = v4 - v6 + 1 >> 1;\n v4 = v4 + v6 + 1 >> 1;\n v6 = t;\n t = v7 + v5 + 1 >> 1;\n v5 = v7 - v5 + 1 >> 1;\n v7 = t;\n t = v0 - v3 + 1 >> 1;\n v0 = v0 + v3 + 1 >> 1;\n v3 = t;\n t = v1 - v2 + 1 >> 1;\n v1 = v1 + v2 + 1 >> 1;\n v2 = t;\n t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;\n v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;\n v7 = t;\n t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;\n v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;\n v6 = t;\n p[0 * 8 + col] = v0 + v7;\n p[7 * 8 + col] = v0 - v7;\n p[1 * 8 + col] = v1 + v6;\n p[6 * 8 + col] = v1 - v6;\n p[2 * 8 + col] = v2 + v5;\n p[5 * 8 + col] = v2 - v5;\n p[3 * 8 + col] = v3 + v4;\n p[4 * 8 + col] = v3 - v4;\n }\n for (i2 = 0; i2 < 64; ++i2) {\n var sample2 = 128 + (p[i2] + 8 >> 4);\n dataOut[i2] = sample2 < 0 ? 0 : sample2 > 255 ? 255 : sample2;\n }\n }\n requestMemoryAllocation(samplesPerLine * blocksPerColumn * 8);\n var i, j;\n for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {\n var scanLine = blockRow << 3;\n for (i = 0; i < 8; i++)\n lines.push(new Uint8Array(samplesPerLine));\n for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {\n quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);\n var offset = 0, sample = blockCol << 3;\n for (j = 0; j < 8; j++) {\n var line = lines[scanLine + j];\n for (i = 0; i < 8; i++)\n line[sample + i] = r[offset++];\n }\n }\n }\n return lines;\n }\n function clampTo8bit(a) {\n return a < 0 ? 0 : a > 255 ? 255 : a;\n }\n constructor.prototype = {\n load: function load(path) {\n var xhr = new XMLHttpRequest();\n xhr.open("GET", path, true);\n xhr.responseType = "arraybuffer";\n xhr.onload = function() {\n var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);\n this.parse(data);\n if (this.onload)\n this.onload();\n }.bind(this);\n xhr.send(null);\n },\n parse: function parse(data) {\n var maxResolutionInPixels = this.opts.maxResolutionInMP * 1e3 * 1e3;\n var offset = 0, length = data.length;\n function readUint16() {\n var value = data[offset] << 8 | data[offset + 1];\n offset += 2;\n return value;\n }\n function readDataBlock() {\n var length2 = readUint16();\n var array = data.subarray(offset, offset + length2 - 2);\n offset += array.length;\n return array;\n }\n function prepareComponents(frame2) {\n var maxH2 = 1, maxV2 = 1;\n var component2, componentId2;\n for (componentId2 in frame2.components) {\n if (frame2.components.hasOwnProperty(componentId2)) {\n component2 = frame2.components[componentId2];\n if (maxH2 < component2.h)\n maxH2 = component2.h;\n if (maxV2 < component2.v)\n maxV2 = component2.v;\n }\n }\n var mcusPerLine = Math.ceil(frame2.samplesPerLine / 8 / maxH2);\n var mcusPerColumn = Math.ceil(frame2.scanLines / 8 / maxV2);\n for (componentId2 in frame2.components) {\n if (frame2.components.hasOwnProperty(componentId2)) {\n component2 = frame2.components[componentId2];\n var blocksPerLine = Math.ceil(Math.ceil(frame2.samplesPerLine / 8) * component2.h / maxH2);\n var blocksPerColumn = Math.ceil(Math.ceil(frame2.scanLines / 8) * component2.v / maxV2);\n var blocksPerLineForMcu = mcusPerLine * component2.h;\n var blocksPerColumnForMcu = mcusPerColumn * component2.v;\n var blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;\n var blocks = [];\n requestMemoryAllocation(blocksToAllocate * 256);\n for (var i2 = 0; i2 < blocksPerColumnForMcu; i2++) {\n var row = [];\n for (var j2 = 0; j2 < blocksPerLineForMcu; j2++)\n row.push(new Int32Array(64));\n blocks.push(row);\n }\n component2.blocksPerLine = blocksPerLine;\n component2.blocksPerColumn = blocksPerColumn;\n component2.blocks = blocks;\n }\n }\n frame2.maxH = maxH2;\n frame2.maxV = maxV2;\n frame2.mcusPerLine = mcusPerLine;\n frame2.mcusPerColumn = mcusPerColumn;\n }\n var jfif = null;\n var adobe = null;\n var pixels = null;\n var frame, resetInterval;\n var quantizationTables = [], frames = [];\n var huffmanTablesAC = [], huffmanTablesDC = [];\n var fileMarker = readUint16();\n var malformedDataOffset = -1;\n this.comments = [];\n if (fileMarker != 65496) {\n throw new Error("SOI not found");\n }\n fileMarker = readUint16();\n while (fileMarker != 65497) {\n var i, j, l;\n switch (fileMarker) {\n case 65280:\n break;\n case 65504:\n case 65505:\n case 65506:\n case 65507:\n case 65508:\n case 65509:\n case 65510:\n case 65511:\n case 65512:\n case 65513:\n case 65514:\n case 65515:\n case 65516:\n case 65517:\n case 65518:\n case 65519:\n case 65534:\n var appData = readDataBlock();\n if (fileMarker === 65534) {\n var comment = String.fromCharCode.apply(null, appData);\n this.comments.push(comment);\n }\n if (fileMarker === 65504) {\n if (appData[0] === 74 && appData[1] === 70 && appData[2] === 73 && appData[3] === 70 && appData[4] === 0) {\n jfif = {\n version: { major: appData[5], minor: appData[6] },\n densityUnits: appData[7],\n xDensity: appData[8] << 8 | appData[9],\n yDensity: appData[10] << 8 | appData[11],\n thumbWidth: appData[12],\n thumbHeight: appData[13],\n thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])\n };\n }\n }\n if (fileMarker === 65505) {\n if (appData[0] === 69 && appData[1] === 120 && appData[2] === 105 && appData[3] === 102 && appData[4] === 0) {\n this.exifBuffer = appData.subarray(5, appData.length);\n }\n }\n if (fileMarker === 65518) {\n if (appData[0] === 65 && appData[1] === 100 && appData[2] === 111 && appData[3] === 98 && appData[4] === 101 && appData[5] === 0) {\n adobe = {\n version: appData[6],\n flags0: appData[7] << 8 | appData[8],\n flags1: appData[9] << 8 | appData[10],\n transformCode: appData[11]\n };\n }\n }\n break;\n case 65499:\n var quantizationTablesLength = readUint16();\n var quantizationTablesEnd = quantizationTablesLength + offset - 2;\n while (offset < quantizationTablesEnd) {\n var quantizationTableSpec = data[offset++];\n requestMemoryAllocation(64 * 4);\n var tableData = new Int32Array(64);\n if (quantizationTableSpec >> 4 === 0) {\n for (j = 0; j < 64; j++) {\n var z = dctZigZag[j];\n tableData[z] = data[offset++];\n }\n } else if (quantizationTableSpec >> 4 === 1) {\n for (j = 0; j < 64; j++) {\n var z = dctZigZag[j];\n tableData[z] = readUint16();\n }\n } else\n throw new Error("DQT: invalid table spec");\n quantizationTables[quantizationTableSpec & 15] = tableData;\n }\n break;\n case 65472:\n case 65473:\n case 65474:\n readUint16();\n frame = {};\n frame.extended = fileMarker === 65473;\n frame.progressive = fileMarker === 65474;\n frame.precision = data[offset++];\n frame.scanLines = readUint16();\n frame.samplesPerLine = readUint16();\n frame.components = {};\n frame.componentsOrder = [];\n var pixelsInFrame = frame.scanLines * frame.samplesPerLine;\n if (pixelsInFrame > maxResolutionInPixels) {\n var exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);\n throw new Error(`maxResolutionInMP limit exceeded by ${exceededAmount}MP`);\n }\n var componentsCount = data[offset++], componentId;\n var maxH = 0, maxV = 0;\n for (i = 0; i < componentsCount; i++) {\n componentId = data[offset];\n var h = data[offset + 1] >> 4;\n var v = data[offset + 1] & 15;\n var qId = data[offset + 2];\n if (h <= 0 || v <= 0) {\n throw new Error("Invalid sampling factor, expected values above 0");\n }\n frame.componentsOrder.push(componentId);\n frame.components[componentId] = {\n h,\n v,\n quantizationIdx: qId\n };\n offset += 3;\n }\n prepareComponents(frame);\n frames.push(frame);\n break;\n case 65476:\n var huffmanLength = readUint16();\n for (i = 2; i < huffmanLength; ) {\n var huffmanTableSpec = data[offset++];\n var codeLengths = new Uint8Array(16);\n var codeLengthSum = 0;\n for (j = 0; j < 16; j++, offset++) {\n codeLengthSum += codeLengths[j] = data[offset];\n }\n requestMemoryAllocation(16 + codeLengthSum);\n var huffmanValues = new Uint8Array(codeLengthSum);\n for (j = 0; j < codeLengthSum; j++, offset++)\n huffmanValues[j] = data[offset];\n i += 17 + codeLengthSum;\n (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = buildHuffmanTable2(codeLengths, huffmanValues);\n }\n break;\n case 65501:\n readUint16();\n resetInterval = readUint16();\n break;\n case 65500:\n readUint16();\n readUint16();\n break;\n case 65498:\n var scanLength = readUint16();\n var selectorsCount = data[offset++];\n var components = [], component;\n for (i = 0; i < selectorsCount; i++) {\n component = frame.components[data[offset++]];\n var tableSpec = data[offset++];\n component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];\n component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];\n components.push(component);\n }\n var spectralStart = data[offset++];\n var spectralEnd = data[offset++];\n var successiveApproximation = data[offset++];\n var processed = decodeScan(\n data,\n offset,\n frame,\n components,\n resetInterval,\n spectralStart,\n spectralEnd,\n successiveApproximation >> 4,\n successiveApproximation & 15,\n this.opts\n );\n offset += processed;\n break;\n case 65535:\n if (data[offset] !== 255) {\n offset--;\n }\n break;\n default:\n if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) {\n offset -= 3;\n break;\n } else if (fileMarker === 224 || fileMarker == 225) {\n if (malformedDataOffset !== -1) {\n throw new Error(`first unknown JPEG marker at offset ${malformedDataOffset.toString(16)}, second unknown JPEG marker ${fileMarker.toString(16)} at offset ${(offset - 1).toString(16)}`);\n }\n malformedDataOffset = offset - 1;\n const nextOffset = readUint16();\n if (data[offset + nextOffset - 2] === 255) {\n offset += nextOffset - 2;\n break;\n }\n }\n throw new Error("unknown JPEG marker " + fileMarker.toString(16));\n }\n fileMarker = readUint16();\n }\n if (frames.length != 1)\n throw new Error("only single frame JPEGs supported");\n for (var i = 0; i < frames.length; i++) {\n var cp = frames[i].components;\n for (var j in cp) {\n cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx];\n delete cp[j].quantizationIdx;\n }\n }\n this.width = frame.samplesPerLine;\n this.height = frame.scanLines;\n this.jfif = jfif;\n this.adobe = adobe;\n this.components = [];\n for (var i = 0; i < frame.componentsOrder.length; i++) {\n var component = frame.components[frame.componentsOrder[i]];\n this.components.push({\n lines: buildComponentData(frame, component),\n scaleX: component.h / frame.maxH,\n scaleY: component.v / frame.maxV\n });\n }\n },\n getData: function getData(width, height) {\n var scaleX = this.width / width, scaleY = this.height / height;\n var component1, component2, component3, component4;\n var component1Line, component2Line, component3Line, component4Line;\n var x, y;\n var offset = 0;\n var Y, Cb, Cr, K, C, M, Ye, R, G, B;\n var colorTransform;\n var dataLength = width * height * this.components.length;\n requestMemoryAllocation(dataLength);\n var data = new Uint8Array(dataLength);\n switch (this.components.length) {\n case 1:\n component1 = this.components[0];\n for (y = 0; y < height; y++) {\n component1Line = component1.lines[0 | y * component1.scaleY * scaleY];\n for (x = 0; x < width; x++) {\n Y = component1Line[0 | x * component1.scaleX * scaleX];\n data[offset++] = Y;\n }\n }\n break;\n case 2:\n component1 = this.components[0];\n component2 = this.components[1];\n for (y = 0; y < height; y++) {\n component1Line = component1.lines[0 | y * component1.scaleY * scaleY];\n component2Line = component2.lines[0 | y * component2.scaleY * scaleY];\n for (x = 0; x < width; x++) {\n Y = component1Line[0 | x * component1.scaleX * scaleX];\n data[offset++] = Y;\n Y = component2Line[0 | x * component2.scaleX * scaleX];\n data[offset++] = Y;\n }\n }\n break;\n case 3:\n colorTransform = true;\n if (this.adobe && this.adobe.transformCode)\n colorTransform = true;\n else if (typeof this.opts.colorTransform !== "undefined")\n colorTransform = !!this.opts.colorTransform;\n component1 = this.components[0];\n component2 = this.components[1];\n component3 = this.components[2];\n for (y = 0; y < height; y++) {\n component1Line = component1.lines[0 | y * component1.scaleY * scaleY];\n component2Line = component2.lines[0 | y * component2.scaleY * scaleY];\n component3Line = component3.lines[0 | y * component3.scaleY * scaleY];\n for (x = 0; x < width; x++) {\n if (!colorTransform) {\n R = component1Line[0 | x * component1.scaleX * scaleX];\n G = component2Line[0 | x * component2.scaleX * scaleX];\n B = component3Line[0 | x * component3.scaleX * scaleX];\n } else {\n Y = component1Line[0 | x * component1.scaleX * scaleX];\n Cb = component2Line[0 | x * component2.scaleX * scaleX];\n Cr = component3Line[0 | x * component3.scaleX * scaleX];\n R = clampTo8bit(Y + 1.402 * (Cr - 128));\n G = clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));\n B = clampTo8bit(Y + 1.772 * (Cb - 128));\n }\n data[offset++] = R;\n data[offset++] = G;\n data[offset++] = B;\n }\n }\n break;\n case 4:\n if (!this.adobe)\n throw new Error("Unsupported color mode (4 components)");\n colorTransform = false;\n if (this.adobe && this.adobe.transformCode)\n colorTransform = true;\n else if (typeof this.opts.colorTransform !== "undefined")\n colorTransform = !!this.opts.colorTransform;\n component1 = this.components[0];\n component2 = this.components[1];\n component3 = this.components[2];\n component4 = this.components[3];\n for (y = 0; y < height; y++) {\n component1Line = component1.lines[0 | y * component1.scaleY * scaleY];\n component2Line = component2.lines[0 | y * component2.scaleY * scaleY];\n component3Line = component3.lines[0 | y * component3.scaleY * scaleY];\n component4Line = component4.lines[0 | y * component4.scaleY * scaleY];\n for (x = 0; x < width; x++) {\n if (!colorTransform) {\n C = component1Line[0 | x * component1.scaleX * scaleX];\n M = component2Line[0 | x * component2.scaleX * scaleX];\n Ye = component3Line[0 | x * component3.scaleX * scaleX];\n K = component4Line[0 | x * component4.scaleX * scaleX];\n } else {\n Y = component1Line[0 | x * component1.scaleX * scaleX];\n Cb = component2Line[0 | x * component2.scaleX * scaleX];\n Cr = component3Line[0 | x * component3.scaleX * scaleX];\n K = component4Line[0 | x * component4.scaleX * scaleX];\n C = 255 - clampTo8bit(Y + 1.402 * (Cr - 128));\n M = 255 - clampTo8bit(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));\n Ye = 255 - clampTo8bit(Y + 1.772 * (Cb - 128));\n }\n data[offset++] = 255 - C;\n data[offset++] = 255 - M;\n data[offset++] = 255 - Ye;\n data[offset++] = 255 - K;\n }\n }\n break;\n default:\n throw new Error("Unsupported color mode");\n }\n return data;\n },\n copyToImageData: function copyToImageData(imageData, formatAsRGBA) {\n var width = imageData.width, height = imageData.height;\n var imageDataArray = imageData.data;\n var data = this.getData(width, height);\n var i = 0, j = 0, x, y;\n var Y, K, C, M, R, G, B;\n switch (this.components.length) {\n case 1:\n for (y = 0; y < height; y++) {\n for (x = 0; x < width; x++) {\n Y = data[i++];\n imageDataArray[j++] = Y;\n imageDataArray[j++] = Y;\n imageDataArray[j++] = Y;\n if (formatAsRGBA) {\n imageDataArray[j++] = 255;\n }\n }\n }\n break;\n case 3:\n for (y = 0; y < height; y++) {\n for (x = 0; x < width; x++) {\n R = data[i++];\n G = data[i++];\n B = data[i++];\n imageDataArray[j++] = R;\n imageDataArray[j++] = G;\n imageDataArray[j++] = B;\n if (formatAsRGBA) {\n imageDataArray[j++] = 255;\n }\n }\n }\n break;\n case 4:\n for (y = 0; y < height; y++) {\n for (x = 0; x < width; x++) {\n C = data[i++];\n M = data[i++];\n Y = data[i++];\n K = data[i++];\n R = 255 - clampTo8bit(C * (1 - K / 255) + K);\n G = 255 - clampTo8bit(M * (1 - K / 255) + K);\n B = 255 - clampTo8bit(Y * (1 - K / 255) + K);\n imageDataArray[j++] = R;\n imageDataArray[j++] = G;\n imageDataArray[j++] = B;\n if (formatAsRGBA) {\n imageDataArray[j++] = 255;\n }\n }\n }\n break;\n default:\n throw new Error("Unsupported color mode");\n }\n }\n };\n var totalBytesAllocated = 0;\n var maxMemoryUsageBytes = 0;\n function requestMemoryAllocation(increaseAmount = 0) {\n var totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;\n if (totalMemoryImpactBytes > maxMemoryUsageBytes) {\n var exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);\n throw new Error(`maxMemoryUsageInMB limit exceeded by at least ${exceededAmount}MB`);\n }\n totalBytesAllocated = totalMemoryImpactBytes;\n }\n constructor.resetMaxMemoryUsage = function(maxMemoryUsageBytes_) {\n totalBytesAllocated = 0;\n maxMemoryUsageBytes = maxMemoryUsageBytes_;\n };\n constructor.getBytesAllocated = function() {\n return totalBytesAllocated;\n };\n constructor.requestMemoryAllocation = requestMemoryAllocation;\n return constructor;\n }();\n if (typeof module !== "undefined") {\n module.exports = decode3;\n } else if (typeof window !== "undefined") {\n window["jpeg-js"] = window["jpeg-js"] || {};\n window["jpeg-js"].decode = decode3;\n }\n function decode3(jpegData, userOpts = {}) {\n var defaultOpts = {\n colorTransform: void 0,\n useTArray: false,\n formatAsRGBA: true,\n tolerantDecoding: true,\n maxResolutionInMP: 100,\n maxMemoryUsageInMB: 512\n };\n var opts = { ...defaultOpts, ...userOpts };\n var arr = new Uint8Array(jpegData);\n var decoder = new JpegImage();\n decoder.opts = opts;\n JpegImage.resetMaxMemoryUsage(opts.maxMemoryUsageInMB * 1024 * 1024);\n decoder.parse(arr);\n var channels = opts.formatAsRGBA ? 4 : 3;\n var bytesNeeded = decoder.width * decoder.height * channels;\n try {\n JpegImage.requestMemoryAllocation(bytesNeeded);\n var image = {\n width: decoder.width,\n height: decoder.height,\n exifBuffer: decoder.exifBuffer,\n data: opts.useTArray ? new Uint8Array(bytesNeeded) : Buffer2.alloc(bytesNeeded)\n };\n if (decoder.comments.length > 0) {\n image["comments"] = decoder.comments;\n }\n } catch (err) {\n if (err instanceof RangeError) {\n throw new Error("Could not allocate enough memory for the image. Required: " + bytesNeeded);\n }\n if (err instanceof ReferenceError) {\n if (err.message === "Buffer is not defined") {\n throw new Error("Buffer is not globally defined in this environment. Consider setting useTArray to true");\n }\n }\n throw err;\n }\n decoder.copyToImageData(image, opts.formatAsRGBA);\n return image;\n }\n }\n});\n\n// node_modules/jpeg-js/index.js\nvar require_jpeg_js = __commonJS({\n "node_modules/jpeg-js/index.js"(exports, module) {\n init_define_BUILD_VERSION();\n init_esbuild_inject();\n var encode2 = require_encoder();\n var decode3 = require_decoder();\n module.exports = {\n encode: encode2,\n decode: decode3\n };\n }\n});\n\n// src/processor.worker.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// src/platform.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// src/requests.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar xmlhttprequest;\nif (false)\n xmlhttprequest = typeof GM_xmlhttpRequest != "undefined" ? GM_xmlhttpRequest : typeof GM != "undefined" ? GM.xmlHttpRequest : window["GM_xmlhttpRequest"];\nvar GM_fetch = (...[url, opt, lisn]) => {\n function blobTo(to, blob) {\n if (to == "arrayBuffer" && blob.arrayBuffer) {\n const ret = blob.arrayBuffer();\n if (ret)\n return ret;\n }\n return new Promise((resolve, reject) => {\n const fileReader = new FileReader();\n fileReader.onload = function(event) {\n if (!event)\n return;\n if (to == "base64")\n resolve(event.target.result);\n else\n resolve(event.target.result);\n };\n if (to == "arrayBuffer")\n fileReader.readAsArrayBuffer(blob);\n else if (to == "base64")\n fileReader.readAsDataURL(blob);\n else if (to == "text")\n fileReader.readAsText(blob, "utf-8");\n else\n reject(new Error("unknown to"));\n });\n }\n return new Promise((resolve, reject) => {\n const gmopt = {\n url: url.toString(),\n data: opt?.body,\n responseType: "blob",\n headers: opt?.headers,\n method: opt?.method || "GET",\n ...lisn ? {\n onprogress: (prog) => {\n if (prog.loaded != prog.total && prog.total != 0)\n lisn.dispatchEvent(new CustomEvent("progress", { detail: [prog.loaded, prog.total] }));\n }\n } : {},\n onload: (resp) => {\n if (resp.status / 100 >= 4) {\n reject(new Error("Server Error: " + resp.status));\n return;\n }\n const blob = resp.response;\n const ref = resp;\n ref.blob = () => Promise.resolve(blob);\n ref.arrayBuffer = () => blobTo("arrayBuffer", blob);\n ref.text = () => blobTo("text", blob);\n ref.json = async () => JSON.parse(await blobTo("text", blob));\n resolve(resp);\n },\n ontimeout: () => reject(new Error("fetch timeout")),\n onerror: (...args) => {\n reject(new Error("fetch error"));\n },\n onabort: () => reject(new Error("fetch abort"))\n };\n xmlhttprequest(gmopt);\n });\n};\n\n// src/platform.ts\nvar lqueue = {};\nvar localSet = (key2, value) => localStorage.setItem("__pee__" + key2, JSON.stringify(value));\nvar port1;\nconsole.log("worker", false);\nvar msgBuff = [];\nvar setupPort = (port) => {\n port1 = port;\n port1.onmessage = (ev) => {\n lqueue[ev.data.id](ev.data);\n };\n if (true) {\n for (const msg of msgBuff) {\n port.postMessage(msg[0], { transfer: msg[1] });\n }\n msgBuff = [];\n }\n};\nif (true) {\n port1 = {\n onmessage(ev) {\n lqueue[ev.data.id](ev.data);\n },\n postMessage(msg, tr) {\n msgBuff.push([msg, tr]);\n }\n };\n}\nvar gid = 0;\nvar sendCmd = (cmd, tr, overwrite = false, todelete = false) => {\n const prom = new Promise((_) => {\n const id = gid++;\n if (overwrite)\n cmd.id = id;\n lqueue[id] = (e) => {\n _(e.res);\n if (todelete)\n delete lqueue[id];\n };\n port1.postMessage({ id, ...cmd }, tr || []);\n });\n return prom;\n};\nvar bridge = (name, f) => {\n if (false)\n return f;\n if (false)\n return f;\n return (...args) => {\n return sendCmd({ name, args });\n };\n};\nvar Bridged = (ctor) => {\n const keys = Object.getOwnPropertyNames(ctor).filter((k) => typeof ctor[k] == "function");\n for (const k of keys)\n ctor[k] = bridge(k, ctor[k]);\n};\nif (false) {\n}\nvar Platform = class {\n static async openInTab(src, opts) {\n if (false) {\n return GM.openInTab(src, opts);\n }\n const obj = false ? chrome : browser;\n let i;\n if (opts.insert)\n i = (await obj.tabs.getCurrent()).index + 1;\n return obj.tabs.create({ active: opts.active, url: src, index: i });\n }\n static async getValue(key2, def) {\n const ret = def;\n const d = await chrome.storage.local.get([key2]);\n if (typeof d[key2] == "string")\n return { ...def, ...await JSON.parse("" + d[key2] || "{}") };\n return ret;\n }\n static setValue(name, val) {\n localSet(name, val);\n }\n};\n__publicField(Platform, "cmdid", 0);\nPlatform = __decorateClass([\n Bridged\n], Platform);\nvar corsFetch = async (input, init3, lsn) => {\n const id = gid++;\n let transfer = [];\n if (init3?.body) {\n if (false) {\n [init3.body, transfer] = await braveserialize(init3.body);\n }\n }\n const prom = new Promise((_, rej) => {\n let gcontroller;\n let buffer = [];\n let finished = false;\n const rs = new ReadableStream({\n start(controller) {\n gcontroller = controller;\n buffer.forEach((b) => gcontroller?.enqueue(b));\n buffer = [];\n if (finished) {\n gcontroller.close();\n }\n }\n });\n let s;\n s = 0;\n const cmdbuff = [];\n lqueue[id] = async (e) => {\n if (e.progress) {\n if (lsn)\n lsn.dispatchEvent(new CustomEvent("progress", { detail: e.progress }));\n }\n if (e.pushData) {\n if (e.s > s) {\n let idx = 0;\n while (idx < cmdbuff.length) {\n if (cmdbuff[idx].s > e.s)\n break;\n idx++;\n }\n cmdbuff.splice(idx, 0, e);\n return;\n }\n const processCmd = (e2) => {\n if (e2.pushData.data) {\n const data = new Uint8Array(e2.pushData.data);\n if (gcontroller)\n gcontroller.enqueue(data);\n else\n buffer.push(data);\n } else {\n if (gcontroller)\n gcontroller?.close();\n else\n finished = true;\n }\n };\n await processCmd(e);\n s++;\n while (cmdbuff[0]?.s == s) {\n await processCmd(cmdbuff.shift());\n s++;\n }\n }\n if (e.setRes) {\n const arrayBuffer = async () => {\n const r = rs.getReader();\n await sendCmd({ name: "fullyRead", fid: id });\n const abs = [];\n let res;\n do {\n res = await r.read();\n if (res.done)\n break;\n abs.push(res.value);\n } while (!res.done);\n const sum = abs.reduce((a, b) => a + b.byteLength, 0);\n const ret = new Uint8Array(sum);\n abs.reduce((ptr, arr) => {\n ret.set(arr, ptr);\n return ptr + arr.byteLength;\n }, 0);\n r.releaseLock();\n return ret;\n };\n const blob = async () => new Blob([await arrayBuffer()]);\n const text = async () => new TextDecoder().decode(await arrayBuffer());\n const json = async () => JSON.parse(await text());\n if (e.ok)\n _({\n body: rs,\n ok: e.ok,\n headers: e.headers,\n redirected: e.redirected,\n type: e.type,\n url: e.url,\n status: e.status,\n bodyUsed: e.bodyUsed,\n statusText: e.statusText,\n clone() {\n return this;\n },\n arrayBuffer,\n blob,\n text,\n json,\n async formData() {\n return new FormData();\n }\n });\n else {\n rej(new Error(`${e.url} - ${e.status}`));\n }\n }\n };\n port1.postMessage({\n id,\n name: "corsFetch",\n args: [input, init3]\n }, transfer);\n });\n return prom;\n};\nasync function getHeaders(s) {\n if (false)\n return headerStringToObject(await GM_head(s));\n const res = await ifetch(s, {\n method: "HEAD"\n });\n return res.headers;\n}\nasync function ifetch(...[url, opt, lisn]) {\n if (true)\n return corsFetch(url.toString(), opt, lisn);\n return GM_fetch(url, opt, lisn);\n}\nasync function* streamRemote(url, chunkSize = 72 * 1024, fetchRestOnNonCanceled = true) {\n let size = Number.POSITIVE_INFINITY;\n let ptr = 0;\n let fetchSize = chunkSize;\n while (ptr != size) {\n let obj;\n const fres = await ifetch(url, { headers: { range: `bytes=${ptr}-${ptr + fetchSize - 1}` } });\n if (false) {\n obj = headerStringToObject(fres.responseHeaders);\n } else {\n obj = fres.headers;\n }\n if (!("content-length" in obj)) {\n console.warn("no content lenght???", url);\n break;\n }\n if ("content-range" in obj) {\n size = +obj["content-range"].split("/")[1];\n }\n const len = +obj["content-length"];\n ptr += len;\n if (fetchRestOnNonCanceled)\n fetchSize = size;\n const val = Buffer2.from(await fres.arrayBuffer());\n const e = yield val;\n if (e) {\n break;\n }\n }\n}\n\n// src/stores.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/svelte/store/index.mjs\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/svelte/internal/index.mjs\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nfunction noop() {\n}\nfunction run(fn) {\n return fn();\n}\nfunction run_all(fns) {\n fns.forEach(run);\n}\nfunction is_function(thing) {\n return typeof thing === "function";\n}\nfunction safe_not_equal(a, b) {\n return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function");\n}\nfunction is_empty(obj) {\n return Object.keys(obj).length === 0;\n}\nvar resolved_promise = Promise.resolve();\nfunction destroy_component(component, detaching) {\n const $$ = component.$$;\n if ($$.fragment !== null) {\n run_all($$.on_destroy);\n $$.fragment && $$.fragment.d(detaching);\n $$.on_destroy = $$.fragment = null;\n $$.ctx = [];\n }\n}\nvar SvelteElement;\nif (typeof HTMLElement === "function") {\n SvelteElement = class extends HTMLElement {\n constructor() {\n super();\n this.attachShadow({ mode: "open" });\n }\n connectedCallback() {\n const { on_mount } = this.$$;\n this.$$.on_disconnect = on_mount.map(run).filter(is_function);\n for (const key2 in this.$$.slotted) {\n this.appendChild(this.$$.slotted[key2]);\n }\n }\n attributeChangedCallback(attr, _oldValue, newValue) {\n this[attr] = newValue;\n }\n disconnectedCallback() {\n run_all(this.$$.on_disconnect);\n }\n $destroy() {\n destroy_component(this, 1);\n this.$destroy = noop;\n }\n $on(type, callback) {\n if (!is_function(callback)) {\n return noop;\n }\n const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);\n callbacks.push(callback);\n return () => {\n const index = callbacks.indexOf(callback);\n if (index !== -1)\n callbacks.splice(index, 1);\n };\n }\n $set($$props) {\n if (this.$$set && !is_empty($$props)) {\n this.$$.skip_bound = true;\n this.$$set($$props);\n this.$$.skip_bound = false;\n }\n }\n };\n}\n\n// node_modules/svelte/store/index.mjs\nvar subscriber_queue = [];\nfunction writable(value, start = noop) {\n let stop;\n const subscribers = /* @__PURE__ */ new Set();\n function set(new_value) {\n if (safe_not_equal(value, new_value)) {\n value = new_value;\n if (stop) {\n const run_queue = !subscriber_queue.length;\n for (const subscriber of subscribers) {\n subscriber[1]();\n subscriber_queue.push(subscriber, value);\n }\n if (run_queue) {\n for (let i = 0; i < subscriber_queue.length; i += 2) {\n subscriber_queue[i][0](subscriber_queue[i + 1]);\n }\n subscriber_queue.length = 0;\n }\n }\n }\n }\n function update(fn) {\n set(fn(value));\n }\n function subscribe2(run2, invalidate = noop) {\n const subscriber = [run2, invalidate];\n subscribers.add(subscriber);\n if (subscribers.size === 1) {\n stop = start(set) || noop;\n }\n run2(value);\n return () => {\n subscribers.delete(subscriber);\n if (subscribers.size === 0) {\n stop();\n stop = null;\n }\n };\n }\n return { set, update, subscribe: subscribe2 };\n}\n\n// src/stores.ts\nvar localLoad = async (key2, def) => {\n const ret = await Platform.getValue(key2, def);\n return ret;\n};\nvar localSet2 = (key2, value) => {\n if (true) {\n return;\n }\n chrome.storage.local.set({ [key2]: JSON.stringify(value) });\n};\nvar initial_settings = {\n loop: true,\n dh: false,\n pmeth: 5,\n xpv: false,\n xpi: false,\n hyd: false,\n notcata: false,\n ak: "",\n auto_embed: 0,\n auto_tags: "",\n te: false,\n eye: false,\n ca: false,\n pre: false,\n prev: false,\n sh: false,\n ep: false,\n tm: false,\n dvc: false,\n expte: false,\n mdist: -1,\n phash: false,\n hotlink: false,\n jpeg: false,\n vercheck: false,\n cache: void 0,\n fhost: 0,\n maxe: 5,\n conc: 8,\n ho: false,\n blacklist: [],\n rsources: [\n {\n name: "Gelbooru",\n domain: "gelbooru.com",\n endpoint: "/index.php?page=dapi&s=post&q=index&json=1&tags=md5:",\n view: "https://gelbooru.com/index.php?page=post&s=view&id="\n },\n {\n name: "Yandere",\n domain: "yande.re",\n endpoint: "/post.json?tags=md5:",\n view: `https://yande.re/post/show/`\n },\n {\n name: "Sankaku",\n domain: "capi-v2.sankakucomplex.com",\n endpoint: "/posts/keyset?tags=md5:",\n view: `https://chan.sankakucomplex.com/post/show/`\n },\n {\n name: "Rule34",\n domain: "api.rule34.xxx",\n endpoint: "/index.php?page=dapi&s=post&q=index&json=1&tags=md5:",\n view: "https://rule34.xxx/index.php?page=post&s=view&id="\n },\n {\n name: "Danbooru",\n domain: "danbooru.donmai.us",\n endpoint: "/posts.json?tags=md5:",\n view: "https://danbooru.donmai.us/posts/"\n },\n {\n name: "Lolibooru",\n domain: "lolibooru.moe",\n endpoint: "/post.json?tags=md5:",\n view: "https://lolibooru.moe/post/show/"\n },\n {\n name: "ATFbooru",\n domain: "booru.allthefallen.moe",\n endpoint: "/posts.json?tags=md5:",\n view: "https://booru.allthefallen.moe/posts/"\n }\n ]\n};\nvar settings = writable();\nvar appState = writable({\n isCatalog: false,\n is4chanX: false,\n akValid: false,\n herror: "",\n client: null,\n processing: 0,\n processed: 0,\n foundPosts: []\n});\nsettings.subscribe((newVal) => {\n if (newVal)\n localSet2("settingsv2", newVal);\n});\n\n// src/pngv3.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar import_buffer3 = __toESM(require_buffer(), 1);\n\n// src/png.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar import_crc_32 = __toESM(require_crc32(), 1);\nvar import_buffer = __toESM(require_buffer(), 1);\nvar PNGDecoder = class {\n constructor(reader, strict = true) {\n this.reader = reader;\n this.strict = strict;\n __publicField(this, "repr");\n __publicField(this, "req", 8);\n __publicField(this, "ptr", 8);\n __publicField(this, "stopped", false);\n this.repr = import_buffer.Buffer.from([]);\n }\n async catchup() {\n while (this.repr.byteLength < this.req) {\n const chunk = await this.reader.read();\n if (chunk.done) {\n if (this.strict)\n throw new Error(`Unexpected EOF, got ${this.repr.byteLength}, required ${this.req}, ${chunk.value}`);\n this.stopped = true;\n return;\n }\n this.repr = import_buffer.Buffer.concat([this.repr, chunk.value]);\n }\n }\n async *chunks() {\n while (true) {\n this.req += 8;\n await this.catchup();\n if (this.stopped)\n break;\n const length = this.repr.readUInt32BE(this.ptr);\n const name = this.repr.slice(this.ptr + 4, this.ptr + 8).toString();\n this.ptr += 4;\n this.req += length + 4;\n await this.catchup();\n yield [\n name,\n this.repr.slice(this.ptr, this.ptr + length + 4),\n this.ptr + length > this.repr.length ? -1 : this.repr.readUInt32BE(this.ptr + length + 4),\n this.ptr\n ];\n if (this.stopped)\n break;\n this.ptr += length + 8;\n if (name == "IEND")\n break;\n }\n }\n async dtor() {\n }\n};\nvar PNGEncoder = class {\n constructor(bytes) {\n __publicField(this, "writer");\n this.writer = bytes.getWriter();\n this.writer.write(import_buffer.Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));\n }\n async insertchunk(chunk) {\n let b = import_buffer.Buffer.alloc(4);\n const buff = chunk[1];\n b.writeInt32BE(buff.length - 4, 0);\n await this.writer.write(b);\n await this.writer.write(buff);\n b = import_buffer.Buffer.alloc(4);\n b.writeInt32BE((0, import_crc_32.buf)(buff), 0);\n await this.writer.write(b);\n }\n async dtor() {\n this.writer.releaseLock();\n }\n};\n\n// src/utils.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar import_buffer2 = __toESM(require_buffer(), 1);\n\n// src/assets/hasembed.png\nvar hasembed_exports = {};\n__export(hasembed_exports, {\n default: () => hasembed_default\n});\nvar hasembed_default = __toBinary("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");\n\n// src/filehosts.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nfunction parseForm(data) {\n const form = new FormData();\n Object.entries(data).filter(([key2, value]) => value !== null).map(([key2, value]) => form.append(key2, value));\n return form;\n}\nvar catbox = (domain, serving) => ({\n domain,\n serving,\n async uploadFile(inj) {\n const resp = await ifetch(`https://${domain}/user/api.php`, {\n method: "POST",\n body: parseForm({\n reqtype: "fileupload",\n fileToUpload: inj\n })\n });\n return resp.text();\n }\n});\nvar filehosts = [\n catbox("catbox.moe", "files.catbox.moe")\n];\n\n// node_modules/file-type/browser.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar import_node_buffer4 = __toESM(require_buffer(), 1);\nvar import_readable_web_to_node_stream = __toESM(require_lib(), 1);\n\n// node_modules/file-type/core.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar import_node_buffer3 = __toESM(require_buffer(), 1);\n\n// node_modules/token-types/lib/index.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar ieee754 = __toESM(require_ieee754(), 1);\nvar import_node_buffer = __toESM(require_buffer(), 1);\nvar AnsiStringType = class {\n constructor(len) {\n this.len = len;\n }\n static decode(buffer, offset, until) {\n let str = "";\n for (let i = offset; i < until; ++i) {\n str += AnsiStringType.codePointToString(AnsiStringType.singleByteDecoder(buffer[i]));\n }\n return str;\n }\n static inRange(a, min, max) {\n return min <= a && a <= max;\n }\n static codePointToString(cp) {\n if (cp <= 65535) {\n return String.fromCharCode(cp);\n } else {\n cp -= 65536;\n return String.fromCharCode((cp >> 10) + 55296, (cp & 1023) + 56320);\n }\n }\n static singleByteDecoder(bite) {\n if (AnsiStringType.inRange(bite, 0, 127)) {\n return bite;\n }\n const codePoint = AnsiStringType.windows1252[bite - 128];\n if (codePoint === null) {\n throw Error("invaliding encoding");\n }\n return codePoint;\n }\n get(buffer, offset = 0) {\n return AnsiStringType.decode(buffer, offset, offset + this.len);\n }\n};\nAnsiStringType.windows1252 = [\n 8364,\n 129,\n 8218,\n 402,\n 8222,\n 8230,\n 8224,\n 8225,\n 710,\n 8240,\n 352,\n 8249,\n 338,\n 141,\n 381,\n 143,\n 144,\n 8216,\n 8217,\n 8220,\n 8221,\n 8226,\n 8211,\n 8212,\n 732,\n 8482,\n 353,\n 8250,\n 339,\n 157,\n 382,\n 376,\n 160,\n 161,\n 162,\n 163,\n 164,\n 165,\n 166,\n 167,\n 168,\n 169,\n 170,\n 171,\n 172,\n 173,\n 174,\n 175,\n 176,\n 177,\n 178,\n 179,\n 180,\n 181,\n 182,\n 183,\n 184,\n 185,\n 186,\n 187,\n 188,\n 189,\n 190,\n 191,\n 192,\n 193,\n 194,\n 195,\n 196,\n 197,\n 198,\n 199,\n 200,\n 201,\n 202,\n 203,\n 204,\n 205,\n 206,\n 207,\n 208,\n 209,\n 210,\n 211,\n 212,\n 213,\n 214,\n 215,\n 216,\n 217,\n 218,\n 219,\n 220,\n 221,\n 222,\n 223,\n 224,\n 225,\n 226,\n 227,\n 228,\n 229,\n 230,\n 231,\n 232,\n 233,\n 234,\n 235,\n 236,\n 237,\n 238,\n 239,\n 240,\n 241,\n 242,\n 243,\n 244,\n 245,\n 246,\n 247,\n 248,\n 249,\n 250,\n 251,\n 252,\n 253,\n 254,\n 255\n];\n\n// node_modules/strtok3/lib/core.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/strtok3/lib/ReadStreamTokenizer.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/strtok3/lib/AbstractTokenizer.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/peek-readable/lib/index.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/peek-readable/lib/EndOfFileStream.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/peek-readable/lib/StreamReader.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/peek-readable/lib/Deferred.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/peek-readable/lib/StreamReader.js\nvar maxStreamReadSize = 1 * 1024 * 1024;\n\n// node_modules/strtok3/lib/AbstractTokenizer.js\nvar import_node_buffer2 = __toESM(require_buffer(), 1);\n\n// node_modules/strtok3/lib/BufferTokenizer.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/file-type/util.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\n\n// node_modules/file-type/supported.js\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar extensions = [\n "jpg",\n "png",\n "apng",\n "gif",\n "webp",\n "flif",\n "xcf",\n "cr2",\n "cr3",\n "orf",\n "arw",\n "dng",\n "nef",\n "rw2",\n "raf",\n "tif",\n "bmp",\n "icns",\n "jxr",\n "psd",\n "indd",\n "zip",\n "tar",\n "rar",\n "gz",\n "bz2",\n "7z",\n "dmg",\n "mp4",\n "mid",\n "mkv",\n "webm",\n "mov",\n "avi",\n "mpg",\n "mp2",\n "mp3",\n "m4a",\n "oga",\n "ogg",\n "ogv",\n "opus",\n "flac",\n "wav",\n "spx",\n "amr",\n "pdf",\n "epub",\n "elf",\n "exe",\n "swf",\n "rtf",\n "wasm",\n "woff",\n "woff2",\n "eot",\n "ttf",\n "otf",\n "ico",\n "flv",\n "ps",\n "xz",\n "sqlite",\n "nes",\n "crx",\n "xpi",\n "cab",\n "deb",\n "ar",\n "rpm",\n "Z",\n "lz",\n "cfb",\n "mxf",\n "mts",\n "blend",\n "bpg",\n "docx",\n "pptx",\n "xlsx",\n "3gp",\n "3g2",\n "jp2",\n "jpm",\n "jpx",\n "mj2",\n "aif",\n "qcp",\n "odt",\n "ods",\n "odp",\n "xml",\n "mobi",\n "heic",\n "cur",\n "ktx",\n "ape",\n "wv",\n "dcm",\n "ics",\n "glb",\n "pcap",\n "dsf",\n "lnk",\n "alias",\n "voc",\n "ac3",\n "m4v",\n "m4p",\n "m4b",\n "f4v",\n "f4p",\n "f4b",\n "f4a",\n "mie",\n "asf",\n "ogm",\n "ogx",\n "mpc",\n "arrow",\n "shp",\n "aac",\n "mp1",\n "it",\n "s3m",\n "xm",\n "ai",\n "skp",\n "avif",\n "eps",\n "lzh",\n "pgp",\n "asar",\n "stl",\n "chm",\n "3mf",\n "zst",\n "jxl",\n "vcf"\n];\nvar mimeTypes = [\n "image/jpeg",\n "image/png",\n "image/gif",\n "image/webp",\n "image/flif",\n "image/x-xcf",\n "image/x-canon-cr2",\n "image/x-canon-cr3",\n "image/tiff",\n "image/bmp",\n "image/vnd.ms-photo",\n "image/vnd.adobe.photoshop",\n "application/x-indesign",\n "application/epub+zip",\n "application/x-xpinstall",\n "application/vnd.oasis.opendocument.text",\n "application/vnd.oasis.opendocument.spreadsheet",\n "application/vnd.oasis.opendocument.presentation",\n "application/vnd.openxmlformats-officedocument.wordprocessingml.document",\n "application/vnd.openxmlformats-officedocument.presentationml.presentation",\n "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",\n "application/zip",\n "application/x-tar",\n "application/x-rar-compressed",\n "application/gzip",\n "application/x-bzip2",\n "application/x-7z-compressed",\n "application/x-apple-diskimage",\n "application/x-apache-arrow",\n "video/mp4",\n "audio/midi",\n "video/x-matroska",\n "video/webm",\n "video/quicktime",\n "video/vnd.avi",\n "audio/vnd.wave",\n "audio/qcelp",\n "audio/x-ms-asf",\n "video/x-ms-asf",\n "application/vnd.ms-asf",\n "video/mpeg",\n "video/3gpp",\n "audio/mpeg",\n "audio/mp4",\n "audio/opus",\n "video/ogg",\n "audio/ogg",\n "application/ogg",\n "audio/x-flac",\n "audio/ape",\n "audio/wavpack",\n "audio/amr",\n "application/pdf",\n "application/x-elf",\n "application/x-msdownload",\n "application/x-shockwave-flash",\n "application/rtf",\n "application/wasm",\n "font/woff",\n "font/woff2",\n "application/vnd.ms-fontobject",\n "font/ttf",\n "font/otf",\n "image/x-icon",\n "video/x-flv",\n "application/postscript",\n "application/eps",\n "application/x-xz",\n "application/x-sqlite3",\n "application/x-nintendo-nes-rom",\n "application/x-google-chrome-extension",\n "application/vnd.ms-cab-compressed",\n "application/x-deb",\n "application/x-unix-archive",\n "application/x-rpm",\n "application/x-compress",\n "application/x-lzip",\n "application/x-cfb",\n "application/x-mie",\n "application/mxf",\n "video/mp2t",\n "application/x-blender",\n "image/bpg",\n "image/jp2",\n "image/jpx",\n "image/jpm",\n "image/mj2",\n "audio/aiff",\n "application/xml",\n "application/x-mobipocket-ebook",\n "image/heif",\n "image/heif-sequence",\n "image/heic",\n "image/heic-sequence",\n "image/icns",\n "image/ktx",\n "application/dicom",\n "audio/x-musepack",\n "text/calendar",\n "text/vcard",\n "model/gltf-binary",\n "application/vnd.tcpdump.pcap",\n "audio/x-dsf",\n "application/x.ms.shortcut",\n "application/x.apple.alias",\n "audio/x-voc",\n "audio/vnd.dolby.dd-raw",\n "audio/x-m4a",\n "image/apng",\n "image/x-olympus-orf",\n "image/x-sony-arw",\n "image/x-adobe-dng",\n "image/x-nikon-nef",\n "image/x-panasonic-rw2",\n "image/x-fujifilm-raf",\n "video/x-m4v",\n "video/3gpp2",\n "application/x-esri-shape",\n "audio/aac",\n "audio/x-it",\n "audio/x-s3m",\n "audio/x-xm",\n "video/MP1S",\n "video/MP2P",\n "application/vnd.sketchup.skp",\n "image/avif",\n "application/x-lzh-compressed",\n "application/pgp-encrypted",\n "application/x-asar",\n "model/stl",\n "application/vnd.ms-htmlhelp",\n "model/3mf",\n "image/jxl",\n "application/zstd"\n];\n\n// node_modules/file-type/core.js\nvar supportedExtensions = new Set(extensions);\nvar supportedMimeTypes = new Set(mimeTypes);\n\n// src/utils.ts\nvar csettings;\nsettings.subscribe((b) => {\n csettings = b;\n});\nvar threadDataCache = writable();\nvar cthreadDataCache;\nthreadDataCache.subscribe((newval) => {\n cthreadDataCache = newval;\n});\nvar decodeCoom3Payload = async (buff) => {\n if (!csettings)\n throw new Error("Settings uninit");\n const allowed_domains = filehosts.map((e) => e.serving.replaceAll(".", "\\\\."));\n const pees = buff.toString().split(" ").slice(0, csettings.maxe).filter((e) => allowed_domains.some((v) => e.match(`https://(.*\\\\.)?${v}/`)));\n return (await Promise.all(pees.map(async (pee) => {\n try {\n const m = pee.match(/(?<protocol>https?):\\/\\/(?<domain>.*?)(?<file>\\/.*)/);\n if (!m)\n return;\n const { domain, file } = m.groups;\n const headers = await getHeaders(pee);\n const res = await ifetch(pee, {\n headers: { range: "bytes=0-32767" },\n mode: "cors"\n });\n const size = +headers["content-length"] || 0;\n const header = import_buffer2.Buffer.from(await res.arrayBuffer());\n let hptr = 0;\n if (header.slice(0, 4).toString() == "PEE\\0")\n hptr += 4;\n else\n return;\n const flags = header[hptr];\n const hasFn = !!(flags & 1);\n const hasTags = !!(flags & 2);\n const hasThumbnail = !!(flags & 4);\n let [ptr, ptr2] = [hptr + 1, hptr + 1];\n let fn = "embedded";\n let tags = [];\n let thumb = import_buffer2.Buffer.from(hasembed_default);\n if (hasFn) {\n while (header[ptr2] != 0)\n ptr2++;\n fn = header.slice(ptr, ptr2).toString();\n ptr = ++ptr2;\n }\n if (hasTags) {\n while (header[ptr2] != 0)\n ptr2++;\n tags = header.slice(ptr, ptr2).toString().split(/\\s+/);\n }\n let thumbsize = 0;\n if (hasThumbnail) {\n thumbsize = header.readInt32LE(ptr);\n ptr += 4;\n if (header.byteLength >= ptr + thumbsize)\n thumb = header.slice(ptr, ptr + thumbsize);\n else\n thumb = import_buffer2.Buffer.from(await (await ifetch(pee, { headers: { "user-agent": "", range: `bytes=${ptr}-${ptr + thumbsize}` } })).arrayBuffer());\n ptr += thumbsize;\n }\n const unzip = { url: pee, headers: { "user-agent": "", range: `bytes=${ptr}-${size - 1}` } };\n let data;\n data = unzip;\n if (size < 3072) {\n thumb = data = import_buffer2.Buffer.from(await (await ifetch(unzip.url, { headers: unzip.headers })).arrayBuffer());\n }\n return {\n filename: fn,\n data,\n thumbnail: thumb\n };\n } catch (e) {\n console.warn(e);\n }\n }))).filter((e) => e).map((e) => e);\n};\n\n// src/pngv3.ts\nvar bs58 = __toESM(require_bs58(), 1);\n\n// src/bitstream.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar revbyte = (n, len = 8) => {\n let acc = 0;\n let n2 = n;\n let len2 = len;\n while (len2) {\n acc = acc * 2 + (n2 & 1);\n n2 >>= 1;\n len2--;\n }\n return acc;\n};\nvar BitstreamReader = class {\n constructor() {\n __publicField(this, "buffers", []);\n __publicField(this, "bufferedLength", 0);\n __publicField(this, "_offsetIntoBuffer", 0);\n __publicField(this, "_bufferIndex", 0);\n __publicField(this, "_offset", 0);\n __publicField(this, "skippedLength", 0);\n }\n get bufferIndex() {\n return this._bufferIndex;\n }\n get offset() {\n return this._offset;\n }\n get available() {\n return this.bufferedLength - this.skippedLength;\n }\n getBit(offset) {\n const byte = this.buffers[0][offset >> 3];\n return +!!(byte & 1 << (offset & 7));\n }\n readSync(length) {\n let value = 0;\n if (this._offset >> 3 > this.buffers[0].byteLength) {\n throw "Out of data";\n }\n for (let i = length - 1; i >= 0; --i) {\n value = value * 2 + this.getBit(this._offset + i);\n }\n this._offset += length;\n this.bufferedLength -= length;\n return value;\n }\n addBuffer(buffer) {\n this.buffers.push(buffer);\n this.bufferedLength += buffer.length * 8;\n }\n};\nvar BitstreamWriter = class {\n constructor(stream, bufferSize = 1) {\n this.stream = stream;\n __publicField(this, "pendingBits", 0);\n __publicField(this, "buffer");\n __publicField(this, "bufferoffset", 0);\n __publicField(this, "_offset", 0);\n bufferSize = 1;\n this.buffer = new Uint8Array(bufferSize);\n }\n get offset() {\n return this._offset;\n }\n get byteOffset() {\n return this.pendingBits;\n }\n end() {\n this.flush();\n }\n flush() {\n this.stream.write(new Uint8Array(this.buffer));\n this.bufferoffset = 0;\n this.buffer.fill(0);\n }\n setBit(b) {\n let byte = this.buffer[0];\n byte |= b << (this._offset & 7);\n this.buffer[0] = byte;\n this._offset += 1;\n if (++this.bufferoffset == this.buffer.length * 8) {\n this.flush();\n }\n }\n write(length, value) {\n while (length--) {\n this.setBit(value & 1);\n value >>= 1;\n }\n }\n};\n\n// src/dh-deflate.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar TINF_OK = 0;\nvar Tree = class {\n constructor() {\n __publicField(this, "table", new Uint16Array(16));\n __publicField(this, "trans", new Uint16Array(288));\n }\n};\nvar getPathTo = (tree, value) => {\n if (tree[0] === value)\n return "0";\n if (tree[1] === value)\n return "1";\n let p;\n if (typeof tree[0] != "number")\n p = getPathTo(tree[0], value);\n let b = "0";\n if (!p) {\n if (tree[1] && typeof tree[1] != "number")\n p = getPathTo(tree[1], value);\n b = "1";\n }\n if (p)\n return b + p;\n};\nfunction buildHuffmanTable(codeLengths, values) {\n let k = 0, code = [], i, j, length = 16;\n while (length > 0 && !codeLengths[length - 1])\n length--;\n code.push({ children: [], index: 0 });\n let p = code[0], q;\n for (i = 0; i < length; i++) {\n for (j = 0; j < codeLengths[i]; j++) {\n p = code.pop();\n p.children[p.index] = values[k];\n while (p.index > 0) {\n if (code.length === 0)\n throw new Error("Could not recreate Huffman Table");\n p = code.pop();\n }\n p.index++;\n code.push(p);\n while (code.length <= i) {\n code.push(q = { children: [], index: 0 });\n p.children[p.index] = q.children;\n p = q;\n }\n k++;\n }\n if (i + 1 < length) {\n code.push(q = { children: [], index: 0 });\n p.children[p.index] = q.children;\n p = q;\n }\n }\n return code[0].children;\n}\nvar Data = class {\n constructor(source, dests, to_hide, hidden) {\n this.source = source;\n this.dests = dests;\n this.to_hide = to_hide;\n this.hidden = hidden;\n __publicField(this, "pathMap", /* @__PURE__ */ new Map());\n __publicField(this, "ltree");\n __publicField(this, "dtree");\n __publicField(this, "rltree");\n __publicField(this, "rdtree");\n __publicField(this, "adists");\n __publicField(this, "dest", []);\n this.ltree = new Tree();\n this.dtree = new Tree();\n }\n computeReverse() {\n this.rltree = buildHuffmanTable(this.ltree.table, this.ltree.trans)[0];\n this.rdtree = buildHuffmanTable(this.dtree.table, this.dtree.trans)[0];\n this.adists = new Set(this.rdtree.flat(16));\n }\n};\nvar sltree = new Tree();\nvar sdtree = new Tree();\nvar rltree;\nvar rdtree;\nvar sadist;\nvar length_bits = new Uint8Array(30);\nvar length_base = new Uint16Array(30);\nvar dist_bits = new Uint8Array(30);\nvar dist_base = new Uint16Array(30);\nvar clcidx = new Uint8Array([\n 16,\n 17,\n 18,\n 0,\n 8,\n 7,\n 9,\n 6,\n 10,\n 5,\n 11,\n 4,\n 12,\n 3,\n 13,\n 2,\n 14,\n 1,\n 15\n]);\nvar code_tree = new Tree();\nvar lengths = new Uint8Array(288 + 32);\nfunction tinf_build_bits_base(bits, base, delta, first) {\n let i, sum;\n for (i = 0; i < delta; ++i)\n bits[i] = 0;\n for (i = 0; i < 30 - delta; ++i)\n bits[i + delta] = i / delta | 0;\n for (sum = first, i = 0; i < 30; ++i) {\n base[i] = sum;\n sum += 1 << bits[i];\n }\n}\nfunction tinf_build_fixed_trees(lt, dt) {\n let i;\n for (i = 0; i < 7; ++i)\n lt.table[i] = 0;\n lt.table[7] = 24;\n lt.table[8] = 152;\n lt.table[9] = 112;\n for (i = 0; i < 24; ++i)\n lt.trans[i] = 256 + i;\n for (i = 0; i < 144; ++i)\n lt.trans[24 + i] = i;\n for (i = 0; i < 8; ++i)\n lt.trans[24 + 144 + i] = 280 + i;\n for (i = 0; i < 112; ++i)\n lt.trans[24 + 144 + 8 + i] = 144 + i;\n for (i = 0; i < 5; ++i)\n dt.table[i] = 0;\n dt.table[5] = 32;\n for (i = 0; i < 32; ++i)\n dt.trans[i] = i;\n}\nvar offs = new Uint16Array(16);\nfunction tinf_build_tree(t, lengths2, off, num) {\n let i, sum;\n for (i = 0; i < 16; ++i)\n t.table[i] = 0;\n for (i = 0; i < num; ++i)\n t.table[lengths2[off + i]]++;\n t.table[0] = 0;\n for (sum = 0, i = 0; i < 16; ++i) {\n offs[i] = sum;\n sum += t.table[i];\n }\n for (i = 0; i < num; ++i) {\n if (lengths2[off + i])\n t.trans[offs[lengths2[off + i]]++] = i;\n }\n}\nfunction tinf_getbit(d) {\n const v = d.source.readSync(1);\n return v;\n}\nvar loff = 0;\nvar loffs = [];\nfunction tinf_read_bits(d, num, base) {\n if (!num)\n return base;\n const v = d.source.readSync(num) + base;\n loff = v;\n loffs.push(v);\n if (loffs.length > 4) {\n loffs.shift();\n }\n return v;\n}\nfunction tinf_decode_symbol(d, t, copy = true, ext = {}) {\n let sum = 0, cur = 0, len = 0;\n let s = 0;\n do {\n const b = d.source.readSync(1);\n copy && d.hidden?.write(1, b);\n s = s << 1 | b;\n cur = 2 * cur + b;\n ++len;\n sum += t.table[len];\n cur -= t.table[len];\n } while (cur >= 0);\n ext.length = len;\n ext.sym = s;\n return t.trans[sum + cur];\n}\nfunction tinf_decode_trees(d, lt, dt, copy = true) {\n let i, num, length;\n const hlit = tinf_read_bits(d, 5, 257);\n copy && d.hidden?.write(5, hlit - 257);\n const hdist = tinf_read_bits(d, 5, 1);\n copy && d.hidden?.write(5, hdist - 1);\n const hclen = tinf_read_bits(d, 4, 4);\n copy && d.hidden?.write(4, hclen - 4);\n for (i = 0; i < 19; ++i)\n lengths[i] = 0;\n for (i = 0; i < hclen; ++i) {\n const clen = tinf_read_bits(d, 3, 0);\n copy && d.hidden?.write(3, clen);\n lengths[clcidx[i]] = clen;\n }\n tinf_build_tree(code_tree, lengths, 0, 19);\n for (num = 0; num < hlit + hdist; ) {\n const sym = tinf_decode_symbol(d, code_tree, copy);\n let prev;\n switch (sym) {\n case 16:\n prev = lengths[num - 1];\n length = tinf_read_bits(d, 2, 3);\n copy && d.hidden?.write(2, length - 3);\n for (; length; --length) {\n lengths[num++] = prev;\n }\n break;\n case 17:\n length = tinf_read_bits(d, 3, 3);\n copy && d.hidden?.write(3, length - 3);\n for (; length; --length) {\n lengths[num++] = 0;\n }\n break;\n case 18:\n length = tinf_read_bits(d, 7, 11);\n copy && d.hidden?.write(7, length - 11);\n for (; length; --length) {\n lengths[num++] = 0;\n }\n break;\n default:\n lengths[num++] = sym;\n break;\n }\n }\n tinf_build_tree(lt, lengths, 0, hlit);\n tinf_build_tree(dt, lengths, hlit, hdist);\n}\nvar get_symbol = (value, bits_table, base_table) => {\n let i = 0;\n for (i = 0; i < base_table.length; ++i) {\n if (base_table[i] > value) {\n i--;\n return [i, bits_table[i], value - base_table[i]];\n }\n }\n i--;\n return [i, bits_table[i], value - base_table[i]];\n};\nvar encode_symbol = (sym, tree, pathMap) => {\n const code = getPathTo(tree, sym);\n const v = {\n length: code?.length,\n val: parseInt(code, 2)\n };\n return v;\n};\nvar capacity = 0;\nfunction tinf_inflate_block_data(d, lt, dt) {\n while (1) {\n let sym = tinf_decode_symbol(d, lt);\n if (sym === 256) {\n return TINF_OK;\n }\n if (sym < 256) {\n d.dest.push(sym);\n } else {\n sym -= 257;\n const length = tinf_read_bits(d, length_bits[sym], length_base[sym]);\n if (length_bits[sym])\n d.hidden?.write(length_bits[sym], length - length_base[sym]);\n const ext = { length: 0, sym: 0 };\n const dist = tinf_decode_symbol(d, dt, false, ext);\n let backoffset = tinf_read_bits(d, dist_bits[dist], dist_base[dist]);\n const offs2 = d.dest.length - backoffset;\n let match;\n const skip = !d.to_hide || d.to_hide && d.to_hide instanceof BitstreamReader && d.to_hide.available == 0;\n if (!skip && (match = Buffer2.from(d.dest.slice(offs2, offs2 + length))).length == length) {\n let begin = d.dest.length - 32768;\n if (begin < 0)\n begin = 0;\n let matches = [];\n let o = 0;\n const slic = Buffer2.from(d.dest.slice(begin + o, d.dest.length));\n while (begin + o < d.dest.length) {\n const r = slic.slice(o, d.dest.length).indexOf(match);\n if (r >= 0) {\n matches.push(r + begin + o);\n o += r;\n } else {\n break;\n }\n o++;\n }\n if (matches.length > 1) {\n matches = matches.map((e) => -(e - d.dest.length)).filter((e) => {\n const [dsym2] = get_symbol(e, dist_bits, dist_base);\n return d.adists.has(dsym2);\n });\n matches.reverse();\n const v = Math.floor(Math.log2(matches.length));\n capacity += v;\n if (d.to_hide instanceof BitstreamReader) {\n if (d.to_hide.available) {\n const s = d.to_hide.readSync(Math.min(d.to_hide.available, v));\n backoffset = matches[s];\n }\n } else {\n const idx = matches.indexOf(backoffset);\n d.to_hide.write(v, idx);\n }\n }\n }\n const [dsym, dlen, doff] = get_symbol(backoffset, dist_bits, dist_base);\n const encdist = encode_symbol(dsym, d.rdtree, d.pathMap);\n d.hidden?.write(encdist.length, revbyte(encdist.val, encdist.length));\n d.hidden?.write(dlen, doff);\n for (let i = offs2; i < offs2 + length; ++i) {\n d.dest.push(d.dest[i]);\n }\n }\n }\n}\nfunction tinf_inflate_uncompressed_block(d) {\n if (d.source.offset & 7)\n d.source.readSync(8 - d.source.offset & 7);\n if (d.hidden && d.hidden.offset & 7)\n d.hidden?.write(8 - d.hidden.offset & 7, 0);\n const length = d.source.readSync(16);\n d.hidden?.write(16, length);\n const invlength = d.source.readSync(16);\n d.hidden?.write(16, invlength);\n if (length !== (~invlength & 65535)) {\n return -4;\n }\n for (let i = length; i; --i) {\n const v = d.source.readSync(8);\n d.dest.push(v);\n d.hidden?.write(8, v);\n }\n return TINF_OK;\n}\nfunction tinf_uncompress(source, decompressed, to_hide, hidden, opt = 0) {\n const decomp = decompressed ? new BitstreamWriter({ write: decompressed }) : null;\n const hid = hidden && new BitstreamWriter({ write: hidden }, 4);\n const d = new Data(source, decomp, to_hide, hid);\n let res;\n let bfinal, btype;\n do {\n bfinal = tinf_getbit(d);\n d.hidden?.write(1, bfinal);\n btype = tinf_read_bits(d, 2, 0);\n d.hidden?.write(2, btype);\n switch (btype) {\n case 0:\n res = tinf_inflate_uncompressed_block(d);\n break;\n case 1:\n d.rdtree = rdtree;\n d.rltree = rltree;\n d.adists = sadist;\n res = tinf_inflate_block_data(d, sltree, sdtree);\n break;\n case 2:\n tinf_decode_trees(d, d.ltree, d.dtree);\n d.computeReverse();\n res = tinf_inflate_block_data(d, d.ltree, d.dtree);\n break;\n default:\n res = -2;\n }\n if (res !== TINF_OK)\n throw new Error("Data error " + res);\n } while (!bfinal);\n decomp?.end();\n hid?.end();\n}\ntinf_build_fixed_trees(sltree, sdtree);\ntinf_build_bits_base(length_bits, length_base, 4, 3);\ntinf_build_bits_base(dist_bits, dist_base, 2, 1);\nrltree = buildHuffmanTable(sltree.table, sltree.trans)[0];\nrdtree = buildHuffmanTable(sdtree.table, sdtree.trans)[0];\nsadist = new Set(rdtree.flat(16));\nlength_bits[28] = 0;\nlength_base[28] = 258;\n\n// src/pngv3.ts\nvar csettings2;\nsettings.subscribe((b) => {\n csettings2 = b;\n});\nvar CUM3 = import_buffer3.Buffer.from("doo\\0m");\nvar CUM4 = import_buffer3.Buffer.from("voo\\0m");\nvar CUM5 = import_buffer3.Buffer.from("boo\\0");\nvar CUM6 = import_buffer3.Buffer.from("Creation Time\\0");\nvar CUM7 = import_buffer3.Buffer.from("Software\\0");\nvar BufferReadStream = (b) => {\n const ret = new ReadableStream({\n pull(cont) {\n cont.enqueue(b);\n cont.close();\n }\n });\n return ret;\n};\nvar password = import_buffer3.Buffer.from("NOA");\nvar xor = (a, p) => {\n let n = 0;\n for (let i = 0; i < a.byteLength; ++i) {\n a[i] ^= p[n];\n n++;\n n %= p.byteLength;\n }\n};\nvar prefs = {\n "files.catbox.moe": "c",\n "a.pomf.cat": "p",\n "take-me-to.space": "t",\n "z.zz.fo": "z"\n};\nvar rprefs = {\n "c": "files.catbox.moe",\n "p": "a.pomf.cat",\n "t": "take-me-to.space",\n "z": "z.zz.fo"\n};\nvar extractFromRawDeflate = (b) => {\n const src = new BitstreamReader();\n src.addBuffer(b);\n const chnks = [];\n const hidden = new BitstreamWriter({\n write(chunk) {\n for (const i of chunk) {\n if (i >= 32 && i <= 128)\n chnks.push(i);\n else\n throw "Finish";\n }\n }\n });\n try {\n tinf_uncompress(src, void 0, hidden, void 0);\n } catch (e) {\n if (e == "Finish")\n return import_buffer3.Buffer.from(chnks);\n }\n return false;\n};\nvar extract = async (png, doextract = true) => {\n const reader = BufferReadStream(png).getReader();\n const sneed = new PNGDecoder(reader, false);\n const ret = [];\n let w;\n if (!csettings2)\n throw new Error("Settings uninit");\n try {\n let complete = false;\n const idats = [];\n for await (const [name, chunk, crc, offset] of sneed.chunks()) {\n let buff;\n switch (name) {\n case "tEXt":\n buff = chunk;\n if (buff.slice(4, 4 + CUM3.length).equals(CUM3)) {\n if (!doextract)\n return true;\n const k = await decodeCoom3Payload(buff.slice(4 + CUM3.length));\n ret.push(...k.filter((e) => e));\n }\n if (buff.slice(4, 4 + CUM4.length).equals(CUM4)) {\n if (!doextract)\n return true;\n const passed = buff.slice(4 + CUM4.length);\n xor(passed, password);\n const k = await decodeCoom3Payload(passed);\n ret.push(...k.filter((e) => e));\n }\n if (buff.slice(4, 4 + CUM5.length).equals(CUM5)) {\n if (!doextract)\n return true;\n const passed = buff.slice(4 + CUM5.length);\n const decoded = import_buffer3.Buffer.from(passed.toString(), "base64").toString().split(" ").map((e) => {\n return `https://${rprefs[e[0]]}/${e.slice(1)}`;\n }).join(" ");\n const k = await decodeCoom3Payload(import_buffer3.Buffer.from(decoded));\n ret.push(...k.filter((e) => e));\n }\n if (w = [CUM6, CUM7].find((e) => buff.slice(4, 4 + e.length).equals(e))) {\n const passed = buff.slice(4 + w.length);\n if (!passed.toString().match(/^[0-9a-zA-Z+/=]+$/g))\n continue;\n const decoders = [\n (b) => import_buffer3.Buffer.from(b.toString(), "base64").toString(),\n (b) => import_buffer3.Buffer.from(bs58.decode(passed.toString())).toString()\n ];\n for (const d of decoders) {\n try {\n const decoded = d(passed).split(" ").map((e) => {\n if (!(e[0] in rprefs))\n throw "Uhh";\n return `https://${rprefs[e[0]]}/${e.slice(1)}`;\n }).join(" ");\n if (!doextract)\n return true;\n const k = await decodeCoom3Payload(import_buffer3.Buffer.from(decoded));\n ret.push(...k.filter((e) => e));\n } catch (e) {\n }\n }\n }\n break;\n case "IDAT":\n if (ret.length)\n return ret;\n buff = chunk;\n idats.push(buff.slice(4));\n break;\n case "IEND":\n complete = true;\n default:\n break;\n }\n }\n if (idats.length) {\n let decoded;\n if ((decoded = extractFromRawDeflate(import_buffer3.Buffer.concat(idats).slice(2))) === false)\n return false;\n const dec = decoded.toString().split(" ").map((e) => {\n if (!(e[0] in rprefs) || e.length < 5)\n throw "Uhh";\n return `https://${rprefs[e[0]]}/${e.slice(1)}`;\n }).join(" ");\n if (doextract)\n return decodeCoom3Payload(import_buffer3.Buffer.from(dec));\n return true;\n }\n } catch (e) {\n if (e != "Uhh")\n console.error(e);\n } finally {\n reader.releaseLock();\n }\n};\nvar buildChunk = (tag, data) => {\n const ret = import_buffer3.Buffer.alloc(data.byteLength + 4);\n ret.write(tag.slice(0, 4), 0);\n data.copy(ret, 4);\n return ret;\n};\nvar BufferWriteStream = () => {\n let b = import_buffer3.Buffer.from([]);\n const ret = new WritableStream({\n write(chunk) {\n b = import_buffer3.Buffer.concat([b, chunk]);\n console.log("finished appending");\n }\n });\n return [ret, () => b];\n};\nvar embedInRawDeflate = (b, h) => {\n const src = new BitstreamReader();\n const hid = new BitstreamReader();\n hid.addBuffer(h);\n src.addBuffer(b);\n const chnks = [];\n tinf_uncompress(src, void 0, hid, (c) => chnks.push(c));\n return import_buffer3.Buffer.concat(chnks);\n};\nvar inject_data = async (container, injb) => {\n injb = import_buffer3.Buffer.concat([injb, import_buffer3.Buffer.from([0])]);\n if (!csettings2)\n throw new Error("Settings uninit");\n if (csettings2.pmeth < 5) {\n let magic = false;\n const [writestream2, extract6] = BufferWriteStream();\n const encoder = new PNGEncoder(writestream2);\n const decoder = new PNGDecoder(container.stream().getReader());\n for await (const [name, chunk, crc, offset] of decoder.chunks()) {\n if (magic && name != "IDAT")\n break;\n if (!magic && name == "IDAT") {\n const passed = import_buffer3.Buffer.from(injb);\n switch (csettings2.pmeth) {\n case 0:\n await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM3, passed])), 0, 0]);\n break;\n case 1:\n xor(passed, password);\n await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM4, import_buffer3.Buffer.from(import_buffer3.Buffer.from(passed).toString("base64"))])), 0, 0]);\n break;\n case 2:\n await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM5, import_buffer3.Buffer.from(import_buffer3.Buffer.from(passed).toString("base64"))])), 0, 0]);\n break;\n case 3:\n await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM6, import_buffer3.Buffer.from(import_buffer3.Buffer.from(passed).toString("base64"))])), 0, 0]);\n break;\n case 4:\n await encoder.insertchunk(["tEXt", buildChunk("tEXt", import_buffer3.Buffer.concat([CUM7, import_buffer3.Buffer.from(bs58.encode(passed))])), 0, 0]);\n break;\n }\n magic = true;\n }\n await encoder.insertchunk([name, chunk, crc, offset]);\n }\n await encoder.insertchunk([\n "IEND",\n buildChunk("IEND", import_buffer3.Buffer.from([])),\n 0,\n 0\n ]);\n return extract6();\n }\n let pdec = new PNGDecoder(container.stream().getReader());\n const concat = [];\n for await (const chk of pdec.chunks())\n if (chk[0] == "IDAT")\n concat.push(chk[1].slice(4));\n const comp = import_buffer3.Buffer.concat(concat);\n const head = comp.slice(0, 2);\n const chksum = comp.slice(-4);\n const idatblk = embedInRawDeflate(comp.slice(2, -4), injb);\n const [writestream, extract5] = BufferWriteStream();\n const penc = new PNGEncoder(writestream);\n pdec = new PNGDecoder(container.stream().getReader());\n let ins = false;\n for await (const chk of pdec.chunks()) {\n if (chk[0] != "IDAT") {\n await penc.insertchunk(chk);\n } else {\n if (!ins) {\n await penc.insertchunk(["IDAT", import_buffer3.Buffer.concat([import_buffer3.Buffer.from("IDAT"), head, idatblk, chksum]), 0, 0]);\n ins = true;\n }\n }\n }\n await penc.dtor();\n console.log("Finished writing");\n return extract5();\n};\nvar inject = async (container, links) => {\n links = links.map((link) => {\n for (const h of filehosts) {\n if (link.includes(h.serving)) {\n const end = link.split("/").slice(-1)[0];\n return `${prefs[h.serving]}${end}`;\n }\n }\n return "";\n });\n const injb = import_buffer3.Buffer.from(links.join(" "));\n return inject_data(container, injb);\n};\nvar has_embed = async (png) => {\n const r = await extract(png, false);\n return !!r;\n};\nvar pngv3_default = {\n extract,\n has_embed,\n inject,\n match: (fn) => !!fn.match(/\\.png$/)\n};\n\n// src/jpg.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar import_buffer4 = __toESM(require_buffer(), 1);\n\n// src/f5stego.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nfunction* f5get() {\n let extrBit = 0;\n let k = 0;\n for (let i = 0; i < 4; ++i) {\n const b2 = yield;\n k |= b2 << i;\n }\n k = (k & 15) + 1;\n let toread = 8;\n let len = 0;\n while (toread--) {\n const b2 = yield;\n len = len * 2 + b2;\n }\n const b = yield;\n toread += 8;\n if (b)\n toread += 7;\n else\n len *= 2;\n while (toread--) {\n const b2 = yield;\n len = len * 2 + b2;\n }\n const rlen = revbyte(len, b ? 23 : 16);\n len = rlen;\n if (len > 256)\n throw new Error("Too big for Smash");\n len *= 8;\n const chunks = [];\n const bw = new BitstreamWriter({\n write(chunk) {\n chunks.push(chunk);\n }\n });\n while (len) {\n extrBit = yield;\n bw.write(1, extrBit);\n len--;\n }\n bw.end();\n return Buffer2.concat(chunks).slice(0, rlen);\n}\nvar bitcode = new Array(65535);\nvar category = new Array(65535);\nvar std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];\nvar std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];\nvar std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125];\nvar std_ac_luminance_values = [\n 1,\n 2,\n 3,\n 0,\n 4,\n 17,\n 5,\n 18,\n 33,\n 49,\n 65,\n 6,\n 19,\n 81,\n 97,\n 7,\n 34,\n 113,\n 20,\n 50,\n 129,\n 145,\n 161,\n 8,\n 35,\n 66,\n 177,\n 193,\n 21,\n 82,\n 209,\n 240,\n 36,\n 51,\n 98,\n 114,\n 130,\n 9,\n 10,\n 22,\n 23,\n 24,\n 25,\n 26,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 83,\n 84,\n 85,\n 86,\n 87,\n 88,\n 89,\n 90,\n 99,\n 100,\n 101,\n 102,\n 103,\n 104,\n 105,\n 106,\n 115,\n 116,\n 117,\n 118,\n 119,\n 120,\n 121,\n 122,\n 131,\n 132,\n 133,\n 134,\n 135,\n 136,\n 137,\n 138,\n 146,\n 147,\n 148,\n 149,\n 150,\n 151,\n 152,\n 153,\n 154,\n 162,\n 163,\n 164,\n 165,\n 166,\n 167,\n 168,\n 169,\n 170,\n 178,\n 179,\n 180,\n 181,\n 182,\n 183,\n 184,\n 185,\n 186,\n 194,\n 195,\n 196,\n 197,\n 198,\n 199,\n 200,\n 201,\n 202,\n 210,\n 211,\n 212,\n 213,\n 214,\n 215,\n 216,\n 217,\n 218,\n 225,\n 226,\n 227,\n 228,\n 229,\n 230,\n 231,\n 232,\n 233,\n 234,\n 241,\n 242,\n 243,\n 244,\n 245,\n 246,\n 247,\n 248,\n 249,\n 250\n];\nvar std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];\nvar std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];\nvar std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119];\nvar std_ac_chrominance_values = [\n 0,\n 1,\n 2,\n 3,\n 17,\n 4,\n 5,\n 33,\n 49,\n 6,\n 18,\n 65,\n 81,\n 7,\n 97,\n 113,\n 19,\n 34,\n 50,\n 129,\n 8,\n 20,\n 66,\n 145,\n 161,\n 177,\n 193,\n 9,\n 35,\n 51,\n 82,\n 240,\n 21,\n 98,\n 114,\n 209,\n 10,\n 22,\n 36,\n 52,\n 225,\n 37,\n 241,\n 23,\n 24,\n 25,\n 26,\n 38,\n 39,\n 40,\n 41,\n 42,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 83,\n 84,\n 85,\n 86,\n 87,\n 88,\n 89,\n 90,\n 99,\n 100,\n 101,\n 102,\n 103,\n 104,\n 105,\n 106,\n 115,\n 116,\n 117,\n 118,\n 119,\n 120,\n 121,\n 122,\n 130,\n 131,\n 132,\n 133,\n 134,\n 135,\n 136,\n 137,\n 138,\n 146,\n 147,\n 148,\n 149,\n 150,\n 151,\n 152,\n 153,\n 154,\n 162,\n 163,\n 164,\n 165,\n 166,\n 167,\n 168,\n 169,\n 170,\n 178,\n 179,\n 180,\n 181,\n 182,\n 183,\n 184,\n 185,\n 186,\n 194,\n 195,\n 196,\n 197,\n 198,\n 199,\n 200,\n 201,\n 202,\n 210,\n 211,\n 212,\n 213,\n 214,\n 215,\n 216,\n 217,\n 218,\n 226,\n 227,\n 228,\n 229,\n 230,\n 231,\n 232,\n 233,\n 234,\n 242,\n 243,\n 244,\n 245,\n 246,\n 247,\n 248,\n 249,\n 250\n];\nfunction _initCategoryNumber() {\n let nrlower = 1;\n let nrupper = 2;\n for (let cat = 1; cat <= 15; cat++) {\n for (let nr = nrlower; nr < nrupper; nr++) {\n category[32767 + nr] = cat;\n bitcode[32767 + nr] = [];\n bitcode[32767 + nr][1] = cat;\n bitcode[32767 + nr][0] = nr;\n }\n for (let nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {\n category[32767 + nrneg] = cat;\n bitcode[32767 + nrneg] = [];\n bitcode[32767 + nrneg][1] = cat;\n bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg;\n }\n nrlower <<= 1;\n nrupper <<= 1;\n }\n}\n_initCategoryNumber();\nfunction _computeHuffmanTbl(nrcodes, std_table) {\n let codevalue = 0;\n let pos_in_table = 0;\n const HT = [];\n for (let k = 1; k <= 16; k++) {\n for (let j = 1; j <= nrcodes[k]; j++) {\n HT[std_table[pos_in_table]] = [];\n HT[std_table[pos_in_table]][0] = codevalue;\n HT[std_table[pos_in_table]][1] = k;\n pos_in_table++;\n codevalue++;\n }\n codevalue *= 2;\n }\n return HT;\n}\nvar YDC_HT = _computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values);\nvar UVDC_HT = _computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values);\nvar YAC_HT = _computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values);\nvar UVAC_HT = _computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values);\nvar __raw, _jfif, _APPn, _qts, _frame, _tail, __f5write, _f5write_fn;\nvar f5stego = class {\n constructor(key2, maxPixels = 4096 * 4096) {\n this.maxPixels = maxPixels;\n __privateAdd(this, __f5write);\n __privateAdd(this, __raw, void 0);\n __privateAdd(this, _jfif, void 0);\n __privateAdd(this, _APPn, void 0);\n __privateAdd(this, _qts, void 0);\n __privateAdd(this, _frame, null);\n __privateAdd(this, _tail, null);\n __publicField(this, "gengen");\n }\n embed(image, data, k) {\n this.parse(image);\n this.f5put(data, k);\n return this.pack();\n }\n extract(image) {\n try {\n this.gengen = f5get();\n this.gengen.next();\n this.parse(image, true);\n return this.f5get();\n } catch (e) {\n if (e instanceof Buffer2)\n return e;\n throw e;\n }\n }\n f5put(data, k) {\n if (!__privateGet(this, _frame))\n throw "Parser not run";\n let t, i, comp = __privateGet(this, _frame).components[0];\n if (data.length > 8388607)\n throw "Data too big. Max 8388607 bytes allowed.";\n if (data.length < 32768) {\n t = new Uint8Array(2 + data.length);\n t[0] = data.length & 255;\n t[1] = data.length >>> 8;\n t.set(data, 2);\n } else {\n t = new Uint8Array(3 + data.length);\n t[0] = data.length & 255;\n t[1] = (data.length >>> 8 & 127) + 128;\n t[2] = data.length >>> 15;\n t.set(data, 3);\n }\n if (comp.componentId != 1) {\n for (i = 0; i < __privateGet(this, _frame).components.length; i++) {\n if (__privateGet(this, _frame).components[i].componentId == 1) {\n comp = __privateGet(this, _frame).components[i];\n break;\n }\n }\n }\n if (!("blocks" in comp)) {\n throw "Blocks failed to be parsed";\n }\n return __privateMethod(this, __f5write, _f5write_fn).call(this, comp.blocks, t, k);\n }\n f5get() {\n if (!__privateGet(this, _frame))\n throw "Parser not run";\n let comp = __privateGet(this, _frame).components[0];\n if (comp.componentId != 1) {\n for (let i = 0; i < __privateGet(this, _frame).components.length; i++) {\n if (__privateGet(this, _frame).components[i].componentId == 1) {\n comp = __privateGet(this, _frame).components[i];\n break;\n }\n }\n }\n if (!("blocks" in comp)) {\n throw "Blocks failed to be parsed";\n }\n const coeff = new Int16Array(comp.blocks.length);\n coeff.set(comp.blocks);\n let pos = -1, extrBit = 0, cCount = coeff.length - 1;\n let n, k = 0;\n let out = new Uint8Array(coeff.length / 8 | 0), extrByte = 0, outPos = 0, bitsAvail = 0, code = 0, hash = 0;\n while (bitsAvail < 4) {\n pos++;\n if (coeff[pos] === 0) {\n continue;\n }\n extrBit = coeff[pos] & 1;\n if (coeff[pos] < 0) {\n extrBit = 1 - extrBit;\n }\n k |= extrBit << bitsAvail;\n bitsAvail++;\n }\n k = (k & 15) + 1;\n n = (1 << k) - 1;\n bitsAvail = 0;\n if (k == 1) {\n while (pos < cCount) {\n pos++;\n if (coeff[pos] === 0) {\n continue;\n }\n extrBit = coeff[pos] & 1;\n if (coeff[pos] < 0) {\n extrBit = 1 - extrBit;\n }\n extrByte |= extrBit << bitsAvail;\n bitsAvail++;\n if (bitsAvail == 8) {\n out[outPos++] = extrByte;\n extrByte = 0;\n bitsAvail = 0;\n }\n }\n } else {\n while (pos < cCount) {\n pos++;\n if (coeff[pos] === 0) {\n continue;\n }\n extrBit = coeff[pos] & 1;\n if (coeff[pos] < 0) {\n extrBit = 1 - extrBit;\n }\n hash ^= extrBit * ++code;\n if (code == n) {\n extrByte |= hash << bitsAvail;\n bitsAvail += k;\n code = 0;\n hash = 0;\n while (bitsAvail >= 8) {\n out[outPos++] = extrByte & 255;\n bitsAvail -= 8;\n extrByte = extrByte >> 8;\n }\n }\n }\n }\n while (bitsAvail > 0) {\n out[outPos++] = extrByte & 255;\n bitsAvail -= 8;\n extrByte = extrByte >> 8;\n }\n let s = 2, l = out[0];\n if (out[1] & 128) {\n s++;\n l += ((out[1] & 127) << 8) + (out[2] << 15);\n } else {\n l += out[1] << 8;\n }\n return out.subarray(s, s + l);\n }\n parse(data, tolerant = false) {\n let offset = 0;\n function _buildHuffmanTable(nrcodes, values) {\n let codevalue = 0, pos_in_table = 0, HT = new Uint16Array(65536);\n for (let k = 0; k < 16; k++) {\n for (let j2 = 0; j2 < nrcodes[k]; j2++) {\n for (let i2 = codevalue << 15 - k, cntTo = codevalue + 1 << 15 - k; i2 < cntTo; i2++) {\n HT[i2] = values[pos_in_table] + (k + 1 << 8);\n }\n pos_in_table++;\n codevalue++;\n }\n codevalue *= 2;\n }\n return HT;\n }\n const decodeScan = (data2, offset2, frame, components, resetInterval2, spectralStart, spectralEnd, successivePrev, successive) => {\n let startOffset = offset2, bitsData = 0, bitsCount = 0, eobrun = 0, p1 = 1 << successive, m1 = -1 << successive;\n const prevpos = 0;\n const decodeBaseline = (component2, pos) => {\n while (bitsCount < 16) {\n bitsData = (bitsData << 8) + (data2[offset2] | 0);\n bitsCount += 8;\n if (data2[offset2] == 255)\n offset2++;\n offset2++;\n }\n let t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535];\n if (!t)\n throw "invalid huffman sequence";\n bitsCount -= t >>> 8;\n t &= 255;\n let diff = 0;\n if (t !== 0) {\n while (bitsCount < t) {\n bitsData = (bitsData << 8) + data2[offset2++];\n if ((bitsData & 255) == 255)\n offset2++;\n bitsCount += 8;\n }\n diff = bitsData >>> bitsCount - t & (1 << t) - 1;\n bitsCount -= t;\n if (diff < 1 << t - 1)\n diff += (-1 << t) + 1;\n }\n component2.blocksDC[pos >> 6] = component2.pred += diff;\n let k2 = 1, s, r;\n while (k2 < 64) {\n while (bitsCount < 16) {\n bitsData = (bitsData << 8) + (data2[offset2] | 0);\n bitsCount += 8;\n if (data2[offset2] == 255)\n offset2++;\n offset2++;\n }\n s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535];\n if (!s)\n throw "invalid huffman sequence";\n bitsCount -= s >>> 8;\n r = s >> 4 & 15;\n s &= 15;\n if (s === 0) {\n if (r < 15) {\n break;\n }\n k2 += 16;\n continue;\n }\n k2 += r;\n while (bitsCount < s) {\n bitsData = (bitsData << 8) + data2[offset2++];\n if ((bitsData & 255) == 255)\n offset2++;\n bitsCount += 8;\n }\n component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1;\n if (component2.blocks[pos + k2] < 1 << s - 1)\n component2.blocks[pos + k2] += (-1 << s) + 1;\n bitsCount -= s;\n k2++;\n }\n };\n function decodeDCFirst(component2, pos) {\n let diff = 0;\n while (bitsCount < 16) {\n bitsData = (bitsData << 8) + (data2[offset2] | 0);\n bitsCount += 8;\n if (data2[offset2] == 255)\n offset2++;\n offset2++;\n }\n let t = component2.huffmanTableDC[bitsData >>> bitsCount - 16 & 65535];\n if (!t)\n throw "invalid huffman sequence";\n bitsCount -= t >>> 8;\n t &= 255;\n if (t !== 0) {\n while (bitsCount < t) {\n bitsData = (bitsData << 8) + data2[offset2++];\n if ((bitsData & 255) == 255)\n offset2++;\n bitsCount += 8;\n }\n diff = bitsData >>> bitsCount - t & (1 << t) - 1;\n bitsCount -= t;\n if (diff < 1 << t - 1)\n diff += (-1 << t) + 1;\n }\n component2.blocksDC[pos >> 6] = component2.pred += diff << successive;\n }\n function decodeDCSuccessive(component2, pos) {\n if (!bitsCount) {\n bitsData = data2[offset2++];\n if (bitsData == 255)\n offset2++;\n bitsCount = 8;\n }\n component2.blocksDC[pos >> 6] |= (bitsData >>> --bitsCount & 1) << successive;\n }\n if (!frame)\n throw "Frame not parsed yet";\n function decodeACFirst(component2, pos) {\n if (eobrun > 0) {\n eobrun--;\n return;\n }\n let k2 = spectralStart, s, r;\n while (k2 <= spectralEnd) {\n while (bitsCount < 16) {\n bitsData = (bitsData << 8) + (data2[offset2] | 0);\n bitsCount += 8;\n if (data2[offset2] == 255)\n offset2++;\n offset2++;\n }\n s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535];\n if (!s)\n throw "invalid huffman sequence";\n bitsCount -= s >>> 8;\n r = s >> 4 & 15;\n s &= 15;\n if (s === 0) {\n if (r != 15) {\n eobrun = (1 << r) - 1;\n if (r) {\n while (bitsCount < r) {\n bitsData = (bitsData << 8) + data2[offset2++];\n if ((bitsData & 255) == 255)\n offset2++;\n bitsCount += 8;\n }\n eobrun += bitsData >>> bitsCount - r & (1 << r) - 1;\n bitsCount -= r;\n }\n break;\n }\n k2 += 16;\n continue;\n }\n k2 += r;\n while (bitsCount < s) {\n bitsData = (bitsData << 8) + data2[offset2++];\n if ((bitsData & 255) == 255)\n offset2++;\n bitsCount += 8;\n }\n component2.blocks[pos + k2] = bitsData >>> bitsCount - s & (1 << s) - 1;\n bitsCount -= s;\n if (component2.blocks[pos + k2] < 1 << s - 1)\n component2.blocks[pos + k2] += (-1 << s) + 1;\n component2.blocks[pos + k2] *= p1;\n k2++;\n }\n }\n function decodeACSuccessive(component2, pos) {\n let k2 = spectralStart, r, s;\n if (frame == null)\n throw "Frame not defined";\n if (!eobrun) {\n while (k2 <= spectralEnd) {\n while (bitsCount < 16) {\n bitsData = (bitsData << 8) + (data2[offset2] | 0);\n bitsCount += 8;\n if (data2[offset2] == 255)\n offset2++;\n offset2++;\n }\n s = component2.huffmanTableAC[bitsData >>> bitsCount - 16 & 65535];\n if (!s)\n throw "invalid huffman sequence";\n bitsCount -= s >>> 8;\n r = s >> 4 & 15;\n s &= 15;\n if (s) {\n if (s != 1)\n throw "bad jpeg";\n if (!bitsCount) {\n bitsData = data2[offset2++];\n if (bitsData == 255)\n offset2++;\n bitsCount = 8;\n }\n s = bitsData >>> --bitsCount & 1 ? p1 : m1;\n } else {\n if (r != 15) {\n eobrun = 1 << r;\n if (r) {\n while (bitsCount < r) {\n bitsData = (bitsData << 8) + data2[offset2++];\n if ((bitsData & 255) == 255)\n offset2++;\n bitsCount += 8;\n }\n eobrun += bitsData >>> bitsCount - r & (1 << r) - 1;\n bitsCount -= r;\n }\n break;\n }\n }\n while (k2 <= spectralEnd) {\n if (component2.blocks[pos + k2]) {\n if (!bitsCount) {\n bitsData = data2[offset2++];\n if (bitsData == 255)\n offset2++;\n bitsCount = 8;\n }\n component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1);\n } else {\n if (--r < 0)\n break;\n }\n k2++;\n }\n if (s)\n component2.blocks[pos + k2] = s;\n k2++;\n }\n }\n if (eobrun) {\n while (k2 <= spectralEnd) {\n if (component2.blocks[pos + k2]) {\n if (!bitsCount) {\n bitsData = data2[offset2++];\n if (bitsData == 255)\n offset2++;\n bitsCount = 8;\n }\n component2.blocks[pos + k2] += (bitsData >>> --bitsCount & 1) * (component2.blocks[pos + k2] >= 0 ? p1 : m1);\n }\n k2++;\n }\n eobrun--;\n }\n }\n let decodeFn;\n if (frame.progressive) {\n if (spectralStart === 0)\n decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;\n else\n decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;\n } else {\n decodeFn = decodeBaseline;\n }\n let marker, mcuExpected, i2, j2, k, n, mcusPerLine, mcusPerRow, x, y;\n let lastflushidx = 0;\n const flushBits = () => {\n if (!this.gengen)\n return;\n const component2 = components.find((e) => e.componentId == 1);\n while (component2.blocks[lastflushidx + 1] !== void 0) {\n const blk = component2.blocks[lastflushidx];\n if (blk != 0) {\n const v = blk < 0 ? 1 - (blk & 1) : blk & 1;\n const it = this.gengen.next(v);\n if (it.done) {\n throw it.value;\n }\n }\n lastflushidx++;\n }\n };\n if (components.length == 1) {\n mcusPerLine = components[0].blocksPerLine;\n mcusPerRow = components[0].blocksPerColumn;\n mcuExpected = mcusPerRow * mcusPerLine;\n if (!resetInterval2)\n resetInterval2 = mcuExpected;\n n = resetInterval2;\n components[0].pred = 0;\n eobrun = 0;\n for (y = 0; y < mcusPerRow; y++) {\n for (x = 0; x < mcusPerLine; x++) {\n if (!n) {\n n = resetInterval2;\n components[0].pred = 0;\n eobrun = 0;\n offset2 -= bitsCount / 8 | 0;\n if (data2[offset2 - 1] == 255)\n offset2--;\n bitsCount = 0;\n marker = data2[offset2] << 8 | data2[offset2 + 1];\n if (marker >= 65488 && marker <= 65495) {\n offset2 += 2;\n } else {\n if (marker <= 65280) {\n throw "bad jpeg";\n }\n break;\n }\n }\n n--;\n for (i2 = 0; i2 < components.length; i2++) {\n decodeFn(components[i2], (y * components[i2].blocksPerLineForMcu + x) * 64);\n }\n }\n flushBits();\n }\n } else {\n mcusPerLine = frame.mcusPerLine;\n mcusPerRow = frame.mcusPerColumn;\n mcuExpected = mcusPerRow * mcusPerLine;\n if (!resetInterval2)\n resetInterval2 = mcuExpected;\n n = resetInterval2;\n for (i2 = 0; i2 < components.length; i2++)\n components[i2].pred = 0;\n eobrun = 0;\n for (y = 0; y < mcusPerRow; y++) {\n for (x = 0; x < mcusPerLine; x++) {\n if (!n) {\n n = resetInterval2;\n for (i2 = 0; i2 < components.length; i2++)\n components[i2].pred = 0;\n eobrun = 0;\n offset2 -= bitsCount / 8 | 0;\n if (data2[offset2 - 1] == 255)\n offset2--;\n bitsCount = 0;\n marker = data2[offset2] << 8 | data2[offset2 + 1];\n if (marker >= 65488 && marker <= 65495) {\n offset2 += 2;\n } else {\n if (marker <= 65280) {\n throw "bad jpeg";\n }\n break;\n }\n }\n n--;\n for (i2 = 0; i2 < components.length; i2++) {\n for (j2 = 0; j2 < components[i2].v; j2++) {\n for (k = 0; k < components[i2].h; k++) {\n decodeFn(components[i2], ((y * components[i2].v + j2) * components[i2].blocksPerLineForMcu + x * components[i2].h + k) * 64);\n }\n }\n }\n }\n flushBits();\n }\n }\n offset2 -= bitsCount / 8 | 0;\n if (data2[offset2 - 1] == 255)\n offset2--;\n return offset2 - startOffset;\n };\n function readUint16() {\n const value = data[offset] << 8 | data[offset + 1];\n offset += 2;\n return value;\n }\n function readDataBlock() {\n const length = readUint16();\n const array = data.subarray(offset, offset + length - 2);\n offset += array.length;\n return array;\n }\n __privateSet(this, __raw, data);\n __privateSet(this, _jfif, null);\n __privateSet(this, _APPn, []);\n __privateSet(this, _qts, []);\n __privateSet(this, _frame, null);\n __privateSet(this, _tail, null);\n let markerHi, markerLo, i, j, resetInterval, component;\n const huffmanTablesAC = [];\n const huffmanTablesDC = [];\n while (1) {\n if (offset >= data.length) {\n if (tolerant)\n break;\n throw "unexpected EOF";\n }\n markerHi = data[offset++];\n markerLo = data[offset++];\n if (markerHi == 255) {\n if (markerLo == 224) {\n __privateSet(this, _jfif, readDataBlock());\n }\n if (markerLo > 224 && markerLo < 240 || markerLo == 254) {\n __privateGet(this, _APPn).push({\n "app": markerLo,\n "data": readDataBlock()\n });\n }\n if (markerLo == 219) {\n __privateGet(this, _qts).push(readDataBlock());\n }\n if (markerLo >= 192 && markerLo <= 194) {\n if (__privateGet(this, _frame))\n throw "Only single frame JPEGs supported";\n readUint16();\n __privateSet(this, _frame, {\n "extended": markerLo === 193,\n "progressive": markerLo === 194,\n "precision": data[offset++],\n "scanLines": readUint16(),\n "samplesPerLine": readUint16(),\n "components": [],\n "componentIds": {},\n "maxH": 1,\n "maxV": 1\n });\n if (__privateGet(this, _frame).scanLines * __privateGet(this, _frame).samplesPerLine > this.maxPixels)\n throw "Image is too big.";\n var componentsCount = data[offset++], componentId;\n let maxH = 0, maxV = 0;\n for (i = 0; i < componentsCount; i++) {\n componentId = data[offset];\n const h = data[offset + 1] >> 4;\n const v = data[offset + 1] & 15;\n if (maxH < h)\n maxH = h;\n if (maxV < v)\n maxV = v;\n const qId = data[offset + 2];\n const l = __privateGet(this, _frame).components.push({\n componentId,\n h,\n v,\n quantizationTable: qId\n });\n __privateGet(this, _frame).componentIds[componentId] = l - 1;\n offset += 3;\n }\n __privateGet(this, _frame).maxH = maxH;\n __privateGet(this, _frame).maxV = maxV;\n const mcusPerLine = Math.ceil(__privateGet(this, _frame).samplesPerLine / 8 / maxH);\n const mcusPerColumn = Math.ceil(__privateGet(this, _frame).scanLines / 8 / maxV);\n for (i = 0; i < __privateGet(this, _frame).components.length; i++) {\n component = __privateGet(this, _frame).components[i];\n const blocksPerLine = Math.ceil(Math.ceil(__privateGet(this, _frame).samplesPerLine / 8) * component.h / maxH);\n const blocksPerColumn = Math.ceil(Math.ceil(__privateGet(this, _frame).scanLines / 8) * component.v / maxV);\n const blocksPerLineForMcu = mcusPerLine * component.h;\n const blocksPerColumnForMcu = mcusPerColumn * component.v;\n __privateGet(this, _frame).components[i] = {\n ...component,\n blocks: new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu * 64),\n blocksDC: new Int16Array(blocksPerColumnForMcu * blocksPerLineForMcu),\n blocksPerLine,\n blocksPerColumn,\n blocksPerLineForMcu,\n blocksPerColumnForMcu\n };\n }\n __privateGet(this, _frame).mcusPerLine = mcusPerLine;\n __privateGet(this, _frame).mcusPerColumn = mcusPerColumn;\n }\n if (markerLo == 196) {\n const huffmanLength = readUint16();\n for (i = 2; i < huffmanLength; ) {\n const huffmanTableSpec = data[offset++];\n const codeLengths = new Uint8Array(16);\n let codeLengthSum = 0;\n for (j = 0; j < 16; j++, offset++)\n codeLengthSum += codeLengths[j] = data[offset];\n const huffmanValues = new Uint8Array(codeLengthSum);\n for (j = 0; j < codeLengthSum; j++, offset++)\n huffmanValues[j] = data[offset];\n i += 17 + codeLengthSum;\n const v = _buildHuffmanTable(codeLengths, huffmanValues);\n if (huffmanTableSpec >> 4 === 0)\n huffmanTablesDC[huffmanTableSpec & 15] = v;\n else\n huffmanTablesAC[huffmanTableSpec & 15] = v;\n }\n }\n if (markerLo == 221) {\n resetInterval = readUint16();\n }\n if (markerLo == 218) {\n if (__privateGet(this, _frame) == null)\n throw "SOS before SOF";\n readUint16();\n const selectorsCount = data[offset++];\n const components = [];\n for (i = 0; i < selectorsCount; i++) {\n const componentIndex = __privateGet(this, _frame).componentIds[data[offset++]];\n component = __privateGet(this, _frame).components[componentIndex];\n const tableSpec = data[offset++];\n component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];\n component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];\n components.push(component);\n }\n const spectralStart = data[offset++];\n const spectralEnd = data[offset++];\n const successiveApproximation = data[offset++];\n const processed = decodeScan(\n data,\n offset,\n __privateGet(this, _frame),\n components,\n resetInterval,\n spectralStart,\n spectralEnd,\n successiveApproximation >> 4,\n successiveApproximation & 15\n );\n offset += processed;\n }\n if (markerLo == 217) {\n break;\n }\n } else {\n if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) {\n offset -= 3;\n }\n while (data[offset] != 255 && offset < data.length) {\n offset++;\n }\n if (data[offset] != 255) {\n throw "bad jpeg ";\n }\n }\n }\n if (!__privateGet(this, _frame))\n throw "bad jpeg";\n if (offset < data.length)\n __privateSet(this, _tail, data.subarray(offset));\n return this;\n }\n pack() {\n let byteout;\n let bytenew;\n let bytepos;\n let poslast;\n let outpos;\n let byte;\n function writeByte(value) {\n let t;\n byteout[outpos++] = value;\n if (outpos > poslast) {\n t = new Uint8Array(byteout.length * 2);\n t.set(byteout);\n byteout = t;\n poslast = t.length - 128;\n }\n }\n function writeWord(value) {\n writeByte(value >> 8 & 255);\n writeByte(value & 255);\n }\n function writeBlock(block) {\n let t;\n if (outpos + block.length > poslast) {\n t = new Uint8Array(byteout.length * 2 + block.length);\n t.set(byteout);\n byteout = t;\n poslast = t.length - 128;\n }\n byteout.set(block, outpos);\n outpos += block.length;\n }\n function writeAPP0(self2) {\n writeWord(65504);\n if (!__privateGet(self2, _jfif)) {\n writeWord(16);\n writeByte(74);\n writeByte(70);\n writeByte(73);\n writeByte(70);\n writeByte(0);\n writeByte(1);\n writeByte(1);\n writeByte(0);\n writeWord(1);\n writeWord(1);\n writeByte(0);\n writeByte(0);\n } else {\n writeWord(__privateGet(self2, _jfif).length + 2);\n writeBlock(__privateGet(self2, _jfif));\n }\n }\n function writeDQT(self2) {\n for (let i2 = 0; i2 < __privateGet(self2, _qts).length; i2++) {\n writeWord(65499);\n writeWord(__privateGet(self2, _qts)[i2].length + 2);\n writeBlock(__privateGet(self2, _qts)[i2]);\n }\n }\n function writeAPPn(self2) {\n for (let i2 = 0; i2 < __privateGet(self2, _APPn).length; i2++) {\n writeWord(65280 | __privateGet(self2, _APPn)[i2].app);\n writeWord(__privateGet(self2, _APPn)[i2].data.length + 2);\n writeBlock(__privateGet(self2, _APPn)[i2].data);\n }\n }\n function writeSOF0(self2) {\n if (!__privateGet(self2, _frame))\n throw "Frame not ready";\n writeWord(65472);\n writeWord(8 + __privateGet(self2, _frame).components.length * 3);\n writeByte(__privateGet(self2, _frame).precision);\n writeWord(__privateGet(self2, _frame).scanLines);\n writeWord(__privateGet(self2, _frame).samplesPerLine);\n writeByte(__privateGet(self2, _frame).components.length);\n for (let i2 = 0; i2 < __privateGet(self2, _frame).components.length; i2++) {\n const c2 = __privateGet(self2, _frame).components[i2];\n writeByte(c2.componentId);\n writeByte(c2.h << 4 | c2.v);\n writeByte(c2.quantizationTable);\n }\n }\n function writeDHT(self2) {\n if (!__privateGet(self2, _frame))\n throw "Frame not ready";\n writeWord(65476);\n writeWord(31);\n writeByte(0);\n for (let i2 = 0; i2 < 16; i2++) {\n writeByte(std_dc_luminance_nrcodes[i2 + 1]);\n }\n for (let j = 0; j <= 11; j++) {\n writeByte(std_dc_luminance_values[j]);\n }\n writeWord(65476);\n writeWord(181);\n writeByte(16);\n for (let k = 0; k < 16; k++) {\n writeByte(std_ac_luminance_nrcodes[k + 1]);\n }\n for (let l = 0; l <= 161; l++) {\n writeByte(std_ac_luminance_values[l]);\n }\n if (__privateGet(self2, _frame).components.length != 1) {\n writeWord(65476);\n writeWord(31);\n writeByte(1);\n for (let m = 0; m < 16; m++) {\n writeByte(std_dc_chrominance_nrcodes[m + 1]);\n }\n for (let n = 0; n <= 11; n++) {\n writeByte(std_dc_chrominance_values[n]);\n }\n writeWord(65476);\n writeWord(181);\n writeByte(17);\n for (let o = 0; o < 16; o++) {\n writeByte(std_ac_chrominance_nrcodes[o + 1]);\n }\n for (let p = 0; p <= 161; p++) {\n writeByte(std_ac_chrominance_values[p]);\n }\n }\n }\n function writeSOS(self2) {\n if (!__privateGet(self2, _frame))\n throw "Frame not ready";\n writeWord(65498);\n writeWord(6 + __privateGet(self2, _frame).components.length * 2);\n writeByte(__privateGet(self2, _frame).components.length);\n for (let i2 = 0; i2 < __privateGet(self2, _frame).components.length; i2++) {\n const c2 = __privateGet(self2, _frame).components[i2];\n writeByte(c2.componentId);\n if (i2 === 0) {\n writeByte(0);\n } else {\n writeByte(17);\n }\n }\n writeByte(0);\n writeByte(63);\n writeByte(0);\n }\n function processDU(comp, POS, DC, HTDC, HTAC) {\n let pos, posval, t;\n if (bytepos === 0)\n bytenew = 0;\n if (!("blocks" in comp))\n throw "Blocks not parsed";\n const Diff = comp.blocksDC[POS >> 6] - DC;\n DC = comp.blocksDC[POS >> 6];\n if (Diff === 0) {\n posval = HTDC[0][1];\n bytenew <<= posval;\n bytenew += HTDC[0][0];\n bytepos += posval;\n while (bytepos > 7) {\n byte = 255 & bytenew >>> bytepos - 8;\n byteout[outpos++] = byte;\n if (byte == 255) {\n outpos++;\n }\n bytepos -= 8;\n bytenew &= (1 << bytepos) - 1;\n }\n } else {\n pos = 32767 + Diff;\n posval = HTDC[category[pos]][1];\n bytenew <<= posval;\n bytenew += HTDC[category[pos]][0];\n bytepos += posval;\n posval = bitcode[pos][1];\n bytenew <<= posval;\n bytenew += bitcode[pos][0];\n bytepos += posval;\n while (bytepos > 7) {\n byte = 255 & bytenew >>> bytepos - 8;\n byteout[outpos++] = byte;\n if (byte == 255) {\n outpos++;\n }\n bytepos -= 8;\n bytenew &= (1 << bytepos) - 1;\n }\n }\n let end0pos = 63;\n for (; end0pos > 0 && comp.blocks[POS + end0pos] === 0; end0pos--) {\n }\n if (end0pos === 0) {\n posval = HTAC[0][1];\n bytenew <<= posval;\n bytenew += HTAC[0][0];\n bytepos += posval;\n while (bytepos > 7) {\n byte = 255 & bytenew >>> bytepos - 8;\n byteout[outpos++] = byte;\n if (byte == 255) {\n outpos++;\n }\n bytepos -= 8;\n bytenew &= (1 << bytepos) - 1;\n }\n return DC;\n }\n let i2 = 1;\n let lng;\n while (i2 <= end0pos) {\n const startpos = i2;\n for (; comp.blocks[POS + i2] === 0 && i2 <= end0pos; ++i2) {\n }\n let nrzeroes = i2 - startpos;\n if (nrzeroes >= 16) {\n lng = nrzeroes >> 4;\n for (let nrmarker = 1; nrmarker <= lng; ++nrmarker) {\n posval = HTAC[240][1];\n bytenew <<= posval;\n bytenew += HTAC[240][0];\n bytepos += posval;\n while (bytepos > 7) {\n byte = 255 & bytenew >>> bytepos - 8;\n byteout[outpos++] = byte;\n if (byte == 255) {\n outpos++;\n }\n bytepos -= 8;\n bytenew &= (1 << bytepos) - 1;\n }\n }\n nrzeroes = nrzeroes & 15;\n }\n pos = 32767 + comp.blocks[POS + i2];\n posval = HTAC[(nrzeroes << 4) + category[pos]][1];\n bytenew <<= posval;\n bytenew += HTAC[(nrzeroes << 4) + category[pos]][0];\n bytepos += posval;\n while (bytepos > 7) {\n byte = 255 & bytenew >>> bytepos - 8;\n byteout[outpos++] = byte;\n if (byte == 255) {\n outpos++;\n }\n bytepos -= 8;\n bytenew &= (1 << bytepos) - 1;\n }\n posval = bitcode[pos][1];\n bytenew <<= posval;\n bytenew += bitcode[pos][0];\n bytepos += posval;\n while (bytepos > 7) {\n byte = 255 & bytenew >>> bytepos - 8;\n byteout[outpos++] = byte;\n if (byte == 255) {\n outpos++;\n }\n bytepos -= 8;\n bytenew &= (1 << bytepos) - 1;\n }\n i2++;\n }\n if (end0pos != 63) {\n posval = HTAC[0][1];\n bytenew <<= posval;\n bytenew += HTAC[0][0];\n bytepos += posval;\n while (bytepos > 7) {\n byte = 255 & bytenew >>> bytepos - 8;\n byteout[outpos++] = byte;\n if (byte == 255) {\n outpos++;\n }\n bytepos -= 8;\n bytenew &= (1 << bytepos) - 1;\n }\n }\n if (outpos > poslast) {\n t = new Uint8Array(byteout.length * 2);\n t.set(byteout);\n byteout = t;\n poslast = t.length - 128;\n }\n return DC;\n }\n byteout = new Uint8Array(65536);\n poslast = 65536 - 128;\n outpos = 0;\n bytenew = 0;\n bytepos = 0;\n writeWord(65496);\n writeAPP0(this);\n writeAPPn(this);\n writeDQT(this);\n writeSOF0(this);\n writeDHT(this);\n writeSOS(this);\n bytenew = 0;\n bytepos = 0;\n if (!__privateGet(this, _frame))\n throw "Frame not ready";\n let c, mcuRow, mcuCol, blockRow, blockCol, mcu, i, v, h;\n const DCdiff = [];\n for (i = 0; i < __privateGet(this, _frame).components.length; i++) {\n DCdiff.push(0);\n }\n for (mcu = 0; mcu < __privateGet(this, _frame).mcusPerLine * __privateGet(this, _frame).mcusPerColumn; mcu++) {\n mcuRow = mcu / __privateGet(this, _frame).mcusPerLine | 0;\n mcuCol = mcu % __privateGet(this, _frame).mcusPerLine;\n for (i = 0; i < __privateGet(this, _frame).components.length; i++) {\n c = __privateGet(this, _frame).components[i];\n for (v = 0; v < c.v; v++) {\n blockRow = mcuRow * c.v + v;\n for (h = 0; h < c.h; h++) {\n blockCol = mcuCol * c.h + h;\n if (i === 0) {\n DCdiff[i] = processDU(c, (blockRow * __privateGet(this, _frame).mcusPerLine * c.h + blockCol) * 64, DCdiff[i], YDC_HT, YAC_HT);\n } else {\n DCdiff[i] = processDU(c, (blockRow * __privateGet(this, _frame).mcusPerLine * c.h + blockCol) * 64, DCdiff[i], UVDC_HT, UVAC_HT);\n }\n }\n }\n }\n }\n while (bytepos > 7) {\n byte = 255 & bytenew >>> bytepos - 8;\n byteout[outpos++] = byte;\n if (byte == 255) {\n outpos++;\n }\n bytepos -= 8;\n }\n if (bytepos > 0) {\n bytenew <<= 8 - bytepos;\n bytenew += (1 << 8 - bytepos) - 1;\n byteout[outpos++] = 255 & bytenew;\n }\n writeWord(65497);\n if (__privateGet(this, _tail))\n writeBlock(__privateGet(this, _tail));\n return byteout.slice(0, outpos);\n }\n};\n__raw = new WeakMap();\n_jfif = new WeakMap();\n_APPn = new WeakMap();\n_qts = new WeakMap();\n_frame = new WeakMap();\n_tail = new WeakMap();\n__f5write = new WeakSet();\n_f5write_fn = function(coeff, data, k) {\n const coeff_count = coeff.length;\n let _changed = 0, _embedded = 0, _examined = 0, _thrown = 0, shuffled_index = 0, i, n, ii;\n let next_bit_to_embed = 0, byte_to_embed = data.length, data_idx = 0, available_bits_to_embed = 0;\n n = (1 << k) - 1;\n byte_to_embed = k - 1;\n byte_to_embed ^= 0;\n next_bit_to_embed = byte_to_embed & 1;\n byte_to_embed >>= 1;\n available_bits_to_embed = 3;\n for (ii = 0; ii < coeff_count; ii++) {\n shuffled_index = ii;\n if (shuffled_index % 64 === 0 || coeff[shuffled_index] === 0)\n continue;\n const cc = coeff[shuffled_index];\n _examined++;\n if (cc > 0 && (cc & 1) != next_bit_to_embed) {\n coeff[shuffled_index]--;\n _changed++;\n } else if (cc < 0 && (cc & 1) == next_bit_to_embed) {\n coeff[shuffled_index]++;\n _changed++;\n }\n if (coeff[shuffled_index] !== 0) {\n _embedded++;\n if (available_bits_to_embed === 0) {\n if (k != 1 || data_idx >= data.length)\n break;\n byte_to_embed = data[data_idx++];\n byte_to_embed ^= 0;\n available_bits_to_embed = 8;\n }\n next_bit_to_embed = byte_to_embed & 1;\n byte_to_embed >>= 1;\n available_bits_to_embed--;\n } else {\n _thrown++;\n }\n }\n if (k == 1 && _embedded < data.length * 8)\n throw "capacity exceeded " + _embedded / 8 + " " + data.length;\n if (k != 1) {\n let is_last_byte = false, k_bits_to_embed = 0;\n while (!is_last_byte || available_bits_to_embed !== 0 && is_last_byte) {\n k_bits_to_embed = 0;\n for (i = 0; i < k; i++) {\n if (available_bits_to_embed === 0) {\n if (data_idx >= data.length) {\n is_last_byte = true;\n break;\n }\n byte_to_embed = data[data_idx++];\n byte_to_embed ^= 0;\n available_bits_to_embed = 8;\n }\n next_bit_to_embed = byte_to_embed & 1;\n byte_to_embed >>= 1;\n available_bits_to_embed--;\n k_bits_to_embed |= next_bit_to_embed << i;\n }\n const code_word = [];\n let ci = null;\n for (i = 0; i < n; i++) {\n while (true) {\n if (++ii >= coeff_count) {\n throw "capacity exceeded " + _embedded / 8;\n }\n ci = ii;\n if (ci % 64 !== 0 && coeff[ci] !== 0)\n break;\n }\n code_word.push(ci);\n }\n _examined += n;\n while (true) {\n var vhash = 0, extracted_bit;\n for (i = 0; i < code_word.length; i++) {\n if (coeff[code_word[i]] > 0) {\n extracted_bit = coeff[code_word[i]] & 1;\n } else {\n extracted_bit = 1 - (coeff[code_word[i]] & 1);\n }\n if (extracted_bit == 1)\n vhash ^= i + 1;\n }\n i = vhash ^ k_bits_to_embed;\n if (!i) {\n _embedded += k;\n break;\n }\n i--;\n coeff[code_word[i]] += coeff[code_word[i]] < 0 ? 1 : -1;\n _changed++;\n if (coeff[code_word[i]] === 0) {\n _thrown++;\n code_word.splice(i, 1);\n while (true) {\n if (++ii >= coeff_count) {\n throw "capacity exceeded " + _embedded / 8;\n }\n ci = ii;\n if (ci % 64 !== 0 && coeff[ci] !== 0)\n break;\n }\n _examined++;\n code_word.push(ci);\n } else {\n _embedded += k;\n break;\n }\n }\n }\n }\n return {\n "k": k,\n "embedded": _embedded / 8,\n "examined": _examined,\n "changed": _changed,\n "thrown": _thrown,\n "efficiency": (_embedded / _changed).toFixed(2)\n };\n};\n\n// src/jpg.ts\nvar key = import_buffer4.Buffer.from("CUNNYCUNNYCUNNY");\nvar f5inst = new f5stego(key);\nvar inject2 = async (b, links) => {\n if (b.size / 20 < links.join(" ").length)\n throw "Image too small to embed.";\n const arr = new Uint8Array(new Uint8Array(await b.arrayBuffer()));\n const buff = f5inst.embed(arr, new TextEncoder().encode(links.join(" ")), 1);\n return import_buffer4.Buffer.from(buff);\n};\nvar has_embed2 = (b) => {\n try {\n const res = f5inst.extract(b);\n if (!res)\n return false;\n if (res.length > 1024)\n return false;\n const str = import_buffer4.Buffer.from(res).toString();\n if (!str.match(/^[a-zA-Z0-9:/.\\-_ ]+$/))\n return false;\n return str;\n } catch {\n return false;\n }\n};\nvar extract2 = (b, ex) => {\n return decodeCoom3Payload(import_buffer4.Buffer.from(ex));\n};\nvar jpg_default = {\n match: (fn) => !!fn.match(/\\.jpe?g$/),\n has_embed: has_embed2,\n extract: extract2,\n inject: inject2\n};\n\n// src/thirdeye.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar import_buffer5 = __toESM(require_buffer(), 1);\nvar import_jpeg_js = __toESM(require_jpeg_js(), 1);\n\n// src/phash.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar median = (data) => {\n const mdarr = data.slice(0);\n mdarr.sort((a, b) => a - b);\n if (mdarr.length % 2 === 0)\n return (mdarr[mdarr.length / 2 - 1] + mdarr[mdarr.length / 2]) / 2;\n return mdarr[Math.floor(mdarr.length / 2)];\n};\nvar translate_blocks_to_bits = function(blocks, pixels_per_block) {\n const half_block_value = pixels_per_block * 256 * 3 / 2;\n const bandsize = blocks.length / 4;\n for (let i = 0; i < 4; i++) {\n const m = median(blocks.slice(i * bandsize, (i + 1) * bandsize));\n for (let j = i * bandsize; j < (i + 1) * bandsize; j++) {\n const v = blocks[j];\n blocks[j] = Number(v > m || Math.abs(v - m) < 1 && m > half_block_value);\n }\n }\n};\nvar bits_to_hexhash = (bitsArray) => {\n const hex = [];\n for (let i = 0; i < bitsArray.length; i += 4) {\n const nibble = bitsArray.slice(i, i + 4);\n hex.push(parseInt(nibble.join(""), 2).toString(16));\n }\n return hex.join("");\n};\nvar bmvbhash_even = (data, bits) => {\n const blocksize_x = Math.floor(data.width / bits);\n const blocksize_y = Math.floor(data.height / bits);\n const result = [];\n for (let y = 0; y < bits; y++) {\n for (let x = 0; x < bits; x++) {\n let total = 0;\n for (let iy = 0; iy < blocksize_y; iy++) {\n for (let ix = 0; ix < blocksize_x; ix++) {\n const cx = x * blocksize_x + ix;\n const cy = y * blocksize_y + iy;\n const ii = (cy * data.width + cx) * 4;\n const alpha = data.data[ii + 3];\n if (alpha === 0) {\n total += 765;\n } else {\n total += data.data[ii] + data.data[ii + 1] + data.data[ii + 2];\n }\n }\n }\n result.push(total);\n }\n }\n translate_blocks_to_bits(result, blocksize_x * blocksize_y);\n return bits_to_hexhash(result);\n};\n\n// src/thirdeye.ts\nvar csettings3;\nsettings.subscribe((b) => {\n csettings3 = b;\n});\nvar gelquirk = (prefix) => (a) => {\n let base = a.post || a.data || a;\n if (!Array.isArray(base))\n return [];\n base = base.filter((e) => e.file_url);\n return base.map((e) => ({\n full_url: e.file_url,\n preview_url: e.preview_url || e.preview_url,\n source: e.source,\n ext: e.file_ext || e.file_url.substr(e.file_url.lastIndexOf(".") + 1),\n page: `${prefix}${e.id || e.parent_id}`,\n tags: (e.tag_string || (e.tags && (Array.isArray(e.tags) && (typeof e.tags[0] == "string" ? e.tags.join(" ") : e.tags.map((e2) => e2.name_en).join(" "))) || e.tags) || "").split(" ")\n })) || [];\n};\nvar experimentalApi = false;\nvar black = /* @__PURE__ */ new Set();\nvar phashEn = false;\nvar mindist = 5;\nsettings.subscribe((s) => {\n if (!s)\n return;\n experimentalApi = s.expte;\n boorus = s.rsources.map((e) => ({\n ...e,\n quirks: gelquirk(e.view)\n }));\n black = new Set(s.blacklist);\n mindist = s.mdist || 5;\n phashEn = s.phash;\n});\nvar boorus = [];\nvar unlockQueue = Promise.resolve();\nvar cache = {};\nvar findFileFrom = async (b, hex, abort) => {\n try {\n if (b.domain in cache && hex in cache[b.domain])\n return cache[b.domain][hex];\n const res = await ifetch(`https://${b.domain}${b.endpoint}${hex}`);\n const txt = await res.text();\n const pres = JSON.parse(txt);\n const tran = b.quirks(pres).filter((e) => !e.tags.some((e2) => black.has(e2)));\n if (!(b.domain in cache))\n cache[b.domain] = {};\n cache[b.domain][hex] = tran;\n return tran;\n } catch (e) {\n const error = e;\n if (!error.message.includes("Unexpected end of JSON input"))\n console.error(e);\n return [];\n }\n};\nvar extract3 = async (b, fn) => {\n if (!csettings3)\n throw new Error("Settings uninit");\n let result;\n let booru;\n for (const e of Object.values(boorus)) {\n if (e.disabled)\n continue;\n result = await findFileFrom(e, fn.substring(0, 32));\n if (result.length) {\n booru = e.name;\n break;\n }\n }\n let cachedFile;\n const prev = result[0].preview_url;\n const full = result[0].full_url;\n return [{\n source: result[0].source,\n page: {\n title: booru,\n url: result[0].page\n },\n filename: fn.substring(0, 33) + result[0].ext,\n thumbnail: csettings3.hotlink ? prev || full : import_buffer5.Buffer.from(await (await ifetch(prev || full)).arrayBuffer()),\n data: csettings3.hotlink ? full || prev : { url: full || prev }\n }];\n};\nvar phash = (b) => {\n const res = (0, import_jpeg_js.decode)(b);\n return bmvbhash_even(res, 8);\n};\nvar hammingDist = (a, b) => {\n let res = BigInt("0x" + a) ^ BigInt("0x" + b);\n let acc = 0;\n while (res != 0n) {\n acc += Number(res & 1n);\n res >>= 1n;\n }\n return acc;\n};\nvar has_embed3 = async (b, fn, prevlink) => {\n if (import_buffer5.Buffer.from(fn, "hex").equals(b))\n return false;\n let result = void 0;\n for (const e of Object.values(boorus)) {\n if (e.disabled)\n continue;\n result = await findFileFrom(e, fn.substring(0, 32));\n result = result.filter((e2) => e2.full_url || e2.preview_url);\n if (result.length)\n break;\n }\n if (result && result.length != 0 && phashEn && prevlink) {\n if (!result[0].preview_url)\n return true;\n const getHash = async (l) => {\n const ogreq = await ifetch(l);\n const origPreview = await ogreq.arrayBuffer();\n return phash(import_buffer5.Buffer.from(origPreview));\n };\n const [orighash, tehash] = await Promise.all([\n getHash(prevlink),\n getHash(result[0].preview_url)\n ]);\n const d = hammingDist(orighash, tehash);\n console.log(d, prevlink);\n return d > mindist;\n }\n return result && result.length != 0;\n};\nvar thirdeye_default = {\n skip: true,\n extract: extract3,\n has_embed: has_embed3,\n match: (fn) => !!fn.match(/^[0-9a-f]{32}\\.....?/)\n};\n\n// src/pomf.ts\ninit_define_BUILD_VERSION();\ninit_esbuild_inject();\nvar import_buffer6 = __toESM(require_buffer(), 1);\nvar sources = [\n { host: "Catbox", prefix: "files.catbox.moe/" },\n { host: "Litter", prefix: "litter.catbox.moe/" },\n { host: "Zzzz", prefix: "z.zz.fo/" }\n];\nvar csettings4;\nsettings.subscribe((b) => {\n csettings4 = b;\n});\nvar getExt = (fn) => {\n const isB64 = fn.match(/^((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=))?\\.(gif|jpe?g|png|webm)/);\n const isExt = fn.match(/\\[.*=(.*)\\]/);\n let ext;\n let source;\n try {\n if (isB64) {\n ext = atob(isB64[1]);\n } else if (isExt) {\n ext = decodeURIComponent(isExt[1]);\n if (ext.startsWith("https://"))\n ext = ext.slice("https://".length);\n for (const cs of sources)\n if (ext.startsWith(cs.prefix)) {\n source = cs.prefix;\n ext = ext.slice(cs.prefix.length);\n break;\n }\n }\n } catch {\n }\n return { ext, source };\n};\nvar extract4 = async (b, fn) => {\n if (!csettings4)\n throw new Error("Settings uninit");\n const { ext, source } = getExt(fn);\n let rsource;\n for (const cs of sources) {\n if (source && cs.prefix != source)\n continue;\n try {\n await getHeaders("https://" + cs.prefix + ext);\n rsource = "https://" + cs.prefix + ext;\n break;\n } catch {\n }\n }\n return [{\n filename: ext,\n data: csettings4.hotlink ? rsource : { url: rsource },\n thumbnail: import_buffer6.Buffer.from(hasembed_default)\n }];\n};\nvar has_embed4 = async (b, fn) => {\n const { ext, source } = getExt(fn);\n if (!ext)\n return false;\n for (const cs of sources) {\n if (source && cs.prefix != source)\n continue;\n try {\n const e = await getHeaders("https://" + cs.prefix + ext);\n return true;\n } catch {\n }\n }\n return false;\n};\nvar pomf_default = {\n skip: true,\n extract: extract4,\n has_embed: has_embed4,\n match: (fn) => !!getExt(fn)\n};\n\n// src/processor.worker.ts\nconsole.log("Worker started");\nvar pendinggens = {};\nvar proxyAsyncGen = (id) => {\n return {\n next(arg) {\n postMessage({\n type: "ag",\n id\n });\n return new Promise((res) => {\n if (!pendinggens[id])\n pendinggens[id] = [];\n pendinggens[id].push(res);\n });\n },\n return(v) {\n postMessage({\n type: "ag",\n id\n });\n return new Promise((res) => {\n if (!pendinggens[id])\n pendinggens[id] = [];\n pendinggens[id].push(res);\n });\n },\n throw() {\n postMessage({\n type: "ag",\n id\n });\n return new Promise((res) => {\n if (!pendinggens[id])\n pendinggens[id] = [];\n pendinggens[id].push(res);\n });\n },\n [Symbol.asyncIterator]() {\n return this;\n }\n };\n};\nvar deserializeMessage = (m) => {\n if (m instanceof MessagePort)\n return m;\n if (typeof m == "object" && m.type == "AsyncGenerator") {\n return proxyAsyncGen(m.id);\n }\n if (typeof m == "object") {\n for (const p in m) {\n m[p] = deserializeMessage(m[p]);\n }\n }\n return m;\n};\nvar processors = [thirdeye_default, pomf_default, pngv3_default, jpg_default];\nvar processImage = async (srcs, fn, hex, prevurl) => {\n const ret = await Promise.all(processors.filter((e) => e.match(fn)).map(async (proc) => {\n if (proc.skip) {\n const md5 = Buffer2.from(hex, "base64");\n if (await proc.has_embed(md5, fn, prevurl) === true) {\n return [await proc.extract(md5, fn), true];\n }\n return;\n }\n let succ = false;\n let cumul;\n do {\n try {\n const n = await srcs.next();\n if (n.done)\n return;\n const iter = streamRemote(n.value);\n if (!iter)\n return;\n cumul = Buffer2.alloc(0);\n let found;\n let chunk = { done: true };\n do {\n const { value, done } = await iter.next(typeof found === "boolean");\n if (done) {\n chunk = { done: true };\n } else {\n chunk = { done: false, value };\n cumul = Buffer2.concat([cumul, value]);\n const v = await proc.has_embed(cumul);\n if (typeof v == "string") {\n return [await proc.extract(cumul, v), false];\n }\n found = v;\n }\n } while (found !== false && !chunk.done);\n succ = true;\n await iter.next(true);\n if (found !== true) {\n return;\n }\n return [await proc.extract(cumul), false];\n } catch (err) {\n console.log(err);\n }\n } while (!succ);\n }));\n return ret.filter((e) => e).map((e) => e);\n};\nvar init2 = false;\n(async () => {\n onmessage = async (msg) => {\n const des = deserializeMessage(msg.data);\n switch (des.type) {\n case "ipc": {\n setupPort(des.port);\n const nset = await localLoad("settingsv2", initial_settings);\n settings.set(nset);\n break;\n }\n case "cmd": {\n switch (des.fun) {\n case "processImage": {\n if (!init2) {\n await new Promise((_) => {\n settings.subscribe((v) => {\n if (v)\n _();\n });\n });\n init2 = true;\n }\n const res = await processImage(des.args[0], des.args[1], des.args[2], des.args[3]);\n const tr = [];\n for (const ef of res) {\n for (const e of ef[0]) {\n if (e.thumbnail && Buffer2.isBuffer(e.thumbnail) || typeof e.thumbnail != "string")\n tr.push(e.thumbnail.buffer);\n if (Buffer2.isBuffer(e.data) || typeof e.data != "string" && !("url" in e.data))\n tr.push(e.data.buffer);\n }\n }\n postMessage({\n type: "reply",\n id: des.id,\n res\n }, [...new Set(tr)]);\n }\n }\n break;\n }\n case "ag": {\n const cb = pendinggens[des.id].shift();\n if (cb) {\n cb(des.res);\n }\n break;\n }\n }\n };\n})();\n/*! Bundled license information:\n\nieee754/index.js:\n (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n\nbuffer/index.js:\n (*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh <https://feross.org>\n * @license MIT\n *)\n\ncrc-32/crc32.js:\n (*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *)\n\nsafe-buffer/index.js:\n (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n*/\n');
|
|
}
|
|
|
|
// src/main.ts
|
|
var ProcessWorker = Worker2;
|
|
if (!supportedMainDomain(location.host) && !supportedAltDomain(location.host))
|
|
throw "PEE not supported here, skipping";
|
|
var qp;
|
|
var csettings5;
|
|
var processors = [thirdeye_default, pomf_default, pngv3_default, jpg_default];
|
|
var cappState;
|
|
settings.subscribe(async (b) => {
|
|
if (!b)
|
|
return;
|
|
csettings5 = b;
|
|
if (b.hyd) {
|
|
if (b.ak) {
|
|
const hydCli = new HydrusClient(b.ak);
|
|
console.log(b.ak);
|
|
let herror;
|
|
try {
|
|
const valid = await hydCli.verify();
|
|
if (!valid)
|
|
herror = "Hydrus appears to not be running or the key is wrong.";
|
|
appState.set({ ...cappState, akValid: valid, client: hydCli, herror });
|
|
} catch {
|
|
herror = "Hydrus appears to not be running";
|
|
appState.set({ ...cappState, akValid: false, client: null, herror });
|
|
}
|
|
}
|
|
}
|
|
});
|
|
appState.subscribe((v) => {
|
|
cappState = v;
|
|
});
|
|
var textToElement = (s) => document.createRange().createContextualFragment(s).children[0];
|
|
var pendingPosts = [];
|
|
var pendingNoPosts = [];
|
|
var signalNewEmbeds = debounce(async () => {
|
|
if (!csettings5)
|
|
return;
|
|
if (!csettings5.tm)
|
|
return;
|
|
try {
|
|
const boardname = location.pathname.match(/\/([^/]*)\//)[1];
|
|
const reshaped = Object.fromEntries([...new Set(pendingPosts.map((e) => e.op))].map((e) => [e, pendingPosts.filter((p) => p.op == e).map((e2) => e2.id)]));
|
|
const reshaped2 = Object.fromEntries([...new Set(pendingNoPosts.map((e) => e.op))].map((e) => [e, pendingNoPosts.filter((p) => p.op == e).map((e2) => e2.id)]));
|
|
const res = await ifetch("https://shoujo.coom.tech/listing/" + boardname, {
|
|
method: "POST",
|
|
body: JSON.stringify({
|
|
emb: reshaped,
|
|
noemb: reshaped2
|
|
}),
|
|
headers: {
|
|
"content-type": "application/json"
|
|
}
|
|
});
|
|
await res.json();
|
|
pendingPosts = [];
|
|
pendingNoPosts = [];
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
}, 5e3, { trailing: true });
|
|
var shouldUseCache = () => {
|
|
if (location.host.includes("kohlchan.net"))
|
|
return false;
|
|
if (cappState.isCatalog)
|
|
return false;
|
|
if (!csettings5)
|
|
return false;
|
|
return typeof csettings5.cache == "boolean" ? csettings5.cache : location.hostname.includes("b4k");
|
|
};
|
|
var cp;
|
|
var BackgroundEmulator = class {
|
|
constructor(port) {
|
|
this.port = port;
|
|
const pendingFetches = /* @__PURE__ */ new Map();
|
|
port.onmessage = async (obj) => {
|
|
const { id, name, args, sid, fid, url } = obj.data;
|
|
if (name == "keepAlive") {
|
|
console.log("im alive, tho?");
|
|
return;
|
|
}
|
|
if (name == "abortCorsFetch") {
|
|
return;
|
|
}
|
|
if (name == "corsFetch") {
|
|
this.bgCorsFetch(port, pendingFetches, id, ...args);
|
|
return;
|
|
}
|
|
if (name == "revoke") {
|
|
URL.revokeObjectURL(url);
|
|
port.postMessage({
|
|
id,
|
|
ok: 1
|
|
});
|
|
return;
|
|
}
|
|
if (name == "fullyRead") {
|
|
const obj2 = pendingFetches.get(port);
|
|
if (obj2 && fid in obj2)
|
|
obj2[fid].fetchFully = true;
|
|
port.postMessage({
|
|
id,
|
|
ok: 1
|
|
});
|
|
return;
|
|
}
|
|
const res = await Platform[name](...args);
|
|
port.postMessage({
|
|
id,
|
|
res
|
|
});
|
|
};
|
|
}
|
|
async bgCorsFetch(c, pendingFetches, id, input, init5) {
|
|
try {
|
|
const res = await ifetch(input, init5);
|
|
const headersStr = res.responseHeaders;
|
|
const headerObj = headerStringToObject(headersStr);
|
|
c.postMessage({
|
|
id,
|
|
ok: res.ok || true,
|
|
setRes: true,
|
|
headers: headerObj,
|
|
responseHeaders: headersStr,
|
|
redirected: res.redirected,
|
|
type: res.type,
|
|
url: res.url,
|
|
status: res.status,
|
|
bodyUsed: res.bodyUsed,
|
|
statusText: res.statusText
|
|
});
|
|
if (["GET", "POST"].includes(init5?.method || "GET")) {
|
|
const data = await res.arrayBuffer();
|
|
c.postMessage({
|
|
id,
|
|
pushData: {
|
|
data
|
|
}
|
|
}, [data]);
|
|
}
|
|
c.postMessage({
|
|
id,
|
|
pushData: {}
|
|
}, []);
|
|
} catch (e) {
|
|
c.postMessage({
|
|
id,
|
|
ok: false,
|
|
setRes: true,
|
|
headers: {},
|
|
responseHeaders: "",
|
|
redirected: false,
|
|
status: 400,
|
|
bodyUsed: false,
|
|
statusText: "shit broke"
|
|
});
|
|
}
|
|
}
|
|
};
|
|
var CommandProcessor = class {
|
|
processor = ProcessWorker();
|
|
genid = 0;
|
|
pendinggens = {};
|
|
cmdid = 0;
|
|
pendingprom = {};
|
|
constructor() {
|
|
this.processor.onmessage = async (msg) => {
|
|
let gen;
|
|
let res;
|
|
switch (msg.data.type) {
|
|
case "reply":
|
|
if (msg.data.id in this.pendingprom) {
|
|
this.pendingprom[msg.data.id](msg.data.res);
|
|
delete this.pendingprom[msg.data.id];
|
|
}
|
|
break;
|
|
case "ag":
|
|
gen = this.pendinggens[msg.data.id];
|
|
res = await gen.next(msg.data.args);
|
|
if (res.done) {
|
|
delete this.pendinggens[msg.data.id];
|
|
}
|
|
this.processor.postMessage({
|
|
type: "ag",
|
|
id: msg.data.id,
|
|
res
|
|
});
|
|
break;
|
|
}
|
|
};
|
|
if (false) {
|
|
const ipcport = genPort();
|
|
this.processor.postMessage({ type: "ipc", port: ipcport }, [ipcport]);
|
|
} else {
|
|
const nmc = new MessageChannel();
|
|
const port12 = nmc.port1;
|
|
const port2 = nmc.port2;
|
|
new BackgroundEmulator(port2);
|
|
const ipcport = port12;
|
|
this.processor.postMessage({ type: "ipc", port: ipcport }, [ipcport]);
|
|
}
|
|
}
|
|
serializeArg(m) {
|
|
if (m[Symbol.toStringTag] == "AsyncGenerator") {
|
|
const genid = this.genid++;
|
|
this.pendinggens[genid] = m;
|
|
return {
|
|
type: "AsyncGenerator",
|
|
id: genid
|
|
};
|
|
}
|
|
return m;
|
|
}
|
|
sendCmd(cmd, ...args) {
|
|
const id = this.cmdid++;
|
|
this.processor.postMessage({
|
|
type: "cmd",
|
|
id,
|
|
fun: cmd,
|
|
args: args.map((a) => this.serializeArg(a))
|
|
});
|
|
return new Promise((res) => {
|
|
this.pendingprom[id] = res;
|
|
});
|
|
}
|
|
sendAg(id, res) {
|
|
this.processor.postMessage({
|
|
type: "ag",
|
|
id,
|
|
res
|
|
});
|
|
}
|
|
processImage(origlink, fn, md5, thumb) {
|
|
return this.sendCmd("processImage", origlink, fn, md5, thumb);
|
|
}
|
|
};
|
|
var convertToLocalEmbed = (wef) => {
|
|
let ret;
|
|
ret = { ...wef };
|
|
if (typeof wef.data == "object") {
|
|
if ("url" in wef.data) {
|
|
const ref = wef.data;
|
|
if (!wef.thumbnail)
|
|
return wef;
|
|
ret = {
|
|
...wef,
|
|
thumbnail: import_buffer9.Buffer.from(wef.thumbnail),
|
|
data: async (lsn) => {
|
|
return import_buffer9.Buffer.from(await (await ifetch(ref.url, { headers: ref.headers }, lsn)).arrayBuffer());
|
|
}
|
|
};
|
|
}
|
|
}
|
|
if (typeof wef.data != "string" && !("url" in wef.data)) {
|
|
ret.data = import_buffer9.Buffer.from(wef.data);
|
|
}
|
|
if (wef.thumbnail && typeof wef.thumbnail != "string") {
|
|
ret.thumbnail = import_buffer9.Buffer.from(wef.thumbnail);
|
|
}
|
|
return ret;
|
|
};
|
|
var reportEmbed = (post, op) => {
|
|
if (!csettings5)
|
|
return;
|
|
if (csettings5.tm) {
|
|
if (["boards.4chan.org", "boards.4channel.org"].includes(location.host)) {
|
|
if (!cappState.isCatalog) {
|
|
pendingPosts.push({ id: +post.id.match(/([0-9]+)/)[1], op });
|
|
signalNewEmbeds();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var reportNoEmbed = (post, op) => {
|
|
if (!csettings5)
|
|
return;
|
|
if (csettings5.tm) {
|
|
if (["boards.4chan.org", "boards.4channel.org"].includes(location.host)) {
|
|
if (!cappState.isCatalog) {
|
|
pendingNoPosts.push({ id: +post.id.match(/([0-9]+)/)[1], op });
|
|
signalNewEmbeds();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var processed = /* @__PURE__ */ new Set();
|
|
var processPost = async (post) => {
|
|
let inc = true;
|
|
try {
|
|
if (processed.has(post.id)) {
|
|
inc = false;
|
|
return;
|
|
}
|
|
const origlink = qp.getImageLink(post);
|
|
if (!origlink)
|
|
return;
|
|
const thumbLink = qp.getThumbnailLink(post);
|
|
if (!thumbLink)
|
|
return;
|
|
let res2 = void 0;
|
|
let op;
|
|
if (cappState.isCatalog)
|
|
op = +post.id.slice(2);
|
|
else
|
|
op = qp.getCurrentThread() || 0;
|
|
if (shouldUseCache()) {
|
|
res2 = await getEmbedsFromCache(qp.getCurrentBoard(), +qp.getCurrentThread(), post.id);
|
|
}
|
|
if (!res2) {
|
|
res2 = [];
|
|
const tmp = await cp.processImage(origlink, qp.getFilename(post), qp.getMD5(post), thumbLink);
|
|
res2.push(...tmp);
|
|
res2 = res2?.filter((e) => e);
|
|
}
|
|
if (!res2 || res2.length == 0)
|
|
return reportNoEmbed(post, op);
|
|
reportEmbed(post, op);
|
|
post.querySelector(".post")?.classList.add("embedfound");
|
|
processAttachments(post, res2?.flatMap((e) => e[0].map((k) => [convertToLocalEmbed(k), e[1]])));
|
|
} catch (e) {
|
|
console.error(e);
|
|
return;
|
|
} finally {
|
|
processed.add(post.id);
|
|
if (inc)
|
|
appState.update((v) => {
|
|
return v.processed++, v;
|
|
});
|
|
}
|
|
};
|
|
var versionCheck = async () => {
|
|
const txt = await (await ifetch("https://raw.githubusercontent.com/coomdev/pngextraembedder/main/main.meta.js")).text();
|
|
const [lmajor, lminor] = txt.split("\n").filter((e) => e.includes("// @version"))[0].match(/.*version\s+(.*)/)[1].split(".").map((e) => +e);
|
|
const [major, minor] = define_BUILD_VERSION_default;
|
|
if (major < lmajor || major == lmajor && minor < lminor) {
|
|
fireNotification("info", `Last PEE version is ${lmajor}.${lminor}, you're on ${major}.${minor}`);
|
|
}
|
|
};
|
|
var scrapeBoard = async (self) => {
|
|
};
|
|
var gmo;
|
|
var earlystartup = async () => {
|
|
if (["arch.b4k.co", "desuarchive.org"].includes(location.host) && true) {
|
|
if (!GM_getValue("warning_seen2", false)) {
|
|
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;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
var init4 = false;
|
|
var startup = async (is4chanX = true) => {
|
|
if (init4)
|
|
return;
|
|
init4 = true;
|
|
window.addEventListener("securitypolicyviolation", (e) => {
|
|
if (e.blockedURI.startsWith("blob")) {
|
|
if (supportedMainDomain(location.host)) {
|
|
fireNotification("error", "CSP is preventing PEE from running, add blob: to the allowed JS whitelist in 4chanX in Advanced Settings");
|
|
} else if (supportedAltDomain(location.host)) {
|
|
fireNotification("error", "CSP is preventing PEE from running, use a CSP bypass extension like PEE-companion");
|
|
}
|
|
}
|
|
});
|
|
let meta = document.querySelector('meta[name="referrer"]');
|
|
const customStyles = document.createElement("style");
|
|
customStyles.appendChild(document.createTextNode(global_default));
|
|
document.documentElement.insertBefore(customStyles, null);
|
|
if (!navigator.userAgent.includes("Firefox") && meta)
|
|
meta.setAttribute("content", "no-referrer");
|
|
meta = document.createElement("meta");
|
|
meta.setAttribute("http-equiv", "Content-Security-Policy");
|
|
meta.setAttribute("content", "worker-src 'self' blob:");
|
|
document.head.append(meta);
|
|
appState.set({ ...cappState, is4chanX });
|
|
const lqp = getQueryProcessor(is4chanX);
|
|
if (!lqp)
|
|
return;
|
|
else
|
|
qp = lqp;
|
|
if (false)
|
|
await initMainIPC();
|
|
const nset = await localLoad("settingsv2", initial_settings);
|
|
settings.set(nset);
|
|
if (!csettings5)
|
|
return false;
|
|
if (csettings5.vercheck)
|
|
versionCheck();
|
|
const postQuote = ({ scanner, parser, utils }) => {
|
|
const { CLOSEANGLEBRACKET: CLOSEANGLEBRACKET2, NUM: NUM2 } = scanner.tokens;
|
|
const START_STATE = parser.start;
|
|
const pref = qp.getPostIdPrefix();
|
|
const endQuote = createTokenClass("postQuote", {
|
|
isLink: true,
|
|
toHref() {
|
|
return `#${pref}${this.toString().substr(2)}`;
|
|
}
|
|
});
|
|
const MEMEARROW1 = START_STATE.tt(CLOSEANGLEBRACKET2);
|
|
const MEMEARROW2 = MEMEARROW1.tt(CLOSEANGLEBRACKET2);
|
|
const POSTNUM_STATE = MEMEARROW2.tt(NUM2, endQuote);
|
|
};
|
|
registerPlugin("quote", postQuote);
|
|
if (!is4chanX && location.host.startsWith("boards.4chan")) {
|
|
const QRObs = new MutationObserver((rec) => {
|
|
rec.forEach((m) => {
|
|
m.addedNodes.forEach((no) => {
|
|
if (no.id != "quickReply") {
|
|
return;
|
|
}
|
|
document.dispatchEvent(new CustomEvent("QRDialogCreation", {
|
|
detail: no
|
|
}));
|
|
});
|
|
});
|
|
});
|
|
QRObs.observe(document.body, { childList: true });
|
|
document.addEventListener("QRGetFile", (e) => {
|
|
const qr = document.getElementById("qrFile");
|
|
document.dispatchEvent(new CustomEvent("QRFile", { detail: (qr?.files || [])[0] }));
|
|
});
|
|
document.addEventListener("QRSetFile", (e) => {
|
|
const qr = document.getElementById("qrFile");
|
|
if (!qr)
|
|
return;
|
|
const dt = new DataTransfer();
|
|
dt.items.add(new File([e.detail.file], e.detail.name));
|
|
qr.files = dt.files;
|
|
});
|
|
}
|
|
if (!document.body) {
|
|
let bodyRes;
|
|
const bodyInit = new Promise((r) => bodyRes = r);
|
|
const mo2 = new MutationObserver((r) => {
|
|
if (document.body) {
|
|
mo2.disconnect();
|
|
bodyRes();
|
|
}
|
|
});
|
|
mo2.observe(document.documentElement, { childList: true, subtree: true });
|
|
await bodyInit;
|
|
}
|
|
if (!cappState.isCatalog) {
|
|
const mo = new MutationObserver((reco) => {
|
|
for (const rec of reco)
|
|
if (rec.type == "childList")
|
|
rec.addedNodes.forEach((e) => {
|
|
if (!(e instanceof HTMLElement))
|
|
return;
|
|
if (!csettings5)
|
|
return false;
|
|
if (cappState.isCatalog && csettings5.notcata)
|
|
return;
|
|
let el = qp.postsWithFiles(e);
|
|
if (!el && e.classList.contains("postContainer"))
|
|
el = [e];
|
|
if (el) {
|
|
for (const e2 of el) {
|
|
if (processed.has(e2.id))
|
|
continue;
|
|
appState.update((v) => {
|
|
v.processing += 1;
|
|
return v;
|
|
});
|
|
processPost(e2);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
document.querySelectorAll(".board").forEach((e) => {
|
|
mo.observe(e, { childList: true, subtree: true });
|
|
});
|
|
}
|
|
document.addEventListener("QRDialogCreation", (e) => {
|
|
const a = document.createElement("span");
|
|
const po = new PostOptions_default({
|
|
target: a,
|
|
props: { processors, textinput: (e.detail || e.target).querySelector("textarea") }
|
|
});
|
|
let prevFile;
|
|
let target;
|
|
const somethingChanged = async (m) => {
|
|
const currentFile = await getSelectedFile();
|
|
if (prevFile != currentFile) {
|
|
prevFile = currentFile;
|
|
document.dispatchEvent(new CustomEvent("PEEFile", { detail: prevFile }));
|
|
}
|
|
};
|
|
const obs = new MutationObserver(somethingChanged);
|
|
if (["kohlchan.net", "nocsp.kohlchan.net"].includes(location.host)) {
|
|
target = e.detail;
|
|
a.style.display = "inline-block";
|
|
const filesinp = target.querySelector("#selectedDivQr");
|
|
filesinp.parentElement?.appendChild(a);
|
|
} else if (!cappState.is4chanX) {
|
|
target = e.detail;
|
|
a.style.display = "inline-block";
|
|
target.querySelector("input[type=submit]")?.insertAdjacentElement("beforebegin", a);
|
|
const filesinp = target.querySelector("#qrFile");
|
|
filesinp.addEventListener("change", somethingChanged);
|
|
} else {
|
|
target = e.target;
|
|
target.querySelector("#qr-filename-container")?.appendChild(a);
|
|
const filesinp = target.querySelector("#file-n-submit");
|
|
obs.observe(filesinp, { attributes: true });
|
|
}
|
|
}, { once: !cappState.is4chanX });
|
|
if (location.host == "kohlchan.net") {
|
|
setTimeout(() => {
|
|
const no = document.querySelector("#quick-reply");
|
|
console.log("emitting qrdialog");
|
|
document.dispatchEvent(new CustomEvent("QRDialogCreation", {
|
|
detail: no
|
|
}));
|
|
const s = document.createElement("script");
|
|
s.src = chrome.runtime.getURL("kohlchan-hooks.js");
|
|
s.onload = function() {
|
|
s.remove();
|
|
};
|
|
(document.head || document.documentElement).appendChild(s);
|
|
}, 1e3);
|
|
}
|
|
try {
|
|
cp = new CommandProcessor();
|
|
} catch {
|
|
if (true)
|
|
fireNotification("error", "The page you're on has a CSP that prevents PEE from functionning properly.\n\n If using 4chanX, Add 'blob:' to the JS whitelist. Else, install PEE-companion.");
|
|
else
|
|
fireNotification("error", "You may be using 4chanX\n\nGo to 4chanX's settings, Advanced > JS Whitelist and add 'blob:' without quotes to the list.");
|
|
}
|
|
if (!is4chanX && location.host.startsWith("boards.4chan") || location.host.includes("kohlchan.net")) {
|
|
const notificationHost = document.createElement("span");
|
|
new NotificationsHandler_default({
|
|
target: notificationHost
|
|
});
|
|
document.body.append(notificationHost);
|
|
}
|
|
if (location.host == "arch.b4k.co") {
|
|
document.querySelectorAll("img[data-src]").forEach((i) => {
|
|
i.src = i.getAttribute("data-src");
|
|
});
|
|
}
|
|
const appHost = textToElement(`<div class="peee-settings"></div>`);
|
|
const appInstance = new App_default({ target: appHost, props: { rev: define_BUILD_VERSION_default[1] } });
|
|
document.body.append(appHost);
|
|
const scrollHost = textToElement(`<div></div>`);
|
|
new ScrollHighlighter_default({ target: scrollHost });
|
|
document.body.append(scrollHost);
|
|
const posts = qp.postsWithFiles();
|
|
const scts = qp.settingsHost();
|
|
const button = textToElement(`<span></span>`);
|
|
const settingsButton = new SettingsButton_default({
|
|
target: button
|
|
});
|
|
scts?.appendChild(button);
|
|
appState.set({
|
|
...cappState,
|
|
isCatalog: !!document.querySelector(".catalog-small") || !!location.pathname.match(/\/catalog$/)
|
|
});
|
|
if (cappState.isCatalog) {
|
|
const opts = qp.catalogControlHost();
|
|
if (opts) {
|
|
const button2 = document.createElement("button");
|
|
button2.textContent = "\u304A\u3082\u3089\u3057";
|
|
button2.onclick = () => scrapeBoard(button2);
|
|
opts.insertAdjacentElement("beforebegin", button2);
|
|
}
|
|
if (csettings5.notcata)
|
|
return;
|
|
}
|
|
const n = 1;
|
|
const range = ~~(posts.length / n) + 1;
|
|
appState.update((v) => {
|
|
v.processing += posts.length;
|
|
return v;
|
|
});
|
|
await Promise.all([...new Array(n + 1)].map(async (e, i) => {
|
|
const postsslice = posts.slice(i * range, (i + 1) * range);
|
|
for (const post of postsslice) {
|
|
try {
|
|
await processPost(post);
|
|
} catch (e2) {
|
|
console.log("Processing failed for post", post, e2);
|
|
}
|
|
}
|
|
}));
|
|
};
|
|
if (location.host.startsWith("boards.4chan")) {
|
|
document.addEventListener("4chanParsingDone", () => startup(false), { once: true });
|
|
}
|
|
document.addEventListener("4chanXInitFinished", () => startup(true), { once: true });
|
|
if (supportedAltDomain(location.host)) {
|
|
if (location.host == "arch.b4k.co") {
|
|
gmo = new MutationObserver((m) => {
|
|
for (const r of m) {
|
|
r.addedNodes.forEach((e) => {
|
|
if (e.tagName == "SCRIPT") {
|
|
const scr = e;
|
|
if (scr.src.startsWith("https://arch.b4k.co/") || scr.src.startsWith("https://b4k.co/")) {
|
|
let file = scr.src.slice(scr.src.lastIndexOf("/") + 1);
|
|
if (file.includes("?"))
|
|
file = file.slice(0, file.lastIndexOf("?"));
|
|
if (true)
|
|
scr.src = `https://based.coom.tech/` + file;
|
|
else
|
|
scr.src = chrome.runtime.getURL("b4k/" + file);
|
|
return;
|
|
}
|
|
if (scr.src && !scr.src.startsWith("https://ajax.googleapis.com/") || scr.innerHTML.includes("googletagmanager") || scr.src.startsWith("data:")) {
|
|
scr.parentElement?.removeChild(scr);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
gmo.observe(document.documentElement, { subtree: true, childList: true });
|
|
}
|
|
const proceed = earlystartup();
|
|
window.addEventListener("load", async () => {
|
|
if (await proceed)
|
|
startup(false);
|
|
}, { once: true });
|
|
}
|
|
document.addEventListener("4chanThreadUpdated", (e) => {
|
|
document.dispatchEvent(new CustomEvent("ThreadUpdate", {
|
|
detail: {
|
|
newPosts: [...document.querySelector(".thread").children].slice(-e.detail.count).map((e2) => "b." + e2.id.slice(2))
|
|
}
|
|
}));
|
|
});
|
|
document.addEventListener("ThreadUpdate", async (e) => {
|
|
const newPosts = e.detail.newPosts;
|
|
const qp2 = getQueryProcessor(cappState.is4chanX);
|
|
if (!qp2)
|
|
return;
|
|
for (const post of newPosts) {
|
|
const postContainer = document.getElementById(qp2.getPostIdPrefix() + post.substring(post.indexOf(".") + 1));
|
|
const fn = qp2.getFilename(postContainer);
|
|
if (fn) {
|
|
if (!processed.has(postContainer.id)) {
|
|
appState.update((v) => {
|
|
v.processing++;
|
|
return v;
|
|
});
|
|
processPost(postContainer);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
function processAttachments(post, ress) {
|
|
if (ress.length == 0)
|
|
return;
|
|
const replyBox = qp.getPost(post);
|
|
const external = ress[0][1];
|
|
if (external)
|
|
replyBox?.classList.add("hasext");
|
|
else
|
|
replyBox?.classList.add("hasembed");
|
|
if (ress.length > 1)
|
|
replyBox?.classList.add("hasmultiple");
|
|
if (!cappState.foundPosts.includes(replyBox))
|
|
cappState.foundPosts.push(replyBox);
|
|
appState.set(cappState);
|
|
(async () => {
|
|
const viewcounthost = document.createElement("div");
|
|
const pid = +post.id.slice(post.id.match(/\d/).index);
|
|
if (pid == qp.getCurrentThread()) {
|
|
viewcounthost.style.right = "0px";
|
|
viewcounthost.style.bottom = "0px";
|
|
viewcounthost.style.position = "absolute";
|
|
} else {
|
|
viewcounthost.style.right = "0px";
|
|
viewcounthost.style.transform = "translateX(calc(100% + 10px))";
|
|
viewcounthost.style.position = "absolute";
|
|
}
|
|
new ViewCount_default({
|
|
target: viewcounthost,
|
|
props: {
|
|
board: qp.getCurrentBoard(),
|
|
op: cappState.isCatalog ? pid : qp.getCurrentThread(),
|
|
pid
|
|
}
|
|
});
|
|
replyBox.insertAdjacentElement("afterbegin", viewcounthost);
|
|
replyBox.style.position = "relative";
|
|
})();
|
|
const isCatalog = replyBox?.classList.contains("catalog-post");
|
|
if (!isCatalog) {
|
|
const ft = qp.getFileThumbnail(post);
|
|
const info = qp.getInfoBox(post);
|
|
const quot = qp.getTextBox(post);
|
|
const textInsertCursor = document.createElement("div");
|
|
quot?.appendChild(textInsertCursor);
|
|
const filehost = ft.querySelector(".fiilehost");
|
|
const eyehost = info.querySelector(".eyeehost");
|
|
const imgcont = filehost || document.createElement("div");
|
|
const eyecont = eyehost || document.createElement("span");
|
|
if (!filehost) {
|
|
ft.append(imgcont);
|
|
imgcont.classList.add("fileThumb");
|
|
imgcont.classList.add("fiilehost");
|
|
} else {
|
|
imgcont.innerHTML = "";
|
|
}
|
|
if (!eyehost) {
|
|
info.append(eyecont);
|
|
eyecont.classList.add("eyeehost");
|
|
} else {
|
|
eyecont.innerHTML = "";
|
|
}
|
|
const id = ~~(Math.random() * 2e7);
|
|
const text2 = new TextEmbeddings_default({
|
|
target: textInsertCursor,
|
|
props: {
|
|
files: ress.map((e) => e[0]).filter(
|
|
(e) => (import_buffer9.Buffer.isBuffer(e.data) || e.data instanceof Uint8Array) && e.filename.endsWith(".txt") && e.filename.startsWith("message")
|
|
)
|
|
}
|
|
});
|
|
const emb = new Embeddings_default({
|
|
target: imgcont,
|
|
props: {
|
|
files: ress.map((e) => e[0]),
|
|
id: "" + id
|
|
}
|
|
});
|
|
new EyeButton_default({
|
|
target: eyecont,
|
|
props: {
|
|
files: ress.map((e) => e[0]),
|
|
inst: emb,
|
|
id: "" + id
|
|
}
|
|
});
|
|
} else {
|
|
const opFile = post.querySelector(".catalog-link");
|
|
const ahem = opFile?.querySelector(".catalog-host");
|
|
const imgcont = ahem || document.createElement("div");
|
|
imgcont.className = "catalog-host";
|
|
if (ahem) {
|
|
imgcont.innerHTML = "";
|
|
}
|
|
const emb = new Embeddings_default({
|
|
target: imgcont,
|
|
props: {
|
|
files: ress.map((e) => e[0])
|
|
}
|
|
});
|
|
if (!ahem)
|
|
opFile?.append(imgcont);
|
|
}
|
|
post.setAttribute("data-processed", "true");
|
|
}
|
|
})();
|
|
/*! Bundled license information:
|
|
|
|
ieee754/index.js:
|
|
(*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
|
|
|
|
buffer/index.js:
|
|
(*!
|
|
* The buffer module from node.js, for the browser.
|
|
*
|
|
* @author Feross Aboukhadijeh <https://feross.org>
|
|
* @license MIT
|
|
*)
|
|
|
|
crc-32/crc32.js:
|
|
(*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *)
|
|
|
|
safe-buffer/index.js:
|
|
(*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
|
|
*/
|