711 lines
24 KiB
JavaScript
711 lines
24 KiB
JavaScript
// Metro module 4751 (f4752).
|
|
(function(a0) {
|
|
let r9;
|
|
L8: {
|
|
if (typeof exports === "object") {
|
|
module.exports = a0();
|
|
} else {
|
|
if (typeof globalThis.define === "function" && define.amd) {
|
|
define(a0);
|
|
break L8;
|
|
}
|
|
try {
|
|
r9 = window;
|
|
} catch ($e) {
|
|
r9 = self;
|
|
}
|
|
r9.SparkMD5 = a0();
|
|
}
|
|
}
|
|
})(function(a0) {
|
|
"use strict";
|
|
let r16;
|
|
let c14425_0, c14425_1, md5cycle2, md512, SparkMD52;
|
|
L4: {
|
|
c14425_0 = a0;
|
|
md5cycle2 = function md5cycle(a0, a1) {
|
|
const r24 = a0[0];
|
|
const r21 = a0[1];
|
|
const r22 = a0[2];
|
|
const r23 = a0[3];
|
|
const r33 = r24 + ((r21 & r22 | ~r21 & r23) + a1[0] - 680876936 | 0);
|
|
const r7 = (r33 << 7 | r33 >>> 25) + r21 | 0;
|
|
const r46 = r23 + ((r7 & r21 | ~r7 & r22) + a1[1] - 389564586 | 0);
|
|
const r3 = (r46 << 12 | r46 >>> 20) + r7 | 0;
|
|
const r60 = r22 + ((r3 & r7 | ~r3 & r21) + a1[2] + 606105819 | 0);
|
|
const r2 = (r60 << 17 | r60 >>> 15) + r3 | 0;
|
|
const r74 = r21 + ((r2 & r3 | ~r2 & r7) + a1[3] - 1044525330 | 0);
|
|
const r79 = (r74 << 22 | r74 >>> 10) + r2 | 0;
|
|
const r88 = r7 + ((r79 & r2 | ~r79 & r3) + a1[4] - 176418897 | 0);
|
|
const r93 = (r88 << 7 | r88 >>> 25) + r79 | 0;
|
|
const r103 = r3 + ((r93 & r79 | ~r93 & r2) + a1[5] + 1200080426 | 0);
|
|
const r108 = (r103 << 12 | r103 >>> 20) + r93 | 0;
|
|
const r118 = r2 + ((r108 & r93 | ~r108 & r79) + a1[6] - 1473231341 | 0);
|
|
const r123 = (r118 << 17 | r118 >>> 15) + r108 | 0;
|
|
const r133 = r79 + ((r123 & r108 | ~r123 & r93) + a1[7] - 45705983 | 0);
|
|
const r138 = (r133 << 22 | r133 >>> 10) + r123 | 0;
|
|
const r148 = r93 + ((r138 & r123 | ~r138 & r108) + a1[8] + 1770035416 | 0);
|
|
const r153 = (r148 << 7 | r148 >>> 25) + r138 | 0;
|
|
const r163 = r108 + ((r153 & r138 | ~r153 & r123) + a1[9] - 1958414417 | 0);
|
|
const r168 = (r163 << 12 | r163 >>> 20) + r153 | 0;
|
|
const r178 = r123 + ((r168 & r153 | ~r168 & r138) + a1[10] - 42063 | 0);
|
|
const r183 = (r178 << 17 | r178 >>> 15) + r168 | 0;
|
|
const r193 = r138 + ((r183 & r168 | ~r183 & r153) + a1[11] - 1990404162 | 0);
|
|
const r198 = (r193 << 22 | r193 >>> 10) + r183 | 0;
|
|
const r208 = r153 + ((r198 & r183 | ~r198 & r168) + a1[12] + 1804603682 | 0);
|
|
const r213 = (r208 << 7 | r208 >>> 25) + r198 | 0;
|
|
const r223 = r168 + ((r213 & r198 | ~r213 & r183) + a1[13] - 40341101 | 0);
|
|
const r228 = (r223 << 12 | r223 >>> 20) + r213 | 0;
|
|
const r229 = ~r228;
|
|
const r238 = r183 + ((r228 & r213 | r229 & r198) + a1[14] - 1502002290 | 0);
|
|
const r243 = (r238 << 17 | r238 >>> 15) + r228 | 0;
|
|
const r244 = ~r243;
|
|
const r253 = r198 + ((r243 & r228 | r244 & r213) + a1[15] + 1236535329 | 0);
|
|
const r258 = (r253 << 22 | r253 >>> 10) + r243 | 0;
|
|
const r267 = r213 + ((r258 & r228 | r243 & r229) + a1[1] - 165796510 | 0);
|
|
const r13 = (r267 << 5 | r267 >>> 27) + r258 | 0;
|
|
const r281 = r228 + ((r13 & r243 | r258 & r244) + a1[6] - 1069501632 | 0);
|
|
const r288 = (r281 << 9 | r281 >>> 23) + r13 | 0;
|
|
const r298 = r243 + ((r288 & r258 | r13 & ~r258) + a1[11] + 643717713 | 0);
|
|
const r304 = (r298 << 14 | r298 >>> 18) + r288 | 0;
|
|
const r313 = r258 + ((r304 & r13 | r288 & ~r13) + a1[0] - 373897302 | 0);
|
|
const r318 = (r313 << 20 | r313 >>> 12) + r304 | 0;
|
|
const r328 = r13 + ((r318 & r288 | r304 & ~r288) + a1[5] - 701558691 | 0);
|
|
const r333 = (r328 << 5 | r328 >>> 27) + r318 | 0;
|
|
const r343 = r288 + ((r333 & r304 | r318 & ~r304) + a1[10] + 38016083 | 0);
|
|
const r348 = (r343 << 9 | r343 >>> 23) + r333 | 0;
|
|
const r358 = r304 + ((r348 & r318 | r333 & ~r318) + a1[15] - 660478335 | 0);
|
|
const r363 = (r358 << 14 | r358 >>> 18) + r348 | 0;
|
|
const r373 = r318 + ((r363 & r333 | r348 & ~r333) + a1[4] - 405537848 | 0);
|
|
const r378 = (r373 << 20 | r373 >>> 12) + r363 | 0;
|
|
const r388 = r333 + ((r378 & r348 | r363 & ~r348) + a1[9] + 568446438 | 0);
|
|
const r393 = (r388 << 5 | r388 >>> 27) + r378 | 0;
|
|
const r403 = r348 + ((r393 & r363 | r378 & ~r363) + a1[14] - 1019803690 | 0);
|
|
const r408 = (r403 << 9 | r403 >>> 23) + r393 | 0;
|
|
const r418 = r363 + ((r408 & r378 | r393 & ~r378) + a1[3] - 187363961 | 0);
|
|
const r423 = (r418 << 14 | r418 >>> 18) + r408 | 0;
|
|
const r433 = r378 + ((r423 & r393 | r408 & ~r393) + a1[8] + 1163531501 | 0);
|
|
const r438 = (r433 << 20 | r433 >>> 12) + r423 | 0;
|
|
const r448 = r393 + ((r438 & r408 | r423 & ~r408) + a1[13] - 1444681467 | 0);
|
|
const r453 = (r448 << 5 | r448 >>> 27) + r438 | 0;
|
|
const r463 = r408 + ((r453 & r423 | r438 & ~r423) + a1[2] - 51403784 | 0);
|
|
const r468 = (r463 << 9 | r463 >>> 23) + r453 | 0;
|
|
const r478 = r423 + ((r468 & r438 | r453 & ~r438) + a1[7] + 1735328473 | 0);
|
|
const r483 = (r478 << 14 | r478 >>> 18) + r468 | 0;
|
|
const r493 = r438 + ((r483 & r453 | r468 & ~r453) + a1[12] - 1926607734 | 0);
|
|
const r498 = (r493 << 20 | r493 >>> 12) + r483 | 0;
|
|
const r506 = r453 + ((r498 ^ r483 ^ r468) + a1[5] - 378558 | 0);
|
|
const r513 = (r506 << 4 | r506 >>> 28) + r498 | 0;
|
|
const r521 = r468 + ((r513 ^ r498 ^ r483) + a1[8] - 2022574463 | 0);
|
|
const r528 = (r521 << 11 | r521 >>> 21) + r513 | 0;
|
|
const r536 = r483 + ((r528 ^ r513 ^ r498) + a1[11] + 1839030562 | 0);
|
|
const r542 = (r536 << 16 | r536 >>> 16) + r528 | 0;
|
|
const r550 = r498 + ((r542 ^ r528 ^ r513) + a1[14] - 35309556 | 0);
|
|
const r555 = (r550 << 23 | r550 >>> 9) + r542 | 0;
|
|
const r563 = r513 + ((r555 ^ r542 ^ r528) + a1[1] - 1530992060 | 0);
|
|
const r568 = (r563 << 4 | r563 >>> 28) + r555 | 0;
|
|
const r576 = r528 + ((r568 ^ r555 ^ r542) + a1[4] + 1272893353 | 0);
|
|
const r581 = (r576 << 11 | r576 >>> 21) + r568 | 0;
|
|
const r589 = r542 + ((r581 ^ r568 ^ r555) + a1[7] - 155497632 | 0);
|
|
const r594 = (r589 << 16 | r589 >>> 16) + r581 | 0;
|
|
const r602 = r555 + ((r594 ^ r581 ^ r568) + a1[10] - 1094730640 | 0);
|
|
const r607 = (r602 << 23 | r602 >>> 9) + r594 | 0;
|
|
const r615 = r568 + ((r607 ^ r594 ^ r581) + a1[13] + 681279174 | 0);
|
|
const r620 = (r615 << 4 | r615 >>> 28) + r607 | 0;
|
|
const r628 = r581 + ((r620 ^ r607 ^ r594) + a1[0] - 358537222 | 0);
|
|
const r633 = (r628 << 11 | r628 >>> 21) + r620 | 0;
|
|
const r641 = r594 + ((r633 ^ r620 ^ r607) + a1[3] - 722521979 | 0);
|
|
const r646 = (r641 << 16 | r641 >>> 16) + r633 | 0;
|
|
const r654 = r607 + ((r646 ^ r633 ^ r620) + a1[6] + 76029189 | 0);
|
|
const r659 = (r654 << 23 | r654 >>> 9) + r646 | 0;
|
|
const r667 = r620 + ((r659 ^ r646 ^ r633) + a1[9] - 640364487 | 0);
|
|
const r672 = (r667 << 4 | r667 >>> 28) + r659 | 0;
|
|
const r680 = r633 + ((r672 ^ r659 ^ r646) + a1[12] - 421815835 | 0);
|
|
const r685 = (r680 << 11 | r680 >>> 21) + r672 | 0;
|
|
const r693 = r646 + ((r685 ^ r672 ^ r659) + a1[15] + 530742520 | 0);
|
|
const r698 = (r693 << 16 | r693 >>> 16) + r685 | 0;
|
|
const r706 = r659 + ((r698 ^ r685 ^ r672) + a1[2] - 995338651 | 0);
|
|
const r711 = (r706 << 23 | r706 >>> 9) + r698 | 0;
|
|
const r720 = r672 + ((r698 ^ (r711 | ~r685)) + a1[0] - 198630844 | 0);
|
|
const r727 = (r720 << 6 | r720 >>> 26) + r711 | 0;
|
|
const r736 = r685 + ((r711 ^ (r727 | ~r698)) + a1[7] + 1126891415 | 0);
|
|
const r741 = (r736 << 10 | r736 >>> 22) + r727 | 0;
|
|
const r750 = r698 + ((r727 ^ (r741 | ~r711)) + a1[14] - 1416354905 | 0);
|
|
const r755 = (r750 << 15 | r750 >>> 17) + r741 | 0;
|
|
const r764 = r711 + ((r741 ^ (r755 | ~r727)) + a1[5] - 57434055 | 0);
|
|
const r769 = (r764 << 21 | r764 >>> 11) + r755 | 0;
|
|
const r778 = r727 + ((r755 ^ (r769 | ~r741)) + a1[12] + 1700485571 | 0);
|
|
const r783 = (r778 << 6 | r778 >>> 26) + r769 | 0;
|
|
const r792 = r741 + ((r769 ^ (r783 | ~r755)) + a1[3] - 1894986606 | 0);
|
|
const r797 = (r792 << 10 | r792 >>> 22) + r783 | 0;
|
|
const r806 = r755 + ((r783 ^ (r797 | ~r769)) + a1[10] - 1051523 | 0);
|
|
const r811 = (r806 << 15 | r806 >>> 17) + r797 | 0;
|
|
const r820 = r769 + ((r797 ^ (r811 | ~r783)) + a1[1] - 2054922799 | 0);
|
|
const r825 = (r820 << 21 | r820 >>> 11) + r811 | 0;
|
|
const r834 = r783 + ((r811 ^ (r825 | ~r797)) + a1[8] + 1873313359 | 0);
|
|
const r839 = (r834 << 6 | r834 >>> 26) + r825 | 0;
|
|
const r848 = r797 + ((r825 ^ (r839 | ~r811)) + a1[15] - 30611744 | 0);
|
|
const r853 = (r848 << 10 | r848 >>> 22) + r839 | 0;
|
|
const r862 = r811 + ((r839 ^ (r853 | ~r825)) + a1[6] - 1560198380 | 0);
|
|
const r867 = (r862 << 15 | r862 >>> 17) + r853 | 0;
|
|
const r876 = r825 + ((r853 ^ (r867 | ~r839)) + a1[13] + 1309151649 | 0);
|
|
const r881 = (r876 << 21 | r876 >>> 11) + r867 | 0;
|
|
const r890 = r839 + ((r867 ^ (r881 | ~r853)) + a1[4] - 145523070 | 0);
|
|
const r895 = (r890 << 6 | r890 >>> 26) + r881 | 0;
|
|
const r904 = r853 + ((r881 ^ (r895 | ~r867)) + a1[11] - 1120210379 | 0);
|
|
const r909 = (r904 << 10 | r904 >>> 22) + r895 | 0;
|
|
const r918 = r867 + ((r895 ^ (r909 | ~r881)) + a1[2] + 718787259 | 0);
|
|
const r923 = (r918 << 15 | r918 >>> 17) + r909 | 0;
|
|
const r932 = r881 + ((r909 ^ (r923 | ~r895)) + a1[9] - 343485551 | 0);
|
|
const r937 = (r932 << 21 | r932 >>> 11) + r923 | 0;
|
|
a0[0] = r895 + a0[0] | 0;
|
|
a0[1] = r937 + a0[1] | 0;
|
|
a0[2] = r923 + a0[2] | 0;
|
|
a0[3] = r909 + a0[3] | 0;
|
|
};
|
|
md512 = function md51(a0) {
|
|
let r13, r16, length;
|
|
L4: {
|
|
length = a0.length;
|
|
r16 = [1732584193, -271733879, -1732584194, 271733878];
|
|
const r15 = 64 <= length;
|
|
let r5 = 64;
|
|
r13 = 64;
|
|
if (r15) {
|
|
loop1: while (true) {
|
|
const r22 = a0.substring(r5 - 64, r5);
|
|
const r25 = [];
|
|
const r26 = r5;
|
|
let r1 = 0;
|
|
while (true) {
|
|
r25[r1 >> 2] = r22.charCodeAt(r1) + (r22.charCodeAt(r1 + 1) << 8) + (r22.charCodeAt(r1 + 2) << 16) + (r22.charCodeAt(r1 + 3) << 24);
|
|
r1 = r1 + 4;
|
|
if (!(r1 < 64)) {
|
|
md5cycle2(r16, r25);
|
|
r5 = r26 + 64;
|
|
r13 = r5;
|
|
if (r13 <= length) {
|
|
continue loop1;
|
|
}
|
|
break L4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const r44 = a0.substring(r13 - 64);
|
|
const length2 = r44.length;
|
|
const r46 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
const r47 = 0 < length2;
|
|
let r48 = 0;
|
|
let r49 = 0;
|
|
if (r47) {
|
|
do {
|
|
const r50 = r48 >> 2;
|
|
r46[r50] = r46[r50] | r44.charCodeAt(r48) << (r48 % 4 << 3);
|
|
r48 = r48 + 1;
|
|
r49 = r48;
|
|
} while (r49 < length2);
|
|
}
|
|
const r58 = r49 >> 2;
|
|
r46[r58] = r46[r58] | 128 << (r49 % 4 << 3);
|
|
if (55 < r49) {
|
|
md5cycle2(r16, r46);
|
|
let r68 = 0;
|
|
do {
|
|
r46[r68] = 0;
|
|
r68 = r68 + 1;
|
|
} while (r68 < 16);
|
|
}
|
|
const r74 = (8 * length).toString(16).match(/(.*?)(.{0,8})$/);
|
|
const r79 = parseInt(r74[2], 16);
|
|
const r82 = parseInt(r74[1], 16) || 0;
|
|
r46[14] = r79;
|
|
r46[15] = r82;
|
|
md5cycle2(r16, r46);
|
|
return r16;
|
|
};
|
|
SparkMD52 = function SparkMD5() {
|
|
this.reset();
|
|
};
|
|
const r17 = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
|
|
c14425_1 = r17;
|
|
r16 = md512("hello");
|
|
const r11 = 0 < r16.length;
|
|
let r7 = 0;
|
|
if (r11) {
|
|
loop1: while (true) {
|
|
const r19 = r16[r7];
|
|
const r8 = r7;
|
|
let r18 = "";
|
|
let r1 = 0;
|
|
while (true) {
|
|
const r0 = 8 * r1;
|
|
const r31 = r18 + (r17[r19 >> r0 + 4 & 15] + r17[r19 >> r0 & 15]);
|
|
r1 = r1 + 1;
|
|
r18 = r31;
|
|
if (!(r1 < 4)) {
|
|
r16[r8] = r31;
|
|
r7 = r8 + 1;
|
|
if (r7 < r16.length) {
|
|
continue loop1;
|
|
}
|
|
break L4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (r16.join("") !== "5d41402abc4b2a76b9719d911017c592") {
|
|
add32 = function(a0, a1) {
|
|
const r3 = (65535 & a0) + (65535 & a1);
|
|
return (a0 >> 16) + (a1 >> 16) + (r3 >> 16) << 16 | 65535 & r3;
|
|
};
|
|
}
|
|
const ArrayBuffer2 = globalThis.ArrayBuffer;
|
|
if (!(typeof ArrayBuffer2 !== "undefined" ? ArrayBuffer.prototype.slice : typeof ArrayBuffer2 === "undefined")) {
|
|
ArrayBuffer.prototype.slice = function(a0, a1) {
|
|
let r35;
|
|
const byteLength = this.byteLength;
|
|
const r0 = a0 | 0 || 0;
|
|
const r7 = r0 < 0 ? Math.max(r0 + byteLength, 0) : Math.min(r0, byteLength);
|
|
let r21 = byteLength;
|
|
if (a1 !== c14425_0) {
|
|
const r22 = a1 | 0 || 0;
|
|
r21 = r22 < 0 ? Math.max(r22 + byteLength, 0) : Math.min(r22, byteLength);
|
|
}
|
|
if (r7 > r21) {
|
|
r35 = new ArrayBuffer(0);
|
|
} else {
|
|
const r30 = r21 - r7;
|
|
r35 = new ArrayBuffer(r30);
|
|
new Uint8Array(r35).set(new Uint8Array(this, r7, r30));
|
|
}
|
|
return r35;
|
|
};
|
|
}
|
|
SparkMD52.prototype.append = function(a0) {
|
|
this.appendBinary(/[\u0080-\uFFFF]/.test(a0) ? unescape(encodeURIComponent(a0)) : a0);
|
|
return this;
|
|
};
|
|
SparkMD52.prototype.appendBinary = function(a0) {
|
|
let r14;
|
|
L4: {
|
|
this._buff = this._buff + a0;
|
|
this._length = this._length + a0.length;
|
|
const length = this._buff.length;
|
|
const r15 = 64 <= length;
|
|
let r10 = 64;
|
|
r14 = 64;
|
|
if (r15) {
|
|
loop1: while (true) {
|
|
const _hash = this._hash;
|
|
const r32 = this._buff.substring(r10 - 64, r10);
|
|
const r33 = [];
|
|
const r34 = r10;
|
|
let r1 = 0;
|
|
while (true) {
|
|
r33[r1 >> 2] = r32.charCodeAt(r1) + (r32.charCodeAt(r1 + 1) << 8) + (r32.charCodeAt(r1 + 2) << 16) + (r32.charCodeAt(r1 + 3) << 24);
|
|
r1 = r1 + 4;
|
|
if (!(r1 < 64)) {
|
|
md5cycle2(_hash, r33);
|
|
r10 = r34 + 64;
|
|
r14 = r10;
|
|
if (r14 <= length) {
|
|
continue loop1;
|
|
}
|
|
break L4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this._buff = this._buff.substring(r14 - 64);
|
|
return this;
|
|
};
|
|
SparkMD52.prototype.end = function(a0) {
|
|
let _hash;
|
|
const _buff = this._buff;
|
|
const length = _buff.length;
|
|
const r15 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
const r11 = 0 < length;
|
|
let r5 = 0;
|
|
if (r11) {
|
|
do {
|
|
const r9 = r5 >> 2;
|
|
r15[r9] = r15[r9] | _buff.charCodeAt(r5) << (r5 % 4 << 3);
|
|
r5 = r5 + 1;
|
|
} while (r5 < length);
|
|
}
|
|
L6: {
|
|
this._finish(r15, length);
|
|
_hash = this._hash;
|
|
const r29 = 0 < _hash.length;
|
|
let r33 = 0;
|
|
if (r29) {
|
|
loop3: while (true) {
|
|
const r34 = _hash[r33];
|
|
const r35 = r33;
|
|
let r36 = "";
|
|
let r1 = 0;
|
|
while (true) {
|
|
const r0 = 8 * r1;
|
|
const r44 = r36 + (c14425_1[r34 >> r0 + 4 & 15] + c14425_1[r34 >> r0 & 15]);
|
|
r1 = r1 + 1;
|
|
r36 = r44;
|
|
if (!(r1 < 4)) {
|
|
_hash[r35] = r44;
|
|
r33 = r35 + 1;
|
|
if (r33 < _hash.length) {
|
|
continue loop3;
|
|
}
|
|
break L6;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const r48 = _hash.join("");
|
|
let r49 = r48;
|
|
if (a0) {
|
|
const r50 = [];
|
|
const length2 = r48.length;
|
|
const r52 = length2 - 1;
|
|
let r56 = 0;
|
|
if (0 < r52) {
|
|
do {
|
|
r50.push(parseInt(r48.substr(r56, 2), 16));
|
|
r56 = r56 + 2;
|
|
} while (r56 < length2 - 1);
|
|
}
|
|
r49 = String.fromCharCode.apply(String, r50);
|
|
}
|
|
this.reset();
|
|
return r49;
|
|
};
|
|
SparkMD52.prototype.reset = function() {
|
|
this._buff = "";
|
|
this._length = 0;
|
|
this._hash = [1732584193, -271733879, -1732584194, 271733878];
|
|
return this;
|
|
};
|
|
SparkMD52.prototype.getState = function() {
|
|
return {
|
|
buff: this._buff,
|
|
length: this._length,
|
|
hash: this._hash.slice()
|
|
};
|
|
};
|
|
SparkMD52.prototype.setState = function(a0) {
|
|
this._buff = a0.buff;
|
|
this._length = a0.length;
|
|
this._hash = a0.hash;
|
|
return this;
|
|
};
|
|
SparkMD52.prototype.destroy = function() {
|
|
delete this["_hash"];
|
|
delete this["_buff"];
|
|
delete this["_length"];
|
|
};
|
|
SparkMD52.prototype._finish = function(a0, a1) {
|
|
const r2 = a1 >> 2;
|
|
a0[r2] = a0[r2] | 128 << (a1 % 4 << 3);
|
|
if (a1 > 55) {
|
|
md5cycle2(this._hash, a0);
|
|
let r25 = 0;
|
|
do {
|
|
a0[r25] = 0;
|
|
r25 = r25 + 1;
|
|
} while (r25 < 16);
|
|
}
|
|
const r33 = (8 * this._length).toString(16).match(/(.*?)(.{0,8})$/);
|
|
const r37 = parseInt(r33[2], 16);
|
|
const r40 = parseInt(r33[1], 16) || 0;
|
|
a0[14] = r37;
|
|
a0[15] = r40;
|
|
md5cycle2(this._hash, a0);
|
|
};
|
|
SparkMD52.hash = function(a0, a1) {
|
|
return SparkMD52.hashBinary(/[\u0080-\uFFFF]/.test(a0) ? unescape(encodeURIComponent(a0)) : a0, a1);
|
|
};
|
|
SparkMD52.hashBinary = function(a0, a1) {
|
|
let r14;
|
|
L4: {
|
|
r14 = md512(a0);
|
|
const r10 = 0 < r14.length;
|
|
let r8 = 0;
|
|
if (r10) {
|
|
loop1: while (true) {
|
|
const r16 = r14[r8];
|
|
const r9 = r8;
|
|
let r15 = "";
|
|
let r1 = 0;
|
|
while (true) {
|
|
const r0 = 8 * r1;
|
|
const r28 = r15 + (c14425_1[r16 >> r0 + 4 & 15] + c14425_1[r16 >> r0 & 15]);
|
|
r1 = r1 + 1;
|
|
r15 = r28;
|
|
if (!(r1 < 4)) {
|
|
r14[r9] = r28;
|
|
r8 = r9 + 1;
|
|
if (r8 < r14.length) {
|
|
continue loop1;
|
|
}
|
|
break L4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const r32 = r14.join("");
|
|
let r33 = r32;
|
|
if (a1) {
|
|
const r34 = [];
|
|
const length = r32.length;
|
|
const r36 = length - 1;
|
|
let r41 = 0;
|
|
if (0 < r36) {
|
|
do {
|
|
r34.push(parseInt(r32.substr(r41, 2), 16));
|
|
r41 = r41 + 2;
|
|
} while (r41 < length - 1);
|
|
}
|
|
r33 = String.fromCharCode.apply(String, r34);
|
|
}
|
|
return r33;
|
|
};
|
|
SparkMD52.ArrayBuffer = function() {
|
|
this.reset();
|
|
};
|
|
SparkMD52.ArrayBuffer.prototype.append = function(a0) {
|
|
let r14, length, uint8Array;
|
|
L4: {
|
|
const buffer = this._buff.buffer;
|
|
uint8Array = new Uint8Array(buffer.byteLength + a0.byteLength);
|
|
uint8Array.set(new Uint8Array(buffer));
|
|
uint8Array.set(new Uint8Array(a0), buffer.byteLength);
|
|
length = uint8Array.length;
|
|
this._length = this._length + a0.byteLength;
|
|
const r15 = 64 <= length;
|
|
let r10 = 64;
|
|
r14 = 64;
|
|
if (r15) {
|
|
loop1: while (true) {
|
|
const _hash = this._hash;
|
|
const r57 = uint8Array.subarray(r10 - 64, r10);
|
|
const r58 = [];
|
|
const r59 = r10;
|
|
let r1 = 0;
|
|
while (true) {
|
|
r58[r1 >> 2] = r57[r1] + (r57[r1 + 1] << 8) + (r57[r1 + 2] << 16) + (r57[r1 + 3] << 24);
|
|
r1 = r1 + 4;
|
|
if (!(r1 < 64)) {
|
|
md5cycle2(_hash, r58);
|
|
r10 = r59 + 64;
|
|
r14 = r10;
|
|
if (r14 <= length) {
|
|
continue loop1;
|
|
}
|
|
break L4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const r71 = r14 - 64;
|
|
this._buff = r71 < length ? new Uint8Array(uint8Array.buffer.slice(r71)) : new Uint8Array(0);
|
|
return this;
|
|
};
|
|
SparkMD52.ArrayBuffer.prototype.end = function(a0) {
|
|
let _hash;
|
|
const _buff = this._buff;
|
|
const length = _buff.length;
|
|
const r15 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
const r11 = 0 < length;
|
|
let r5 = 0;
|
|
if (r11) {
|
|
do {
|
|
const r9 = r5 >> 2;
|
|
r15[r9] = r15[r9] | _buff[r5] << (r5 % 4 << 3);
|
|
r5 = r5 + 1;
|
|
} while (r5 < length);
|
|
}
|
|
L6: {
|
|
this._finish(r15, length);
|
|
_hash = this._hash;
|
|
const r28 = 0 < _hash.length;
|
|
let r32 = 0;
|
|
if (r28) {
|
|
loop3: while (true) {
|
|
const r33 = _hash[r32];
|
|
const r34 = r32;
|
|
let r35 = "";
|
|
let r1 = 0;
|
|
while (true) {
|
|
const r0 = 8 * r1;
|
|
const r43 = r35 + (c14425_1[r33 >> r0 + 4 & 15] + c14425_1[r33 >> r0 & 15]);
|
|
r1 = r1 + 1;
|
|
r35 = r43;
|
|
if (!(r1 < 4)) {
|
|
_hash[r34] = r43;
|
|
r32 = r34 + 1;
|
|
if (r32 < _hash.length) {
|
|
continue loop3;
|
|
}
|
|
break L6;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const r47 = _hash.join("");
|
|
let r48 = r47;
|
|
if (a0) {
|
|
const r49 = [];
|
|
const length2 = r47.length;
|
|
const r51 = length2 - 1;
|
|
let r55 = 0;
|
|
if (0 < r51) {
|
|
do {
|
|
r49.push(parseInt(r47.substr(r55, 2), 16));
|
|
r55 = r55 + 2;
|
|
} while (r55 < length2 - 1);
|
|
}
|
|
r48 = String.fromCharCode.apply(String, r49);
|
|
}
|
|
this.reset();
|
|
return r48;
|
|
};
|
|
SparkMD52.ArrayBuffer.prototype.reset = function() {
|
|
this._buff = new Uint8Array(0);
|
|
this._length = 0;
|
|
this._hash = [1732584193, -271733879, -1732584194, 271733878];
|
|
return this;
|
|
};
|
|
SparkMD52.ArrayBuffer.prototype.getState = function() {
|
|
const r13 = SparkMD52.prototype.getState.call(this);
|
|
r13.buff = String.fromCharCode.apply(null, new Uint8Array(r13.buff));
|
|
return r13;
|
|
};
|
|
SparkMD52.ArrayBuffer.prototype.setState = function(a0) {
|
|
const buff = a0.buff;
|
|
const length = buff.length;
|
|
const uint8Array = new Uint8Array(new ArrayBuffer(length));
|
|
let r0 = 0;
|
|
while (r0 < length) {
|
|
uint8Array[r0] = buff.charCodeAt(r0);
|
|
r0 = r0 + 1;
|
|
}
|
|
a0.buff = uint8Array;
|
|
return SparkMD52.prototype.setState.call(this, a0);
|
|
};
|
|
SparkMD52.ArrayBuffer.prototype.destroy = SparkMD52.prototype.destroy;
|
|
SparkMD52.ArrayBuffer.prototype._finish = SparkMD52.prototype._finish;
|
|
SparkMD52.ArrayBuffer.hash = function(a0, a1) {
|
|
let r5, r31, length, uint8Array;
|
|
L4: {
|
|
uint8Array = new Uint8Array(a0);
|
|
length = uint8Array.length;
|
|
r31 = [1732584193, -271733879, -1732584194, 271733878];
|
|
const r15 = 64 <= length;
|
|
let r12 = 64;
|
|
r5 = 64;
|
|
if (r15) {
|
|
loop1: while (true) {
|
|
const r24 = uint8Array.subarray(r12 - 64, r12);
|
|
const r33 = [];
|
|
const r34 = r12;
|
|
let r1 = 0;
|
|
while (true) {
|
|
r33[r1 >> 2] = r24[r1] + (r24[r1 + 1] << 8) + (r24[r1 + 2] << 16) + (r24[r1 + 3] << 24);
|
|
r1 = r1 + 4;
|
|
if (!(r1 < 64)) {
|
|
md5cycle2(r31, r33);
|
|
r12 = r34 + 64;
|
|
r5 = r12;
|
|
if (r5 <= length) {
|
|
continue loop1;
|
|
}
|
|
break L4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const r46 = r5 - 64;
|
|
const r52 = r46 < length ? uint8Array.subarray(r46) : new Uint8Array(0);
|
|
const length2 = r52.length;
|
|
const r55 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
const r56 = 0 < length2;
|
|
let r57 = 0;
|
|
let r58 = 0;
|
|
if (r56) {
|
|
do {
|
|
const r59 = r57 >> 2;
|
|
r55[r59] = r55[r59] | r52[r57] << (r57 % 4 << 3);
|
|
r57 = r57 + 1;
|
|
r58 = r57;
|
|
} while (r58 < length2);
|
|
}
|
|
const r66 = r58 >> 2;
|
|
r55[r66] = r55[r66] | 128 << (r58 % 4 << 3);
|
|
if (55 < r58) {
|
|
md5cycle2(r31, r55);
|
|
let r76 = 0;
|
|
do {
|
|
r55[r76] = 0;
|
|
r76 = r76 + 1;
|
|
} while (r76 < 16);
|
|
}
|
|
const r82 = (8 * length).toString(16).match(/(.*?)(.{0,8})$/);
|
|
const r86 = parseInt(r82[2], 16);
|
|
const r89 = parseInt(r82[1], 16) || 0;
|
|
L18: {
|
|
r55[14] = r86;
|
|
r55[15] = r89;
|
|
md5cycle2(r31, r55);
|
|
const r94 = 0 < r31.length;
|
|
let r96 = 0;
|
|
if (r94) {
|
|
loop15: while (true) {
|
|
const r97 = r31[r96];
|
|
const r98 = r96;
|
|
let r99 = "";
|
|
let r100 = 0;
|
|
while (true) {
|
|
const r102 = 8 * r100;
|
|
const r111 = r99 + (c14425_1[r97 >> r102 + 4 & 15] + c14425_1[r97 >> r102 & 15]);
|
|
r100 = r100 + 1;
|
|
r99 = r111;
|
|
if (!(r100 < 4)) {
|
|
r31[r98] = r111;
|
|
r96 = r98 + 1;
|
|
if (r96 < r31.length) {
|
|
continue loop15;
|
|
}
|
|
break L18;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const r115 = r31.join("");
|
|
let r116 = r115;
|
|
if (a1) {
|
|
const r117 = [];
|
|
const length3 = r115.length;
|
|
const r119 = length3 - 1;
|
|
let r120 = 0;
|
|
if (0 < r119) {
|
|
do {
|
|
r117.push(parseInt(r115.substr(r120, 2), 16));
|
|
r120 = r120 + 2;
|
|
} while (r120 < length3 - 1);
|
|
}
|
|
r116 = String.fromCharCode.apply(String, r117);
|
|
}
|
|
return r116;
|
|
};
|
|
return SparkMD52;
|
|
});
|