Current File : //usr/lib/node_modules/pm2/node_modules/git-sha1/git-sha1.js
"use strict";
var isNode = typeof process === 'object' &&
typeof process.versions === 'object' &&
process.versions.node &&
process.__atom_type !== "renderer";
var shared, create, crypto;
if (isNode) {
var nodeRequire = require; // Prevent mine.js from seeing this require
crypto = nodeRequire('crypto');
create = createNode;
}
else {
shared = new Uint32Array(80);
create = createJs;
}
// Input chunks must be either arrays of bytes or "raw" encoded strings
module.exports = function sha1(buffer) {
if (buffer === undefined) return create(false);
var shasum = create(true);
shasum.update(buffer);
return shasum.digest();
};
// Use node's openssl bindings when available
function createNode() {
var shasum = crypto.createHash('sha1');
return {
update: function (buffer) {
return shasum.update(buffer);
},
digest: function () {
return shasum.digest('hex');
}
};
}
// A pure JS implementation of sha1 for non-node environments.
function createJs(sync) {
var h0 = 0x67452301;
var h1 = 0xEFCDAB89;
var h2 = 0x98BADCFE;
var h3 = 0x10325476;
var h4 = 0xC3D2E1F0;
// The first 64 bytes (16 words) is the data chunk
var block, offset = 0, shift = 24;
var totalLength = 0;
if (sync) block = shared;
else block = new Uint32Array(80);
return { update: update, digest: digest };
// The user gave us more data. Store it!
function update(chunk) {
if (typeof chunk === "string") return updateString(chunk);
var length = chunk.length;
totalLength += length * 8;
for (var i = 0; i < length; i++) {
write(chunk[i]);
}
}
function updateString(string) {
var length = string.length;
totalLength += length * 8;
for (var i = 0; i < length; i++) {
write(string.charCodeAt(i));
}
}
function write(byte) {
block[offset] |= (byte & 0xff) << shift;
if (shift) {
shift -= 8;
}
else {
offset++;
shift = 24;
}
if (offset === 16) processBlock();
}
// No more data will come, pad the block, process and return the result.
function digest() {
// Pad
write(0x80);
if (offset > 14 || (offset === 14 && shift < 24)) {
processBlock();
}
offset = 14;
shift = 24;
// 64-bit length big-endian
write(0x00); // numbers this big aren't accurate in javascript anyway
write(0x00); // ..So just hard-code to zero.
write(totalLength > 0xffffffffff ? totalLength / 0x10000000000 : 0x00);
write(totalLength > 0xffffffff ? totalLength / 0x100000000 : 0x00);
for (var s = 24; s >= 0; s -= 8) {
write(totalLength >> s);
}
// At this point one last processBlock() should trigger and we can pull out the result.
return toHex(h0) +
toHex(h1) +
toHex(h2) +
toHex(h3) +
toHex(h4);
}
// We have a full block to process. Let's do it!
function processBlock() {
// Extend the sixteen 32-bit words into eighty 32-bit words:
for (var i = 16; i < 80; i++) {
var w = block[i - 3] ^ block[i - 8] ^ block[i - 14] ^ block[i - 16];
block[i] = (w << 1) | (w >>> 31);
}
// log(block);
// Initialize hash value for this chunk:
var a = h0;
var b = h1;
var c = h2;
var d = h3;
var e = h4;
var f, k;
// Main loop:
for (i = 0; i < 80; i++) {
if (i < 20) {
f = d ^ (b & (c ^ d));
k = 0x5A827999;
}
else if (i < 40) {
f = b ^ c ^ d;
k = 0x6ED9EBA1;
}
else if (i < 60) {
f = (b & c) | (d & (b | c));
k = 0x8F1BBCDC;
}
else {
f = b ^ c ^ d;
k = 0xCA62C1D6;
}
var temp = (a << 5 | a >>> 27) + f + e + k + (block[i]|0);
e = d;
d = c;
c = (b << 30 | b >>> 2);
b = a;
a = temp;
}
// Add this chunk's hash to result so far:
h0 = (h0 + a) | 0;
h1 = (h1 + b) | 0;
h2 = (h2 + c) | 0;
h3 = (h3 + d) | 0;
h4 = (h4 + e) | 0;
// The block is now reusable.
offset = 0;
for (i = 0; i < 16; i++) {
block[i] = 0;
}
}
function toHex(word) {
var hex = "";
for (var i = 28; i >= 0; i -= 4) {
hex += ((word >> i) & 0xf).toString(16);
}
return hex;
}
}
Mini Shell