/*
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
Author Tobias Koppers @sokra
|
*/
|
|
'use strict';
|
|
// 65536 is the size of a wasm memory page
|
// 64 is the maximum chunk size for every possible wasm hash implementation
|
// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
|
// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
|
const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
|
|
class WasmHash {
|
/**
|
* @param {WebAssembly.Instance} instance wasm instance
|
* @param {WebAssembly.Instance[]} instancesPool pool of instances
|
* @param {number} chunkSize size of data chunks passed to wasm
|
* @param {number} digestSize size of digest returned by wasm
|
*/
|
constructor(instance, instancesPool, chunkSize, digestSize) {
|
const exports = /** @type {any} */ (instance.exports);
|
|
exports.init();
|
|
this.exports = exports;
|
this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
|
this.buffered = 0;
|
this.instancesPool = instancesPool;
|
this.chunkSize = chunkSize;
|
this.digestSize = digestSize;
|
}
|
|
reset() {
|
this.buffered = 0;
|
this.exports.init();
|
}
|
|
/**
|
* @param {Buffer | string} data data
|
* @param {BufferEncoding=} encoding encoding
|
* @returns {this} itself
|
*/
|
update(data, encoding) {
|
if (typeof data === 'string') {
|
while (data.length > MAX_SHORT_STRING) {
|
this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
|
data = data.slice(MAX_SHORT_STRING);
|
}
|
|
this._updateWithShortString(data, encoding);
|
|
return this;
|
}
|
|
this._updateWithBuffer(data);
|
|
return this;
|
}
|
|
/**
|
* @param {string} data data
|
* @param {BufferEncoding=} encoding encoding
|
* @returns {void}
|
*/
|
_updateWithShortString(data, encoding) {
|
const { exports, buffered, mem, chunkSize } = this;
|
|
let endPos;
|
|
if (data.length < 70) {
|
if (!encoding || encoding === 'utf-8' || encoding === 'utf8') {
|
endPos = buffered;
|
for (let i = 0; i < data.length; i++) {
|
const cc = data.charCodeAt(i);
|
|
if (cc < 0x80) {
|
mem[endPos++] = cc;
|
} else if (cc < 0x800) {
|
mem[endPos] = (cc >> 6) | 0xc0;
|
mem[endPos + 1] = (cc & 0x3f) | 0x80;
|
endPos += 2;
|
} else {
|
// bail-out for weird chars
|
endPos += mem.write(data.slice(i), endPos, encoding);
|
break;
|
}
|
}
|
} else if (encoding === 'latin1') {
|
endPos = buffered;
|
|
for (let i = 0; i < data.length; i++) {
|
const cc = data.charCodeAt(i);
|
|
mem[endPos++] = cc;
|
}
|
} else {
|
endPos = buffered + mem.write(data, buffered, encoding);
|
}
|
} else {
|
endPos = buffered + mem.write(data, buffered, encoding);
|
}
|
|
if (endPos < chunkSize) {
|
this.buffered = endPos;
|
} else {
|
const l = endPos & ~(this.chunkSize - 1);
|
|
exports.update(l);
|
|
const newBuffered = endPos - l;
|
|
this.buffered = newBuffered;
|
|
if (newBuffered > 0) {
|
mem.copyWithin(0, l, endPos);
|
}
|
}
|
}
|
|
/**
|
* @param {Buffer} data data
|
* @returns {void}
|
*/
|
_updateWithBuffer(data) {
|
const { exports, buffered, mem } = this;
|
const length = data.length;
|
|
if (buffered + length < this.chunkSize) {
|
data.copy(mem, buffered, 0, length);
|
|
this.buffered += length;
|
} else {
|
const l = (buffered + length) & ~(this.chunkSize - 1);
|
|
if (l > 65536) {
|
let i = 65536 - buffered;
|
|
data.copy(mem, buffered, 0, i);
|
exports.update(65536);
|
|
const stop = l - buffered - 65536;
|
|
while (i < stop) {
|
data.copy(mem, 0, i, i + 65536);
|
exports.update(65536);
|
i += 65536;
|
}
|
|
data.copy(mem, 0, i, l - buffered);
|
|
exports.update(l - buffered - i);
|
} else {
|
data.copy(mem, buffered, 0, l - buffered);
|
|
exports.update(l);
|
}
|
|
const newBuffered = length + buffered - l;
|
|
this.buffered = newBuffered;
|
|
if (newBuffered > 0) {
|
data.copy(mem, 0, length - newBuffered, length);
|
}
|
}
|
}
|
|
digest(type) {
|
const { exports, buffered, mem, digestSize } = this;
|
|
exports.final(buffered);
|
|
this.instancesPool.push(this);
|
|
const hex = mem.toString('latin1', 0, digestSize);
|
|
if (type === 'hex') {
|
return hex;
|
}
|
|
if (type === 'binary' || !type) {
|
return Buffer.from(hex, 'hex');
|
}
|
|
return Buffer.from(hex, 'hex').toString(type);
|
}
|
}
|
|
const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
|
if (instancesPool.length > 0) {
|
const old = instancesPool.pop();
|
|
old.reset();
|
|
return old;
|
} else {
|
return new WasmHash(
|
new WebAssembly.Instance(wasmModule),
|
instancesPool,
|
chunkSize,
|
digestSize
|
);
|
}
|
};
|
|
module.exports = create;
|
module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
|
