@helloao/cli 0.0.1

package/node_modules/@zip.js/zip.js/lib/core/streams/codecs/sjcl.js

@@ -0,0 +1,827 @@
+// Derived from https://github.com/xqdoo00o/jszip/blob/master/lib/sjcl.js and https://github.com/bitwiseshiftleft/sjcl
+
+// deno-lint-ignore-file no-this-alias
+
+/*
+ * SJCL is open. You can use, modify and redistribute it under a BSD
+ * license or under the GNU GPL, version 2.0.
+ */
+
+/** @fileOverview Javascript cryptography implementation.
+ *
+ * Crush to remove comments, shorten variable names and
+ * generally reduce transmission size.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/*jslint indent: 2, bitwise: false, nomen: false, plusplus: false, white: false, regexp: false */
+
+/** @fileOverview Arrays of bits, encoded as arrays of Numbers.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * Arrays of bits, encoded as arrays of Numbers.
+ * @namespace
+ * @description
+ * <p>
+ * These objects are the currency accepted by SJCL's crypto functions.
+ * </p>
+ *
+ * <p>
+ * Most of our crypto primitives operate on arrays of 4-byte words internally,
+ * but many of them can take arguments that are not a multiple of 4 bytes.
+ * This library encodes arrays of bits (whose size need not be a multiple of 8
+ * bits) as arrays of 32-bit words.  The bits are packed, big-endian, into an
+ * array of words, 32 bits at a time.  Since the words are double-precision
+ * floating point numbers, they fit some extra data.  We use this (in a private,
+ * possibly-changing manner) to encode the number of bits actually  present
+ * in the last word of the array.
+ * </p>
+ *
+ * <p>
+ * Because bitwise ops clear this out-of-band data, these arrays can be passed
+ * to ciphers like AES which want arrays of words.
+ * </p>
+ */
+const bitArray = {
+	/**
+	 * Concatenate two bit arrays.
+	 * @param {bitArray} a1 The first array.
+	 * @param {bitArray} a2 The second array.
+	 * @return {bitArray} The concatenation of a1 and a2.
+	 */
+	concat(a1, a2) {
+		if (a1.length === 0 || a2.length === 0) {
+			return a1.concat(a2);
+		}
+
+		const last = a1[a1.length - 1], shift = bitArray.getPartial(last);
+		if (shift === 32) {
+			return a1.concat(a2);
+		} else {
+			return bitArray._shiftRight(a2, shift, last | 0, a1.slice(0, a1.length - 1));
+		}
+	},
+
+	/**
+	 * Find the length of an array of bits.
+	 * @param {bitArray} a The array.
+	 * @return {Number} The length of a, in bits.
+	 */
+	bitLength(a) {
+		const l = a.length;
+		if (l === 0) {
+			return 0;
+		}
+		const x = a[l - 1];
+		return (l - 1) * 32 + bitArray.getPartial(x);
+	},
+
+	/**
+	 * Truncate an array.
+	 * @param {bitArray} a The array.
+	 * @param {Number} len The length to truncate to, in bits.
+	 * @return {bitArray} A new array, truncated to len bits.
+	 */
+	clamp(a, len) {
+		if (a.length * 32 < len) {
+			return a;
+		}
+		a = a.slice(0, Math.ceil(len / 32));
+		const l = a.length;
+		len = len & 31;
+		if (l > 0 && len) {
+			a[l - 1] = bitArray.partial(len, a[l - 1] & 0x80000000 >> (len - 1), 1);
+		}
+		return a;
+	},
+
+	/**
+	 * Make a partial word for a bit array.
+	 * @param {Number} len The number of bits in the word.
+	 * @param {Number} x The bits.
+	 * @param {Number} [_end=0] Pass 1 if x has already been shifted to the high side.
+	 * @return {Number} The partial word.
+	 */
+	partial(len, x, _end) {
+		if (len === 32) {
+			return x;
+		}
+		return (_end ? x | 0 : x << (32 - len)) + len * 0x10000000000;
+	},
+
+	/**
+	 * Get the number of bits used by a partial word.
+	 * @param {Number} x The partial word.
+	 * @return {Number} The number of bits used by the partial word.
+	 */
+	getPartial(x) {
+		return Math.round(x / 0x10000000000) || 32;
+	},
+
+	/** Shift an array right.
+	 * @param {bitArray} a The array to shift.
+	 * @param {Number} shift The number of bits to shift.
+	 * @param {Number} [carry=0] A byte to carry in
+	 * @param {bitArray} [out=[]] An array to prepend to the output.
+	 * @private
+	 */
+	_shiftRight(a, shift, carry, out) {
+		if (out === undefined) {
+			out = [];
+		}
+
+		for (; shift >= 32; shift -= 32) {
+			out.push(carry);
+			carry = 0;
+		}
+		if (shift === 0) {
+			return out.concat(a);
+		}
+
+		for (let i = 0; i < a.length; i++) {
+			out.push(carry | a[i] >>> shift);
+			carry = a[i] << (32 - shift);
+		}
+		const last2 = a.length ? a[a.length - 1] : 0;
+		const shift2 = bitArray.getPartial(last2);
+		out.push(bitArray.partial(shift + shift2 & 31, (shift + shift2 > 32) ? carry : out.pop(), 1));
+		return out;
+	}
+};
+
+/** @fileOverview Bit array codec implementations.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/**
+ * Arrays of bytes
+ * @namespace
+ */
+const codec = {
+	bytes: {
+		/** Convert from a bitArray to an array of bytes. */
+		fromBits(arr) {
+			const bl = bitArray.bitLength(arr);
+			const byteLength = bl / 8;
+			const out = new Uint8Array(byteLength);
+			let tmp;
+			for (let i = 0; i < byteLength; i++) {
+				if ((i & 3) === 0) {
+					tmp = arr[i / 4];
+				}
+				out[i] = tmp >>> 24;
+				tmp <<= 8;
+			}
+			return out;
+		},
+		/** Convert from an array of bytes to a bitArray. */
+		toBits(bytes) {
+			const out = [];
+			let i;
+			let tmp = 0;
+			for (i = 0; i < bytes.length; i++) {
+				tmp = tmp << 8 | bytes[i];
+				if ((i & 3) === 3) {
+					out.push(tmp);
+					tmp = 0;
+				}
+			}
+			if (i & 3) {
+				out.push(bitArray.partial(8 * (i & 3), tmp));
+			}
+			return out;
+		}
+	}
+};
+
+const hash = {};
+
+/**
+ * Context for a SHA-1 operation in progress.
+ * @constructor
+ */
+hash.sha1 = class {
+	constructor(hash) {
+		const sha1 = this;
+		/**
+		 * The hash's block size, in bits.
+		 * @constant
+		 */
+		sha1.blockSize = 512;
+		/**
+		 * The SHA-1 initialization vector.
+		 * @private
+		 */
+		sha1._init = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];
+		/**
+		 * The SHA-1 hash key.
+		 * @private
+		 */
+		sha1._key = [0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6];
+		if (hash) {
+			sha1._h = hash._h.slice(0);
+			sha1._buffer = hash._buffer.slice(0);
+			sha1._length = hash._length;
+		} else {
+			sha1.reset();
+		}
+	}
+
+	/**
+	 * Reset the hash state.
+	 * @return this
+	 */
+	reset() {
+		const sha1 = this;
+		sha1._h = sha1._init.slice(0);
+		sha1._buffer = [];
+		sha1._length = 0;
+		return sha1;
+	}
+
+	/**
+	 * Input several words to the hash.
+	 * @param {bitArray|String} data the data to hash.
+	 * @return this
+	 */
+	update(data) {
+		const sha1 = this;
+		if (typeof data === "string") {
+			data = codec.utf8String.toBits(data);
+		}
+		const b = sha1._buffer = bitArray.concat(sha1._buffer, data);
+		const ol = sha1._length;
+		const nl = sha1._length = ol + bitArray.bitLength(data);
+		if (nl > 9007199254740991) {
+			throw new Error("Cannot hash more than 2^53 - 1 bits");
+		}
+		const c = new Uint32Array(b);
+		let j = 0;
+		for (let i = sha1.blockSize + ol - ((sha1.blockSize + ol) & (sha1.blockSize - 1)); i <= nl;
+			i += sha1.blockSize) {
+			sha1._block(c.subarray(16 * j, 16 * (j + 1)));
+			j += 1;
+		}
+		b.splice(0, 16 * j);
+		return sha1;
+	}
+
+	/**
+	 * Complete hashing and output the hash value.
+	 * @return {bitArray} The hash value, an array of 5 big-endian words. TODO
+	 */
+	finalize() {
+		const sha1 = this;
+		let b = sha1._buffer;
+		const h = sha1._h;
+
+		// Round out and push the buffer
+		b = bitArray.concat(b, [bitArray.partial(1, 1)]);
+		// Round out the buffer to a multiple of 16 words, less the 2 length words.
+		for (let i = b.length + 2; i & 15; i++) {
+			b.push(0);
+		}
+
+		// append the length
+		b.push(Math.floor(sha1._length / 0x100000000));
+		b.push(sha1._length | 0);
+
+		while (b.length) {
+			sha1._block(b.splice(0, 16));
+		}
+
+		sha1.reset();
+		return h;
+	}
+
+	/**
+	 * The SHA-1 logical functions f(0), f(1), ..., f(79).
+	 * @private
+	 */
+	_f(t, b, c, d) {
+		if (t <= 19) {
+			return (b & c) | (~b & d);
+		} else if (t <= 39) {
+			return b ^ c ^ d;
+		} else if (t <= 59) {
+			return (b & c) | (b & d) | (c & d);
+		} else if (t <= 79) {
+			return b ^ c ^ d;
+		}
+	}
+
+	/**
+	 * Circular left-shift operator.
+	 * @private
+	 */
+	_S(n, x) {
+		return (x << n) | (x >>> 32 - n);
+	}
+
+	/**
+	 * Perform one cycle of SHA-1.
+	 * @param {Uint32Array|bitArray} words one block of words.
+	 * @private
+	 */
+	_block(words) {
+		const sha1 = this;
+		const h = sha1._h;
+		// When words is passed to _block, it has 16 elements. SHA1 _block
+		// function extends words with new elements (at the end there are 80 elements). 
+		// The problem is that if we use Uint32Array instead of Array, 
+		// the length of Uint32Array cannot be changed. Thus, we replace words with a 
+		// normal Array here.
+		const w = Array(80); // do not use Uint32Array here as the instantiation is slower
+		for (let j = 0; j < 16; j++) {
+			w[j] = words[j];
+		}
+
+		let a = h[0];
+		let b = h[1];
+		let c = h[2];
+		let d = h[3];
+		let e = h[4];
+
+		for (let t = 0; t <= 79; t++) {
+			if (t >= 16) {
+				w[t] = sha1._S(1, w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]);
+			}
+			const tmp = (sha1._S(5, a) + sha1._f(t, b, c, d) + e + w[t] +
+				sha1._key[Math.floor(t / 20)]) | 0;
+			e = d;
+			d = c;
+			c = sha1._S(30, b);
+			b = a;
+			a = tmp;
+		}
+
+		h[0] = (h[0] + a) | 0;
+		h[1] = (h[1] + b) | 0;
+		h[2] = (h[2] + c) | 0;
+		h[3] = (h[3] + d) | 0;
+		h[4] = (h[4] + e) | 0;
+	}
+};
+
+/** @fileOverview Low-level AES implementation.
+ *
+ * This file contains a low-level implementation of AES, optimized for
+ * size and for efficiency on several browsers.  It is based on
+ * OpenSSL's aes_core.c, a public-domain implementation by Vincent
+ * Rijmen, Antoon Bosselaers and Paulo Barreto.
+ *
+ * An older version of this implementation is available in the public
+ * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,
+ * Stanford University 2008-2010 and BSD-licensed for liability
+ * reasons.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+const cipher = {};
+
+/**
+ * Schedule out an AES key for both encryption and decryption.  This
+ * is a low-level class.  Use a cipher mode to do bulk encryption.
+ *
+ * @constructor
+ * @param {Array} key The key as an array of 4, 6 or 8 words.
+ */
+cipher.aes = class {
+	constructor(key) {
+		/**
+		 * The expanded S-box and inverse S-box tables.  These will be computed
+		 * on the client so that we don't have to send them down the wire.
+		 *
+		 * There are two tables, _tables[0] is for encryption and
+		 * _tables[1] is for decryption.
+		 *
+		 * The first 4 sub-tables are the expanded S-box with MixColumns.  The
+		 * last (_tables[01][4]) is the S-box itself.
+		 *
+		 * @private
+		 */
+		const aes = this;
+		aes._tables = [[[], [], [], [], []], [[], [], [], [], []]];
+
+		if (!aes._tables[0][0][0]) {
+			aes._precompute();
+		}
+
+		const sbox = aes._tables[0][4];
+		const decTable = aes._tables[1];
+		const keyLen = key.length;
+
+		let i, encKey, decKey, rcon = 1;
+
+		if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
+			throw new Error("invalid aes key size");
+		}
+
+		aes._key = [encKey = key.slice(0), decKey = []];
+
+		// schedule encryption keys
+		for (i = keyLen; i < 4 * keyLen + 28; i++) {
+			let tmp = encKey[i - 1];
+
+			// apply sbox
+			if (i % keyLen === 0 || (keyLen === 8 && i % keyLen === 4)) {
+				tmp = sbox[tmp >>> 24] << 24 ^ sbox[tmp >> 16 & 255] << 16 ^ sbox[tmp >> 8 & 255] << 8 ^ sbox[tmp & 255];
+
+				// shift rows and add rcon
+				if (i % keyLen === 0) {
+					tmp = tmp << 8 ^ tmp >>> 24 ^ rcon << 24;
+					rcon = rcon << 1 ^ (rcon >> 7) * 283;
+				}
+			}
+
+			encKey[i] = encKey[i - keyLen] ^ tmp;
+		}
+
+		// schedule decryption keys
+		for (let j = 0; i; j++, i--) {
+			const tmp = encKey[j & 3 ? i : i - 4];
+			if (i <= 4 || j < 4) {
+				decKey[j] = tmp;
+			} else {
+				decKey[j] = decTable[0][sbox[tmp >>> 24]] ^
+					decTable[1][sbox[tmp >> 16 & 255]] ^
+					decTable[2][sbox[tmp >> 8 & 255]] ^
+					decTable[3][sbox[tmp & 255]];
+			}
+		}
+	}
+	// public
+	/* Something like this might appear here eventually
+	name: "AES",
+	blockSize: 4,
+	keySizes: [4,6,8],
+	*/
+
+	/**
+	 * Encrypt an array of 4 big-endian words.
+	 * @param {Array} data The plaintext.
+	 * @return {Array} The ciphertext.
+	 */
+	encrypt(data) {
+		return this._crypt(data, 0);
+	}
+
+	/**
+	 * Decrypt an array of 4 big-endian words.
+	 * @param {Array} data The ciphertext.
+	 * @return {Array} The plaintext.
+	 */
+	decrypt(data) {
+		return this._crypt(data, 1);
+	}
+
+	/**
+	 * Expand the S-box tables.
+	 *
+	 * @private
+	 */
+	_precompute() {
+		const encTable = this._tables[0];
+		const decTable = this._tables[1];
+		const sbox = encTable[4];
+		const sboxInv = decTable[4];
+		const d = [];
+		const th = [];
+		let xInv, x2, x4, x8;
+
+		// Compute double and third tables
+		for (let i = 0; i < 256; i++) {
+			th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i;
+		}
+
+		for (let x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
+			// Compute sbox
+			let s = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4;
+			s = s >> 8 ^ s & 255 ^ 99;
+			sbox[x] = s;
+			sboxInv[s] = x;
+
+			// Compute MixColumns
+			x8 = d[x4 = d[x2 = d[x]]];
+			let tDec = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100;
+			let tEnc = d[s] * 0x101 ^ s * 0x1010100;
+
+			for (let i = 0; i < 4; i++) {
+				encTable[i][x] = tEnc = tEnc << 24 ^ tEnc >>> 8;
+				decTable[i][s] = tDec = tDec << 24 ^ tDec >>> 8;
+			}
+		}
+
+		// Compactify.  Considerable speedup on Firefox.
+		for (let i = 0; i < 5; i++) {
+			encTable[i] = encTable[i].slice(0);
+			decTable[i] = decTable[i].slice(0);
+		}
+	}
+
+	/**
+	 * Encryption and decryption core.
+	 * @param {Array} input Four words to be encrypted or decrypted.
+	 * @param dir The direction, 0 for encrypt and 1 for decrypt.
+	 * @return {Array} The four encrypted or decrypted words.
+	 * @private
+	 */
+	_crypt(input, dir) {
+		if (input.length !== 4) {
+			throw new Error("invalid aes block size");
+		}
+
+		const key = this._key[dir];
+
+		const nInnerRounds = key.length / 4 - 2;
+		const out = [0, 0, 0, 0];
+		const table = this._tables[dir];
+
+		// load up the tables
+		const t0 = table[0];
+		const t1 = table[1];
+		const t2 = table[2];
+		const t3 = table[3];
+		const sbox = table[4];
+
+		// state variables a,b,c,d are loaded with pre-whitened data
+		let a = input[0] ^ key[0];
+		let b = input[dir ? 3 : 1] ^ key[1];
+		let c = input[2] ^ key[2];
+		let d = input[dir ? 1 : 3] ^ key[3];
+		let kIndex = 4;
+		let a2, b2, c2;
+
+		// Inner rounds.  Cribbed from OpenSSL.
+		for (let i = 0; i < nInnerRounds; i++) {
+			a2 = t0[a >>> 24] ^ t1[b >> 16 & 255] ^ t2[c >> 8 & 255] ^ t3[d & 255] ^ key[kIndex];
+			b2 = t0[b >>> 24] ^ t1[c >> 16 & 255] ^ t2[d >> 8 & 255] ^ t3[a & 255] ^ key[kIndex + 1];
+			c2 = t0[c >>> 24] ^ t1[d >> 16 & 255] ^ t2[a >> 8 & 255] ^ t3[b & 255] ^ key[kIndex + 2];
+			d = t0[d >>> 24] ^ t1[a >> 16 & 255] ^ t2[b >> 8 & 255] ^ t3[c & 255] ^ key[kIndex + 3];
+			kIndex += 4;
+			a = a2; b = b2; c = c2;
+		}
+
+		// Last round.
+		for (let i = 0; i < 4; i++) {
+			out[dir ? 3 & -i : i] =
+				sbox[a >>> 24] << 24 ^
+				sbox[b >> 16 & 255] << 16 ^
+				sbox[c >> 8 & 255] << 8 ^
+				sbox[d & 255] ^
+				key[kIndex++];
+			a2 = a; a = b; b = c; c = d; d = a2;
+		}
+
+		return out;
+	}
+};
+
+/**
+ * Random values
+ * @namespace
+ */
+const random = {
+	/** 
+	 * Generate random words with pure js, cryptographically not as strong & safe as native implementation.
+	 * @param {TypedArray} typedArray The array to fill.
+	 * @return {TypedArray} The random values.
+	 */
+	getRandomValues(typedArray) {
+		const words = new Uint32Array(typedArray.buffer);
+		const r = (m_w) => {
+			let m_z = 0x3ade68b1;
+			const mask = 0xffffffff;
+			return function () {
+				m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
+				m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
+				const result = ((((m_z << 0x10) + m_w) & mask) / 0x100000000) + .5;
+				return result * (Math.random() > .5 ? 1 : -1);
+			};
+		};
+		for (let i = 0, rcache; i < typedArray.length; i += 4) {
+			const _r = r((rcache || Math.random()) * 0x100000000);
+			rcache = _r() * 0x3ade67b7;
+			words[i / 4] = (_r() * 0x100000000) | 0;
+		}
+		return typedArray;
+	}
+};
+
+/** @fileOverview CTR mode implementation.
+ *
+ * Special thanks to Roy Nicholson for pointing out a bug in our
+ * implementation.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/** Brian Gladman's CTR Mode.
+* @constructor
+* @param {Object} _prf The aes instance to generate key.
+* @param {bitArray} _iv The iv for ctr mode, it must be 128 bits.
+*/
+
+const mode = {};
+
+/**
+ * Brian Gladman's CTR Mode.
+ * @namespace
+ */
+mode.ctrGladman = class {
+	constructor(prf, iv) {
+		this._prf = prf;
+		this._initIv = iv;
+		this._iv = iv;
+	}
+
+	reset() {
+		this._iv = this._initIv;
+	}
+
+	/** Input some data to calculate.
+	 * @param {bitArray} data the data to process, it must be intergral multiple of 128 bits unless it's the last.
+	 */
+	update(data) {
+		return this.calculate(this._prf, data, this._iv);
+	}
+
+	incWord(word) {
+		if (((word >> 24) & 0xff) === 0xff) { //overflow
+			let b1 = (word >> 16) & 0xff;
+			let b2 = (word >> 8) & 0xff;
+			let b3 = word & 0xff;
+
+			if (b1 === 0xff) { // overflow b1   
+				b1 = 0;
+				if (b2 === 0xff) {
+					b2 = 0;
+					if (b3 === 0xff) {
+						b3 = 0;
+					} else {
+						++b3;
+					}
+				} else {
+					++b2;
+				}
+			} else {
+				++b1;
+			}
+
+			word = 0;
+			word += (b1 << 16);
+			word += (b2 << 8);
+			word += b3;
+		} else {
+			word += (0x01 << 24);
+		}
+		return word;
+	}
+
+	incCounter(counter) {
+		if ((counter[0] = this.incWord(counter[0])) === 0) {
+			// encr_data in fileenc.c from  Dr Brian Gladman's counts only with DWORD j < 8
+			counter[1] = this.incWord(counter[1]);
+		}
+	}
+
+	calculate(prf, data, iv) {
+		let l;
+		if (!(l = data.length)) {
+			return [];
+		}
+		const bl = bitArray.bitLength(data);
+		for (let i = 0; i < l; i += 4) {
+			this.incCounter(iv);
+			const e = prf.encrypt(iv);
+			data[i] ^= e[0];
+			data[i + 1] ^= e[1];
+			data[i + 2] ^= e[2];
+			data[i + 3] ^= e[3];
+		}
+		return bitArray.clamp(data, bl);
+	}
+};
+
+const misc = {
+	importKey(password) {
+		return new misc.hmacSha1(codec.bytes.toBits(password));
+	},
+	pbkdf2(prf, salt, count, length) {
+		count = count || 10000;
+		if (length < 0 || count < 0) {
+			throw new Error("invalid params to pbkdf2");
+		}
+		const byteLength = ((length >> 5) + 1) << 2;
+		let u, ui, i, j, k;
+		const arrayBuffer = new ArrayBuffer(byteLength);
+		const out = new DataView(arrayBuffer);
+		let outLength = 0;
+		const b = bitArray;
+		salt = codec.bytes.toBits(salt);
+		for (k = 1; outLength < (byteLength || 1); k++) {
+			u = ui = prf.encrypt(b.concat(salt, [k]));
+			for (i = 1; i < count; i++) {
+				ui = prf.encrypt(ui);
+				for (j = 0; j < ui.length; j++) {
+					u[j] ^= ui[j];
+				}
+			}
+			for (i = 0; outLength < (byteLength || 1) && i < u.length; i++) {
+				out.setInt32(outLength, u[i]);
+				outLength += 4;
+			}
+		}
+		return arrayBuffer.slice(0, length / 8);
+	}
+};
+
+/** @fileOverview HMAC implementation.
+ *
+ * @author Emily Stark
+ * @author Mike Hamburg
+ * @author Dan Boneh
+ */
+
+/** HMAC with the specified hash function.
+ * @constructor
+ * @param {bitArray} key the key for HMAC.
+ * @param {Object} [Hash=hash.sha1] The hash function to use.
+ */
+misc.hmacSha1 = class {
+
+	constructor(key) {
+		const hmac = this;
+		const Hash = hmac._hash = hash.sha1;
+		const exKey = [[], []];
+		hmac._baseHash = [new Hash(), new Hash()];
+		const bs = hmac._baseHash[0].blockSize / 32;
+
+		if (key.length > bs) {
+			key = new Hash().update(key).finalize();
+		}
+
+		for (let i = 0; i < bs; i++) {
+			exKey[0][i] = key[i] ^ 0x36363636;
+			exKey[1][i] = key[i] ^ 0x5C5C5C5C;
+		}
+
+		hmac._baseHash[0].update(exKey[0]);
+		hmac._baseHash[1].update(exKey[1]);
+		hmac._resultHash = new Hash(hmac._baseHash[0]);
+	}
+	reset() {
+		const hmac = this;
+		hmac._resultHash = new hmac._hash(hmac._baseHash[0]);
+		hmac._updated = false;
+	}
+
+	update(data) {
+		const hmac = this;
+		hmac._updated = true;
+		hmac._resultHash.update(data);
+	}
+
+	digest() {
+		const hmac = this;
+		const w = hmac._resultHash.finalize();
+		const result = new (hmac._hash)(hmac._baseHash[1]).update(w).finalize();
+
+		hmac.reset();
+
+		return result;
+	}
+
+	encrypt(data) {
+		if (!this._updated) {
+			this.update(data);
+			return this.digest(data);
+		} else {
+			throw new Error("encrypt on already updated hmac called!");
+		}
+	}
+};
+
+export {
+	cipher,
+	codec,
+	misc,
+	mode,
+	random
+};