SheWhoReignsSupreme/decord
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
decord/source/1953_decodeImage.js
github-actions 332fe55b4f chore: update source for alpha 344.1
2026-08-25 06:04:03 +00:00

3819 lines
122 KiB
JavaScript
Raw Blame History

// Module ID: 1953
// Function ID: 1954
// Name: decodeImage
// Dependencies: []
// Module 1953 (decodeImage)
let length3;
let length6;
let num2;
let tmp22;
let tmp24;
let tmp26;
let tmp28;
let tmp43;
let tmp58;
let tmp60;
let tmp62;
let tmp64;
c1 = function decodeImage(uint8Array, arg1, arg2, depth) {
const result = arg1 * arg2;
const rounded = Math.ceil(arg1 * ([1, null, 3, 1, 2, null, 4][depth.ctype] * depth.depth) / 8);
uint8Array = new Uint8Array(4 * result);
const uint32Array = new Uint32Array(uint8Array.buffer);
({ ctype, depth } = depth);
const readUshort = _undefined.readUshort;
const timestamp = Date.now();
if (6 == ctype) {
if (8 == depth) {
let num52 = 0;
if (0 < tmp64) {
do {
uint8Array[num52] = uint8Array[num52];
let sum = num52 + 1;
uint8Array[sum] = uint8Array[sum];
let sum1 = num52 + 2;
uint8Array[sum1] = uint8Array[sum1];
let sum2 = num52 + 3;
uint8Array[sum2] = uint8Array[sum2];
num52 = num52 + 4;
} while (num52 < tmp64);
}
}
if (16 == depth) {
let num55 = 0;
if (0 < tmp64) {
do {
uint8Array[num55] = uint8Array[num55 << 1];
num55 = num55 + 1;
} while (num55 < tmp64);
}
}
} else if (2 == ctype) {
let tRNS = depth.tabs.tRNS;
if (null == tRNS) {
if (8 == depth) {
let num46 = 0;
if (0 < result) {
do {
let result1 = 3 * num46;
uint32Array[num46] = -16777216 | uint8Array[result1 + 2] << 16 | uint8Array[result1 + 1] << 8 | uint8Array[result1];
num46 = num46 + 1;
} while (num46 < result);
}
}
if (16 == depth) {
let num48 = 0;
if (0 < result) {
do {
let result2 = 6 * num48;
uint32Array[num48] = -16777216 | uint8Array[result2 + 4] << 16 | uint8Array[result2 + 2] << 8 | uint8Array[result2];
num48 = num48 + 1;
} while (num48 < result);
}
}
} else {
[tmp69, tmp70, tmp71] = tRNS;
if (8 == depth) {
let num39 = 0;
if (0 < result) {
do {
let result3 = 3 * num39;
let sum3 = result3 + 2;
let sum4 = result3 + 1;
uint32Array[num39] = -16777216 | uint8Array[sum3] << 16 | uint8Array[sum4] << 8 | uint8Array[result3];
let tmp55 = uint8Array[result3] == tmp69;
let tmp56 = num39;
if (tmp55) {
tmp55 = uint8Array[sum4] == tmp70;
}
if (tmp55) {
tmp55 = uint8Array[sum3] == tmp71;
}
if (tmp55) {
uint8Array[(num39 << 2) + 3] = 0;
}
num39 = num39 + 1;
} while (num39 < result);
}
}
if (16 == depth) {
let num41 = 0;
if (0 < result) {
do {
let result4 = 6 * num41;
let sum5 = result4 + 4;
let sum6 = result4 + 2;
uint32Array[num41] = -16777216 | uint8Array[sum5] << 16 | uint8Array[sum6] << 8 | uint8Array[result4];
let tmp60 = readUshort(uint8Array, result4) == tmp69;
let tmp61 = num41;
if (tmp60) {
tmp60 = readUshort(uint8Array, sum6) == tmp70;
}
if (tmp60) {
tmp60 = readUshort(uint8Array, sum5) == tmp71;
}
if (tmp60) {
uint8Array[(num41 << 2) + 3] = 0;
}
num41 = num41 + 1;
} while (num41 < result);
}
}
}
} else if (3 == ctype) {
const PLTE = depth.tabs.PLTE;
tRNS = depth.tabs.tRNS;
let num26 = 0;
if (tRNS) {
num26 = tRNS.length;
}
if (1 == depth) {
for (let num30 = 0; num30 < arg2; num30 = num30 + 1) {
let tmp28 = num30;
for (let num28 = 0; num28 < arg1; num28 = num28 + 1) {
let tmp29 = tmp27 + num28 << 2;
let tmp30 = uint8Array[tmp26 + (num28 >> 3)] >> 7 - (7 & num28) & 1;
let result5 = 3 * tmp30;
uint8Array[tmp29] = PLTE[result5];
uint8Array[tmp29 + 1] = PLTE[result5 + 1];
uint8Array[tmp29 + 2] = PLTE[result5 + 2];
let tmp32 = num28;
let num29 = 255;
if (tmp30 < num26) {
num29 = tRNS[tmp30];
}
uint8Array[tmp29 + 3] = num29;
}
}
}
if (2 == depth) {
for (let num33 = 0; num33 < arg2; num33 = num33 + 1) {
let tmp35 = num33;
for (let num31 = 0; num31 < arg1; num31 = num31 + 1) {
let tmp36 = tmp34 + num31 << 2;
let tmp37 = uint8Array[tmp33 + (num31 >> 2)] >> 6 - ((3 & num31) << 1) & 3;
let result6 = 3 * tmp37;
uint8Array[tmp36] = PLTE[result6];
uint8Array[tmp36 + 1] = PLTE[result6 + 1];
uint8Array[tmp36 + 2] = PLTE[result6 + 2];
let tmp39 = num31;
let num32 = 255;
if (tmp37 < num26) {
num32 = tRNS[tmp37];
}
uint8Array[tmp36 + 3] = num32;
}
}
}
if (4 == depth) {
for (let num36 = 0; num36 < arg2; num36 = num36 + 1) {
let tmp42 = num36;
for (let num34 = 0; num34 < arg1; num34 = num34 + 1) {
let tmp43 = tmp41 + num34 << 2;
let tmp44 = uint8Array[tmp40 + (num34 >> 1)] >> 4 - ((1 & num34) << 2) & 15;
let result7 = 3 * tmp44;
uint8Array[tmp43] = PLTE[result7];
uint8Array[tmp43 + 1] = PLTE[result7 + 1];
uint8Array[tmp43 + 2] = PLTE[result7 + 2];
let tmp46 = num34;
let num35 = 255;
if (tmp44 < num26) {
num35 = tRNS[tmp44];
}
uint8Array[tmp43 + 3] = num35;
}
}
}
if (8 == depth) {
let num38 = 0;
if (0 < result) {
do {
let tmp47 = num38 << 2;
let tmp48 = uint8Array[num38];
let result8 = 3 * tmp48;
uint8Array[tmp47] = PLTE[result8];
uint8Array[tmp47 + 1] = PLTE[result8 + 1];
uint8Array[tmp47 + 2] = PLTE[result8 + 2];
let tmp50 = num38;
let num37 = 255;
if (tmp48 < num26) {
num37 = tRNS[tmp48];
}
uint8Array[tmp47 + 3] = num37;
num38 = num38 + 1;
} while (num38 < result);
}
}
} else if (4 == ctype) {
if (8 == depth) {
let num22 = 0;
if (0 < result) {
do {
let tmp20 = num22 << 2;
let tmp21 = num22 << 1;
let tmp22 = uint8Array[tmp21];
uint8Array[tmp20] = tmp22;
uint8Array[tmp20 + 1] = tmp22;
uint8Array[tmp20 + 2] = tmp22;
uint8Array[tmp20 + 3] = uint8Array[tmp21 + 1];
num22 = num22 + 1;
} while (num22 < result);
}
}
if (16 == depth) {
let num24 = 0;
if (0 < result) {
do {
let tmp23 = num24 << 2;
let tmp24 = uint8Array[tmp23];
uint8Array[tmp23] = tmp24;
uint8Array[tmp23 + 1] = tmp24;
let sum7 = tmp23 + 2;
uint8Array[sum7] = tmp24;
uint8Array[tmp23 + 3] = uint8Array[sum7];
num24 = num24 + 1;
} while (num24 < result);
}
}
} else if (0 == ctype) {
let num = -1;
if (depth.tabs.tRNS) {
num = depth.tabs.tRNS;
}
for (let num10 = 0; num10 < arg2; num10 = num10 + 1) {
let result9 = num10 * rounded;
let result10 = num10 * arg1;
let tmp8 = num10;
if (1 == depth) {
for (let num19 = 0; num19 < arg1; num19 = num19 + 1) {
let result11 = 255 * (uint8Array[result9 + (num19 >>> 3)] >>> 7 - (7 & num19) & 1);
let tmp19 = num19;
let num20 = 255;
if (result11 === 255 * num) {
num20 = 0;
}
uint32Array[result10 + num19] = num20 << 24 | result11 << 16 | result11 << 8 | result11;
}
} else if (2 == depth) {
for (let num17 = 0; num17 < arg1; num17 = num17 + 1) {
let result12 = 85 * (uint8Array[result9 + (num17 >>> 2)] >>> 6 - ((3 & num17) << 1) & 3);
let tmp17 = num17;
let num18 = 255;
if (result12 === 85 * num) {
num18 = 0;
}
uint32Array[result10 + num17] = num18 << 24 | result12 << 16 | result12 << 8 | result12;
}
} else if (4 == depth) {
for (let num15 = 0; num15 < arg1; num15 = num15 + 1) {
let result13 = 17 * (uint8Array[result9 + (num15 >>> 1)] >>> 4 - ((1 & num15) << 2) & 15);
let tmp15 = num15;
let num16 = 255;
if (result13 === 17 * num) {
num16 = 0;
}
uint32Array[result10 + num15] = num16 << 24 | result13 << 16 | result13 << 8 | result13;
}
} else if (8 == depth) {
for (let num13 = 0; num13 < arg1; num13 = num13 + 1) {
let tmp12 = uint8Array[result9 + num13];
let tmp13 = num13;
let num14 = 255;
if (tmp12 == num) {
num14 = 0;
}
uint32Array[result10 + num13] = num14 << 24 | tmp12 << 16 | tmp12 << 8 | tmp12;
}
} else if (16 == depth) {
for (let num12 = 0; num12 < arg1; num12 = num12 + 1) {
let sum8 = result9 + (num12 << 1);
let tmp10 = uint8Array[sum8];
let tmp11 = num12;
let num11 = 255;
if (readUshort(uint8Array, sum8) == num) {
num11 = 0;
}
uint32Array[result10 + num12] = num11 << 24 | tmp10 << 16 | tmp10 << 8 | tmp10;
}
}
}
}
return uint8Array;
};
c2 = function _decompress(depth, buffer) {
const timestamp = Date.now();
const uint8Array = new Uint8Array((Math.ceil(arg2 * ([1, null, 3, 1, 2, null, 4][depth.ctype] * depth.depth) / 8) + 1 + depth.interlace) * arg3);
if (depth.tabs.CgBI) {
let tmp3Result = tmp3(buffer, uint8Array);
} else {
const _Uint8Array = Uint8Array;
const uint8Array1 = new Uint8Array(buffer.buffer, 2, buffer.length - 6);
tmp3Result = tmp3(uint8Array1, uint8Array);
}
const timestamp1 = Date.now();
if (0 == depth.interlace) {
_main(tmp3Result, depth, 0, arg2, arg3);
let tmp36 = tmp3Result;
} else {
tmp36 = tmp3Result;
if (1 == depth.interlace) {
({ width, height } = depth);
const result = [1, null, 3, 1, 2, null, 4][depth.ctype] * depth.depth;
const _Math2 = Math;
const rounded = Math.ceil(width * result / 8);
const _Uint8Array2 = Uint8Array;
const uint8Array2 = new Uint8Array(height * rounded);
const items = [0, 0, 4, 0, 2, 0, 1];
const items1 = [0, 4, 0, 2, 0, 1, 0];
let num9 = 0;
let num10 = 0;
do {
let tmp10 = [8, 8, 8, 4, 4, 2, 2][num9];
let tmp11 = tmp50[num9];
let sum = items[num9];
let tmp13 = num9;
let num3 = 0;
let num4 = 0;
let tmp14 = num10;
while (sum < height) {
sum = sum + tmp10;
num3 = num3 + 1;
num4 = num3;
}
let sum1 = items1[num9];
let num5 = 0;
let num6 = 0;
while (sum1 < width) {
sum1 = sum1 + tmp11;
num5 = num5 + 1;
num6 = num5;
}
let _Math = Math;
let rounded1 = Math.ceil(num6 * result / 8);
let tmp17 = _main;
let tmp18 = tmp3Result;
let tmp19 = depth;
let tmp20 = num10;
let tmp21 = num6;
let tmp22 = num4;
let tmp23 = _main(tmp3Result, depth, tmp14, num6, num4);
let sum7 = items[num9];
let num7 = 0;
while (sum7 < height) {
let sum6 = items1[num9];
let sum5 = num10 + num7 * rounded1 << 3;
let tmp27 = sum7;
let tmp28 = num7;
if (sum6 < width) {
do {
let tmp29 = sum5;
let tmp30 = sum6;
if (1 == result) {
let sum2 = sum7 * rounded + (sum6 >> 3);
uint8Array2[sum2] = uint8Array2[sum2] | (tmp3Result[sum5 >> 3] >> 7 - (7 & sum5) & 1) << 7 - (7 & sum6);
}
if (2 == result) {
let sum3 = sum7 * rounded + (sum6 >> 2);
uint8Array2[sum3] = uint8Array2[sum3] | (tmp3Result[sum5 >> 3] >> 6 - (7 & sum5) & 3) << 6 - ((3 & sum6) << 1);
}
if (4 == result) {
let sum4 = sum7 * rounded + (sum6 >> 1);
uint8Array2[sum4] = uint8Array2[sum4] | (tmp3Result[sum5 >> 3] >> 4 - (7 & sum5) & 15) << 4 - ((1 & sum6) << 2);
}
if (result >= 8) {
let num8 = 0;
if (0 < tmp44) {
do {
uint8Array2[tmp34 + num8] = tmp3Result[(sum5 >> 3) + num8];
num8 = num8 + 1;
} while (num8 < tmp44);
}
}
sum5 = sum5 + result;
sum6 = sum6 + tmp11;
} while (sum6 < width);
}
num7 = num7 + 1;
sum7 = sum7 + tmp10;
}
let sum8 = num10;
if (num6 * num4 !== 0) {
sum8 = num10 + num4 * (1 + rounded1);
}
num9 = num9 + 1;
num10 = sum8;
tmp36 = uint8Array2;
} while (num9 < 7);
}
}
return tmp36;
};
let c3 = function _inflate(buffer, width) {
const uint8Array = new Uint8Array(buffer.buffer, 2, buffer.length - 6);
return dither(uint8Array, width);
};
let _main = function _filterZero(arg0, depth) {
const result = [1, null, 3, 1, 2, null, 4][depth.ctype] * depth.depth;
const rounded = Math.ceil(arg3 * result / 8);
const rounded1 = Math.ceil(result / 8);
if (arg0[arg2] > 1) {
arg0[arg2] = [0, 0, 1][tmp4 - 2];
}
if (3 == arg0[arg2]) {
let sum = rounded1;
if (rounded1 < rounded) {
do {
arg0[sum + 1] = arg0[sum + 1] + (arg0[sum + 1 - rounded1] >>> 1) & 255;
sum = sum + 1;
} while (sum < rounded);
}
}
for (let num3 = 0; num3 < arg4; num3 = num3 + 1) {
let sum1 = arg2 + num3 * rounded;
let sum2 = sum1 + num3 + 1;
let tmp8 = arg0[sum2 - 1];
let tmp9 = num3;
if (0 == tmp8) {
for (let num13 = 0; num13 < rounded; num13 = num13 + 1) {
arg0[sum1 + num13] = arg0[sum2 + num13];
}
} else if (1 == tmp8) {
let num11 = 0;
let num12 = 0;
if (0 < rounded1) {
do {
arg0[sum1 + num11] = arg0[sum2 + num11];
num11 = num11 + 1;
num12 = num11;
} while (num11 < rounded1);
}
if (num12 < rounded) {
do {
let sum3 = sum1 + num12;
arg0[sum3] = arg0[sum2 + num12] + arg0[sum3 - rounded1];
num12 = num12 + 1;
} while (num12 < rounded);
}
} else if (2 == tmp8) {
for (let num10 = 0; num10 < rounded; num10 = num10 + 1) {
let sum4 = sum1 + num10;
arg0[sum4] = arg0[sum2 + num10] + arg0[sum4 - rounded];
}
} else if (3 == tmp8) {
let num8 = 0;
let num9 = 0;
if (0 < rounded1) {
do {
let sum5 = sum1 + num8;
arg0[sum5] = arg0[sum2 + num8] + (arg0[sum5 - rounded] >>> 1);
num8 = num8 + 1;
num9 = num8;
} while (num8 < rounded1);
}
if (num9 < rounded) {
do {
let sum6 = sum1 + num9;
arg0[sum6] = arg0[sum2 + num9] + (arg0[sum6 - rounded] + arg0[sum6 - rounded1] >>> 1);
num9 = num9 + 1;
} while (num9 < rounded);
}
} else {
let num6 = 0;
let num7 = 0;
if (0 < rounded1) {
do {
let sum7 = sum1 + num6;
let tmp11 = arg0[sum7 - rounded];
let tmp12 = tmp11;
let tmp13 = tmp12;
let diff = tmp12 - tmp11;
let result1 = tmp13 * tmp13;
let result2 = diff * diff;
let tmp17 = num6;
if (result1 > result2) {
let num5 = 0;
if (result2 <= result1) {
num5 = tmp11;
}
let num4 = num5;
} else {
num4 = 0;
}
arg0[sum7] = arg0[sum2 + num6] + num4;
num6 = num6 + 1;
num7 = num6;
} while (num6 < rounded1);
}
if (num7 < rounded) {
do {
let sum8 = sum1 + num7;
let tmp19 = arg0[sum8 - rounded1];
let tmp20 = arg0[sum8 - rounded];
let tmp21 = arg0[sum8 - rounded1 - rounded];
let diff1 = tmp19 + tmp20 - tmp21;
let diff2 = diff1 - tmp19;
let diff3 = diff1 - tmp20;
let diff4 = diff1 - tmp21;
let tmp26 = num7;
if (diff2 * diff2 > diff3 * diff3) {
if (diff3 * diff3 <= diff4 * diff4) {
tmp21 = tmp20;
}
tmp19 = tmp21;
}
arg0[sum8] = arg0[sum2 + num7] + tmp19;
num7 = num7 + 1;
} while (num7 < rounded);
}
}
}
return arg0;
};
let compressPNG = function _IHDR(uint8Array, sum1) {
arg2.width = _undefined.readUint(uint8Array, sum1);
const sum = sum1 + 4;
arg2.height = _undefined.readUint(uint8Array, sum);
sum1 = sum + 4;
arg2.depth = uint8Array[sum1];
const sum2 = sum1 + 1;
arg2.ctype = uint8Array[sum2];
const sum3 = sum2 + 1;
arg2.compress = uint8Array[sum3];
const sum4 = sum3 + 1;
arg2.filter = uint8Array[sum4];
arg2.interlace = uint8Array[sum4 + 1];
};
function _copyTile(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
const bound = Math.min(arg1, arg4);
const bound1 = Math.min(arg2, arg5);
for (let num = 0; num < bound1; num = num + 1) {
let tmp3 = num;
let num2 = 0;
if (0 < bound) {
while (true) {
let tmp4 = num2;
if (arg6 >= 0) {
if (arg7 >= 0) {
let tmp5 = num * arg1 + num2 << 2;
let tmp6 = (arg7 + num) * arg4 + arg6 + num2 << 2;
if (0 == arg8) {
arg3[tmp6] = arg0[tmp5];
arg3[tmp6 + 1] = arg0[tmp5 + 1];
arg3[tmp6 + 2] = arg0[tmp5 + 2];
arg3[tmp6 + 3] = arg0[tmp5 + 3];
} else if (1 == arg8) {
let result = 0.00392156862745098 * arg0[tmp5 + 3];
let sum = tmp6 + 3;
let result1 = 0.00392156862745098 * arg3[sum];
let sum1 = tmp6 + 1;
let sum2 = tmp6 + 2;
let diff = 1 - result;
let sum3 = result + result1 * diff;
let num3 = 0;
let result2 = arg0[tmp5] * result;
let result3 = arg0[tmp5 + 1] * result;
let result4 = arg0[tmp5 + 2] * result;
let result5 = arg3[tmp6] * result1;
let result6 = arg3[sum1] * result1;
let result7 = arg3[sum2] * result1;
if (0 !== sum3) {
num3 = 1 / sum3;
}
arg3[sum] = 255 * sum3;
arg3[tmp6] = (result2 + result5 * diff) * num3;
arg3[sum1] = (result3 + result6 * diff) * num3;
arg3[sum2] = (result4 + result7 * diff) * num3;
} else if (2 == arg8) {
let tmp7 = arg0[tmp5 + 3];
let tmp8 = arg0[tmp5];
let tmp9 = arg0[tmp5 + 1];
let tmp10 = arg0[tmp5 + 2];
let sum4 = tmp6 + 3;
let sum5 = tmp6 + 1;
let sum6 = tmp6 + 2;
if (tmp7 == arg3[sum4]) {
if (tmp8 == arg3[tmp6]) {
if (tmp9 == arg3[sum5]) {
if (tmp10 == arg3[sum6]) {
arg3[tmp6] = 0;
arg3[sum5] = 0;
arg3[sum6] = 0;
arg3[sum4] = 0;
}
}
}
}
arg3[tmp6] = tmp8;
arg3[sum5] = tmp9;
arg3[sum6] = tmp10;
arg3[sum4] = tmp7;
} else if (3 == arg8) {
let tmp27 = arg0[tmp5 + 3];
let tmp28 = arg3[tmp6 + 3];
if (tmp27 < 220) {
if (tmp28 > 20) {
let flag = false;
return false;
}
}
}
num2 = num2 + 1;
if (num2 >= bound) {
break;
}
}
}
tmp5 = (-arg7 + num) * arg1 - arg6 + num2 << 2;
tmp6 = num * arg4 + num2 << 2;
}
}
}
return true;
}
let compress = _copyTile;
let obj = {
nextZero(uint8Array, sum1) {
let tmp4;
let tmp = sum1;
let tmp2 = sum1;
if (0 != uint8Array[sum1]) {
do {
let sum = tmp + 1;
tmp = sum;
tmp2 = sum;
tmp4 = uint8Array[sum];
} while (0 != tmp4);
}
return tmp2;
},
readUshort(uint8Array, sum1) {
return uint8Array[sum1] << 8 | uint8Array[sum1 + 1];
},
writeUshort(uint8Array, sum40, arg2) {
uint8Array[sum40] = arg2 >> 8 & 255;
uint8Array[sum40 + 1] = 255 & arg2;
},
readUint(uint8Array, sum1) {
return 16777216 * uint8Array[sum1] + (uint8Array[sum1 + 1] << 16 | uint8Array[sum1 + 2] << 8 | uint8Array[sum1 + 3]);
},
writeUint(uint8Array, writeUintResult16, height) {
uint8Array[writeUintResult16] = height >> 24 & 255;
uint8Array[writeUintResult16 + 1] = height >> 16 & 255;
uint8Array[writeUintResult16 + 2] = height >> 8 & 255;
uint8Array[writeUintResult16 + 3] = 255 & height;
},
readASCII(uint8Array, sum1, diff2) {
let num = 0;
let str = "";
let str2 = "";
if (0 < diff2) {
do {
let _String = String;
str = `${String.fromCharCode(uint8Array[sum1 + num])}`;
num = num + 1;
str2 = str;
} while (num < diff2);
}
return str2;
},
writeASCII(uint8Array, writeUintResult16, IEND) {
let length;
let num = 0;
if (0 < IEND.length) {
do {
let sum = writeUintResult16 + num;
uint8Array[sum] = IEND.charCodeAt(num);
num = num + 1;
length = IEND.length;
} while (num < length);
}
},
readBytes(uint8Array, sum1, uint) {
const items = [];
for (let num = 0; num < uint; num = num + 1) {
let arr = items.push(uint8Array[sum1 + num]);
}
return items;
},
pad(arg0) {
let text = arg0;
if (arg0.length < 2) {
text = `0${arg0}`;
}
return text;
},
readUTF8(uint8Array, sum7, length) {
let num = 0;
let str = "";
let str2 = "";
if (0 < length) {
do {
let tmp4 = _undefined;
let str3 = uint8Array[sum7 + num];
str = `${"%" + tmp5(str3.toString(16))}`;
num = num + 1;
str2 = str;
} while (num < length);
}
try {
const _decodeURIComponent = decodeURIComponent;
return decodeURIComponent(str2);
} catch (err) {
return _undefined.readASCII(tmp3, tmp2, tmp);
}
}
};
c0 = obj;
obj = { m: null, v: null, d: null, o: null, z: null, B: null, p: null, w: null, h: null, g: null, s: null, A: null, t: null, k: null, c: null, a: null, n: null, e: null, C: null, b: null, i: null, r: null, f: null, l: null, u: null, q: null, j: null };
const uint16Array = new Uint16Array(16);
obj[0] = uint16Array;
const uint16Array1 = new Uint16Array(16);
obj[1] = uint16Array1;
obj[2] = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
obj[3] = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 999, 999, 999];
obj[4] = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0];
const uint16Array2 = new Uint16Array(32);
obj[5] = uint16Array2;
obj[6] = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 65535, 65535];
obj[7] = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0];
let uint32Array = new Uint32Array(32);
obj[8] = uint32Array;
const uint16Array3 = new Uint16Array(512);
obj[9] = uint16Array3;
obj[10] = [];
const uint16Array4 = new Uint16Array(32);
obj[11] = uint16Array4;
obj[12] = [];
const uint16Array5 = new Uint16Array(32768);
obj[13] = uint16Array5;
obj[14] = [];
obj[15] = [];
const uint16Array6 = new Uint16Array(32768);
obj[16] = uint16Array6;
obj[17] = [];
const uint16Array7 = new Uint16Array(512);
obj[18] = uint16Array7;
obj[19] = [];
const uint16Array8 = new Uint16Array(32768);
obj[20] = uint16Array8;
let uint32Array1 = new Uint32Array(286);
obj[21] = uint32Array1;
let uint32Array2 = new Uint32Array(30);
obj[22] = uint32Array2;
let uint32Array3 = new Uint32Array(19);
obj[23] = uint32Array3;
const uint32Array4 = new Uint32Array(15000);
obj[24] = uint32Array4;
const uint16Array9 = new Uint16Array(65536);
obj[25] = uint16Array9;
const uint16Array10 = new Uint16Array(32768);
obj[26] = uint16Array10;
c0 = obj;
let num = 0;
do {
let tmp17 = (2863311530 & num) >>> 1 | (1431655765 & num) << 1;
let tmp18 = (3435973836 & tmp17) >>> 2 | (858993459 & tmp17) << 2;
let tmp19 = (4042322160 & tmp18) >>> 4 | (252645135 & tmp18) << 4;
let tmp20 = (4278255360 & tmp19) >>> 8 | (16711935 & tmp19) << 8;
obj.i[num] = (tmp20 >>> 16 | tmp20 << 16) >>> 17;
num = num + 1;
num2 = 0;
} while (num < 32768);
do {
obj.B[num2] = obj.o[num2] << 3 | obj.z[num2];
obj.h[num2] = obj.p[num2] << 4 | obj.w[num2];
num2 = num2 + 1;
} while (num2 < 32);
const s = obj.s;
let num3 = 143;
do {
let arr = require("module_0");
tmp22 = num3;
num3 = num3 - 1;
} while (0 !== tmp22);
const s1 = obj.s;
let num4 = 111;
do {
arr = require("module_0");
tmp24 = num4;
num4 = num4 - 1;
} while (0 !== tmp24);
const s2 = obj.s;
let num5 = 23;
do {
let arr1 = require("module_0");
tmp26 = num5;
num5 = num5 - 1;
} while (0 !== tmp26);
const s3 = obj.s;
let num6 = 7;
do {
let arr2 = require("module_0");
tmp28 = num6;
num6 = num6 - 1;
} while (0 !== tmp28);
const s4 = obj.s;
let v = obj.v;
let num7 = 0;
do {
v[num7] = 0;
num7 = num7 + 1;
} while (num7 <= 9);
for (let num8 = 1; num8 < length; num8 = num8 + 2) {
let tmp29 = s4[num8];
v[tmp29] = v[tmp29] + 1;
}
let m = obj.m;
v[0] = 0;
let num9 = 1;
let num10 = 0;
do {
let tmp30 = num10 + v[num9 - 1] << 1;
m[num9] = tmp30;
num9 = num9 + 1;
num10 = tmp30;
} while (num9 <= 9);
for (let num11 = 0; num11 < length; num11 = num11 + 2) {
let tmp31 = s4[num11 + 1];
let tmp32 = num11;
if (0 != tmp31) {
s4[num11] = m[tmp31];
m[tmp31] = m[tmp31] + 1;
}
}
const s5 = obj.s;
for (let num12 = 0; num12 < length2; num12 = num12 + 2) {
let sum = num12 + 1;
let tmp36 = num12;
if (0 != s5[sum]) {
let diff = 9 - s5[sum];
let sum2 = s5[num12] << diff;
let sum1 = sum2 + (1 << diff);
if (sum2 !== sum1) {
do {
tmp33[tmp34[sum2] >>> 6] = tmp37;
sum2 = sum2 + 1;
} while (sum2 !== sum1);
}
}
}
const s6 = obj.s;
let num13 = 0;
if (0 < s6.length) {
do {
s6[num13] = tmp41[s6[num13] << 9 - s6[num13 + 1]] >>> 6;
num13 = num13 + 2;
length3 = s6.length;
} while (num13 < length3);
}
const t = obj.t;
let num14 = 31;
do {
let arr3 = require("module_0");
tmp43 = num14;
num14 = num14 - 1;
} while (0 !== tmp43);
const t1 = obj.t;
let v2 = obj.v;
let num15 = 0;
do {
v2[num15] = 0;
num15 = num15 + 1;
} while (num15 <= 5);
for (let num16 = 1; num16 < length4; num16 = num16 + 2) {
let tmp44 = t1[num16];
v2[tmp44] = v2[tmp44] + 1;
}
let m2 = obj.m;
v2[0] = 0;
let num17 = 1;
let num18 = 0;
do {
let tmp45 = num18 + v2[num17 - 1] << 1;
m2[num17] = tmp45;
num17 = num17 + 1;
num18 = tmp45;
} while (num17 <= 5);
for (let num19 = 0; num19 < length4; num19 = num19 + 2) {
let tmp46 = t1[num19 + 1];
let tmp47 = num19;
if (0 != tmp46) {
t1[num19] = m2[tmp46];
m2[tmp46] = m2[tmp46] + 1;
}
}
const t2 = obj.t;
for (let num20 = 0; num20 < length5; num20 = num20 + 2) {
let sum3 = num20 + 1;
let tmp51 = num20;
if (0 != t2[sum3]) {
let diff1 = 5 - t2[sum3];
let sum5 = t2[num20] << diff1;
let sum4 = sum5 + (1 << diff1);
if (sum5 !== sum4) {
do {
tmp48[tmp49[sum5] >>> 10] = tmp52;
sum5 = sum5 + 1;
} while (sum5 !== sum4);
}
}
}
const t3 = obj.t;
let num21 = 0;
if (0 < t3.length) {
do {
t3[num21] = tmp56[t3[num21] << 5 - t3[num21 + 1]] >>> 10;
num21 = num21 + 2;
length6 = t3.length;
} while (num21 < length6);
}
let b = obj.b;
let num22 = 18;
do {
let arr4 = require("module_0");
tmp58 = num22;
num22 = num22 - 1;
} while (0 !== tmp58);
let c = obj.c;
let num23 = 285;
do {
let arr5 = require("module_0");
tmp60 = num23;
num23 = num23 - 1;
} while (0 !== tmp60);
let event = obj.e;
let num24 = 29;
do {
let arr6 = require("module_0");
tmp62 = num24;
num24 = num24 - 1;
} while (0 !== tmp62);
let a = obj.a;
let num25 = 319;
do {
let arr7 = require("module_0");
tmp64 = num25;
num25 = num25 - 1;
} while (0 !== tmp64);
let dither = function v(buffer) {
let arr2;
let sum22;
let _Uint8Array = arg1;
_Uint8Array = Uint8Array;
if (3 == buffer[0]) {
if (0 == buffer[1]) {
if (!_Uint8Array) {
_Uint8Array = new.target;
_Uint8Array = new.target;
_Uint8Array = new _Uint8Array(0);
}
return _Uint8Array;
}
}
let _Uint8Array1 = _Uint8Array;
if (null == _Uint8Array) {
_Uint8Array1 = new _Uint8Array(buffer.length >>> 2 << 3);
}
let num3 = 0;
let num4 = 0;
let num5 = 0;
let num6 = 0;
do {
let tmp7 = num3 >>> 3;
let sum = num3 + 1;
let tmp11 = sum >>> 3;
let tmp12 = (buffer[tmp11] | buffer[1 + tmp11] << 8 | buffer[2 + tmp11] << 16) >>> (7 & sum) & 3;
let sum1 = num3 + 3;
let tmp14 = num3;
let tmp15 = num4;
let num7 = num5;
let num8 = num6;
A = tmp5;
g = tmp6;
let tmp16 = _Uint8Array1;
let tmp8 = buffer[tmp7] | buffer[1 + tmp7] << 8;
let tmp9 = buffer[2 + tmp7] << 16;
if (0 !== tmp12) {
let tmp38 = _Uint8Array1;
if (tmp2) {
let sum2 = num4 + 131072;
let length2 = _Uint8Array1.length;
let tmp40 = _Uint8Array1;
if (sum2 > length2) {
let _Uint8Array3 = Uint8Array;
let _Math2 = Math;
let tmp41 = new.target;
let tmp42 = new.target;
let uint8Array = new Uint8Array(Math.max(length2 << 1, sum2));
let tmp43 = uint8Array;
let result = uint8Array.set(_Uint8Array1, 0);
tmp40 = uint8Array;
}
tmp38 = tmp40;
}
if (1 === tmp12) {
let tmp45 = _undefined;
({ g, A } = _undefined);
num7 = 31;
num8 = 511;
}
let tmp46 = sum1;
let sum18 = num4;
let arr3 = tmp38;
if (2 === tmp12) {
_Uint8Array = sum1 >>> 3;
_Uint8Array = sum1 + 5;
_Uint8Array = _Uint8Array >>> 3;
_Uint8Array = sum1 + 10;
_Uint8Array = _Uint8Array >>> 3;
let num9 = 0;
_Uint8Array = buffer[_Uint8Array] | buffer[1 + _Uint8Array] << 8;
_Uint8Array = buffer[_Uint8Array] | buffer[1 + _Uint8Array] << 8;
_Uint8Array = buffer[_Uint8Array] | buffer[1 + _Uint8Array] << 8;
do {
let tmp48 = _undefined;
_undefined.b[num9] = 0;
_undefined.b[num9 + 1] = 0;
num9 = num9 + 2;
} while (num9 < 38);
let sum3 = (_Uint8Array >>> (7 & _Uint8Array) & 15) + 4;
let sum4 = sum1 + 14;
let num10 = 0;
let num11 = 1;
let num12 = 1;
if (0 < sum3) {
do {
let sum5 = sum4 + 3 * num10;
let tmp52 = sum5 >>> 3;
let tmp53 = (buffer[tmp52] | buffer[1 + tmp52] << 8) >>> (7 & sum5) & 7;
_undefined.b[1 + (_undefined.d[num10] << 1)] = tmp53;
let tmp55 = num10;
let tmp56 = num11;
let tmp54 = _undefined;
if (num11 < tmp53) {
tmp56 = tmp53;
}
num10 = num10 + 1;
num11 = tmp56;
tmp48 = tmp54;
num12 = tmp56;
} while (num10 < sum3);
}
let b = tmp48.b;
let length3 = b.length;
let v = tmp48.v;
let num13 = 0;
if (0 <= num12) {
do {
v[num13] = 0;
num13 = num13 + 1;
} while (num13 <= num12);
}
for (let num14 = 1; num14 < length3; num14 = num14 + 2) {
let tmp57 = b[num14];
v[tmp57] = v[tmp57] + 1;
}
let tmp58 = _undefined;
let m = _undefined.m;
v[0] = 0;
let num15 = 1;
let num16 = 0;
if (1 <= num12) {
do {
let tmp59 = num16 + v[num15 - 1] << 1;
m[num15] = tmp59;
num15 = num15 + 1;
num16 = tmp59;
} while (num15 <= num12);
}
for (let num17 = 0; num17 < length3; num17 = num17 + 2) {
let tmp60 = b[num17 + 1];
let tmp61 = num17;
if (0 != tmp60) {
b[num17] = m[tmp60];
m[tmp60] = m[tmp60] + 1;
}
}
let b1 = tmp48.b;
let length4 = b1.length;
let tmp63 = _undefined;
for (let num18 = 0; num18 < length4; num18 = num18 + 2) {
let sum6 = num18 + 1;
let tmp67 = num18;
if (0 != b1[sum6]) {
let diff = num12 - b1[sum6];
let sum8 = b1[num18] << diff;
let sum7 = sum8 + (1 << diff);
if (sum8 !== sum7) {
do {
tmp62[tmp64[sum8] >>> tmp65] = tmp68;
sum8 = sum8 + 1;
} while (sum8 !== sum7);
}
}
}
let sum9 = (_Uint8Array >>> (7 & sum1) & 31) + 257;
let sum10 = (_Uint8Array >>> (7 & _Uint8Array) & 31) + 1;
let sum11 = sum4 + 3 * sum3;
({ k, n } = tmp48);
let sum12 = sum9 + sum10;
let a = tmp48.a;
let num19 = 0;
let tmp78 = sum11;
let tmp79 = sum11;
if (0 < sum12) {
do {
let tmp80 = tmp78 >>> 3;
let tmp81 = tmp75[(buffer[tmp80] | buffer[1 + tmp80] << 8 | buffer[2 + tmp80] << 16) >>> (7 & tmp78) & tmp76];
let sum13 = tmp78 + (15 & tmp81);
let tmp83 = tmp81 >>> 4;
let tmp84 = num19;
if (tmp83 <= 15) {
a[num19] = tmp83;
sum14 = num19 + 1;
let tmp90 = sum13;
} else {
if (16 === tmp83) {
let tmp87 = sum13 >>> 3;
let num20 = 3 + ((buffer[tmp87] | buffer[1 + tmp87] << 8) >>> (7 & sum13) & 3);
let sum15 = sum13 + 2;
let num21 = a[num19 - 1];
} else if (17 === tmp83) {
let tmp86 = sum13 >>> 3;
num20 = 3 + ((buffer[tmp86] | buffer[1 + tmp86] << 8) >>> (7 & sum13) & 7);
sum15 = sum13 + 3;
num21 = 0;
} else {
num20 = 0;
num21 = 0;
sum15 = sum13;
if (18 === tmp83) {
_Uint8Array = sum13 >>> 3;
num20 = 11 + ((buffer[_Uint8Array] | buffer[1 + _Uint8Array] << 8) >>> (7 & sum13) & 127);
sum15 = sum13 + 7;
num21 = 0;
}
}
let sum16 = num19 + num20;
let sum17 = num19;
tmp90 = sum15;
sum14 = num19;
if (num19 < sum16) {
do {
a[sum17] = num21;
sum17 = sum17 + 1;
tmp90 = sum15;
sum14 = sum17;
} while (sum17 < sum16);
}
}
num19 = sum14;
tmp78 = tmp90;
tmp79 = tmp90;
} while (sum14 < sum12);
}
let c = tmp48.c;
let tmp93 = c.length >>> 1;
let num22 = 0;
let num23 = 0;
let num24 = 0;
let num25 = 0;
if (0 < sum9) {
do {
let tmp94 = tmp92[num22];
let tmp95 = num22 << 1;
c[tmp95] = 0;
c[1 + tmp95] = tmp94;
let tmp96 = num22;
let tmp97 = num23;
if (tmp94 > num23) {
tmp97 = tmp94;
}
num22 = num22 + 1;
num23 = tmp97;
num25 = tmp97;
num24 = num22;
} while (num22 < sum9);
}
if (num24 < tmp93) {
do {
let tmp98 = num24 << 1;
c[tmp98] = 0;
c[1 + tmp98] = 0;
num24 = num24 + 1;
} while (num24 < tmp93);
}
let event = tmp48.e;
_Uint8Array = event.length >>> 1;
let num26 = 0;
let num27 = 0;
let num28 = 0;
let num29 = 0;
let tmp99 = 1 << num25;
if (0 < sum10) {
do {
_Uint8Array = _Uint8Array[num26 + sum9];
_Uint8Array = num26 << 1;
event[_Uint8Array] = 0;
event[1 + _Uint8Array] = _Uint8Array;
_Uint8Array = num26;
_Uint8Array = num27;
num26 = num26 + 1;
num27 = _Uint8Array;
num29 = _Uint8Array;
num28 = num26;
} while (num26 < sum10);
}
if (num28 < _Uint8Array) {
do {
_Uint8Array = num28 << 1;
event[_Uint8Array] = 0;
event[1 + _Uint8Array] = 0;
num28 = num28 + 1;
} while (num28 < _Uint8Array);
}
let _undefined2 = tmp48.c;
let length5 = _undefined2.length;
_Uint8Array = _undefined;
let v2 = _undefined.v;
let num30 = 0;
_Uint8Array = 1 << num29;
if (0 <= num25) {
do {
v2[num30] = 0;
num30 = num30 + 1;
} while (num30 <= num25);
}
for (let num31 = 1; num31 < length5; num31 = num31 + 2) {
_Uint8Array = _undefined2[num31];
v2[_Uint8Array] = v2[_Uint8Array] + 1;
}
_Uint8Array = _undefined;
let m2 = _undefined.m;
v2[0] = 0;
let num32 = 1;
let num33 = 0;
if (1 <= num25) {
do {
_Uint8Array = num33 + v2[num32 - 1] << 1;
m2[num32] = _Uint8Array;
num32 = num32 + 1;
num33 = _Uint8Array;
} while (num32 <= num25);
}
for (let num34 = 0; num34 < length5; num34 = num34 + 2) {
_Uint8Array = _undefined2[num34 + 1];
_Uint8Array = num34;
if (0 != _Uint8Array) {
_undefined2[num34] = m2[_Uint8Array];
m2[_Uint8Array] = m2[_Uint8Array] + 1;
}
}
let _undefined3 = tmp48.c;
let length6 = _undefined3.length;
_Uint8Array = _undefined;
for (let num35 = 0; num35 < length6; num35 = num35 + 2) {
_Uint8Array = num35 + 1;
_Uint8Array = num35;
if (0 != _undefined3[_Uint8Array]) {
_Uint8Array = num25 - _undefined3[_Uint8Array];
_Uint8Array = _undefined3[num35] << _Uint8Array;
_Uint8Array = _Uint8Array + (1 << _Uint8Array);
if (_Uint8Array != _Uint8Array) {
do {
k[_Uint8Array[_Uint8Array] >>> 15 - num25] = _Uint8Array;
_Uint8Array = _Uint8Array + 1;
} while (_Uint8Array != _Uint8Array);
}
}
}
let event1 = tmp48.e;
let length7 = event1.length;
_Uint8Array = _undefined;
let v3 = _undefined.v;
for (let num36 = 0; num36 <= num29; num36 = num36 + 1) {
v3[num36] = 0;
}
for (let num37 = 1; num37 < length7; num37 = num37 + 2) {
_Uint8Array = event1[num37];
v3[_Uint8Array] = v3[_Uint8Array] + 1;
}
_Uint8Array = _undefined;
let m3 = _undefined.m;
v3[0] = 0;
let num38 = 1;
let num39 = 0;
if (1 <= num29) {
do {
_Uint8Array = num39 + v3[num38 - 1] << 1;
m3[num38] = _Uint8Array;
num38 = num38 + 1;
num39 = _Uint8Array;
} while (num38 <= num29);
}
for (let num40 = 0; num40 < length7; num40 = num40 + 2) {
_Uint8Array = event1[num40 + 1];
_Uint8Array = num40;
if (0 != _Uint8Array) {
event1[num40] = m3[_Uint8Array];
m3[_Uint8Array] = m3[_Uint8Array] + 1;
}
}
_Uint8Array = tmp99 - 1;
_Uint8Array = _Uint8Array - 1;
let event2 = tmp48.e;
let length8 = event2.length;
_Uint8Array = _undefined;
let num41 = 0;
tmp46 = tmp79;
sum18 = num4;
num7 = _Uint8Array;
num8 = _Uint8Array;
A = n;
g = k;
arr3 = tmp38;
if (0 < length8) {
do {
_Uint8Array = num41 + 1;
_Uint8Array = num41;
if (0 != event2[_Uint8Array]) {
_Uint8Array = num29 - event2[_Uint8Array];
_Uint8Array = event2[num41] << _Uint8Array;
_Uint8Array = _Uint8Array + (1 << _Uint8Array);
if (_Uint8Array != _Uint8Array) {
do {
n[_Uint8Array[_Uint8Array] >>> 15 - num29] = _Uint8Array;
_Uint8Array = _Uint8Array + 1;
} while (_Uint8Array != _Uint8Array);
}
}
num41 = num41 + 2;
tmp46 = tmp79;
sum18 = num4;
num7 = _Uint8Array;
num8 = _Uint8Array;
A = n;
g = k;
arr3 = tmp38;
} while (num41 < length8);
}
}
while (true) {
_Uint8Array = tmp46 >>> 3;
_Uint8Array = g[(buffer[_Uint8Array] | buffer[1 + _Uint8Array] << 8 | buffer[2 + _Uint8Array] << 16) >>> (7 & tmp46) & num8];
_Uint8Array = tmp46 + (15 & _Uint8Array);
_Uint8Array = _Uint8Array >>> 4;
_Uint8Array = sum18;
_Uint8Array = arr3;
if (_Uint8Array >>> 8 === 0) {
sum18 = sum18 + 1;
arr3[_Uint8Array] = _Uint8Array;
tmp46 = _Uint8Array;
continue;
} else {
let tmp32 = _Uint8Array;
sum22 = sum18;
let tmp34 = num7;
let tmp35 = num8;
let tmp36 = A;
let tmp37 = g;
arr2 = arr3;
if (256 === _Uint8Array) {
break;
} else {
_Uint8Array = sum18 + _Uint8Array - 254;
if (264 < _Uint8Array) {
_Uint8Array = _undefined;
_Uint8Array = _undefined.B[_Uint8Array - 257];
_Uint8Array = _Uint8Array >>> 3;
_Uint8Array = sum18 + (_Uint8Array >>> 3) + ((buffer[_Uint8Array] | buffer[1 + _Uint8Array] << 8) >>> (7 & _Uint8Array) & (1 << (7 & _Uint8Array)) - 1);
_Uint8Array = _Uint8Array + (7 & _Uint8Array);
}
_Uint8Array = _Uint8Array >>> 3;
_Uint8Array = A[(buffer[_Uint8Array] | buffer[1 + _Uint8Array] << 8 | buffer[2 + _Uint8Array] << 16) >>> (7 & _Uint8Array) & num7];
_Uint8Array = _Uint8Array + (15 & _Uint8Array);
_Uint8Array = _undefined;
_Uint8Array = _undefined.h[_Uint8Array >>> 4];
_Uint8Array = _Uint8Array >>> 3;
_Uint8Array = (_Uint8Array >>> 4) + ((buffer[_Uint8Array] | buffer[1 + _Uint8Array] << 8 | buffer[2 + _Uint8Array] << 16) >>> (7 & _Uint8Array) & (1 << (15 & _Uint8Array)) - 1);
_Uint8Array = arr3;
_Uint8Array = 15 & _Uint8Array;
if (tmp2) {
_Uint8Array = sum18 + 131072;
let length9 = arr3.length;
_Uint8Array = arr3;
if (_Uint8Array > length9) {
let _Uint8Array4 = Uint8Array;
let _Math3 = Math;
_Uint8Array = new.target;
_Uint8Array = new.target;
let uint8Array1 = new Uint8Array(Math.max(length9 << 1, _Uint8Array));
_Uint8Array = uint8Array1;
_Uint8Array = uint8Array1.set(arr3, 0);
_Uint8Array = uint8Array1;
}
}
_Uint8Array = _Uint8Array + _Uint8Array;
tmp46 = _Uint8Array;
sum18 = _Uint8Array;
arr3 = _Uint8Array;
if (_Uint8Array >= _Uint8Array) {
continue;
} else {
do {
_Uint8Array = _Uint8Array + 1;
_Uint8Array[_Uint8Array] = _Uint8Array[_Uint8Array - _Uint8Array];
_Uint8Array = _Uint8Array + 1;
_Uint8Array[_Uint8Array] = _Uint8Array[_Uint8Array - _Uint8Array];
_Uint8Array = _Uint8Array + 1;
_Uint8Array[_Uint8Array] = _Uint8Array[_Uint8Array - _Uint8Array];
_Uint8Array = _Uint8Array + 1;
_Uint8Array[_Uint8Array] = _Uint8Array[_Uint8Array - _Uint8Array];
tmp46 = _Uint8Array;
num7 = _Uint8Array;
num8 = _Uint8Array;
A = _Uint8Array;
g = _Uint8Array;
arr3 = _Uint8Array;
sum18 = _Uint8Array;
} while (_Uint8Array < _Uint8Array);
continue;
}
continue;
}
}
}
} else {
_Uint8Array = 7 & sum1;
let sum19 = sum1;
if (_Uint8Array) {
sum19 = sum1 + (8 - _Uint8Array);
}
let sum20 = 4 + (sum19 >>> 3);
let tmp19 = buffer[sum20 - 4] | buffer[sum20 - 3] << 8;
let obj = _Uint8Array1;
if (tmp2) {
let sum21 = num4 + tmp19;
let length = _Uint8Array1.length;
let tmp21 = _Uint8Array1;
if (sum21 > length) {
let _Uint8Array2 = Uint8Array;
let _Math = Math;
let tmp22 = new.target;
let tmp23 = new.target;
let uint8Array2 = new Uint8Array(Math.max(length << 1, sum21));
let tmp24 = uint8Array2;
let result1 = uint8Array2.set(_Uint8Array1, 0);
tmp21 = uint8Array2;
}
obj = tmp21;
}
let tmp26 = new.target;
let tmp27 = new.target;
let tmp28 = tmp19;
_Uint8Array2 = new _Uint8Array(buffer.buffer, buffer.byteOffset + sum20, tmp19);
let tmp30 = _Uint8Array2;
let result2 = obj.set(_Uint8Array2, num4);
tmp32 = sum20 + tmp19 << 3;
sum22 = num4 + tmp19;
arr2 = obj;
tmp34 = num7;
tmp35 = num8;
tmp36 = A;
tmp37 = g;
}
_Uint8Array = (tmp8 | tmp9) >>> (7 & num3) & 1;
num3 = tmp32;
num5 = tmp34;
num6 = tmp35;
tmp5 = tmp36;
tmp6 = tmp37;
num4 = sum22;
_Uint8Array1 = arr2;
} while (0 === _Uint8Array);
_Uint8Array = arr2;
if (arr2.length != sum22) {
_Uint8Array = arr2.slice(0, sum22);
}
return _Uint8Array;
};
obj = {
decode(arg0) {
const uint8Array = new Uint8Array(arg0);
let obj = c0;
({ readUshort, readUint } = c0);
const size = { tabs: {}, frames: [] };
const uint8Array1 = new Uint8Array(uint8Array.length);
let num = 0;
while (uint8Array[num] == [137, 80, 78, 71, 13, 10, 26, 10][num]) {
num = num + 1;
if (num < 8) {
continue;
} else {
let num2 = 4;
let num3 = 2;
let tmp7 = null;
let num4 = 1000;
let num5 = 24;
let num6 = 25;
let num7 = 12;
let num8 = 16;
let num9 = 22;
let num10 = 20;
let num11 = 100;
let str = "tEXt";
let num12 = 3;
let num13 = 100000;
let num14 = 6;
let str2 = "IEND";
let str3 = "bKGD";
let str4 = "sRGB";
let str5 = "gAMA";
let str6 = "tRNS";
let str7 = "hIST";
let str8 = "PLTE";
let str9 = "iTXt";
let str10 = "zTXt";
let str11 = "cHRM";
let str12 = "pHYs";
let str13 = "fdAT";
let str14 = "fcTL";
let str15 = "acTL";
let str16 = "IDAT";
let str17 = "CgBI";
let str18 = "iCCP";
let str19 = "IHDR";
let num15 = 0;
let num16 = 0;
let num17 = 8;
let num18 = 0;
let tmp6 = uint8Array1;
if (8 < uint8Array.length) {
let uint = obj.readUint(uint8Array, num17);
let sum = num17 + 4;
let aSCII = obj.readASCII(uint8Array, sum, 4);
let sum1 = sum + 4;
let tmp12 = num15;
let tmp13 = num16;
let tmp14 = arr1;
if ("IHDR" == aSCII) {
let tmp61 = compressPNG;
let tmp62 = compressPNG(uint8Array, sum1, size);
let sum4 = num15;
let sum3 = num16;
let uint8Array2 = arr1;
} else if ("iCCP" == aSCII) {
let tmp49 = sum1;
let tmp50 = sum1;
if (0 != uint8Array[sum1]) {
do {
let sum2 = tmp49 + 1;
tmp49 = sum2;
tmp50 = sum2;
tmp52 = uint8Array[sum2];
} while (0 != tmp52);
}
let aSCII1 = obj.readASCII(uint8Array, sum1, tmp50 - sum1);
let tmp54 = uint8Array[tmp50 + 1];
let tmp56 = null;
try {
let tmp57 = _undefined4;
let tmp58 = _undefined4(tmp55);
let tmp60 = tmp58;
size.tabs[aSCII] = tmp58;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} catch (err) {
let tmp59 = dither;
tmp58 = dither(tmp4);
}
} else if ("CgBI" == aSCII) {
size.tabs[aSCII] = uint8Array.slice(sum1, sum1 + 4);
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else if ("IDAT" == aSCII) {
for (let num24 = 0; num24 < uint; num24 = num24 + 1) {
uint8Array1[num16 + num24] = uint8Array[sum1 + num24];
}
sum3 = num16 + uint;
sum4 = num15;
uint8Array2 = arr1;
} else if ("acTL" == aSCII) {
obj = { num_frames: null, num_plays: null };
obj[0] = readUint(uint8Array, sum1);
obj[1] = readUint(uint8Array, sum1 + 4);
size.tabs[aSCII] = obj;
let _Uint8Array = Uint8Array;
let tmp47 = new.target;
let tmp48 = new.target;
uint8Array2 = new Uint8Array(uint8Array.length);
sum4 = num15;
sum3 = num16;
} else if ("fcTL" == aSCII) {
let num22 = num15;
if (0 !== num15) {
let tmp41 = size.frames[size.frames.length - 1];
let tmp42 = _undefined3;
let tmp43 = size;
tmp41.data = _undefined3(size, arr1.slice(0, num15), tmp41.rect.width, tmp41.rect.height);
num22 = 0;
}
obj = { x: null, y: null, width: null, height: null };
obj[0] = readUint(uint8Array, sum1 + 12);
obj[1] = readUint(uint8Array, sum1 + 16);
obj[2] = readUint(uint8Array, sum1 + 4);
obj[3] = readUint(uint8Array, sum1 + 8);
let ushort = readUshort(uint8Array, sum1 + 22);
obj1 = { rect: null, delay: null, dispose: null, blend: null };
obj1[0] = obj;
let num23 = 100;
let ushort1 = readUshort(uint8Array, sum1 + 20);
if (0 != ushort) {
num23 = ushort;
}
obj1[1] = 1000 * (ushort1 / num23);
obj1[2] = uint8Array[sum1 + 24];
obj1[3] = uint8Array[sum1 + 25];
let frames = size.frames;
let arr = frames.push(obj1);
sum4 = num22;
sum3 = num16;
uint8Array2 = arr1;
} else if ("fdAT" == aSCII) {
let num21 = 0;
if (0 < uint - 4) {
do {
arr1[num15 + num21] = uint8Array[sum1 + num21 + 4];
num21 = num21 + 1;
diff = uint - 4;
} while (num21 < diff);
}
sum4 = num15 + (uint - 4);
sum3 = num16;
uint8Array2 = arr1;
} else if ("pHYs" == aSCII) {
let items = [obj.readUint(uint8Array, sum1), obj.readUint(uint8Array, sum1 + 4), uint8Array[sum1 + 8]];
size.tabs[aSCII] = items;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else if ("cHRM" == aSCII) {
size.tabs[aSCII] = [];
let num20 = 0;
do {
let arr9 = size.tabs[aSCII];
arr = arr9.push(obj.readUint(uint8Array, sum1 + 4 * num20));
num20 = num20 + 1;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} while (num20 < 8);
} else {
if ("tEXt" != aSCII) {
if ("zTXt" != aSCII) {
if ("iTXt" == aSCII) {
if (null == size.tabs[aSCII]) {
size.tabs[aSCII] = {};
}
let nextZeroResult = obj.nextZero(uint8Array, sum1);
let sum5 = nextZeroResult + 1;
let tmp23 = uint8Array[sum5 + 1];
let sum6 = sum5 + 2;
let aSCII2 = obj.readASCII(uint8Array, sum1, nextZeroResult - sum1);
let nextZeroResult1 = obj.nextZero(uint8Array, sum6);
let aSCII3 = obj.readASCII(uint8Array, sum6, nextZeroResult1 - sum6);
let sum7 = nextZeroResult1 + 1;
let nextZeroResult2 = obj.nextZero(uint8Array, sum7);
let uTF8 = obj.readUTF8(uint8Array, sum7, nextZeroResult2 - sum7);
let sum8 = nextZeroResult2 + 1;
let diff1 = uint - (sum8 - sum1);
if (0 == uint8Array[sum5]) {
let uTF81 = obj.readUTF8(uint8Array, sum8, diff1);
} else {
let tmp32 = _undefined4;
let arr7 = _undefined4(uint8Array.slice(sum8, sum8 + diff1));
uTF81 = obj.readUTF8(arr7, 0, arr7.length);
}
size.tabs[aSCII][aSCII2] = uTF81;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else if ("PLTE" == aSCII) {
size.tabs[aSCII] = obj.readBytes(uint8Array, sum1, uint);
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else if ("hIST" == aSCII) {
let result = size.tabs.PLTE.length / 3;
size.tabs[aSCII] = [];
let num19 = 0;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
if (0 < result) {
do {
let arr6 = size.tabs[aSCII];
arr1 = arr6.push(readUshort(uint8Array, sum1 + 2 * num19));
num19 = num19 + 1;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} while (num19 < result);
}
} else if ("tRNS" == aSCII) {
if (3 == size.ctype) {
size.tabs[aSCII] = obj.readBytes(uint8Array, sum1, uint);
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else if (0 == size.ctype) {
size.tabs[aSCII] = readUshort(uint8Array, sum1);
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else {
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
if (2 == size.ctype) {
let items1 = [readUshort(uint8Array, sum1), readUshort(uint8Array, sum1 + 2), readUshort(uint8Array, sum1 + 4)];
size.tabs[aSCII] = items1;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
}
}
} else if ("gAMA" == aSCII) {
size.tabs[aSCII] = obj.readUint(uint8Array, sum1) / 100000;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else if ("sRGB" == aSCII) {
size.tabs[aSCII] = uint8Array[sum1];
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else if ("bKGD" == aSCII) {
if (0 != size.ctype) {
if (4 != size.ctype) {
if (2 != size.ctype) {
if (6 != size.ctype) {
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
if (3 == size.ctype) {
size.tabs[aSCII] = uint8Array[sum1];
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
}
}
}
let items2 = [readUshort(uint8Array, sum1), readUshort(uint8Array, sum1 + 2), readUshort(uint8Array, sum1 + 4)];
size.tabs[aSCII] = items2;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
}
}
let items3 = [readUshort(uint8Array, sum1)];
size.tabs[aSCII] = items3;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
} else {
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
num18 = num15;
let arr3 = arr1;
}
}
}
if (null == size.tabs[aSCII]) {
size.tabs[aSCII] = {};
}
let nextZeroResult3 = obj.nextZero(uint8Array, sum1);
let diff2 = sum1 + uint - nextZeroResult3 - 1;
let aSCII4 = obj.readASCII(uint8Array, sum1, nextZeroResult3 - sum1);
if ("tEXt" == aSCII) {
let aSCII5 = obj.readASCII(uint8Array, nextZeroResult3 + 1, diff2);
} else {
let tmp37 = _undefined4;
let arr8 = _undefined4(uint8Array.slice(nextZeroResult3 + 2, nextZeroResult3 + 2 + diff2));
aSCII5 = obj.readUTF8(arr8, 0, arr8.length);
}
size.tabs[aSCII][aSCII4] = aSCII5;
sum4 = num15;
sum3 = num16;
uint8Array2 = arr1;
}
let sum9 = sum1 + uint;
let uint1 = obj.readUint(uint8Array, sum9);
num17 = sum9 + 4;
num15 = sum4;
num16 = sum3;
arr1 = uint8Array2;
num18 = sum4;
arr3 = uint8Array2;
}
if (0 !== num18) {
let tmp65 = size.frames[size.frames.length - 1];
let tmp66 = _undefined3;
let tmp67 = size;
tmp65.data = _undefined3(size, arr3.slice(0, num18), tmp65.rect.width, tmp65.rect.height);
}
let tmp68 = _undefined3;
let tmp69 = size;
let tmp70 = uint8Array1;
size.data = _undefined3(size, tmp6, size.width, size.height);
let str20 = "compress";
delete tmp[tmp2];
let str21 = "interlace";
delete tmp[tmp2];
let str22 = "filter";
delete tmp[tmp2];
return size;
}
}
throw "The input is not a PNG file!";
},
toRGBA8(img) {
({ width, height } = img);
if (null == img.tabs.acTL) {
const items = [_undefined2(img.data, width, height, img).buffer];
return items;
} else {
if (null == img.frames[0].data) {
img.frames[0].data = img.data;
}
const items1 = [];
const result = width * height * 4;
const _Uint8Array = Uint8Array;
const uint8Array = new Uint8Array(result);
const _Uint8Array2 = Uint8Array;
const uint8Array1 = new Uint8Array(result);
const _Uint8Array3 = Uint8Array;
const uint8Array2 = new Uint8Array(result);
for (let num5 = 0; num5 < img.frames.length; num5 = num5 + 1) {
let tmp18 = img.frames[num5];
let x = tmp18.rect.x;
let y = tmp18.rect.y;
let width2 = tmp18.rect.width;
let height2 = tmp18.rect.height;
let tmp19 = _undefined2;
let tmp20 = width2;
let tmp21 = height2;
let tmp22 = img;
let tmp23 = _undefined2(tmp18.data, width2, height2, img);
let tmp24 = num5;
if (0 !== num5) {
let num6 = 0;
if (0 < result) {
do {
uint8Array2[num6] = uint8Array[num6];
num6 = num6 + 1;
} while (num6 < result);
}
}
if (0 == tmp18.blend) {
let tmp35 = compress;
let tmp36 = tmp23;
let tmp37 = width2;
let tmp38 = height2;
let tmp39 = uint8Array;
let tmp40 = width;
let tmp41 = height;
let tmp42 = x;
let tmp43 = y;
let num8 = 0;
let tmp44 = compress(tmp23, width2, height2, tmp7, width, height, x, y, 0);
} else if (1 == tmp18.blend) {
let tmp25 = compress;
let tmp26 = tmp23;
let tmp27 = width2;
let tmp28 = height2;
let tmp29 = uint8Array;
let tmp30 = width;
let tmp31 = height;
let tmp32 = x;
let tmp33 = y;
let num7 = 1;
let tmp34 = compress(tmp23, width2, height2, tmp7, width, height, x, y, 1);
}
let buffer = uint8Array.buffer;
let arr = items1.push(buffer.slice(0));
if (0 != tmp18.dispose) {
if (1 == tmp18.dispose) {
let tmp46 = compress;
let tmp47 = uint8Array1;
let tmp48 = width2;
let tmp49 = height2;
let tmp50 = uint8Array;
let tmp51 = width;
let tmp52 = height;
let tmp53 = x;
let tmp54 = y;
let num10 = 0;
let tmp55 = compress(uint8Array1, width2, height2, tmp7, width, height, x, y, 0);
} else if (2 == tmp18.dispose) {
let num9 = 0;
if (0 < result) {
do {
uint8Array[num9] = uint8Array2[num9];
num9 = num9 + 1;
} while (num9 < result);
}
}
}
}
return items1;
}
},
_paeth(arg0, arg1, arg2) {
let tmp = arg0;
let tmp2 = arg2;
const diff = arg0 + arg1 - arg2;
const diff1 = diff - arg0;
const diff2 = diff - arg1;
const diff3 = diff - arg2;
if (diff1 * diff1 > diff2 * diff2) {
if (diff2 * diff2 <= diff3 * diff3) {
tmp2 = arg1;
}
tmp = tmp2;
}
return tmp;
},
_copyTile,
_bin: obj
};
c0 = undefined;
c1 = undefined;
c2 = undefined;
c3 = undefined;
let c16;
dither = function dither(img, width, height, plte, first, first2) {
let length2;
let num = arg6;
if (null == arg6) {
num = 1;
}
const items = [];
for (let num2 = 0; num2 < length; num2 = num2 + 1) {
let tmp = plte[num2];
let items1 = [tmp >>> 0 & 255, tmp >>> 8 & 255, tmp >>> 16 & 255, tmp >>> 24 & 255];
let arr = items.push(items1);
}
for (let num3 = 0; num3 < length; num3 = num3 + 1) {
let tmp3 = num3;
let num4 = 0;
let num5 = 4294967295;
let num6 = 4294967295;
if (0 < length) {
do {
let tmp4 = items[num3];
let tmp5 = items[num4];
let diff = tmp4[0] - tmp5[0];
let diff1 = tmp4[1] - tmp5[1];
let diff2 = tmp4[2] - tmp5[2];
let diff3 = tmp4[3] - tmp5[3];
let sum = diff * diff + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
let tmp11 = num4 !== num3;
let tmp12 = num4;
let tmp13 = num5;
if (num4 !== num3) {
tmp11 = sum < tmp13;
}
if (tmp11) {
tmp13 = sum;
}
num4 = num4 + 1;
num5 = tmp13;
num6 = tmp13;
} while (num4 < length);
}
let _Math = Math;
let result = Math.sqrt(num6) / 2;
[][num3] = ~~result * result;
}
const uint32Array = new Uint32Array(first.buffer);
const int16Array = new Int16Array(width * height * 4);
const items2 = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
let num7 = 0;
if (0 < items2.length) {
do {
items2[num7] = 255 * ((items2[num7] + 0.5) / 16 - 0.5);
num7 = num7 + 1;
length2 = items2.length;
} while (num7 < length2);
}
for (let num8 = 0; num8 < height; num8 = num8 + 1) {
let tmp18 = num8;
for (let num9 = 0; num9 < width; num9 = num9 + 1) {
let result1 = 4 * (num8 * width + num9);
let tmp20 = num9;
if (2 != num) {
let _Math2 = Math;
let _Math3 = Math;
let items3 = [Math.max(0, Math.min(255, img[result1] + int16Array[result1])), , , ];
let sum1 = result1 + 1;
let _Math4 = Math;
let _Math5 = Math;
items3[1] = Math.max(0, Math.min(255, img[sum1] + int16Array[sum1]));
let sum2 = result1 + 2;
let _Math6 = Math;
let _Math7 = Math;
items3[2] = Math.max(0, Math.min(255, img[sum2] + int16Array[sum2]));
let sum3 = result1 + 3;
let _Math8 = Math;
let _Math9 = Math;
items3[3] = Math.max(0, Math.min(255, img[sum3] + int16Array[sum3]));
let items4 = items3;
} else {
let tmp51 = items2[tmp17 + (3 & num9)];
let _Math10 = Math;
let _Math11 = Math;
items4 = [Math.max(0, Math.min(255, img[result1] + tmp51)), , , ];
let _Math12 = Math;
let _Math13 = Math;
items4[1] = Math.max(0, Math.min(255, img[result1 + 1] + tmp51));
let _Math14 = Math;
let _Math15 = Math;
items4[2] = Math.max(0, Math.min(255, img[result1 + 2] + tmp51));
let _Math16 = Math;
let _Math17 = Math;
items4[3] = Math.max(0, Math.min(255, img[result1 + 3] + tmp51));
}
let num10 = 16777215;
let num11 = 0;
let num12 = 0;
let num13 = 0;
if (0 < length) {
do {
let tmp24 = items[num11];
let diff4 = items4[0] - tmp24[0];
let diff5 = items4[1] - tmp24[1];
let diff6 = items4[2] - tmp24[2];
let diff7 = items4[3] - tmp24[3];
let sum4 = diff4 * diff4 + diff5 * diff5 + diff6 * diff6 + diff7 * diff7;
let tmp30 = num10;
let tmp31 = num11;
let tmp32 = num12;
if (sum4 < num10) {
tmp30 = sum4;
tmp32 = num11;
}
num11 = num11 + 1;
num10 = tmp30;
num12 = tmp32;
num13 = tmp32;
} while (num11 < length);
}
let tmp33 = items[num13];
let items5 = [items4[0] - tmp33[0], items4[1] - tmp33[1], items4[2] - tmp33[2], items4[3] - tmp33[3]];
if (1 == num) {
if (num9 !== width - 1) {
let sum5 = result1 + 4;
int16Array[sum5] = int16Array[sum5] + (items5[0] * 7 >> 4);
let sum6 = sum5 + 1;
int16Array[sum6] = int16Array[sum6] + (items5[1] * 7 >> 4);
let sum7 = sum5 + 2;
int16Array[sum7] = int16Array[sum7] + (items5[2] * 7 >> 4);
let sum8 = sum5 + 3;
int16Array[sum8] = int16Array[sum8] + (items5[3] * 7 >> 4);
}
if (num8 !== height - 1) {
if (0 !== num9) {
let diff8 = result1 + 4 * width - 4;
int16Array[diff8] = int16Array[diff8] + (items5[0] * 3 >> 4);
let sum9 = diff8 + 1;
int16Array[sum9] = int16Array[sum9] + (items5[1] * 3 >> 4);
let sum10 = diff8 + 2;
int16Array[sum10] = int16Array[sum10] + (items5[2] * 3 >> 4);
let sum11 = diff8 + 3;
int16Array[sum11] = int16Array[sum11] + (items5[3] * 3 >> 4);
}
let sum12 = result1 + 4 * width;
int16Array[sum12] = int16Array[sum12] + (items5[0] * 5 >> 4);
let sum13 = sum12 + 1;
int16Array[sum13] = int16Array[sum13] + (items5[1] * 5 >> 4);
let sum14 = sum12 + 2;
int16Array[sum14] = int16Array[sum14] + (items5[2] * 5 >> 4);
let sum15 = sum12 + 3;
int16Array[sum15] = int16Array[sum15] + (items5[3] * 5 >> 4);
if (num9 !== width - 1) {
let sum16 = result1 + 4 * width + 4;
int16Array[sum16] = int16Array[sum16] + (items5[0] >> 4);
let sum17 = sum16 + 1;
int16Array[sum17] = int16Array[sum17] + (items5[1] >> 4);
let sum18 = sum16 + 2;
int16Array[sum18] = int16Array[sum18] + (items5[2] >> 4);
let sum19 = sum16 + 3;
int16Array[sum19] = int16Array[sum19] + (items5[3] >> 4);
}
}
}
let tmp50 = result1 >> 2;
first2[tmp50] = num13;
uint32Array[tmp50] = plte[num13];
}
}
};
_main = function _main(tmp3Result, depth, height, arg3, arg4) {
let obj = arg4;
if (null == arg4) {
obj = {};
}
const crc = _undefined4.crc;
({ writeUint, writeUshort, writeASCII } = c1);
let writeUintResult16 = tmp3Result.frames.length > 1;
let num = 0;
if (writeUintResult16) {
num = 20;
}
const sum = 33 + num;
let sum1 = sum;
if (null != obj.sRGB) {
sum1 = sum + 13;
}
let sum2 = sum1;
if (null != obj.pHYs) {
sum2 = sum1 + 21;
}
let sum3 = sum2;
if (null != obj.iCCP) {
const deflateResult = globalThis.pako.deflate(obj.iCCP);
sum3 = sum2 + (21 + deflateResult.length + 4);
}
let sum4 = sum3;
let flag = false;
if (3 == tmp3Result.ctype) {
let num8 = 0;
let flag2 = false;
let flag3 = false;
if (0 < tmp3Result.plte.length) {
do {
let tmp8 = num8;
let flag4 = flag2;
if (tmp3Result.plte[num8] >>> 24 !== 255) {
flag4 = true;
}
num8 = num8 + 1;
flag2 = flag4;
flag3 = flag4;
} while (num8 < length);
}
let num9 = 0;
const result = 3 * length;
if (flag3) {
num9 = 8 + length + 4;
}
sum4 = sum3 + (8 + result + 4 + num9);
flag = flag3;
}
let tmp10 = sum4;
let num14 = 0;
let tmp11 = sum4;
if (0 < tmp3Result.frames.length) {
do {
let tmp12 = num14;
let tmp13 = tmp10;
let sum5 = tmp10;
if (writeUintResult16) {
sum5 = tmp10 + 38;
}
let sum6 = sum5 + (tmp3Result.frames[num14].cimg.length + 12);
let sum7 = sum6;
if (0 !== num14) {
sum7 = sum6 + 4;
}
num14 = num14 + 1;
tmp10 = sum7;
tmp11 = sum7;
} while (num14 < tmp3Result.frames.length);
}
const uint8Array = new Uint8Array(tmp11 + 12);
let num15 = 0;
do {
uint8Array[num15] = [137, 80, 78, 71, 13, 10, 26, 10][num15];
num15 = num15 + 1;
} while (num15 < 8);
writeUint(uint8Array, 8, 13);
writeASCII(uint8Array, 12, "IHDR");
writeUint(uint8Array, 16, depth);
writeUint(uint8Array, 20, height);
uint8Array[24] = tmp3Result.depth;
uint8Array[25] = tmp3Result.ctype;
uint8Array[26] = 0;
uint8Array[27] = 0;
uint8Array[28] = 0;
writeUint(uint8Array, 29, crc(uint8Array, 12, 17));
let num16 = 33;
if (null != obj.sRGB) {
writeUint(uint8Array, 33, 1);
writeASCII(uint8Array, 37, "sRGB");
uint8Array[41] = obj.sRGB;
writeUint(uint8Array, 42, crc(uint8Array, 37, 5));
num16 = 46;
}
let sum14 = num16;
if (null != obj.iCCP) {
const sum8 = 13 + arr.length;
writeUint(uint8Array, num16, sum8);
const sum9 = num16 + 4;
writeASCII(uint8Array, sum9, "iCCP");
const sum10 = sum9 + 4;
writeASCII(uint8Array, sum10, "ICC profile");
const sum11 = sum10 + 11 + 2;
const result1 = uint8Array.set(arr, sum11);
const sum12 = sum11 + arr.length;
const sum13 = sum8 + 4;
writeUint(uint8Array, sum12, crc(uint8Array, sum12 - sum13, sum13));
sum14 = sum12 + 4;
}
let sum20 = sum14;
if (null != obj.pHYs) {
writeUint(uint8Array, sum14, 9);
const sum15 = sum14 + 4;
writeASCII(uint8Array, sum15, "pHYs");
const sum16 = sum15 + 4;
writeUint(uint8Array, sum16, obj.pHYs[0]);
const sum17 = sum16 + 4;
writeUint(uint8Array, sum17, obj.pHYs[1]);
const sum18 = sum17 + 4;
uint8Array[sum18] = obj.pHYs[2];
const sum19 = sum18 + 1;
writeUint(uint8Array, sum19, crc(uint8Array, sum19 - 13, 13));
sum20 = sum19 + 4;
}
let sum25 = sum20;
if (writeUintResult16) {
writeUint(uint8Array, sum20, 8);
const sum21 = sum20 + 4;
writeASCII(uint8Array, sum21, "acTL");
const sum22 = sum21 + 4;
writeUint(uint8Array, sum22, tmp3Result.frames.length);
let num24 = 0;
if (null != obj.loop) {
num24 = obj.loop;
}
const sum23 = sum22 + 4;
writeUint(uint8Array, sum23, num24);
const sum24 = sum23 + 4;
writeUint(uint8Array, sum24, crc(uint8Array, sum24 - 12, 12));
sum25 = sum24 + 4;
}
let sum32 = sum25;
if (3 == tmp3Result.ctype) {
writeUintResult16 = writeUint(uint8Array, sum25, 3 * length3);
writeUintResult16 = sum25 + 4;
writeUintResult16 = writeASCII(uint8Array, writeUintResult16, "PLTE");
writeUintResult16 = writeUintResult16 + 4;
for (let num25 = 0; num25 < length3; num25 = num25 + 1) {
let tmp59 = tmp3Result.plte[num25];
let sum26 = writeUintResult16 + 3 * num25;
uint8Array[sum26] = 255 & tmp59;
uint8Array[sum26 + 1] = tmp59 >>> 8 & 255;
uint8Array[sum26 + 2] = tmp59 >>> 16 & 255;
}
const sum27 = writeUintResult16 + 3 * length3;
writeUint(uint8Array, sum27, crc(uint8Array, sum27 - 3 * tmp3Result.plte.length - 4, 3 * tmp3Result.plte.length + 4));
const sum28 = sum27 + 4;
sum32 = sum28;
if (flag) {
writeUint(uint8Array, sum28, length3);
const sum29 = sum28 + 4;
writeASCII(uint8Array, sum29, "tRNS");
const sum30 = sum29 + 4;
for (let num26 = 0; num26 < length3; num26 = num26 + 1) {
uint8Array[sum30 + num26] = tmp3Result.plte[num26] >>> 24 & 255;
}
const sum31 = sum30 + length3;
writeUint(uint8Array, sum31, crc(uint8Array, sum31 - length3 - 4, length3 + 4));
sum32 = sum31 + 4;
}
}
let sum46 = sum32;
let num27 = 0;
let num28 = 0;
let tmp71 = sum32;
if (0 < tmp3Result.frames.length) {
do {
let tmp72 = tmp3Result.frames[num28];
let tmp73 = num27;
let tmp74 = num28;
let tmp75 = sum46;
let sum35 = num27;
let sum45 = sum46;
if (writeUintResult16) {
let writeUintResult20 = writeUint(uint8Array, sum46, 26);
let sum33 = sum46 + 4;
let writeASCIIResult7 = writeASCII(uint8Array, sum33, "fcTL");
let sum34 = sum33 + 4;
sum35 = num27 + 1;
let writeUintResult21 = writeUint(uint8Array, sum34, num27);
let sum36 = sum34 + 4;
let writeUintResult22 = writeUint(uint8Array, sum36, tmp72.rect.width);
let sum37 = sum36 + 4;
let writeUintResult23 = writeUint(uint8Array, sum37, tmp72.rect.height);
let sum38 = sum37 + 4;
let writeUintResult24 = writeUint(uint8Array, sum38, tmp72.rect.x);
let sum39 = sum38 + 4;
let writeUintResult25 = writeUint(uint8Array, sum39, tmp72.rect.y);
let sum40 = sum39 + 4;
let writeUshortResult = writeUshort(uint8Array, sum40, arg3[num28]);
let sum41 = sum40 + 2;
let writeUshortResult1 = writeUshort(uint8Array, sum41, 1000);
let sum42 = sum41 + 2;
uint8Array[sum42] = tmp72.dispose;
let sum43 = sum42 + 1;
uint8Array[sum43] = tmp72.blend;
let sum44 = sum43 + 1;
let writeUintResult26 = writeUint(uint8Array, sum44, crc(uint8Array, sum44 - 30, 30));
sum45 = sum44 + 4;
}
let cimg = tmp72.cimg;
let length2 = cimg.length;
let num29 = 4;
if (0 === num28) {
num29 = 0;
}
let writeUintResult27 = writeUint(uint8Array, sum45, length2 + num29);
let str7 = "fdAT";
if (0 === num28) {
str7 = "IDAT";
}
writeUintResult16 = sum45 + 4;
writeUintResult16 = writeASCII(uint8Array, writeUintResult16, str7);
writeUintResult16 = writeUintResult16 + 4;
writeUintResult16 = sum35;
if (0 !== num28) {
writeUintResult16 = sum35 + 1;
writeUintResult16 = writeUint(uint8Array, writeUintResult16, sum35);
writeUintResult16 = writeUintResult16 + 4;
}
writeUintResult16 = uint8Array.set(cimg, writeUintResult16);
writeUintResult16 = writeUintResult16 + length2;
writeUintResult16 = writeUint(uint8Array, writeUintResult16, crc(uint8Array, writeUintResult16, writeUintResult16 - writeUintResult16));
sum46 = writeUintResult16 + 4;
num28 = num28 + 1;
num27 = writeUintResult16;
tmp71 = sum46;
} while (num28 < tmp3Result.frames.length);
}
writeUintResult16 = writeUint(uint8Array, tmp71, 0);
writeUintResult16 = tmp71 + 4;
writeUintResult16 = writeASCII(uint8Array, writeUintResult16, "IEND");
writeUintResult16 = writeUintResult16 + 4;
writeUintResult16 = writeUint(uint8Array, writeUintResult16, crc(uint8Array, writeUintResult16 - 4, 4));
return uint8Array.buffer;
};
compressPNG = function compressPNG(uint8Array, sum1, size) {
let num = 0;
if (0 < uint8Array.frames.length) {
while (true) {
let tmp = uint8Array.frames[num];
let width = tmp.rect.width;
let height = tmp.rect.height;
let _Uint8Array = Uint8Array;
let tmp2 = new.target;
let tmp3 = new.target;
uint8Array = new Uint8Array(height * tmp.bpl + height);
({ img, bpp, bpl } = tmp);
let tmp4 = num;
if (-1 != sum1) {
let items = [sum1];
let items1 = items;
} else {
let tmp5 = height * bpl > 500000 || 1 == bpp;
items1 = [0, 1, 2, 3, 4];
if (tmp5) {
items1 = [0];
}
}
if (size) {
let obj = { level: 0 };
}
let tmp6 = uint8Array;
if (uint8Array.length > 10000000) {
let _window = window;
if (null != window.UZIP) {
let _window2 = window;
let pako = window.UZIP;
let items2 = [];
let _Date = Date;
let timestamp = Date.now();
for (let num2 = 0; num2 < items1.length; num2 = num2 + 1) {
let tmp8 = num2;
for (let num3 = 0; num3 < height; num3 = num3 + 1) {
let tmp9 = items1[num2];
let result = num3 * bpl;
let sum = result + num3;
uint8Array[sum] = tmp9;
sum1 = sum + 1;
let tmp13 = num3;
if (0 == tmp9) {
if (bpl < 500) {
for (let num9 = 0; num9 < bpl; num9 = num9 + 1) {
uint8Array[sum1 + num9] = img[result + num9];
}
} else {
let _Uint8Array2 = Uint8Array;
let tmp30 = new.target;
let tmp31 = new.target;
let tmp32 = result;
let tmp33 = bpl;
let uint8Array1 = new Uint8Array(img.buffer, result, bpl);
let tmp35 = uint8Array1;
let result1 = uint8Array.set(uint8Array1, sum1);
}
} else if (1 == tmp9) {
for (let num8 = 0; num8 < bpp; num8 = num8 + 1) {
uint8Array[sum1 + num8] = img[result + num8];
}
let sum2 = bpp;
if (bpp < bpl) {
do {
uint8Array[sum1 + sum2] = img[result + sum2] - img[result + sum2 - bpp] + 256 & 255;
sum2 = sum2 + 1;
} while (sum2 < bpl);
}
} else if (0 === num3) {
for (let num7 = 0; num7 < bpp; num7 = num7 + 1) {
uint8Array[sum1 + num7] = img[result + num7];
}
if (2 == tmp9) {
let sum3 = bpp;
if (bpp < bpl) {
do {
uint8Array[sum1 + sum3] = img[result + sum3];
sum3 = sum3 + 1;
} while (sum3 < bpl);
}
}
if (3 == tmp9) {
let sum4 = bpp;
if (bpp < bpl) {
do {
uint8Array[sum1 + sum4] = img[result + sum4] - (img[result + sum4 - bpp] >> 1) + 256 & 255;
sum4 = sum4 + 1;
} while (sum4 < bpl);
}
}
if (4 == tmp9) {
let sum6 = bpp;
if (bpp < bpl) {
do {
let tmp27 = _undefined3;
let sum5 = sum1 + sum6;
uint8Array[sum5] = img[result + sum6] - _undefined3(img[result + sum6 - bpp], 0, 0) + 256 & 255;
sum6 = sum6 + 1;
} while (sum6 < bpl);
}
}
} else {
if (2 == tmp9) {
for (let num4 = 0; num4 < bpl; num4 = num4 + 1) {
let sum7 = result + num4;
uint8Array[sum1 + num4] = img[sum7] + 256 - img[sum7 - bpl] & 255;
}
}
if (3 == tmp9) {
for (let num5 = 0; num5 < bpp; num5 = num5 + 1) {
let sum8 = result + num5;
uint8Array[sum1 + num5] = img[sum8] + 256 - (img[sum8 - bpl] >> 1) & 255;
}
let sum9 = bpp;
if (bpp < bpl) {
do {
uint8Array[sum1 + sum9] = img[result + sum9] + 256 - (img[result + sum9 - bpl] + img[result + sum9 - bpp] >> 1) & 255;
sum9 = sum9 + 1;
} while (sum9 < bpl);
}
}
if (4 == tmp9) {
for (let num6 = 0; num6 < bpp; num6 = num6 + 1) {
let sum10 = result + num6;
let tmp19 = _undefined3;
let sum11 = img[sum10] + 256;
uint8Array[sum1 + num6] = sum11 - _undefined3(0, img[sum10 - bpl], 0) & 255;
}
let sum14 = bpp;
if (bpp < bpl) {
do {
let tmp23 = _undefined3;
let sum12 = sum1 + sum14;
let sum13 = img[result + sum14] + 256;
uint8Array[sum12] = sum13 - _undefined3(img[result + sum14 - bpp], img[result + sum14 - bpl], img[result + sum14 - bpp - bpl]) & 255;
sum14 = sum14 + 1;
} while (sum14 < bpl);
}
}
}
}
let arr = items2.push(pako.deflate(uint8Array, obj));
}
let num10 = 1000000000;
let num11 = 0;
let tmp39;
if (0 < items2.length) {
do {
let length = num10;
let tmp40 = tmp38;
let tmp41 = num11;
if (items2[num11].length < num10) {
length = items2[num11].length;
tmp40 = num11;
}
num11 = num11 + 1;
num10 = length;
tmp38 = tmp40;
tmp39 = tmp40;
} while (num11 < items2.length);
}
tmp.cimg = items2[tmp39];
num = num + 1;
if (num >= uint8Array.frames.length) {
break;
}
}
}
pako = globalThis.pako;
}
}
};
compress = function compress(arg0, width2, height2, arg3, width, height, arg6, arg7, arg8) {
let length2;
let length5;
let length6;
let length8;
let first = width[0];
let num = 0;
let num2 = 255;
let num3 = 255;
if (0 < arg0.length) {
do {
let _Uint8Array = Uint8Array;
let tmp6 = new.target;
let tmp7 = new.target;
let uint8Array = new Uint8Array(arg0[num]);
let tmp8 = uint8Array;
let length = uint8Array.length;
let tmp9 = num;
let tmp10 = num2;
let num4 = 0;
let tmp11 = num2;
if (0 < length) {
do {
tmp10 = tmp10 & uint8Array[num4 + 3];
num4 = num4 + 4;
tmp11 = tmp10;
} while (num4 < length);
}
num = num + 1;
num2 = tmp11;
num3 = tmp11;
} while (num < arg0.length);
}
const frames = [];
for (let num5 = 0; num5 < arg0.length; num5 = num5 + 1) {
let _Uint8Array2 = Uint8Array;
let tmp13 = new.target;
let tmp14 = new.target;
let uint8Array1 = new Uint8Array(arg0[num5]);
let tmp15 = uint8Array1;
let _Uint32Array = Uint32Array;
let tmp16 = new.target;
let tmp17 = new.target;
let uint32Array = new Uint32Array(uint8Array1.buffer);
let tmp19 = uint32Array;
let tmp20 = num5;
let num6 = 0;
if (first) {
num6 = 1;
}
if (0 !== num5) {
if (!tmp3) {
if (!first) {
if (1 !== num5) {
let num9 = 2;
}
let diff = num5 - 1;
let num10 = 0;
let num11 = 1000000000;
let num12 = 0;
let tmp25 = height2;
let tmp26 = width2;
let num13 = 0;
let num14 = 0;
let num15 = 0;
let tmp27 = height2;
let tmp28 = width2;
let num16 = 0;
let num17 = 0;
if (0 < num9) {
do {
let _Uint8Array3 = Uint8Array;
let diff1 = diff - num10;
let tmp30 = new.target;
let uint8Array2 = new Uint8Array(arg0[diff1]);
let _Uint32Array2 = Uint32Array;
let tmp32 = new.target;
let tmp33 = new.target;
let uint32Array1 = new Uint32Array(arg0[diff1]);
let tmp35 = uint32Array1;
let tmp36 = num10;
let tmp37 = num11;
let tmp38 = num12;
let sum2 = tmp25;
let sum1 = tmp26;
let tmp41 = num13;
let tmp42 = num14;
let num18 = 0;
let num19 = -1;
let num20 = -1;
let tmp43 = height2;
let tmp44 = width2;
let num21 = -1;
let num22 = -1;
let num23 = height2;
let num24 = width2;
if (0 < height2) {
do {
let tmp45 = num18;
let tmp46 = num19;
let tmp47 = num20;
let tmp48 = tmp43;
let tmp49 = tmp44;
let num25 = 0;
let tmp50 = num19;
let tmp51 = num20;
let tmp52 = tmp43;
let tmp53 = tmp44;
if (0 < width2) {
do {
let sum = num18 * width2 + num25;
let tmp55 = num25;
let tmp56 = tmp46;
let tmp57 = tmp47;
let tmp58 = tmp48;
let tmp59 = tmp49;
let tmp60 = tmp46;
let tmp61 = tmp47;
let tmp62 = tmp48;
let tmp63 = tmp49;
if (uint32Array[sum] != uint32Array1[sum]) {
let tmp64 = tmp49;
if (num25 < tmp49) {
tmp64 = num25;
}
let tmp65 = tmp47;
if (tmp47 < num25) {
tmp65 = num25;
}
let tmp66 = tmp48;
if (num18 < tmp48) {
tmp66 = num18;
}
let tmp67 = tmp46;
if (tmp46 < num18) {
tmp67 = num18;
}
tmp60 = tmp67;
tmp61 = tmp65;
tmp62 = tmp66;
tmp63 = tmp64;
}
num25 = num25 + 1;
tmp46 = tmp60;
tmp47 = tmp61;
tmp48 = tmp62;
tmp49 = tmp63;
tmp50 = tmp60;
tmp51 = tmp61;
tmp52 = tmp62;
tmp53 = tmp63;
} while (num25 < width2);
}
num18 = num18 + 1;
num19 = tmp50;
num20 = tmp51;
tmp43 = tmp52;
tmp44 = tmp53;
num21 = tmp50;
num22 = tmp51;
num23 = tmp52;
num24 = tmp53;
} while (num18 < height2);
}
if (-1 === num22) {
num21 = 0;
num22 = 0;
num23 = 0;
num24 = 0;
}
let tmp68 = num23;
let tmp69 = num24;
if (tmp2) {
let diff2 = num24;
if (!(1 & ~num24)) {
diff2 = num24 - 1;
}
let diff3 = num23;
if (!(1 & ~num23)) {
diff3 = num23 - 1;
}
tmp68 = diff3;
tmp69 = diff2;
}
let result = (num22 - tmp69 + 1) * (num21 - tmp68 + 1);
if (result < tmp37) {
sum1 = num22 - tmp69 + 1;
sum2 = num21 - tmp68 + 1;
tmp37 = result;
tmp38 = num10;
tmp41 = tmp68;
tmp42 = tmp69;
}
num10 = num10 + 1;
num11 = tmp37;
num12 = tmp38;
tmp25 = sum2;
tmp26 = sum1;
num13 = tmp41;
num14 = tmp42;
num15 = tmp38;
tmp27 = sum2;
tmp28 = sum1;
num16 = tmp41;
num17 = tmp42;
} while (num10 < num9);
}
let _Uint8Array4 = Uint8Array;
let tmp73 = new.target;
let tmp74 = new.target;
let uint8Array3 = new Uint8Array(arg0[diff - num15]);
if (1 === num15) {
frames[diff].dispose = 2;
}
let tmp76 = uint8Array3;
let _Uint8Array5 = Uint8Array;
let tmp77 = new.target;
let tmp78 = new.target;
let uint8Array4 = new Uint8Array(tmp28 * tmp27 * 4);
let tmp80 = uint8Array4;
let tmp81 = _undefined;
let tmp82 = uint8Array3;
let tmp83 = width2;
let tmp84 = height2;
let tmp85 = uint8Array4;
let tmp86 = tmp28;
let tmp87 = tmp27;
let num26 = 0;
let tmp88 = _undefined(uint8Array3, width2, height2, uint8Array4, tmp28, tmp27, -num17, -num16, 0);
let tmp89 = uint8Array1;
let tmp90 = width2;
let tmp91 = height2;
let tmp92 = uint8Array4;
let tmp93 = tmp28;
let tmp94 = tmp27;
let num27 = 3;
let num28 = 0;
if (_undefined(tmp15, width2, height2, uint8Array4, tmp28, tmp27, -num17, -num16, 3)) {
num28 = 1;
}
if (1 === num28) {
first = uint8Array1;
first = width2;
first = height2;
first = uint8Array4;
first = tmp28;
first = tmp27;
let num30 = 2;
first = tmp81(tmp15, width2, height2, tmp80, tmp28, tmp27, -num17, -num16, 2);
num6 = num28;
let tmp22 = tmp27;
let tmp23 = tmp28;
let num7 = num16;
let num8 = num17;
let substr = uint8Array4;
} else {
let tmp95 = uint8Array1;
let tmp96 = width2;
let tmp97 = height2;
let tmp98 = uint8Array4;
let tmp99 = tmp28;
first = tmp27;
let num29 = 0;
first = tmp81(tmp15, width2, height2, tmp80, tmp28, tmp27, -num17, -num16, 0);
num6 = num28;
tmp22 = tmp27;
tmp23 = tmp28;
num7 = num16;
num8 = num17;
substr = uint8Array4;
}
}
}
num9 = 1;
} else {
substr = uint8Array1.slice(0);
tmp22 = height2;
tmp23 = width2;
num7 = 0;
num8 = 0;
}
let obj = { rect: null, img: null, blend: null, dispose: 0 };
obj = { x: null, y: null, width: null, height: null };
obj[0] = num8;
obj[1] = num7;
obj[2] = tmp23;
obj[3] = tmp22;
obj[0] = obj;
obj[1] = substr;
obj[2] = num6;
first = frames.push(obj);
}
if (first) {
for (let num31 = 0; num31 < frames.length; num31 = num31 + 1) {
first = frames[num31];
if (1 != first.blend) {
let rect = first.rect;
first = num31 - 1;
let rect2 = frames[first].rect;
let _Math3 = Math;
first = Math.min(rect.x, rect2.x);
let _Math4 = Math;
first = Math.min(rect.y, rect2.y);
obj = { x: null, y: null, width: null, height: null };
obj[0] = first;
obj[1] = first;
let _Math5 = Math;
obj[2] = Math.max(rect.x + rect.width, rect2.x + rect2.width) - first;
let _Math6 = Math;
obj[3] = Math.max(rect.y + rect.height, rect2.y + rect2.height) - first;
frames[first].dispose = 1;
if (first !== 0) {
first = _updateFrame;
first = arg0;
first = width2;
first = height2;
first = frames;
first = obj;
first = tmp2;
first = _updateFrame(arg0, width2, height2, frames, first, obj, tmp2);
}
first = _updateFrame;
first = arg0;
first = width2;
first = height2;
first = frames;
first = num31;
first = obj;
first = tmp2;
first = _updateFrame(arg0, width2, height2, frames, first, obj, tmp2);
}
}
}
if (1 != arg0.length) {
let num32 = 0;
if (0 < frames.length) {
do {
first = frames[num32];
first = first.rect.width * first.rect.height;
num32 = num32 + 1;
length2 = frames.length;
} while (num32 < length2);
}
}
obj1 = {};
const plte = [];
const items2 = [];
if (0 != arg3) {
const items3 = [];
let num35 = 0;
if (0 < frames.length) {
do {
first = items3.push(frames[num35].img.buffer);
num35 = num35 + 1;
length5 = frames.length;
} while (num35 < length5);
}
let num36 = 0;
let num37 = 0;
let num38 = 0;
if (0 < items3.length) {
do {
num37 = num37 + items3[num36].byteLength;
num36 = num36 + 1;
num38 = num37;
length6 = items3.length;
} while (num36 < length6);
}
const _Uint8Array7 = Uint8Array;
first = new.target;
first = new.target;
first = num38;
first = new Uint8Array(num38);
let num39 = 0;
for (let num40 = 0; num40 < items3.length; num40 = num40 + 1) {
let _Uint8Array8 = Uint8Array;
first = new.target;
first = new.target;
let uint8Array5 = new Uint8Array(items3[num40]);
first = uint8Array5;
let length7 = uint8Array5.length;
first = num39;
first = num40;
for (let num41 = 0; num41 < length7; num41 = num41 + 4) {
let num42 = uint8Array5[num41];
let num43 = uint8Array5[num41 + 1];
let num44 = uint8Array5[num41 + 2];
first = uint8Array5[num41 + 3];
first = num41;
if (0 == first) {
num44 = 0;
num43 = 0;
num42 = 0;
}
first = num39 + num41;
first[first] = num42;
first[first + 1] = num43;
first[first + 2] = num44;
first[first + 3] = first;
}
num39 = num39 + length7;
}
first = quantize;
first = quantize(first.buffer, arg3);
let num45 = 0;
if (0 < first.plte.length) {
do {
first = plte.push(first.plte[num45].est.rgba);
num45 = num45 + 1;
length8 = first.plte.length;
} while (num45 < length8);
}
let num46 = 0;
for (let num47 = 0; num47 < frames.length; num47 = num47 + 1) {
first = frames[num47];
let length9 = first.img.length;
let _Uint8Array9 = Uint8Array;
first = new.target;
first = new.target;
first = new Uint8Array(first.inds.buffer, num46 >> 2, length9 >> 2);
first = items2.push(first);
let _Uint8Array10 = Uint8Array;
first = new.target;
first = new.target;
first = num46;
first = length9;
first = new Uint8Array(first.abuf, num46, length9);
first = num46;
first = num47;
if (tmp5) {
first = dither;
first = plte;
first = dither(first.img, first.rect.width, first.rect.height, plte, first, first);
}
let img = first.img;
first = img.set(first);
num46 = num46 + length9;
}
} else {
first = null;
for (let num34 = 0; num34 < frames.length; num34 = num34 + 1) {
first = frames[num34];
let _Uint32Array3 = Uint32Array;
first = new.target;
first = new.target;
let uint32Array2 = new Uint32Array(first.img.buffer);
first = uint32Array2;
width = first.rect.width;
let length3 = uint32Array2.length;
let _Uint8Array6 = Uint8Array;
first = new.target;
first = new.target;
first = length3;
first = new Uint8Array(length3);
first = items2.push(first);
first = num34;
let num33 = 0;
if (0 < length3) {
while (true) {
first = uint32Array2[num33];
first = num33;
if (0 !== num33) {
first = num33 - 1;
if (first == uint32Array2[first]) {
first[num33] = first[first];
num33 = num33 + 1;
if (num33 >= length3) {
break;
}
}
}
if (num33 > width) {
if (first == uint32Array2[num33 - width]) {
first[num33] = first[num33 - width];
}
}
first = obj1[first];
if (null != first) {
first[num33] = first;
} else {
let length4 = plte.length;
obj1[first] = length4;
first = plte.push(first);
first = length4;
if (plte.length >= 300) {
break;
}
}
break;
}
}
}
}
first = length10 <= 256 && 0 == tmp4;
let depth = 8;
if (first) {
let num49 = 1;
if (length10 > 2) {
let num50 = 2;
if (length10 > 4) {
let num52 = 8;
if (length10 <= 16) {
num52 = 4;
}
num50 = num52;
}
num49 = num50;
}
const _Math = Math;
depth = Math.max(num49, width[3]);
}
let num53 = 0;
let num54 = 6;
let ctype = 6;
if (0 < frames.length) {
while (true) {
first = frames[num53];
let x = first.rect.x;
let y = first.rect.y;
width2 = first.rect.width;
height = first.rect.height;
let img2 = first.img;
let _Uint32Array4 = Uint32Array;
first = new.target;
first = new Uint32Array(img2.buffer);
first = 4 * width2;
first = num53;
first = num54;
if (length10 <= 256) {
if (0 == tmp4) {
let _Math2 = Math;
first = Math.ceil(depth * width2 / 8);
let _Uint8Array12 = Uint8Array;
first = new.target;
first = new.target;
first = new Uint8Array(first * height);
first = items2[num53];
let num59 = 0;
let num56 = 1;
let num57 = 3;
if (0 < height) {
do {
first = num59 * first;
first = num59 * width2;
first = num59;
if (8 == depth) {
for (let num63 = 0; num63 < width2; num63 = num63 + 1) {
first[first + num63] = first[first + num63];
}
} else if (4 == depth) {
for (let num62 = 0; num62 < width2; num62 = num62 + 1) {
first = first + (num62 >> 1);
first[first] = first[first] | first[first + num62] << 4 - 4 * (1 & num62);
}
} else if (2 == depth) {
for (let num61 = 0; num61 < width2; num61 = num61 + 1) {
first = first + (num61 >> 2);
first[first] = first[first] | first[first + num61] << 6 - 2 * (3 & num61);
}
} else if (1 == depth) {
for (let num60 = 0; num60 < width2; num60 = num60 + 1) {
first = first + (num60 >> 3);
first[first] = first[first] | first[first + num60] << 7 - (7 & num60);
}
}
first = num59 + 1;
num59 = first;
num56 = 1;
num57 = 3;
} while (first < height);
}
first.img = first;
first.bpl = first;
first.bpp = num56;
num53 = num53 + 1;
num54 = num57;
ctype = num57;
if (num53 >= frames.length) {
break;
}
}
}
num56 = 4;
first = img2;
num57 = num54;
if (0 == tmp12) {
num56 = 4;
first = img2;
num57 = num54;
if (1 == frames.length) {
let _Uint8Array11 = Uint8Array;
first = new.target;
first = new.target;
first = new Uint8Array(width2 * height * 3);
first = width2 * height;
let num58 = 0;
if (0 < first) {
do {
first = 3 * num58;
first = 4 * num58;
first[first] = img2[first];
first[first + 1] = img2[first + 1];
first[first + 2] = img2[first + 2];
num58 = num58 + 1;
} while (num58 < first);
}
first = 3 * width2;
num56 = 3;
num57 = 2;
}
}
}
}
return { ctype, depth, plte, frames };
};
function _updateFrame(arg0, width2, height2, frames, first, height, width) {
let _Uint8Array = Uint8Array;
const uint8Array = new Uint8Array(arg0[first - 1]);
const uint32Array = new Uint32Array(arg0[first - 1]);
_Uint8Array = null;
if (first + 1 < arg0.length) {
_Uint8Array = new _Uint8Array(arg0[first + 1]);
}
const _Uint8Array1 = new _Uint8Array(arg0[first]);
const uint32Array1 = new Uint32Array(_Uint8Array1.buffer);
let num = 0;
let num2 = -1;
let num3 = -1;
let tmp9 = height2;
let tmp10 = width2;
let num4 = -1;
let num5 = -1;
let num6 = height2;
let num7 = width2;
if (0 < height.height) {
do {
let tmp11 = num;
let tmp12 = num2;
let tmp13 = num3;
let tmp14 = tmp9;
let tmp15 = tmp10;
let num8 = 0;
let tmp16 = num2;
let tmp17 = num3;
let tmp18 = tmp9;
let tmp19 = tmp10;
if (0 < height.width) {
do {
let sum = height.x + num8;
let sum1 = height.y + num;
let sum2 = sum1 * width2 + sum;
let tmp23 = uint32Array1[sum2];
let tmp24 = 0 == tmp23;
let tmp25 = num8;
let tmp26 = tmp12;
let tmp27 = tmp13;
let tmp28 = tmp14;
let tmp29 = tmp15;
if (!tmp24) {
let tmp30 = 0 == frames[first - 1].dispose && uint32Array[sum2] == tmp23;
if (tmp30) {
let tmp31 = null == _Uint8Array || 0 != _Uint8Array[4 * sum2 + 3];
tmp30 = tmp31;
}
tmp24 = tmp30;
}
let tmp32 = tmp12;
let tmp33 = tmp13;
let tmp34 = tmp14;
let tmp35 = tmp15;
if (!tmp24) {
let tmp36 = tmp15;
if (sum < tmp15) {
tmp36 = sum;
}
let tmp37 = tmp13;
if (sum > tmp13) {
tmp37 = sum;
}
let tmp38 = tmp14;
if (sum1 < tmp14) {
tmp38 = sum1;
}
let tmp39 = tmp12;
if (sum1 > tmp12) {
tmp39 = sum1;
}
tmp32 = tmp39;
tmp33 = tmp37;
tmp34 = tmp38;
tmp35 = tmp36;
}
num8 = num8 + 1;
tmp12 = tmp32;
tmp13 = tmp33;
tmp14 = tmp34;
tmp15 = tmp35;
tmp16 = tmp32;
tmp17 = tmp33;
tmp18 = tmp34;
tmp19 = tmp35;
} while (num8 < height.width);
}
num = num + 1;
num2 = tmp16;
num3 = tmp17;
tmp9 = tmp18;
tmp10 = tmp19;
num4 = tmp16;
num5 = tmp17;
num6 = tmp18;
num7 = tmp19;
} while (num < height.height);
}
if (-1 == num5) {
num4 = 0;
num5 = 0;
num6 = 0;
num7 = 0;
}
let tmp40 = num6;
let tmp41 = num7;
if (width) {
let diff = num7;
if (!(1 & ~num7)) {
diff = num7 - 1;
}
let diff1 = num6;
if (!(1 & ~num6)) {
diff1 = num6 - 1;
}
tmp40 = diff1;
tmp41 = diff;
}
const size = { x: tmp41, y: tmp40, width: num5 - tmp41 + 1, height: num4 - tmp40 + 1 };
frames[first].rect = size;
frames[first].blend = 1;
const uint8Array1 = new Uint8Array(size.width * size.height * 4);
frames[first].img = uint8Array1;
if (0 == frames[first - 1].dispose) {
_undefined(uint8Array, width2, height2, tmp44.img, size.width, size.height, -size.x, -size.y, 0);
_undefined(tmp7, width2, height2, tmp44.img, size.width, size.height, -size.x, -size.y, 2);
} else {
_undefined(tmp7, width2, height2, tmp44.img, size.width, size.height, -size.x, -size.y, 0);
}
}
function quantize(arg0, arg1, arg2) {
let length3;
let length6;
const timestamp = Date.now();
const uint8Array = new Uint8Array(arg0);
const substr = uint8Array.slice(0);
const uint32Array = new Uint32Array(substr.buffer);
[tmp5, arr2] = getKDtree(substr, arg1);
const uint32Array1 = new Uint32Array(length);
const uint8Array1 = new Uint8Array(uint32Array1.buffer);
for (let num = 0; num < length; num = num + 1) {
uint32Array1[num] = arr2[num].est.rgba;
}
const uint8Array2 = new Uint8Array(length2 >> 2);
if (arr2.length <= 60) {
findNearest(uint8Array, uint8Array2, uint8Array1);
let num7 = 0;
if (0 < uint8Array2.length) {
do {
uint32Array[num7] = uint32Array1[uint8Array2[num7]];
num7 = num7 + 1;
length3 = uint8Array2.length;
} while (num7 < length3);
}
} else if (uint8Array.length < 32000000) {
for (let num6 = 0; num6 < length2; num6 = num6 + 4) {
let tmp16 = getNearest;
let tmp17 = tmp5;
let tmp18 = getNearest(tmp5, 0.00392156862745098 * uint8Array[num6], 0.00392156862745098 * uint8Array[num6 + 1], 0.00392156862745098 * uint8Array[num6 + 2], 0.00392156862745098 * uint8Array[num6 + 3]);
let tmp19 = num6 >> 2;
uint8Array2[tmp19] = tmp18.ind;
uint32Array[tmp19] = tmp18.est.rgba;
}
} else {
for (let num2 = 0; num2 < length2; num2 = num2 + 4) {
let tmp11 = num2;
let rect = tmp5;
let tmp12 = tmp5;
if (tmp5.left) {
do {
let est = rect.est;
let e = est.e;
let tmp13 = rect;
tmp14 = e[0] * tmp7 + e[1] * tmp8 + e[2] * tmp9 + e[3] * tmp10 - est.eMq <= 0 ? rect.left : rect.right;
rect = tmp14;
tmp12 = tmp14;
} while (tmp14.left);
}
let tmp15 = num2 >> 2;
uint8Array2[tmp15] = tmp12.ind;
uint32Array[tmp15] = tmp12.est.rgba;
}
}
let num8 = 1000000000;
let num9 = 0;
if (arg2) {
while (true) {
let tmp22 = uint8Array1.length >>> 2;
let _Uint32Array = Uint32Array;
let tmp23 = new.target;
let num11 = 4;
let tmp24 = new.target;
let uint32Array2 = new Uint32Array(4 * tmp22);
let tmp26 = uint32Array2;
let _Uint32Array2 = Uint32Array;
let tmp27 = new.target;
let tmp28 = new.target;
let tmp29 = tmp22;
let uint32Array3 = new Uint32Array(tmp22);
let tmp31 = uint32Array3;
let num12 = 3;
let tmp32 = num8;
let tmp33 = num9;
let num13 = 0;
if (0 < uint8Array.length) {
do {
let tmp34 = uint8Array2[num13 >>> 2];
let result = 4 * tmp34;
uint32Array3[tmp34] = uint32Array3[tmp34] + 1;
uint32Array2[result] = uint32Array2[result] + uint8Array[num13];
let sum = result + 1;
uint32Array2[sum] = uint32Array2[sum] + uint8Array[num13 + 1];
let sum1 = result + 2;
uint32Array2[sum1] = uint32Array2[sum1] + uint8Array[num13 + 2];
let sum2 = result + 3;
uint32Array2[sum2] = uint32Array2[sum2] + uint8Array[num13 + 3];
num13 = num13 + 4;
length4 = uint8Array.length;
} while (num13 < length4);
}
let num14 = 0;
if (0 < uint8Array1.length) {
do {
let _Math = Math;
uint8Array1[num14] = Math.round(uint32Array2[num14] / uint32Array3[num14 >>> 2]);
num14 = num14 + 1;
length5 = uint8Array1.length;
} while (num14 < length5);
}
let tmp39 = findNearest;
let tmp40 = findNearest(uint8Array, uint8Array2, uint8Array1);
let num15 = 0.997;
if (0.997 < tmp40 / num8) {
break;
} else {
num9 = num9 + 1;
let num16 = 10;
num8 = tmp40;
if (num9 >= 10) {
break;
}
}
}
for (let num17 = 0; num17 < length; num17 = num17 + 1) {
arr2[num17].est.rgba = uint32Array1[num17];
}
let num18 = 0;
if (0 < uint8Array2.length) {
do {
uint32Array[num18] = uint32Array1[uint8Array2[num18]];
num18 = num18 + 1;
length6 = uint8Array2.length;
} while (num18 < length6);
}
} else {
num8 = 1000000000;
num9 = 0;
}
return { abuf: substr.buffer, inds: uint8Array2, plte: arr2 };
}
function findNearest(uint8Array, uint8Array2, uint8Array1) {
const items = [];
let num = 0;
if (0 < uint8Array1.length >>> 2) {
do {
let result = 4 * num;
let tmp7 = num;
let num2 = 0;
let num3 = 1000000000;
let num4 = 1000000000;
if (0 < tmp) {
do {
let tmp8 = num2;
let tmp9 = num3;
let tmp10 = num3;
if (num !== num2) {
let result1 = 4 * num2;
let diff = tmp3 - uint8Array1[result1];
let diff1 = tmp4 - uint8Array1[result1 + 1];
let diff2 = tmp5 - uint8Array1[result1 + 2];
let diff3 = tmp6 - uint8Array1[result1 + 3];
let sum = diff * diff + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
tmp10 = num3;
if (sum < num3) {
tmp10 = sum;
}
}
num2 = num2 + 1;
num3 = tmp10;
num4 = tmp10;
} while (num2 < tmp);
}
let _Math = Math;
items[num] = 0.5 * Math.sqrt(num4);
items[num] = items[num] * items[num];
num = num + 1;
} while (num < tmp);
}
let num5 = 0;
let num6 = 0;
let num7 = 0;
if (0 < uint8Array.length) {
do {
let tmp17 = uint8Array[num5];
let tmp18 = uint8Array[num5 + 1];
let tmp19 = uint8Array[num5 + 2];
let tmp20 = uint8Array[num5 + 3];
let tmp21 = num5 >>> 2;
let tmp22 = uint8Array2[tmp21];
let result2 = 4 * tmp22;
let diff4 = tmp17 - uint8Array1[result2];
let diff5 = tmp18 - uint8Array1[result2 + 1];
let diff6 = tmp19 - uint8Array1[result2 + 2];
let diff7 = tmp20 - uint8Array1[result2 + 3];
let sum1 = diff4 * diff4 + diff5 * diff5 + diff6 * diff6 + diff7 * diff7;
let tmp29 = num5;
let tmp30 = num6;
let tmp31 = tmp22;
let tmp32 = sum1;
if (sum1 > items[tmp22]) {
let num8 = 0;
let tmp42 = sum1;
let tmp43 = tmp22;
tmp32 = sum1;
tmp31 = tmp22;
if (0 < tmp) {
while (true) {
let result3 = 4 * num8;
let diff8 = tmp17 - uint8Array1[result3];
let diff9 = tmp18 - uint8Array1[result3 + 1];
let diff10 = tmp19 - uint8Array1[result3 + 2];
let diff11 = tmp20 - uint8Array1[result3 + 3];
let sum2 = diff8 * diff8 + diff9 * diff9 + diff10 * diff10 + diff11 * diff11;
let tmp39 = num8;
let tmp40 = tmp42;
let tmp41 = tmp43;
if (sum2 >= tmp42) {
num8 = num8 + 1;
tmp42 = tmp40;
tmp43 = tmp41;
tmp32 = tmp40;
tmp31 = tmp41;
if (num8 >= tmp) {
break;
}
} else {
tmp40 = sum2;
tmp41 = num8;
tmp31 = num8;
tmp32 = sum2;
if (sum2 < items[num8]) {
break;
}
}
break;
}
}
}
uint8Array2[tmp21] = tmp31;
num6 = num6 + tmp32;
num5 = num5 + 4;
num7 = num6;
} while (num5 < uint8Array.length);
}
return num7 / (uint8Array.length >>> 2);
}
function getKDtree(substr, arg1) {
let length;
let num = arg2;
if (null == arg2) {
num = 0.0001;
}
const uint32Array = new Uint32Array(substr.buffer);
let obj = { i0: 0, i1: substr.length, bst: null, est: null, tdst: 0, left: null, right: null };
obj.bst = stats(substr, obj.i0, obj.i1);
obj.est = estats(obj.bst);
const items = [obj];
if (items.length < arg1) {
while (true) {
let num2 = 0;
let num3 = 0;
let num4 = 0;
let num5 = 0;
let num6 = 0;
if (0 < items.length) {
do {
let tmp2 = num2;
let tmp3 = num3;
let L = num4;
if (items[num2].est.L > num4) {
L = items[num2].est.L;
tmp3 = num2;
}
num2 = num2 + 1;
num3 = tmp3;
num4 = L;
num5 = tmp3;
num6 = L;
} while (num2 < items.length);
}
if (num6 < num) {
break;
} else {
let tmp26 = items[num5];
let i0 = tmp26.i0;
let e = tmp26.est.e;
let eMq255 = tmp26.est.eMq255;
let diff = tmp26.i1 - 4;
let sum3 = i0;
let tmp14 = i0;
if (i0 < diff) {
while (true) {
let tmp4 = vecDot;
let tmp5 = diff;
let tmp6 = sum3;
let tmp7 = sum3;
if (substr[sum3] * e[0] + substr[sum3 + 1] * e[1] + substr[sum3 + 2] * e[2] + substr[sum3 + 3] * e[3] <= eMq255) {
do {
let sum = tmp6 + 4;
tmp4 = vecDot;
tmp6 = sum;
tmp7 = sum;
sum1 = substr[sum] * e[0] + substr[sum + 1] * e[1] + substr[sum + 2] * e[2] + substr[sum + 3] * e[3];
} while (sum1 <= eMq255);
}
let tmp10 = diff;
let tmp11 = diff;
if (tmp4(substr, diff, e) > eMq255) {
do {
let diff1 = tmp10 - 4;
tmp10 = diff1;
tmp11 = diff1;
sum2 = substr[diff1] * e[0] + substr[diff1 + 1] * e[1] + substr[diff1 + 2] * e[2] + substr[diff1 + 3] * e[3];
} while (sum2 > eMq255);
}
tmp14 = tmp7;
if (tmp7 >= tmp11) {
break;
} else {
let tmp15 = tmp11 >> 2;
uint32Array[tmp7 >> 2] = uint32Array[tmp15];
uint32Array[tmp15] = uint32Array[tmp7 >> 2];
sum3 = tmp7 + 4;
diff = tmp11 - 4;
tmp14 = sum3;
if (sum3 >= diff) {
break;
}
}
}
}
let tmp18 = tmp14;
let tmp19 = tmp14;
if (substr[tmp14] * e[0] + substr[tmp14 + 1] * e[1] + substr[tmp14 + 2] * e[2] + substr[tmp14 + 3] * e[3] > eMq255) {
do {
let diff2 = tmp18 - 4;
tmp18 = diff2;
tmp19 = diff2;
sum4 = substr[diff2] * e[0] + substr[diff2 + 1] * e[1] + substr[diff2 + 2] * e[2] + substr[diff2 + 3] * e[3];
} while (sum4 > eMq255);
}
let sum5 = tmp19 + 4;
if (tmp26.i0 < sum5) {
if (tmp26.i1 > sum5) {
obj = { i0: null, i1: null, bst: null, est: null, tdst: 0, left: null, right: null };
obj[0] = tmp26.i0;
obj[1] = sum5;
let tmp27 = stats;
obj.bst = stats(substr, obj.i0, obj.i1);
let tmp28 = estats;
obj.est = estats(obj.bst);
obj = { i0: null, i1: null, bst: null, est: null, tdst: 0, left: null, right: null };
obj[0] = sum5;
obj[1] = tmp26.i1;
obj1 = { R: null, m: null, N: null };
obj1[0] = [];
obj1[1] = [];
obj1[2] = tmp26.bst.N - obj.bst.N;
obj.bst = obj1;
let num7 = 0;
do {
obj.bst.R[num7] = tmp26.bst.R[num7] - obj.bst.R[num7];
num7 = num7 + 1;
let num8 = 0;
} while (num7 < 16);
do {
obj.bst.m[num8] = tmp26.bst.m[num8] - obj.bst.m[num8];
num8 = num8 + 1;
} while (num8 < 4);
let tmp23 = estats;
obj.est = estats(obj.bst);
tmp26.left = obj;
tmp26.right = obj;
items[num5] = obj;
let arr = items.push(obj);
}
if (items.length >= arg1) {
break;
}
}
tmp26.est.L = 0;
}
}
}
const sorted = items.sort((bst, bst2) => bst2.bst.N - bst.bst.N);
let num9 = 0;
if (0 < items.length) {
do {
items[num9].ind = num9;
num9 = num9 + 1;
length = items.length;
} while (num9 < length);
}
const items1 = [obj, items];
return items1;
}
function getNearest(right, arg1, arg2, arg3, arg4) {
if (null == right.left) {
const q = right.est.q;
const diff = arg1 - q[0];
const diff1 = arg2 - q[1];
const diff2 = arg3 - q[2];
const diff3 = arg4 - q[3];
right.tdst = diff * diff + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
return right;
} else {
const est = right.est;
const e = est.e;
const diff4 = e[0] * arg1 + e[1] * arg2 + e[2] * arg3 + e[3] * arg4 - est.eMq;
({ left: right, right: left } = right);
if (diff4 > 0) {
({ right, left } = right);
}
const tmp7 = getNearest(right, arg1, arg2, arg3, arg4);
if (tmp7.tdst <= diff4 * diff4) {
return tmp7;
} else {
const tmpResult = tmp(left, arg1, arg2, arg3, arg4);
let tmp14 = tmp7;
if (tmpResult.tdst < tmp7.tdst) {
tmp14 = tmpResult;
}
return tmp14;
}
tmp = getNearest;
}
}
function vecDot(arg0, arg1, arg2) {
return arg0[arg1] * arg2[0] + arg0[arg1 + 1] * arg2[1] + arg0[arg1 + 2] * arg2[2] + arg0[arg1 + 3] * arg2[3];
}
function stats(substr, i0, i1) {
let sum = i0;
const R = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
const m = [0, 0, 0, 0];
const N = i1 - i0 >> 2;
if (i0 < i1) {
do {
let result = 0.00392156862745098 * substr[sum];
let result1 = 0.00392156862745098 * substr[sum + 1];
let result2 = 0.00392156862745098 * substr[sum + 2];
let result3 = 0.00392156862745098 * substr[sum + 3];
m[0] = m[0] + result;
m[1] = m[1] + result1;
m[2] = m[2] + result2;
m[3] = m[3] + result3;
R[0] = R[0] + result * result;
R[1] = R[1] + result * result1;
R[2] = R[2] + result * result2;
R[3] = R[3] + result * result3;
R[5] = R[5] + result1 * result1;
R[6] = R[6] + result1 * result2;
R[7] = R[7] + result1 * result3;
R[10] = R[10] + result2 * result2;
R[11] = R[11] + result2 * result3;
R[15] = R[15] + result3 * result3;
sum = sum + 4;
} while (sum < i1);
}
R[4] = R[1];
R[8] = R[2];
R[9] = R[6];
R[12] = R[3];
R[13] = R[7];
R[14] = R[11];
return { R, m, N };
}
function estats(bst) {
({ R, m, N } = bst);
[tmp, tmp2, tmp3, tmp4] = m;
let num = 0;
if (0 != N) {
num = 1 / N;
}
const items = [R[0] - tmp * tmp * num, R[1] - tmp * tmp2 * num, R[2] - tmp * tmp3 * num, R[3] - tmp * tmp4 * num, R[4] - tmp2 * tmp * num, R[5] - tmp2 * tmp2 * num, R[6] - tmp2 * tmp3 * num, R[7] - tmp2 * tmp4 * num, R[8] - tmp3 * tmp * num, R[9] - tmp3 * tmp2 * num, R[10] - tmp3 * tmp3 * num, R[11] - tmp3 * tmp4 * num, R[12] - tmp4 * tmp * num, R[13] - tmp4 * tmp2 * num, R[14] - tmp4 * tmp3 * num, R[15] - tmp4 * tmp4 * num];
let obj = c16;
const items1 = [Math.random(), Math.random(), Math.random(), Math.random()];
let num3 = 0;
let tmp5 = items1;
if (0 != N) {
const multVecResult = obj.multVec(items, items1);
const _Math = Math;
const sqrtResult = Math.sqrt(obj.dot(multVecResult, multVecResult));
let num7 = 0;
let tmp8 = sqrtResult;
let smlResult = obj.sml(1 / sqrtResult, multVecResult);
const sum = num7 + 1;
num3 = tmp8;
tmp5 = smlResult;
while (sum < 16) {
let multVecResult1 = obj.multVec(items, smlResult);
let _Math2 = Math;
let sqrtResult1 = Math.sqrt(obj.dot(multVecResult1, multVecResult1));
let smlResult1 = obj.sml(1 / sqrtResult1, multVecResult1);
num7 = sum;
tmp8 = sqrtResult1;
smlResult = smlResult1;
if (0 === sum) {
continue;
} else {
let _Math3 = Math;
num7 = sum;
tmp8 = sqrtResult1;
smlResult = smlResult1;
num3 = tmp11;
tmp5 = smlResult1;
if (Math.abs(sqrtResult1 - tmp11) < 0.000000001) {
break;
}
}
continue;
}
}
const items2 = [tmp * num, tmp2 * num, tmp3 * num, tmp4 * num];
obj = { Cov: items, q: items2, e: tmp5, L: num3, eMq255: obj.dot(obj.sml(255, items2), tmp5), eMq: obj.dot(tmp5, items2), rgba: null };
const tmp16 = Math.round(255 * items2[3]) << 24;
const tmp17 = Math.round(255 * items2[2]) << 16;
obj[6] = (tmp16 | tmp17 | Math.round(255 * items2[1]) << 8 | Math.round(255 * items2[0])) >>> 0;
return obj;
}
({ _copyTile: c0, _bin: c1, _paeth: c2 } = obj);
const uint32Array5 = new Uint32Array(256);
let num26 = 0;
let num27 = 0;
let tmp66 = num26;
do {
do {
let tmp67 = tmp66 >>> 1;
let tmp68 = num27;
let tmp69 = 1 & tmp66 ? 3988292384 ^ tmp67 : tmp67;
num27 = num27 + 1;
tmp66 = tmp69;
} while (num27 < 8);
uint32Array5[num26] = tmp69;
num26 = num26 + 1;
} while (num26 < 256);
Reference in a new issue View git blame Copy permalink