npm package diff
Package: @noble/hashes
Versions: 1.3.2 - 1.3.3
File: package/src/utils.ts
Index: package/src/utils.ts
===================================================================
--- package/src/utils.ts
+++ package/src/utils.ts
@@ -4,21 +4,27 @@
// node.js versions earlier than v19 don't declare it in global scope.
// For node.js, package.json#exports field mapping rewrites import
// from `crypto` to `cryptoNode`, which imports native module.
// Makes the utils un-importable in browsers without a bundler.
-// Once node.js 18 is deprecated, we can just drop the import.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
import { crypto } from '@noble/hashes/crypto';
// prettier-ignore
export type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array |
Uint16Array | Int16Array | Uint32Array | Int32Array;
-const u8a = (a: any): a is Uint8Array => a instanceof Uint8Array;
// Cast array to different type
export const u8 = (arr: TypedArray) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
export const u32 = (arr: TypedArray) =>
new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+function isBytes(a: unknown): a is Uint8Array {
+ return (
+ a instanceof Uint8Array ||
+ (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array')
+ );
+}
+
// Cast array to view
export const createView = (arr: TypedArray) =>
new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
@@ -26,41 +32,56 @@
export const rotr = (word: number, shift: number) => (word << (32 - shift)) | (word >>> shift);
// big-endian hardware is rare. Just in case someone still decides to run hashes:
// early-throw an error because we don't support BE yet.
+// Other libraries would silently corrupt the data instead of throwing an error,
+// when they don't support it.
export const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
if (!isLE) throw new Error('Non little-endian hardware is not supported');
+// Array where index 0xf0 (240) is mapped to string 'f0'
const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>
i.toString(16).padStart(2, '0')
);
/**
* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
*/
export function bytesToHex(bytes: Uint8Array): string {
- if (!u8a(bytes)) throw new Error('Uint8Array expected');
+ if (!isBytes(bytes)) throw new Error('Uint8Array expected');
// pre-caching improves the speed 6x
let hex = '';
for (let i = 0; i < bytes.length; i++) {
hex += hexes[bytes[i]];
}
return hex;
}
+// We use optimized technique to convert hex string to byte array
+const asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 } as const;
+function asciiToBase16(char: number): number | undefined {
+ if (char >= asciis._0 && char <= asciis._9) return char - asciis._0;
+ if (char >= asciis._A && char <= asciis._F) return char - (asciis._A - 10);
+ if (char >= asciis._a && char <= asciis._f) return char - (asciis._a - 10);
+ return;
+}
+
/**
* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
*/
export function hexToBytes(hex: string): Uint8Array {
if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
- const len = hex.length;
- if (len % 2) throw new Error('padded hex string expected, got unpadded hex of length ' + len);
- const array = new Uint8Array(len / 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;
+ const hl = hex.length;
+ const al = hl / 2;
+ if (hl % 2) throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+ const array = new Uint8Array(al);
+ for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+ const n1 = asciiToBase16(hex.charCodeAt(hi));
+ const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+ if (n1 === undefined || n2 === undefined) {
+ const char = hex[hi] + hex[hi + 1];
+ throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+ }
+ array[ai] = n1 * 16 + n2;
}
return array;
}
@@ -101,24 +122,29 @@
* Keep in mind for future mutable operations.
*/
export function toBytes(data: Input): Uint8Array {
if (typeof data === 'string') data = utf8ToBytes(data);
- if (!u8a(data)) throw new Error(`expected Uint8Array, got ${typeof data}`);
+ if (!isBytes(data)) throw new Error(`expected Uint8Array, got ${typeof data}`);
return data;
}
/**
* Copies several Uint8Arrays into one.
*/
export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
- const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
- let pad = 0; // walk through each item, ensure they have proper type
- arrays.forEach((a) => {
- if (!u8a(a)) throw new Error('Uint8Array expected');
- r.set(a, pad);
+ let sum = 0;
+ for (let i = 0; i < arrays.length; i++) {
+ const a = arrays[i];
+ if (!isBytes(a)) throw new Error('Uint8Array expected');
+ sum += a.length;
+ }
+ const res = new Uint8Array(sum);
+ for (let i = 0, pad = 0; i < arrays.length; i++) {
+ const a = arrays[i];
+ res.set(a, pad);
pad += a.length;
- });
- return r;
+ }
+ return res;
}
// For runtime check if class implements interface
export abstract class Hash<T extends Hash<T>> {