|
|
|
|
@ -4047,7 +4047,6 @@ const cloud_runner_system_1 = __nccwpck_require__(4197);
|
|
|
|
|
const cloud_runner_1 = __importDefault(__nccwpck_require__(79144));
|
|
|
|
|
const kubernetes_pods_1 = __importDefault(__nccwpck_require__(90740));
|
|
|
|
|
const follow_log_stream_service_1 = __nccwpck_require__(40266);
|
|
|
|
|
const remote_client_logger_1 = __nccwpck_require__(59412);
|
|
|
|
|
class KubernetesTaskRunner {
|
|
|
|
|
static async runTask(kubeConfig, kubeClient, jobName, podName, containerName, namespace) {
|
|
|
|
|
let output = '';
|
|
|
|
|
@ -4066,25 +4065,6 @@ class KubernetesTaskRunner {
|
|
|
|
|
output += outputChunk;
|
|
|
|
|
// split output chunk and handle per line
|
|
|
|
|
for (const chunk of outputChunk.split(`\n`)) {
|
|
|
|
|
// check if log start included in logs if so log a message
|
|
|
|
|
if (chunk.includes(`Collected Logs`)) {
|
|
|
|
|
cloud_runner_logger_1.default.log(`Log Start found in logs`);
|
|
|
|
|
}
|
|
|
|
|
if (chunk.includes(`LOGHASH:`)) {
|
|
|
|
|
remote_client_logger_1.RemoteClientLogger.HandleLogHash(chunk);
|
|
|
|
|
cloud_runner_logger_1.default.log(`Loghash found`);
|
|
|
|
|
}
|
|
|
|
|
if (chunk.includes(`LOGS:`)) {
|
|
|
|
|
cloud_runner_logger_1.default.log(`LOGS: found`);
|
|
|
|
|
// remove "LOGS: " and decode base64 remaining
|
|
|
|
|
const unpacked = Buffer.from(chunk.split(`LOGS: `)[1], 'base64').toString('ascii');
|
|
|
|
|
const result = remote_client_logger_1.RemoteClientLogger.HandleLogFull(unpacked);
|
|
|
|
|
cloud_runner_logger_1.default.log(`Logs found HandleLogChunkLineResult:${result}`);
|
|
|
|
|
if (result) {
|
|
|
|
|
follow_log_stream_service_1.FollowLogStreamService.DidReceiveEndOfTransmission = true;
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
({ shouldReadLogs, shouldCleanup, output } = follow_log_stream_service_1.FollowLogStreamService.handleIteration(chunk, shouldReadLogs, shouldCleanup, output));
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
@ -4674,29 +4654,6 @@ exports.RemoteClient = RemoteClient;
|
|
|
|
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
|
|
|
if (k2 === undefined) k2 = k;
|
|
|
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
|
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
|
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
|
|
|
}
|
|
|
|
|
Object.defineProperty(o, k2, desc);
|
|
|
|
|
}) : (function(o, m, k, k2) {
|
|
|
|
|
if (k2 === undefined) k2 = k;
|
|
|
|
|
o[k2] = m[k];
|
|
|
|
|
}));
|
|
|
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
|
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
|
|
|
}) : function(o, v) {
|
|
|
|
|
o["default"] = v;
|
|
|
|
|
});
|
|
|
|
|
var __importStar = (this && this.__importStar) || function (mod) {
|
|
|
|
|
if (mod && mod.__esModule) return mod;
|
|
|
|
|
var result = {};
|
|
|
|
|
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
|
|
|
__setModuleDefault(result, mod);
|
|
|
|
|
return result;
|
|
|
|
|
};
|
|
|
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
|
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
|
|
|
};
|
|
|
|
|
@ -4707,7 +4664,6 @@ const node_fs_1 = __importDefault(__nccwpck_require__(87561));
|
|
|
|
|
const node_path_1 = __importDefault(__nccwpck_require__(49411));
|
|
|
|
|
const cloud_runner_1 = __importDefault(__nccwpck_require__(79144));
|
|
|
|
|
const cloud_runner_options_1 = __importDefault(__nccwpck_require__(66965));
|
|
|
|
|
const md5 = __importStar(__nccwpck_require__(7776));
|
|
|
|
|
class RemoteClientLogger {
|
|
|
|
|
static get LogFilePath() {
|
|
|
|
|
return node_path_1.default.join(`/home`, `job-log.txt`);
|
|
|
|
|
@ -4764,40 +4720,10 @@ class RemoteClientLogger {
|
|
|
|
|
// }
|
|
|
|
|
}
|
|
|
|
|
static HandleLog(message) {
|
|
|
|
|
if (message.includes('LOGHASH: ')) {
|
|
|
|
|
RemoteClientLogger.HandleLogHash(message);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
if (RemoteClientLogger.value !== '') {
|
|
|
|
|
RemoteClientLogger.value += `\n`;
|
|
|
|
|
}
|
|
|
|
|
RemoteClientLogger.value += message;
|
|
|
|
|
const hashedValue = md5.Md5.hashStr(RemoteClientLogger.value);
|
|
|
|
|
if (RemoteClientLogger.md5 === hashedValue) {
|
|
|
|
|
cloud_runner_logger_1.default.log(`LOG COMPLETE`);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
static HandleLogHash(message) {
|
|
|
|
|
if (message.includes('LOGHASH: ')) {
|
|
|
|
|
RemoteClientLogger.md5 = message.split(`LOGHASH: `)[1];
|
|
|
|
|
cloud_runner_logger_1.default.log(`LOGHASH: ${RemoteClientLogger.md5}`);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
throw new Error(`LOGHASH: not found`);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
static HandleLogFull(message) {
|
|
|
|
|
const hashedValue = md5.Md5.hashStr(message);
|
|
|
|
|
if (RemoteClientLogger.md5 === hashedValue) {
|
|
|
|
|
cloud_runner_logger_1.default.log(`LOG COMPLETE`);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
cloud_runner_logger_1.default.log(`LOG INCOMPLETE ${RemoteClientLogger.md5} ${hashedValue}`);
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
@ -278289,638 +278215,6 @@ Store.prototype.getAllCookies = function(cb) {
|
|
|
|
|
module.exports = '2.5.0'
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 7776:
|
|
|
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
|
|
|
exports.ParallelHasher = exports.Md5FileHasher = exports.Md5 = void 0;
|
|
|
|
|
var md5_1 = __nccwpck_require__(33033);
|
|
|
|
|
Object.defineProperty(exports, "Md5", ({ enumerable: true, get: function () { return md5_1.Md5; } }));
|
|
|
|
|
var md5_file_hasher_1 = __nccwpck_require__(70269);
|
|
|
|
|
Object.defineProperty(exports, "Md5FileHasher", ({ enumerable: true, get: function () { return md5_file_hasher_1.Md5FileHasher; } }));
|
|
|
|
|
var parallel_hasher_1 = __nccwpck_require__(23395);
|
|
|
|
|
Object.defineProperty(exports, "ParallelHasher", ({ enumerable: true, get: function () { return parallel_hasher_1.ParallelHasher; } }));
|
|
|
|
|
//# sourceMappingURL=index.js.map
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 33033:
|
|
|
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
|
|
TypeScript Md5
|
|
|
|
|
==============
|
|
|
|
|
|
|
|
|
|
Based on work by
|
|
|
|
|
* Joseph Myers: http://www.myersdaily.org/joseph/javascript/md5-text.html
|
|
|
|
|
* André Cruz: https://github.com/satazor/SparkMD5
|
|
|
|
|
* Raymond Hill: https://github.com/gorhill/yamd5.js
|
|
|
|
|
|
|
|
|
|
Effectively a TypeScrypt re-write of Raymond Hill JS Library
|
|
|
|
|
|
|
|
|
|
The MIT License (MIT)
|
|
|
|
|
|
|
|
|
|
Copyright (C) 2014 Raymond Hill
|
|
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
|
THE SOFTWARE.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DO WHAT YOU WANT TO PUBLIC LICENSE
|
|
|
|
|
Version 2, December 2004
|
|
|
|
|
|
|
|
|
|
Copyright (C) 2015 André Cruz <amdfcruz@gmail.com>
|
|
|
|
|
|
|
|
|
|
Everyone is permitted to copy and distribute verbatim or modified
|
|
|
|
|
copies of this license document, and changing it is allowed as long
|
|
|
|
|
as the name is changed.
|
|
|
|
|
|
|
|
|
|
DO WHAT YOU WANT TO PUBLIC LICENSE
|
|
|
|
|
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
|
|
|
|
|
|
|
|
|
0. You just DO WHAT YOU WANT TO.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
|
|
|
exports.Md5 = void 0;
|
|
|
|
|
;
|
|
|
|
|
var Md5 = /** @class */ (function () {
|
|
|
|
|
function Md5() {
|
|
|
|
|
this._dataLength = 0;
|
|
|
|
|
this._bufferLength = 0;
|
|
|
|
|
this._state = new Int32Array(4);
|
|
|
|
|
this._buffer = new ArrayBuffer(68);
|
|
|
|
|
this._buffer8 = new Uint8Array(this._buffer, 0, 68);
|
|
|
|
|
this._buffer32 = new Uint32Array(this._buffer, 0, 17);
|
|
|
|
|
this.start();
|
|
|
|
|
}
|
|
|
|
|
Md5.hashStr = function (str, raw) {
|
|
|
|
|
if (raw === void 0) { raw = false; }
|
|
|
|
|
return this.onePassHasher
|
|
|
|
|
.start()
|
|
|
|
|
.appendStr(str)
|
|
|
|
|
.end(raw);
|
|
|
|
|
};
|
|
|
|
|
Md5.hashAsciiStr = function (str, raw) {
|
|
|
|
|
if (raw === void 0) { raw = false; }
|
|
|
|
|
return this.onePassHasher
|
|
|
|
|
.start()
|
|
|
|
|
.appendAsciiStr(str)
|
|
|
|
|
.end(raw);
|
|
|
|
|
};
|
|
|
|
|
Md5._hex = function (x) {
|
|
|
|
|
var hc = Md5.hexChars;
|
|
|
|
|
var ho = Md5.hexOut;
|
|
|
|
|
var n;
|
|
|
|
|
var offset;
|
|
|
|
|
var j;
|
|
|
|
|
var i;
|
|
|
|
|
for (i = 0; i < 4; i += 1) {
|
|
|
|
|
offset = i * 8;
|
|
|
|
|
n = x[i];
|
|
|
|
|
for (j = 0; j < 8; j += 2) {
|
|
|
|
|
ho[offset + 1 + j] = hc.charAt(n & 0x0F);
|
|
|
|
|
n >>>= 4;
|
|
|
|
|
ho[offset + 0 + j] = hc.charAt(n & 0x0F);
|
|
|
|
|
n >>>= 4;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return ho.join('');
|
|
|
|
|
};
|
|
|
|
|
Md5._md5cycle = function (x, k) {
|
|
|
|
|
var a = x[0];
|
|
|
|
|
var b = x[1];
|
|
|
|
|
var c = x[2];
|
|
|
|
|
var d = x[3];
|
|
|
|
|
// ff()
|
|
|
|
|
a += (b & c | ~b & d) + k[0] - 680876936 | 0;
|
|
|
|
|
a = (a << 7 | a >>> 25) + b | 0;
|
|
|
|
|
d += (a & b | ~a & c) + k[1] - 389564586 | 0;
|
|
|
|
|
d = (d << 12 | d >>> 20) + a | 0;
|
|
|
|
|
c += (d & a | ~d & b) + k[2] + 606105819 | 0;
|
|
|
|
|
c = (c << 17 | c >>> 15) + d | 0;
|
|
|
|
|
b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
|
|
|
|
|
b = (b << 22 | b >>> 10) + c | 0;
|
|
|
|
|
a += (b & c | ~b & d) + k[4] - 176418897 | 0;
|
|
|
|
|
a = (a << 7 | a >>> 25) + b | 0;
|
|
|
|
|
d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
|
|
|
|
|
d = (d << 12 | d >>> 20) + a | 0;
|
|
|
|
|
c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
|
|
|
|
|
c = (c << 17 | c >>> 15) + d | 0;
|
|
|
|
|
b += (c & d | ~c & a) + k[7] - 45705983 | 0;
|
|
|
|
|
b = (b << 22 | b >>> 10) + c | 0;
|
|
|
|
|
a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
|
|
|
|
|
a = (a << 7 | a >>> 25) + b | 0;
|
|
|
|
|
d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
|
|
|
|
|
d = (d << 12 | d >>> 20) + a | 0;
|
|
|
|
|
c += (d & a | ~d & b) + k[10] - 42063 | 0;
|
|
|
|
|
c = (c << 17 | c >>> 15) + d | 0;
|
|
|
|
|
b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
|
|
|
|
|
b = (b << 22 | b >>> 10) + c | 0;
|
|
|
|
|
a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
|
|
|
|
|
a = (a << 7 | a >>> 25) + b | 0;
|
|
|
|
|
d += (a & b | ~a & c) + k[13] - 40341101 | 0;
|
|
|
|
|
d = (d << 12 | d >>> 20) + a | 0;
|
|
|
|
|
c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
|
|
|
|
|
c = (c << 17 | c >>> 15) + d | 0;
|
|
|
|
|
b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
|
|
|
|
|
b = (b << 22 | b >>> 10) + c | 0;
|
|
|
|
|
// gg()
|
|
|
|
|
a += (b & d | c & ~d) + k[1] - 165796510 | 0;
|
|
|
|
|
a = (a << 5 | a >>> 27) + b | 0;
|
|
|
|
|
d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
|
|
|
|
|
d = (d << 9 | d >>> 23) + a | 0;
|
|
|
|
|
c += (d & b | a & ~b) + k[11] + 643717713 | 0;
|
|
|
|
|
c = (c << 14 | c >>> 18) + d | 0;
|
|
|
|
|
b += (c & a | d & ~a) + k[0] - 373897302 | 0;
|
|
|
|
|
b = (b << 20 | b >>> 12) + c | 0;
|
|
|
|
|
a += (b & d | c & ~d) + k[5] - 701558691 | 0;
|
|
|
|
|
a = (a << 5 | a >>> 27) + b | 0;
|
|
|
|
|
d += (a & c | b & ~c) + k[10] + 38016083 | 0;
|
|
|
|
|
d = (d << 9 | d >>> 23) + a | 0;
|
|
|
|
|
c += (d & b | a & ~b) + k[15] - 660478335 | 0;
|
|
|
|
|
c = (c << 14 | c >>> 18) + d | 0;
|
|
|
|
|
b += (c & a | d & ~a) + k[4] - 405537848 | 0;
|
|
|
|
|
b = (b << 20 | b >>> 12) + c | 0;
|
|
|
|
|
a += (b & d | c & ~d) + k[9] + 568446438 | 0;
|
|
|
|
|
a = (a << 5 | a >>> 27) + b | 0;
|
|
|
|
|
d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
|
|
|
|
|
d = (d << 9 | d >>> 23) + a | 0;
|
|
|
|
|
c += (d & b | a & ~b) + k[3] - 187363961 | 0;
|
|
|
|
|
c = (c << 14 | c >>> 18) + d | 0;
|
|
|
|
|
b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
|
|
|
|
|
b = (b << 20 | b >>> 12) + c | 0;
|
|
|
|
|
a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
|
|
|
|
|
a = (a << 5 | a >>> 27) + b | 0;
|
|
|
|
|
d += (a & c | b & ~c) + k[2] - 51403784 | 0;
|
|
|
|
|
d = (d << 9 | d >>> 23) + a | 0;
|
|
|
|
|
c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
|
|
|
|
|
c = (c << 14 | c >>> 18) + d | 0;
|
|
|
|
|
b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
|
|
|
|
|
b = (b << 20 | b >>> 12) + c | 0;
|
|
|
|
|
// hh()
|
|
|
|
|
a += (b ^ c ^ d) + k[5] - 378558 | 0;
|
|
|
|
|
a = (a << 4 | a >>> 28) + b | 0;
|
|
|
|
|
d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
|
|
|
|
|
d = (d << 11 | d >>> 21) + a | 0;
|
|
|
|
|
c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
|
|
|
|
|
c = (c << 16 | c >>> 16) + d | 0;
|
|
|
|
|
b += (c ^ d ^ a) + k[14] - 35309556 | 0;
|
|
|
|
|
b = (b << 23 | b >>> 9) + c | 0;
|
|
|
|
|
a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
|
|
|
|
|
a = (a << 4 | a >>> 28) + b | 0;
|
|
|
|
|
d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
|
|
|
|
|
d = (d << 11 | d >>> 21) + a | 0;
|
|
|
|
|
c += (d ^ a ^ b) + k[7] - 155497632 | 0;
|
|
|
|
|
c = (c << 16 | c >>> 16) + d | 0;
|
|
|
|
|
b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
|
|
|
|
|
b = (b << 23 | b >>> 9) + c | 0;
|
|
|
|
|
a += (b ^ c ^ d) + k[13] + 681279174 | 0;
|
|
|
|
|
a = (a << 4 | a >>> 28) + b | 0;
|
|
|
|
|
d += (a ^ b ^ c) + k[0] - 358537222 | 0;
|
|
|
|
|
d = (d << 11 | d >>> 21) + a | 0;
|
|
|
|
|
c += (d ^ a ^ b) + k[3] - 722521979 | 0;
|
|
|
|
|
c = (c << 16 | c >>> 16) + d | 0;
|
|
|
|
|
b += (c ^ d ^ a) + k[6] + 76029189 | 0;
|
|
|
|
|
b = (b << 23 | b >>> 9) + c | 0;
|
|
|
|
|
a += (b ^ c ^ d) + k[9] - 640364487 | 0;
|
|
|
|
|
a = (a << 4 | a >>> 28) + b | 0;
|
|
|
|
|
d += (a ^ b ^ c) + k[12] - 421815835 | 0;
|
|
|
|
|
d = (d << 11 | d >>> 21) + a | 0;
|
|
|
|
|
c += (d ^ a ^ b) + k[15] + 530742520 | 0;
|
|
|
|
|
c = (c << 16 | c >>> 16) + d | 0;
|
|
|
|
|
b += (c ^ d ^ a) + k[2] - 995338651 | 0;
|
|
|
|
|
b = (b << 23 | b >>> 9) + c | 0;
|
|
|
|
|
// ii()
|
|
|
|
|
a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
|
|
|
|
|
a = (a << 6 | a >>> 26) + b | 0;
|
|
|
|
|
d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
|
|
|
|
|
d = (d << 10 | d >>> 22) + a | 0;
|
|
|
|
|
c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
|
|
|
|
|
c = (c << 15 | c >>> 17) + d | 0;
|
|
|
|
|
b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
|
|
|
|
|
b = (b << 21 | b >>> 11) + c | 0;
|
|
|
|
|
a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
|
|
|
|
|
a = (a << 6 | a >>> 26) + b | 0;
|
|
|
|
|
d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
|
|
|
|
|
d = (d << 10 | d >>> 22) + a | 0;
|
|
|
|
|
c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
|
|
|
|
|
c = (c << 15 | c >>> 17) + d | 0;
|
|
|
|
|
b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
|
|
|
|
|
b = (b << 21 | b >>> 11) + c | 0;
|
|
|
|
|
a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
|
|
|
|
|
a = (a << 6 | a >>> 26) + b | 0;
|
|
|
|
|
d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
|
|
|
|
|
d = (d << 10 | d >>> 22) + a | 0;
|
|
|
|
|
c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
|
|
|
|
|
c = (c << 15 | c >>> 17) + d | 0;
|
|
|
|
|
b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
|
|
|
|
|
b = (b << 21 | b >>> 11) + c | 0;
|
|
|
|
|
a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
|
|
|
|
|
a = (a << 6 | a >>> 26) + b | 0;
|
|
|
|
|
d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
|
|
|
|
|
d = (d << 10 | d >>> 22) + a | 0;
|
|
|
|
|
c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
|
|
|
|
|
c = (c << 15 | c >>> 17) + d | 0;
|
|
|
|
|
b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
|
|
|
|
|
b = (b << 21 | b >>> 11) + c | 0;
|
|
|
|
|
x[0] = a + x[0] | 0;
|
|
|
|
|
x[1] = b + x[1] | 0;
|
|
|
|
|
x[2] = c + x[2] | 0;
|
|
|
|
|
x[3] = d + x[3] | 0;
|
|
|
|
|
};
|
|
|
|
|
/**
|
|
|
|
|
* Initialise buffer to be hashed
|
|
|
|
|
*/
|
|
|
|
|
Md5.prototype.start = function () {
|
|
|
|
|
this._dataLength = 0;
|
|
|
|
|
this._bufferLength = 0;
|
|
|
|
|
this._state.set(Md5.stateIdentity);
|
|
|
|
|
return this;
|
|
|
|
|
};
|
|
|
|
|
// Char to code point to to array conversion:
|
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt
|
|
|
|
|
// #Example.3A_Fixing_charCodeAt_to_handle_non-Basic-Multilingual-Plane_characters_if_their_presence_earlier_in_the_string_is_unknown
|
|
|
|
|
/**
|
|
|
|
|
* Append a UTF-8 string to the hash buffer
|
|
|
|
|
* @param str String to append
|
|
|
|
|
*/
|
|
|
|
|
Md5.prototype.appendStr = function (str) {
|
|
|
|
|
var buf8 = this._buffer8;
|
|
|
|
|
var buf32 = this._buffer32;
|
|
|
|
|
var bufLen = this._bufferLength;
|
|
|
|
|
var code;
|
|
|
|
|
var i;
|
|
|
|
|
for (i = 0; i < str.length; i += 1) {
|
|
|
|
|
code = str.charCodeAt(i);
|
|
|
|
|
if (code < 128) {
|
|
|
|
|
buf8[bufLen++] = code;
|
|
|
|
|
}
|
|
|
|
|
else if (code < 0x800) {
|
|
|
|
|
buf8[bufLen++] = (code >>> 6) + 0xC0;
|
|
|
|
|
buf8[bufLen++] = code & 0x3F | 0x80;
|
|
|
|
|
}
|
|
|
|
|
else if (code < 0xD800 || code > 0xDBFF) {
|
|
|
|
|
buf8[bufLen++] = (code >>> 12) + 0xE0;
|
|
|
|
|
buf8[bufLen++] = (code >>> 6 & 0x3F) | 0x80;
|
|
|
|
|
buf8[bufLen++] = (code & 0x3F) | 0x80;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
code = ((code - 0xD800) * 0x400) + (str.charCodeAt(++i) - 0xDC00) + 0x10000;
|
|
|
|
|
if (code > 0x10FFFF) {
|
|
|
|
|
throw new Error('Unicode standard supports code points up to U+10FFFF');
|
|
|
|
|
}
|
|
|
|
|
buf8[bufLen++] = (code >>> 18) + 0xF0;
|
|
|
|
|
buf8[bufLen++] = (code >>> 12 & 0x3F) | 0x80;
|
|
|
|
|
buf8[bufLen++] = (code >>> 6 & 0x3F) | 0x80;
|
|
|
|
|
buf8[bufLen++] = (code & 0x3F) | 0x80;
|
|
|
|
|
}
|
|
|
|
|
if (bufLen >= 64) {
|
|
|
|
|
this._dataLength += 64;
|
|
|
|
|
Md5._md5cycle(this._state, buf32);
|
|
|
|
|
bufLen -= 64;
|
|
|
|
|
buf32[0] = buf32[16];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
this._bufferLength = bufLen;
|
|
|
|
|
return this;
|
|
|
|
|
};
|
|
|
|
|
/**
|
|
|
|
|
* Append an ASCII string to the hash buffer
|
|
|
|
|
* @param str String to append
|
|
|
|
|
*/
|
|
|
|
|
Md5.prototype.appendAsciiStr = function (str) {
|
|
|
|
|
var buf8 = this._buffer8;
|
|
|
|
|
var buf32 = this._buffer32;
|
|
|
|
|
var bufLen = this._bufferLength;
|
|
|
|
|
var i;
|
|
|
|
|
var j = 0;
|
|
|
|
|
for (;;) {
|
|
|
|
|
i = Math.min(str.length - j, 64 - bufLen);
|
|
|
|
|
while (i--) {
|
|
|
|
|
buf8[bufLen++] = str.charCodeAt(j++);
|
|
|
|
|
}
|
|
|
|
|
if (bufLen < 64) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
this._dataLength += 64;
|
|
|
|
|
Md5._md5cycle(this._state, buf32);
|
|
|
|
|
bufLen = 0;
|
|
|
|
|
}
|
|
|
|
|
this._bufferLength = bufLen;
|
|
|
|
|
return this;
|
|
|
|
|
};
|
|
|
|
|
/**
|
|
|
|
|
* Append a byte array to the hash buffer
|
|
|
|
|
* @param input array to append
|
|
|
|
|
*/
|
|
|
|
|
Md5.prototype.appendByteArray = function (input) {
|
|
|
|
|
var buf8 = this._buffer8;
|
|
|
|
|
var buf32 = this._buffer32;
|
|
|
|
|
var bufLen = this._bufferLength;
|
|
|
|
|
var i;
|
|
|
|
|
var j = 0;
|
|
|
|
|
for (;;) {
|
|
|
|
|
i = Math.min(input.length - j, 64 - bufLen);
|
|
|
|
|
while (i--) {
|
|
|
|
|
buf8[bufLen++] = input[j++];
|
|
|
|
|
}
|
|
|
|
|
if (bufLen < 64) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
this._dataLength += 64;
|
|
|
|
|
Md5._md5cycle(this._state, buf32);
|
|
|
|
|
bufLen = 0;
|
|
|
|
|
}
|
|
|
|
|
this._bufferLength = bufLen;
|
|
|
|
|
return this;
|
|
|
|
|
};
|
|
|
|
|
/**
|
|
|
|
|
* Get the state of the hash buffer
|
|
|
|
|
*/
|
|
|
|
|
Md5.prototype.getState = function () {
|
|
|
|
|
var s = this._state;
|
|
|
|
|
return {
|
|
|
|
|
buffer: String.fromCharCode.apply(null, Array.from(this._buffer8)),
|
|
|
|
|
buflen: this._bufferLength,
|
|
|
|
|
length: this._dataLength,
|
|
|
|
|
state: [s[0], s[1], s[2], s[3]]
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
/**
|
|
|
|
|
* Override the current state of the hash buffer
|
|
|
|
|
* @param state New hash buffer state
|
|
|
|
|
*/
|
|
|
|
|
Md5.prototype.setState = function (state) {
|
|
|
|
|
var buf = state.buffer;
|
|
|
|
|
var x = state.state;
|
|
|
|
|
var s = this._state;
|
|
|
|
|
var i;
|
|
|
|
|
this._dataLength = state.length;
|
|
|
|
|
this._bufferLength = state.buflen;
|
|
|
|
|
s[0] = x[0];
|
|
|
|
|
s[1] = x[1];
|
|
|
|
|
s[2] = x[2];
|
|
|
|
|
s[3] = x[3];
|
|
|
|
|
for (i = 0; i < buf.length; i += 1) {
|
|
|
|
|
this._buffer8[i] = buf.charCodeAt(i);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
/**
|
|
|
|
|
* Hash the current state of the hash buffer and return the result
|
|
|
|
|
* @param raw Whether to return the value as an `Int32Array`
|
|
|
|
|
*/
|
|
|
|
|
Md5.prototype.end = function (raw) {
|
|
|
|
|
if (raw === void 0) { raw = false; }
|
|
|
|
|
var bufLen = this._bufferLength;
|
|
|
|
|
var buf8 = this._buffer8;
|
|
|
|
|
var buf32 = this._buffer32;
|
|
|
|
|
var i = (bufLen >> 2) + 1;
|
|
|
|
|
this._dataLength += bufLen;
|
|
|
|
|
var dataBitsLen = this._dataLength * 8;
|
|
|
|
|
buf8[bufLen] = 0x80;
|
|
|
|
|
buf8[bufLen + 1] = buf8[bufLen + 2] = buf8[bufLen + 3] = 0;
|
|
|
|
|
buf32.set(Md5.buffer32Identity.subarray(i), i);
|
|
|
|
|
if (bufLen > 55) {
|
|
|
|
|
Md5._md5cycle(this._state, buf32);
|
|
|
|
|
buf32.set(Md5.buffer32Identity);
|
|
|
|
|
}
|
|
|
|
|
// Do the final computation based on the tail and length
|
|
|
|
|
// Beware that the final length may not fit in 32 bits so we take care of that
|
|
|
|
|
if (dataBitsLen <= 0xFFFFFFFF) {
|
|
|
|
|
buf32[14] = dataBitsLen;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
var matches = dataBitsLen.toString(16).match(/(.*?)(.{0,8})$/);
|
|
|
|
|
if (matches === null) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
var lo = parseInt(matches[2], 16);
|
|
|
|
|
var hi = parseInt(matches[1], 16) || 0;
|
|
|
|
|
buf32[14] = lo;
|
|
|
|
|
buf32[15] = hi;
|
|
|
|
|
}
|
|
|
|
|
Md5._md5cycle(this._state, buf32);
|
|
|
|
|
return raw ? this._state : Md5._hex(this._state);
|
|
|
|
|
};
|
|
|
|
|
// Private Static Variables
|
|
|
|
|
Md5.stateIdentity = new Int32Array([1732584193, -271733879, -1732584194, 271733878]);
|
|
|
|
|
Md5.buffer32Identity = new Int32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
|
|
|
|
Md5.hexChars = '0123456789abcdef';
|
|
|
|
|
Md5.hexOut = [];
|
|
|
|
|
// Permanent instance is to use for one-call hashing
|
|
|
|
|
Md5.onePassHasher = new Md5();
|
|
|
|
|
return Md5;
|
|
|
|
|
}());
|
|
|
|
|
exports.Md5 = Md5;
|
|
|
|
|
if (Md5.hashStr('hello') !== '5d41402abc4b2a76b9719d911017c592') {
|
|
|
|
|
throw new Error('Md5 self test failed.');
|
|
|
|
|
}
|
|
|
|
|
//# sourceMappingURL=md5.js.map
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 70269:
|
|
|
|
|
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
|
|
|
|
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
|
|
|
exports.Md5FileHasher = void 0;
|
|
|
|
|
var md5_1 = __nccwpck_require__(33033);
|
|
|
|
|
// Hashes any blob
|
|
|
|
|
var Md5FileHasher = /** @class */ (function () {
|
|
|
|
|
function Md5FileHasher(_callback, // Callback to return the result
|
|
|
|
|
_async, // Async version is not always available in a web worker
|
|
|
|
|
_partSize) {
|
|
|
|
|
if (_async === void 0) { _async = true; }
|
|
|
|
|
if (_partSize === void 0) { _partSize = 1048576; }
|
|
|
|
|
this._callback = _callback;
|
|
|
|
|
this._async = _async;
|
|
|
|
|
this._partSize = _partSize;
|
|
|
|
|
this._configureReader();
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Hash a blob of data in the worker
|
|
|
|
|
* @param blob Data to hash
|
|
|
|
|
*/
|
|
|
|
|
Md5FileHasher.prototype.hash = function (blob) {
|
|
|
|
|
var self = this;
|
|
|
|
|
self._blob = blob;
|
|
|
|
|
// self._length = Math.ceil(blob.size / self._partSize);
|
|
|
|
|
self._part = 0;
|
|
|
|
|
self._md5 = new md5_1.Md5();
|
|
|
|
|
self._processPart();
|
|
|
|
|
};
|
|
|
|
|
Md5FileHasher.prototype._fail = function () {
|
|
|
|
|
this._callback({
|
|
|
|
|
success: false,
|
|
|
|
|
result: 'data read failed'
|
|
|
|
|
});
|
|
|
|
|
};
|
|
|
|
|
Md5FileHasher.prototype._hashData = function (e) {
|
|
|
|
|
var self = this;
|
|
|
|
|
self._md5.appendByteArray(new Uint8Array(e.target.result));
|
|
|
|
|
if (self._part * self._partSize >= self._blob.size) {
|
|
|
|
|
self._callback({
|
|
|
|
|
success: true,
|
|
|
|
|
result: self._md5.end()
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
self._processPart();
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
Md5FileHasher.prototype._processPart = function () {
|
|
|
|
|
var self = this;
|
|
|
|
|
var endbyte = 0;
|
|
|
|
|
var current_part;
|
|
|
|
|
self._part += 1;
|
|
|
|
|
if (self._blob.size > self._partSize) { // If blob bigger then part_size we will slice it up
|
|
|
|
|
endbyte = self._part * self._partSize;
|
|
|
|
|
if (endbyte > self._blob.size) {
|
|
|
|
|
endbyte = self._blob.size;
|
|
|
|
|
}
|
|
|
|
|
current_part = self._blob.slice((self._part - 1) * self._partSize, endbyte);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
current_part = self._blob;
|
|
|
|
|
}
|
|
|
|
|
if (self._async) {
|
|
|
|
|
self._reader.readAsArrayBuffer(current_part);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
setTimeout(function () {
|
|
|
|
|
try {
|
|
|
|
|
self._hashData({
|
|
|
|
|
target: {
|
|
|
|
|
result: self._reader.readAsArrayBuffer(current_part)
|
|
|
|
|
},
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
catch (e) {
|
|
|
|
|
self._fail();
|
|
|
|
|
}
|
|
|
|
|
}, 0);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
Md5FileHasher.prototype._configureReader = function () {
|
|
|
|
|
var self = this;
|
|
|
|
|
if (self._async) {
|
|
|
|
|
self._reader = new FileReader();
|
|
|
|
|
self._reader.onload = self._hashData.bind(self);
|
|
|
|
|
self._reader.onerror = self._fail.bind(self);
|
|
|
|
|
self._reader.onabort = self._fail.bind(self);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
self._reader = new FileReaderSync();
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
return Md5FileHasher;
|
|
|
|
|
}());
|
|
|
|
|
exports.Md5FileHasher = Md5FileHasher;
|
|
|
|
|
//# sourceMappingURL=md5_file_hasher.js.map
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 23395:
|
|
|
|
|
/***/ ((__unused_webpack_module, exports) => {
|
|
|
|
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", ({ value: true }));
|
|
|
|
|
exports.ParallelHasher = void 0;
|
|
|
|
|
;
|
|
|
|
|
var ParallelHasher = /** @class */ (function () {
|
|
|
|
|
function ParallelHasher(workerUri, workerOptions) {
|
|
|
|
|
this._queue = [];
|
|
|
|
|
this._ready = true;
|
|
|
|
|
var self = this;
|
|
|
|
|
if (Worker) {
|
|
|
|
|
self._hashWorker = new Worker(workerUri, workerOptions);
|
|
|
|
|
self._hashWorker.onmessage = self._recievedMessage.bind(self);
|
|
|
|
|
self._hashWorker.onerror = function (err) {
|
|
|
|
|
self._ready = false;
|
|
|
|
|
console.error('Hash worker failure', err);
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
self._ready = false;
|
|
|
|
|
console.error('Web Workers are not supported in this browser');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/**
|
|
|
|
|
* Hash a blob of data in the worker
|
|
|
|
|
* @param blob Data to hash
|
|
|
|
|
* @returns Promise of the Hashed result
|
|
|
|
|
*/
|
|
|
|
|
ParallelHasher.prototype.hash = function (blob) {
|
|
|
|
|
var self = this;
|
|
|
|
|
var promise;
|
|
|
|
|
promise = new Promise(function (resolve, reject) {
|
|
|
|
|
self._queue.push({
|
|
|
|
|
blob: blob,
|
|
|
|
|
resolve: resolve,
|
|
|
|
|
reject: reject,
|
|
|
|
|
});
|
|
|
|
|
self._processNext();
|
|
|
|
|
});
|
|
|
|
|
return promise;
|
|
|
|
|
};
|
|
|
|
|
/** Terminate any existing hash requests */
|
|
|
|
|
ParallelHasher.prototype.terminate = function () {
|
|
|
|
|
this._ready = false;
|
|
|
|
|
this._hashWorker.terminate();
|
|
|
|
|
};
|
|
|
|
|
// Processes the next item in the queue
|
|
|
|
|
ParallelHasher.prototype._processNext = function () {
|
|
|
|
|
if (this._ready && !this._processing && this._queue.length > 0) {
|
|
|
|
|
this._processing = this._queue.pop();
|
|
|
|
|
this._hashWorker.postMessage(this._processing.blob);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
// Hash result is returned from the worker
|
|
|
|
|
ParallelHasher.prototype._recievedMessage = function (evt) {
|
|
|
|
|
var _a, _b;
|
|
|
|
|
var data = evt.data;
|
|
|
|
|
if (data.success) {
|
|
|
|
|
(_a = this._processing) === null || _a === void 0 ? void 0 : _a.resolve(data.result);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
(_b = this._processing) === null || _b === void 0 ? void 0 : _b.reject(data.result);
|
|
|
|
|
}
|
|
|
|
|
this._processing = undefined;
|
|
|
|
|
this._processNext();
|
|
|
|
|
};
|
|
|
|
|
return ParallelHasher;
|
|
|
|
|
}());
|
|
|
|
|
exports.ParallelHasher = ParallelHasher;
|
|
|
|
|
//# sourceMappingURL=parallel_hasher.js.map
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
|
|
|
|
/***/ 4351:
|
|
|
|
|
|
Frostebite