706 lines
20 KiB
JavaScript
706 lines
20 KiB
JavaScript
// Module ID: 14612
|
|
// Function ID: 14613
|
|
// Name: thumbHashToRGBA
|
|
// Dependencies: [32]
|
|
// Exports: rgbaToThumbHash, thumbHashToApproximateAspectRatio, thumbHashToAverageRGBA, thumbHashToDataURL
|
|
|
|
// Module 14612 (thumbHashToRGBA)
|
|
import closure_0 from "_slicedToArray" /* 32 */;
|
|
|
|
function thumbHashToRGBA(arg0) {
|
|
let diff3 = arg0[0] | arg0[1] << 8 | arg0[2] << 16;
|
|
const result = (63 & diff3) / 63;
|
|
const diff = (diff3 >> 6 & 63) / 31.5 - 1;
|
|
const diff1 = (diff3 >> 12 & 63) / 31.5 - 1;
|
|
const result1 = (diff3 >> 18 & 31) / 31;
|
|
if ((arg0[3] | arg0[4] << 8) >> 15) {
|
|
let num = 7;
|
|
if (tmp7) {
|
|
num = 5;
|
|
}
|
|
let tmp9 = num;
|
|
} else {
|
|
tmp9 = 7 & tmp2;
|
|
}
|
|
const maxResult = max(3, tmp9);
|
|
if ((arg0[3] | arg0[4] << 8) >> 15) {
|
|
let num2 = 7 & tmp2;
|
|
} else {
|
|
num2 = 7;
|
|
if (tmp7) {
|
|
num2 = 5;
|
|
}
|
|
}
|
|
const maxResult1 = max(3, num2);
|
|
let num3 = 1;
|
|
if (diff3 >> 23) {
|
|
num3 = (15 & arg0[5]) / 15;
|
|
}
|
|
let num4 = 5;
|
|
const result2 = (arg0[5] >> 4) / 15;
|
|
if (diff3 >> 23) {
|
|
num4 = 6;
|
|
}
|
|
const items = [];
|
|
let num5 = 0;
|
|
let num6 = 0;
|
|
let num7 = 0;
|
|
if (0 < maxResult1) {
|
|
do {
|
|
let tmp13 = num5;
|
|
let tmp14 = num6;
|
|
let num8 = 1;
|
|
if (num6) {
|
|
num8 = 0;
|
|
}
|
|
let tmp15 = num5;
|
|
let tmp16 = num5;
|
|
if (num8 * maxResult1 < maxResult * (maxResult1 - num6)) {
|
|
do {
|
|
let sum = tmp15 + 1;
|
|
let arr = items.push(((arg0[num4 + (tmp15 >> 1)] >> ((1 & tmp15) << 2) & 15) / 7.5 - 1) * result1);
|
|
let sum1 = num8 + 1;
|
|
tmp15 = sum;
|
|
num8 = sum1;
|
|
tmp16 = sum;
|
|
result3 = sum1 * maxResult1;
|
|
result4 = maxResult * (maxResult1 - num6);
|
|
} while (result3 < result4);
|
|
}
|
|
num6 = num6 + 1;
|
|
num5 = tmp16;
|
|
num7 = tmp16;
|
|
} while (num6 < maxResult1);
|
|
}
|
|
const items1 = [];
|
|
let num9 = 0;
|
|
do {
|
|
let tmp23 = num7;
|
|
let tmp24 = num9;
|
|
let num10 = 1;
|
|
if (num9) {
|
|
num10 = 0;
|
|
}
|
|
let result5 = 3 * (3 - num9);
|
|
let tmp26 = num7;
|
|
let tmp27 = num7;
|
|
if (num10 * 3 < result5) {
|
|
do {
|
|
let sum2 = tmp26 + 1;
|
|
arr = items1.push(((arg0[num4 + (tmp26 >> 1)] >> ((1 & tmp26) << 2) & 15) / 7.5 - 1) * tmp22);
|
|
let sum3 = num10 + 1;
|
|
tmp26 = sum2;
|
|
num10 = sum3;
|
|
tmp27 = sum2;
|
|
result6 = sum3 * 3;
|
|
} while (result6 < result5);
|
|
}
|
|
num9 = num9 + 1;
|
|
num7 = tmp27;
|
|
} while (num9 < 3);
|
|
const items2 = [];
|
|
let num11 = 0;
|
|
do {
|
|
let tmp33 = tmp27;
|
|
let tmp34 = num11;
|
|
let num12 = 1;
|
|
if (num11) {
|
|
num12 = 0;
|
|
}
|
|
let result7 = 3 * (3 - num11);
|
|
let tmp36 = tmp27;
|
|
let tmp37 = tmp27;
|
|
if (num12 * 3 < result7) {
|
|
do {
|
|
let sum4 = tmp36 + 1;
|
|
let arr1 = items2.push(((arg0[num4 + (tmp36 >> 1)] >> ((1 & tmp36) << 2) & 15) / 7.5 - 1) * tmp32);
|
|
let sum5 = num12 + 1;
|
|
tmp36 = sum4;
|
|
num12 = sum5;
|
|
tmp37 = sum4;
|
|
result8 = sum5 * 3;
|
|
} while (result8 < result7);
|
|
}
|
|
num11 = num11 + 1;
|
|
tmp27 = tmp37;
|
|
} while (num11 < 3);
|
|
let tmp42 = tmp7;
|
|
if (diff3 >> 23) {
|
|
const items3 = [];
|
|
let num13 = 0;
|
|
do {
|
|
let tmp43 = tmp37;
|
|
let tmp44 = num13;
|
|
let num14 = 1;
|
|
if (num13) {
|
|
num14 = 0;
|
|
}
|
|
let result9 = 5 * (5 - num13);
|
|
let tmp46 = tmp37;
|
|
let tmp47 = tmp37;
|
|
if (num14 * 5 < result9) {
|
|
do {
|
|
let sum6 = tmp46 + 1;
|
|
let arr2 = items3.push(((arg0[num4 + (tmp46 >> 1)] >> ((1 & tmp46) << 2) & 15) / 7.5 - 1) * result2);
|
|
let sum7 = num14 + 1;
|
|
tmp46 = sum6;
|
|
num14 = sum7;
|
|
tmp47 = sum6;
|
|
result10 = sum7 * 5;
|
|
} while (result10 < result9);
|
|
}
|
|
num13 = num13 + 1;
|
|
tmp37 = tmp47;
|
|
tmp42 = items3;
|
|
} while (num13 < 5);
|
|
}
|
|
if (128 & arg0[4]) {
|
|
let num15 = 7;
|
|
if (tmp53) {
|
|
num15 = 5;
|
|
}
|
|
let tmp55 = num15;
|
|
} else {
|
|
tmp55 = 7 & tmp52;
|
|
}
|
|
if (128 & arg0[4]) {
|
|
let num16 = 7 & tmp52;
|
|
} else {
|
|
num16 = 7;
|
|
if (tmp53) {
|
|
num16 = 5;
|
|
}
|
|
}
|
|
const result11 = tmp55 / num16;
|
|
let num17 = 32;
|
|
if (1 >= result11) {
|
|
num17 = 32 * result11;
|
|
}
|
|
const w = round(num17);
|
|
let num18 = 32;
|
|
if (1 < result11) {
|
|
num18 = 32 / result11;
|
|
}
|
|
const h = round(num18);
|
|
const rgba = new Uint8Array(w * h * 4);
|
|
const items4 = [];
|
|
let num19 = 0;
|
|
let num20 = 0;
|
|
if (0 < h) {
|
|
do {
|
|
let sum14 = num19;
|
|
let tmp62 = num20;
|
|
let num21 = 0;
|
|
let tmp63 = num19;
|
|
if (0 < w) {
|
|
do {
|
|
let tmp64 = num21;
|
|
let tmp65 = sum14;
|
|
let num22 = 3;
|
|
if (tmp7) {
|
|
num22 = 5;
|
|
}
|
|
let maxResult2 = max(maxResult, num22);
|
|
for (let num23 = 0; num23 < maxResult2; num23 = num23 + 1) {
|
|
items4[num23] = cos(PI / w * tmp67 * num23);
|
|
}
|
|
let num24 = 3;
|
|
if (tmp7) {
|
|
num24 = 5;
|
|
}
|
|
let maxResult3 = max(maxResult1, num24);
|
|
for (let num25 = 0; num25 < maxResult3; num25 = num25 + 1) {
|
|
[][num25] = cos(PI / h * tmp60 * num25);
|
|
}
|
|
let num26 = 0;
|
|
let num27 = 0;
|
|
let tmp69 = result;
|
|
let tmp70 = result;
|
|
if (0 < maxResult1) {
|
|
do {
|
|
let tmp71 = num26;
|
|
let tmp72 = num27;
|
|
let tmp73 = tmp69;
|
|
let num28 = 1;
|
|
if (num27) {
|
|
num28 = 0;
|
|
}
|
|
let sum10 = num26;
|
|
let sum8 = tmp69;
|
|
let tmp77 = num26;
|
|
let tmp78 = tmp69;
|
|
if (num28 * maxResult1 < maxResult * (maxResult1 - num27)) {
|
|
do {
|
|
sum8 = sum8 + items[sum10] * items4[num28] * tmp74;
|
|
let sum9 = num28 + 1;
|
|
sum10 = sum10 + 1;
|
|
num28 = sum9;
|
|
tmp77 = sum10;
|
|
tmp78 = sum8;
|
|
result12 = sum9 * maxResult1;
|
|
result13 = maxResult * (maxResult1 - num27);
|
|
} while (result12 < result13);
|
|
}
|
|
num27 = num27 + 1;
|
|
num26 = tmp77;
|
|
tmp69 = tmp78;
|
|
tmp70 = tmp78;
|
|
} while (num27 < maxResult1);
|
|
}
|
|
let num29 = 0;
|
|
let num30 = 0;
|
|
let tmp82 = diff1;
|
|
let tmp83 = diff;
|
|
do {
|
|
let tmp84 = num29;
|
|
let tmp85 = num30;
|
|
let tmp86 = tmp82;
|
|
let tmp87 = tmp83;
|
|
let num31 = 1;
|
|
if (num30) {
|
|
num31 = 0;
|
|
}
|
|
let diff2 = 3 - num30;
|
|
let sum13 = num29;
|
|
let sum12 = tmp82;
|
|
let sum11 = tmp83;
|
|
let tmp93 = num29;
|
|
let tmp94 = tmp82;
|
|
let tmp95 = tmp83;
|
|
if (num31 < diff2) {
|
|
do {
|
|
let result14 = items4[num31] * tmp88;
|
|
sum11 = sum11 + items1[sum13] * result14;
|
|
sum12 = sum12 + items2[sum13] * result14;
|
|
num31 = num31 + 1;
|
|
sum13 = sum13 + 1;
|
|
tmp93 = sum13;
|
|
tmp94 = sum12;
|
|
tmp95 = sum11;
|
|
} while (num31 < diff2);
|
|
}
|
|
num30 = num30 + 1;
|
|
num29 = tmp93;
|
|
tmp82 = tmp94;
|
|
tmp83 = tmp95;
|
|
} while (num30 < 3);
|
|
let num32 = 0;
|
|
let num33 = 0;
|
|
let tmp97 = num3;
|
|
let tmp98 = num3;
|
|
if (tmp7) {
|
|
do {
|
|
let tmp99 = num32;
|
|
diff3 = num33;
|
|
diff3 = tmp97;
|
|
let num34 = 1;
|
|
if (num33) {
|
|
num34 = 0;
|
|
}
|
|
diff3 = 5 - num33;
|
|
diff3 = num32;
|
|
diff3 = tmp97;
|
|
diff3 = num32;
|
|
diff3 = tmp97;
|
|
if (num34 < diff3) {
|
|
do {
|
|
diff3 = diff3 + tmp42[diff3] * items4[num34] * diff3;
|
|
num34 = num34 + 1;
|
|
diff3 = diff3 + 1;
|
|
} while (num34 < diff3);
|
|
}
|
|
num33 = num33 + 1;
|
|
num32 = diff3;
|
|
tmp97 = diff3;
|
|
tmp98 = diff3;
|
|
} while (num33 < 5);
|
|
}
|
|
diff3 = tmp70 - 0.6666666666666666 * tmp95;
|
|
diff3 = (3 * tmp70 - diff3 + tmp94) / 2;
|
|
rgba[sum14] = max(0, 255 * min(1, diff3));
|
|
rgba[sum14 + 1] = max(0, 255 * min(1, diff3 - tmp94));
|
|
rgba[sum14 + 2] = max(0, 255 * min(1, diff3));
|
|
rgba[sum14 + 3] = max(0, 255 * min(1, tmp98));
|
|
num21 = num21 + 1;
|
|
sum14 = sum14 + 4;
|
|
tmp63 = sum14;
|
|
} while (num21 < w);
|
|
}
|
|
num20 = num20 + 1;
|
|
num19 = tmp63;
|
|
} while (num20 < h);
|
|
}
|
|
return { w, h, rgba };
|
|
}
|
|
function rgbaToDataURL(w, h, rgba) {
|
|
let sum2;
|
|
const sum = 4 * w + 1;
|
|
const sum1 = 6 + h * (5 + sum);
|
|
const items = [137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, w >> 8, 255 & w, 0, 0, h >> 8, 255 & h, 8, 6, 0, 0, 0, 0, 0, 0, 0, sum1 >>> 24, sum1 >> 16 & 255, sum1 >> 8 & 255, 255 & sum1, 73, 68, 65, 84, 120, 1];
|
|
const items1 = [0, 498536548, 997073096, 651767980, 1994146192, 1802195444, 1303535960, 1342533948, -306674912, -267414716, -690576408, -882789492, -1687895376, -2032938284, -1609899400, -1111625188];
|
|
const diff = sum - 1;
|
|
let sum4 = diff;
|
|
let num = 0;
|
|
let num2 = 0;
|
|
let num3 = 0;
|
|
let num4 = 1;
|
|
let num5 = 0;
|
|
let num6 = 1;
|
|
if (0 < h) {
|
|
do {
|
|
sum2 = num2 + 1;
|
|
let tmp10 = sum4;
|
|
let tmp11 = num;
|
|
let tmp12 = num3;
|
|
let tmp13 = num4;
|
|
let num7 = 1;
|
|
if (sum2 < h) {
|
|
num7 = 0;
|
|
}
|
|
let tmp14 = items;
|
|
let tmp15 = num7;
|
|
let tmp16 = tmp7;
|
|
let tmp17 = tmp4;
|
|
let tmp18 = tmp6;
|
|
let tmp19 = tmp5;
|
|
let num8 = 0;
|
|
let arr = items.push(num7, tmp7, tmp4, tmp6, tmp5, 0);
|
|
let result = (num3 + num4) % 65521;
|
|
let sum3 = num;
|
|
let tmp23 = num4;
|
|
let tmp24 = result;
|
|
let tmp25 = num4;
|
|
let tmp26 = num;
|
|
if (num < sum4) {
|
|
do {
|
|
let tmp27 = 255 & rgba[sum3];
|
|
arr = items.push(tmp27);
|
|
let result1 = (tmp23 + tmp27) % 65521;
|
|
result = (result + result1) % 65521;
|
|
sum3 = sum3 + 1;
|
|
tmp23 = result1;
|
|
tmp24 = result;
|
|
tmp25 = result1;
|
|
tmp26 = sum3;
|
|
} while (sum3 < sum4);
|
|
}
|
|
sum4 = sum4 + diff;
|
|
num = tmp26;
|
|
num3 = tmp24;
|
|
num4 = tmp25;
|
|
num5 = tmp24;
|
|
num6 = tmp25;
|
|
num2 = sum2;
|
|
} while (sum2 < h);
|
|
}
|
|
items.push(num5 >> 8, 255 & num5, num6 >> 8, 255 & num6, 0, 0, 0, 0, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130);
|
|
const items2 = [[12, 29], ];
|
|
const items3 = [37, 41 + sum1];
|
|
items2[1] = items3;
|
|
while (tmp31 !== undefined) {
|
|
let tmp33 = callback;
|
|
let tmp34 = callback(tmp32, 2);
|
|
[tmp35, tmp36] = tmp34;
|
|
let tmp37 = tmp36;
|
|
let num9 = -1;
|
|
let tmp38 = tmp35;
|
|
if (tmp35 < tmp36) {
|
|
do {
|
|
let tmp39 = num9;
|
|
let tmp40 = tmp38;
|
|
let tmp41 = num9 ^ items[tmp38];
|
|
let tmp42 = tmp41;
|
|
let tmp43 = tmp41 >>> 4 ^ items1[15 & tmp41];
|
|
let tmp44 = tmp43;
|
|
num9 = tmp43 >>> 4 ^ items1[15 & tmp43];
|
|
sum5 = tmp38 + 1;
|
|
tmp38 = sum5;
|
|
let tmp46 = tmp36;
|
|
} while (sum5 < tmp37);
|
|
}
|
|
let tmp47 = num9;
|
|
let tmp48 = ~num9;
|
|
let tmp49 = tmp48;
|
|
let tmp50 = tmp36;
|
|
let tmp51 = +tmp37;
|
|
let sum6 = tmp51 + 1;
|
|
let tmp53 = sum6;
|
|
items[tmp51] = tmp48 >>> 24;
|
|
let tmp54 = +sum6;
|
|
let sum7 = tmp54 + 1;
|
|
let tmp56 = sum7;
|
|
items[tmp54] = tmp48 >> 16 & 255;
|
|
let tmp57 = +sum7;
|
|
let sum8 = tmp57 + 1;
|
|
let tmp59 = sum8;
|
|
items[tmp57] = tmp48 >> 8 & 255;
|
|
let tmp60 = +sum8;
|
|
let sum9 = tmp60 + 1;
|
|
items[tmp60] = 255 & tmp48;
|
|
continue;
|
|
}
|
|
const items4 = [...items];
|
|
return "data:image/png;base64," + btoa(String.fromCharCode.apply(items4));
|
|
}
|
|
|
|
export const rgbaToThumbHash = function rgbaToThumbHash(arg0, arg1, arg2) {
|
|
let result10;
|
|
let result2;
|
|
const callback = arg0;
|
|
closure_1 = arg1;
|
|
if (arg0 <= 100) {
|
|
if (arg1 <= 100) {
|
|
const _Math = Math;
|
|
const _Math2 = Math;
|
|
const _Math3 = Math;
|
|
const _Math4 = Math;
|
|
const _Math5 = Math;
|
|
let num6 = 0;
|
|
let num5 = 0;
|
|
let num4 = 0;
|
|
let num3 = 0;
|
|
let num2 = 0;
|
|
let num = 0;
|
|
let num7 = 0;
|
|
let num8 = 0;
|
|
let num9 = 0;
|
|
let num10 = 0;
|
|
if (0 < arg0 * arg1) {
|
|
do {
|
|
let result = arg2[num6 + 3] / 255;
|
|
let result1 = result / 255;
|
|
num = num + result1 * arg2[num6];
|
|
num2 = num2 + result1 * arg2[num6 + 1];
|
|
num3 = num3 + result1 * arg2[num6 + 2];
|
|
num4 = num4 + result;
|
|
num5 = num5 + 1;
|
|
num6 = num6 + 4;
|
|
num7 = num4;
|
|
num8 = num3;
|
|
num9 = num2;
|
|
num10 = num;
|
|
result2 = arg0 * arg1;
|
|
} while (num5 < result2);
|
|
}
|
|
let result5 = num8;
|
|
let result4 = num9;
|
|
let result3 = num10;
|
|
if (num7) {
|
|
result3 = num10 / num7;
|
|
result4 = num9 / num7;
|
|
result5 = num8 / num7;
|
|
}
|
|
let num11 = 7;
|
|
if (num7 < arg0 * arg1) {
|
|
num11 = 5;
|
|
}
|
|
const result6 = num11 * arg0;
|
|
let maxResult = max(1, round(result6 / max(arg0, arg1)));
|
|
const result7 = num11 * arg1;
|
|
const maxResult1 = max(1, round(result7 / max(arg0, arg1)));
|
|
let items = [];
|
|
let items1 = [];
|
|
let items2 = [];
|
|
const items3 = [];
|
|
let num12 = 0;
|
|
let num13 = 0;
|
|
if (0 < arg0 * arg1) {
|
|
do {
|
|
let result8 = arg2[num12 + 3] / 255;
|
|
let diff = 1 - result8;
|
|
let result9 = result8 / 255;
|
|
let sum = result3 * diff + result9 * arg2[num12];
|
|
let sum1 = result4 * diff + result9 * arg2[num12 + 1];
|
|
let sum2 = result5 * diff + result9 * arg2[num12 + 2];
|
|
let sum3 = sum + sum1;
|
|
items[num13] = (sum3 + sum2) / 3;
|
|
items1[num13] = sum3 / 2 - sum2;
|
|
items2[num13] = sum - sum1;
|
|
items3[num13] = result8;
|
|
num13 = num13 + 1;
|
|
num12 = num12 + 4;
|
|
result10 = arg0 * arg1;
|
|
} while (num13 < result10);
|
|
}
|
|
function encodeChannel(items, maxResult2, arg2) {
|
|
let length;
|
|
items = [];
|
|
const items1 = [];
|
|
let num = 0;
|
|
let num2 = 0;
|
|
let num3 = 0;
|
|
let num4 = 0;
|
|
let num5 = 0;
|
|
if (0 < arg2) {
|
|
do {
|
|
let tmp = num;
|
|
let tmp2 = num2;
|
|
let tmp3 = num3;
|
|
let num6 = 0;
|
|
let tmp4 = num2;
|
|
let tmp5 = num3;
|
|
if (0 < maxResult2 * (arg2 - num)) {
|
|
do {
|
|
let tmp6 = closure_0;
|
|
let tmp7 = num6;
|
|
let tmp8 = tmp2;
|
|
let tmp9 = tmp3;
|
|
let num7 = 0;
|
|
if (0 < closure_0) {
|
|
do {
|
|
let tmp10 = cos;
|
|
let tmp11 = PI;
|
|
let tmp12 = closure_0;
|
|
items1[num7] = cos(PI / closure_0 * num6 * (num7 + 0.5));
|
|
num7 = num7 + 1;
|
|
tmp6 = closure_0;
|
|
} while (num7 < closure_0);
|
|
}
|
|
let tmp13 = closure_1;
|
|
let num8 = 0;
|
|
let num9 = 0;
|
|
let num10 = 0;
|
|
if (0 < closure_1) {
|
|
do {
|
|
let tmp14 = cos;
|
|
let tmp15 = PI;
|
|
let tmp16 = closure_1;
|
|
let tmp18 = closure_0;
|
|
let tmp19 = num8;
|
|
let sum = num9;
|
|
let num11 = 0;
|
|
let tmp21 = num9;
|
|
if (0 < closure_0) {
|
|
do {
|
|
let tmp22 = closure_0;
|
|
sum = sum + items[num11 + num8 * closure_0] * items1[num11] * tmp17;
|
|
num11 = num11 + 1;
|
|
tmp21 = sum;
|
|
tmp18 = closure_0;
|
|
} while (num11 < closure_0);
|
|
}
|
|
num8 = num8 + 1;
|
|
tmp13 = closure_1;
|
|
num9 = tmp21;
|
|
tmp6 = tmp18;
|
|
num10 = tmp21;
|
|
} while (num8 < closure_1);
|
|
}
|
|
let result = num10 / (tmp6 * tmp13);
|
|
if (num6) {
|
|
let arr = items.push(result);
|
|
let tmp27 = max;
|
|
let tmp28 = abs;
|
|
let tmp24 = max(tmp2, abs(result));
|
|
let tmp25 = tmp3;
|
|
} else {
|
|
tmp24 = tmp2;
|
|
tmp25 = result;
|
|
}
|
|
sum1 = num6 + 1;
|
|
tmp2 = tmp24;
|
|
tmp3 = tmp25;
|
|
num6 = sum1;
|
|
tmp4 = tmp24;
|
|
tmp5 = tmp25;
|
|
} while (sum1 * arg2 < maxResult2 * (arg2 - num));
|
|
}
|
|
num = num + 1;
|
|
num2 = tmp4;
|
|
num3 = tmp5;
|
|
num4 = tmp4;
|
|
num5 = tmp5;
|
|
} while (num < arg2);
|
|
}
|
|
if (num4) {
|
|
let num12 = 0;
|
|
if (0 < items.length) {
|
|
do {
|
|
items[num12] = 0.5 + 0.5 / num4 * items[num12];
|
|
num12 = num12 + 1;
|
|
length = items.length;
|
|
} while (num12 < length);
|
|
}
|
|
}
|
|
const items2 = [num5, items, num4];
|
|
return items2;
|
|
}
|
|
const maxResult2 = max(3, maxResult);
|
|
let tmp21 = callback;
|
|
[tmp23, tmp24, tmp25] = callback(encodeChannel(items, max(3, maxResult), max(3, maxResult1)), 3);
|
|
let tmp22 = callback(encodeChannel(items, max(3, maxResult), max(3, maxResult1)), 3);
|
|
[tmp27, tmp28, tmp29] = callback(encodeChannel(items1, 3, 3), 3);
|
|
const tmp26 = callback(encodeChannel(items1, 3, 3), 3);
|
|
[tmp31, tmp32, tmp33] = callback(encodeChannel(items2, 3, 3), 3);
|
|
if (num7 < arg0 * arg1) {
|
|
let encodeChannelResult = encodeChannel(items3, 5, 5);
|
|
} else {
|
|
encodeChannelResult = [];
|
|
}
|
|
const tmp21Result = tmp21(encodeChannelResult, 3);
|
|
let tmp35 = tmp21Result[1];
|
|
const tmp30 = callback(encodeChannel(items2, 3, 3), 3);
|
|
const roundResult = round(63 * tmp23);
|
|
const tmp38 = round(63 * tmp23) | round(31.5 + 31.5 * tmp27) << 6;
|
|
const tmp39 = round(31.5 + 31.5 * tmp31) << 12;
|
|
if (arg0 > arg1) {
|
|
maxResult = maxResult1;
|
|
}
|
|
const tmp41 = tmp38 | tmp39 | round(31 * tmp25) << 18 | (num7 < arg0 * arg1) << 23;
|
|
const tmp40 = round(31 * tmp25) << 18;
|
|
const tmp43 = maxResult | round(63 * tmp29) << 3 | round(63 * tmp33) << 9 | (arg0 > arg1) << 15;
|
|
const items4 = [255 & tmp41, tmp41 >> 8 & 255, tmp41 >> 16, 255 & tmp43, tmp43 >> 8];
|
|
if (num7 < arg0 * arg1) {
|
|
items4.push(round(15 * tmp21Result[0]) | round(15 * tmp21Result[2]) << 4);
|
|
const roundResult1 = round(15 * tmp21Result[0]);
|
|
}
|
|
if (num7 < arg0 * arg1) {
|
|
const items5 = [tmp24, tmp28, tmp32, tmp35];
|
|
let items6 = items5;
|
|
} else {
|
|
items6 = [tmp24, tmp28, tmp32];
|
|
}
|
|
tmp35 = items6[Symbol.iterator]();
|
|
const tmp42 = maxResult | round(63 * tmp29) << 3;
|
|
}
|
|
}
|
|
error = new Error("" + arg0 + "x" + arg1 + " doesn't fit in 100x100");
|
|
throw error;
|
|
};
|
|
export { thumbHashToRGBA };
|
|
export const thumbHashToAverageRGBA = function thumbHashToAverageRGBA(arg0) {
|
|
let num = 1;
|
|
if ((arg0[0] | arg0[1] << 8 | arg0[2] << 16) >> 23) {
|
|
num = (15 & arg0[5]) / 15;
|
|
}
|
|
const result = (63 & tmp) / 63;
|
|
const diff = (tmp >> 12 & 63) / 31.5 - 1;
|
|
const diff1 = result - 0.6666666666666666 * ((tmp >> 6 & 63) / 31.5 - 1);
|
|
const result1 = (3 * result - diff1 + diff) / 2;
|
|
return { r: max(0, min(1, result1)), g: max(0, min(1, result1 - diff)), b: max(0, min(1, diff1)), a: num };
|
|
};
|
|
export const thumbHashToApproximateAspectRatio = function thumbHashToApproximateAspectRatio(arg0) {
|
|
if (128 & arg0[4]) {
|
|
let num = 7;
|
|
if (tmp2) {
|
|
num = 5;
|
|
}
|
|
let tmp4 = num;
|
|
} else {
|
|
tmp4 = 7 & tmp;
|
|
}
|
|
if (128 & arg0[4]) {
|
|
let num2 = 7 & tmp;
|
|
} else {
|
|
num2 = 7;
|
|
if (tmp2) {
|
|
num2 = 5;
|
|
}
|
|
}
|
|
return tmp4 / num2;
|
|
};
|
|
export { rgbaToDataURL };
|
|
export const thumbHashToDataURL = function thumbHashToDataURL(arg0) {
|
|
const tmp = thumbHashToRGBA(arg0);
|
|
return rgbaToDataURL(tmp.w, tmp.h, tmp.rgba);
|
|
};
|