webpack
Version:
Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.
237 lines (221 loc) • 6.78 kB
JavaScript
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
const Hash = require("../Hash");
// 65536 is a wasm memory page, 64 the largest chunk size any wasm hash
// implementation takes, 4 the most bytes utf-8 spends on one char, and `& ~3`
// keeps it a whole block of 4 chars so base64 never sees a partial encoding.
const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
/**
* Represents the wasm hash runtime component.
* @typedef {object} WasmExports
* @property {WebAssembly.Memory} memory
* @property {() => void} init
* @property {(length: number) => void} update
* @property {(length: number) => void} final
*/
class WasmHash extends Hash {
/**
* Creates an instance of 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) {
super();
const exports = /** @type {WasmExports} */ (instance.exports);
exports.init();
/** @type {WasmExports} */
this.exports = exports;
/** @type {Buffer} */
this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
/** @type {number} */
this.buffered = 0;
/** @type {WebAssembly.Instance[]} */
this.instancesPool = instancesPool;
/** @type {number} */
this.chunkSize = chunkSize;
/** @type {number} */
this.digestSize = digestSize;
}
reset() {
this.buffered = 0;
this.exports.init();
}
/**
* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
* @overload
* @param {string | Buffer} data data
* @returns {Hash} updated hash
*/
/**
* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
* @overload
* @param {string} data data
* @param {string=} inputEncoding data encoding
* @returns {this} updated hash
*/
/**
* Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
* @param {string | Buffer} data data
* @param {string=} inputEncoding data encoding
* @returns {this} updated hash
*/
update(data, inputEncoding) {
if (typeof data === "string") {
while (data.length > MAX_SHORT_STRING) {
this._updateWithShortString(
data.slice(0, MAX_SHORT_STRING),
/** @type {NodeJS.BufferEncoding} */
(inputEncoding)
);
data = data.slice(MAX_SHORT_STRING);
}
this._updateWithShortString(
data,
/** @type {NodeJS.BufferEncoding} */
(inputEncoding)
);
return this;
}
this._updateWithBuffer(data);
return this;
}
/**
* Update with short string.
* @param {string} data data
* @param {BufferEncoding=} encoding encoding
* @returns {void}
*/
_updateWithShortString(data, encoding) {
const { exports, buffered, mem, chunkSize } = this;
/** @type {number} */
let endPos;
if (data.length < 70) {
// eslint-disable-next-line unicorn/text-encoding-identifier-case
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);
}
}
/**
* Update with buffer.
* @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);
}
}
/**
* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
* @overload
* @returns {Buffer} digest
*/
/**
* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
* @overload
* @param {string=} encoding encoding of the return value
* @returns {string} digest
*/
/**
* Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
* @param {string=} encoding encoding of the return value
* @returns {string | Buffer} digest
*/
digest(encoding) {
const { exports, buffered, mem, digestSize } = this;
exports.final(buffered);
this.instancesPool.push(this);
const hex = mem.toString("latin1", 0, digestSize);
if (encoding === "hex") return hex;
if (encoding === "binary" || !encoding) return Buffer.from(hex, "hex");
return Buffer.from(hex, "hex").toString(
/** @type {NodeJS.BufferEncoding} */ (encoding)
);
}
}
/**
* Returns wasm hash.
* @param {WebAssembly.Module} wasmModule wasm module
* @param {WasmHash[]} instancesPool pool of instances
* @param {number} chunkSize size of data chunks passed to wasm
* @param {number} digestSize size of digest returned by wasm
* @returns {WasmHash} wasm hash
*/
const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
if (instancesPool.length > 0) {
const old = /** @type {WasmHash} */ (instancesPool.pop());
old.reset();
return old;
}
return new WasmHash(
new WebAssembly.Instance(wasmModule),
instancesPool,
chunkSize,
digestSize
);
};
create.MAX_SHORT_STRING = MAX_SHORT_STRING;
module.exports = create;