162 lines
6.3 KiB
Plaintext
162 lines
6.3 KiB
Plaintext
"use strict";
|
|
/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.randomBytes = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;
|
|
// The import here is via the package name. This is to ensure
|
|
// that exports mapping/resolution does fall into place.
|
|
const crypto_1 = require("@noble/hashes/crypto");
|
|
// Cast array to different type
|
|
const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
|
|
exports.u8 = u8;
|
|
const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
|
|
exports.u32 = u32;
|
|
// Cast array to view
|
|
const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
|
|
exports.createView = createView;
|
|
// The rotate right (circular right shift) operation for uint32
|
|
const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
|
|
exports.rotr = rotr;
|
|
exports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
|
|
// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.
|
|
// So, just to be sure not to corrupt anything.
|
|
if (!exports.isLE)
|
|
throw new Error('Non little-endian hardware is not supported');
|
|
const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
|
|
/**
|
|
* @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))
|
|
*/
|
|
function bytesToHex(uint8a) {
|
|
// pre-caching improves the speed 6x
|
|
if (!(uint8a instanceof Uint8Array))
|
|
throw new Error('Uint8Array expected');
|
|
let hex = '';
|
|
for (let i = 0; i < uint8a.length; i++) {
|
|
hex += hexes[uint8a[i]];
|
|
}
|
|
return hex;
|
|
}
|
|
exports.bytesToHex = bytesToHex;
|
|
/**
|
|
* @example hexToBytes('deadbeef')
|
|
*/
|
|
function hexToBytes(hex) {
|
|
if (typeof hex !== 'string') {
|
|
throw new TypeError('hexToBytes: expected string, got ' + typeof hex);
|
|
}
|
|
if (hex.length % 2)
|
|
throw new Error('hexToBytes: received invalid unpadded hex');
|
|
const array = new Uint8Array(hex.length / 2);
|
|
for (let i = 0; i < array.length; i++) {
|
|
const j = i * 2;
|
|
const hexByte = hex.slice(j, j + 2);
|
|
const byte = Number.parseInt(hexByte, 16);
|
|
if (Number.isNaN(byte) || byte < 0)
|
|
throw new Error('Invalid byte sequence');
|
|
array[i] = byte;
|
|
}
|
|
return array;
|
|
}
|
|
exports.hexToBytes = hexToBytes;
|
|
// There is no setImmediate in browser and setTimeout is slow. However, call to async function will return Promise
|
|
// which will be fullfiled only on next scheduler queue processing step and this is exactly what we need.
|
|
const nextTick = async () => { };
|
|
exports.nextTick = nextTick;
|
|
// Returns control to thread each 'tick' ms to avoid blocking
|
|
async function asyncLoop(iters, tick, cb) {
|
|
let ts = Date.now();
|
|
for (let i = 0; i < iters; i++) {
|
|
cb(i);
|
|
// Date.now() is not monotonic, so in case if clock goes backwards we return return control too
|
|
const diff = Date.now() - ts;
|
|
if (diff >= 0 && diff < tick)
|
|
continue;
|
|
await (0, exports.nextTick)();
|
|
ts += diff;
|
|
}
|
|
}
|
|
exports.asyncLoop = asyncLoop;
|
|
function utf8ToBytes(str) {
|
|
if (typeof str !== 'string') {
|
|
throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
|
|
}
|
|
return new TextEncoder().encode(str);
|
|
}
|
|
exports.utf8ToBytes = utf8ToBytes;
|
|
function toBytes(data) {
|
|
if (typeof data === 'string')
|
|
data = utf8ToBytes(data);
|
|
if (!(data instanceof Uint8Array))
|
|
throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
|
|
return data;
|
|
}
|
|
exports.toBytes = toBytes;
|
|
/**
|
|
* Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`
|
|
* @example concatBytes(buf1, buf2)
|
|
*/
|
|
function concatBytes(...arrays) {
|
|
if (!arrays.every((a) => a instanceof Uint8Array))
|
|
throw new Error('Uint8Array list expected');
|
|
if (arrays.length === 1)
|
|
return arrays[0];
|
|
const length = arrays.reduce((a, arr) => a + arr.length, 0);
|
|
const result = new Uint8Array(length);
|
|
for (let i = 0, pad = 0; i < arrays.length; i++) {
|
|
const arr = arrays[i];
|
|
result.set(arr, pad);
|
|
pad += arr.length;
|
|
}
|
|
return result;
|
|
}
|
|
exports.concatBytes = concatBytes;
|
|
// For runtime check if class implements interface
|
|
class Hash {
|
|
// Safe version that clones internal state
|
|
clone() {
|
|
return this._cloneInto();
|
|
}
|
|
}
|
|
exports.Hash = Hash;
|
|
// Check if object doens't have custom constructor (like Uint8Array/Array)
|
|
const isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;
|
|
function checkOpts(defaults, opts) {
|
|
if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))
|
|
throw new TypeError('Options should be object or undefined');
|
|
const merged = Object.assign(defaults, opts);
|
|
return merged;
|
|
}
|
|
exports.checkOpts = checkOpts;
|
|
function wrapConstructor(hashConstructor) {
|
|
const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
|
|
const tmp = hashConstructor();
|
|
hashC.outputLen = tmp.outputLen;
|
|
hashC.blockLen = tmp.blockLen;
|
|
hashC.create = () => hashConstructor();
|
|
return hashC;
|
|
}
|
|
exports.wrapConstructor = wrapConstructor;
|
|
function wrapConstructorWithOpts(hashCons) {
|
|
const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
|
|
const tmp = hashCons({});
|
|
hashC.outputLen = tmp.outputLen;
|
|
hashC.blockLen = tmp.blockLen;
|
|
hashC.create = (opts) => hashCons(opts);
|
|
return hashC;
|
|
}
|
|
exports.wrapConstructorWithOpts = wrapConstructorWithOpts;
|
|
/**
|
|
* Secure PRNG
|
|
*/
|
|
function randomBytes(bytesLength = 32) {
|
|
if (crypto_1.crypto.web) {
|
|
return crypto_1.crypto.web.getRandomValues(new Uint8Array(bytesLength));
|
|
}
|
|
else if (crypto_1.crypto.node) {
|
|
return new Uint8Array(crypto_1.crypto.node.randomBytes(bytesLength).buffer);
|
|
}
|
|
else {
|
|
throw new Error("The environment doesn't have randomBytes function");
|
|
}
|
|
}
|
|
exports.randomBytes = randomBytes;
|
|
//# sourceMappingURL=utils.js.map |