tinyhmacmd5 0.5.1-es2026 → 0.5.2-es2026

package/README.md

@@ -2,9 +2,9 @@ English | [中文](README-zh.md)
 
 # Tiny HMAC MD5
 
-A tiny, efficient and reliable HMAC-MD5 implementation for JavaScript.
+A tiny, fast and reliable implementation of MD5 and HMAC-MD5 for JavaScript.
 
-[`browser.min.js`](browser.min.js) is only **923 bytes**.
+[`browser.min.js`](browser.min.js) is only **905 Bytes**.
 
 - **Input type**: `string` (UTF‑8), `Uint8Array` or `Uint8ClampedArray`
 - **Output type**: hex `string` or bytes `Uint8Array`
@@ -29,19 +29,20 @@ If you need a smaller implementation that targets ECMAScript 2026, see the [`es2
 $ node scripts/benchmark.mjs && node scripts/test-513MiB.mjs
 Data length: 104857600 chars (100MiB)
 --------------------------------------------------
-tinyhmacmd5     : 388.35 ms
-js-md5          : 128.71 ms
-blueimp-md5     : 3823.48 ms
-crypto-js       : 1553.58 ms
-node:crypto     : 129.86 ms
+tinyhmacmd5     : 388.45 ms
+spark-md5       : 520.13 ms
+js-md5          : 480.29 ms
+crypto-js       : 1661.32 ms
+blueimp-md5     : 3749.15 ms
+node:crypto     : 129.97 ms
 --------------------------------------------------
 ✅ All pure JS implementations match node:crypto result.
 
 --- Pure 513MiB Test (No prior small tests) ---
-tinyhmacmd5 HMAC-MD5 timer: 1.886s
-node:crypto HMAC-MD5 timer: 548.216ms
-tinyhmacmd5 MD5 timer: 1.868s
-node:crypto MD5 timer: 548.352ms
+tinyhmacmd5 HMAC-MD5 timer: 1.867s
+node:crypto HMAC-MD5 timer: 548.332ms
+tinyhmacmd5 MD5 timer: 1.869s
+node:crypto MD5 timer: 551.244ms
 ```
 
 CPU: i5-10600KF  
@@ -97,7 +98,7 @@ It will define the `md5` function using `var`.
 If you are concerned that others might not recognize what this is, you can add the following comment:
 
 ```js
-// tinyhmacmd5 (The Unlicense)
+// https://npmjs.com/tinyhmacmd5
 ```
 
 ---

package/browser.min.js

@@ -1 +1 @@
-{let e=Int32Array,r=Uint8Array,n=new e(64).map((e,r)=>2**32*Math.sin(++r%Math.PI)),t=(r,t,f=0,o=1732584193,a=271733878,l=e.of(o,~a,~o,a),w=r.length)=>{for(r[w-1]=t/2**29,r[(t-t%4)/4]|=128<<(r[w-2]=t<<3);f<w;f+=16){let{0:e,1:w,2:u,3:h}=l;for(t=o=0;t<16;t+=4)for(;o<4*t+16;w=0|((e+=n[o]+(u^(t>4?t>8?w|~h:w^h:t?h&(w^u):~w&(u^h)))+r[f+(o++*(29521>>t)+(1296>>t)&15)])<<a|e>>>32-a)+(e=h,h=u,u=w))a="',16%).4$+07&*/5".charCodeAt(3&o|t);l[0]+=e,l[1]+=w,l[2]+=u,l[3]+=h}return l},f=(t,f,o=("string"==typeof t?t=(new TextEncoder).encode(t):t).length,a=new e(f+18+(o-(o+8&63))/4),l=1&new r(n.buffer)[3]&&new r(a.buffer,4*f).set(t))=>{for(;l<o;3&++l||f++)a[f]|=t[l]<<8*l;return[a,o]};var md5=(n,o,a)=>{var l=16,w=null!=o,[u,h]=f(n,w*l),d=new r(l);if(w){let[r,n]=f(o,0),a=new e(32);for(n>64&&(r=t(r,n)),n=l;n;)a[--n]=1785358954^(u[n]=909522486^r[n]);a.set(t(u,64+h),l),u=a,h=80}for(u=t(u,h);l;)d[--l]=u[l>>2]>>8*l;return a?d:d.toHex()}}
+{let e=Int32Array,r=Uint8Array,n=new e(64).map((e,r)=>2**32*Math.sin(++r%Math.PI)),t=1&new r(n.buffer)[0],f=e=>e.reverse(),o=(r,t,f=0,o=1732584193,a=271733878,l=e.of(o,~a,~o,a),w=r.length)=>{for(r[w-1]=t/2**29,r[(t-t%4)/4]|=128<<(r[w-2]=t<<3);f<w;f+=16){let{0:e,1:w,2:u,3:h}=l;for(t=o=0;t<16;t+=4)for(;o<4*t+16;w=0|((e+=n[o]+(u^(t>4?t>8?w|~h:w^h:t?h&(w^u):~w&(u^h)))+r[f+(o++*(29521>>t)+(1296>>t)&15)])<<a|e>>>32-a)+(e=h,h=u,u=w))a="',16%).4$+07&*/5".charCodeAt(3&o|t);l[0]+=e,l[1]+=w,l[2]+=u,l[3]+=h}return l},a=(n,o,a=("string"==typeof n?n=(new TextEncoder).encode(n):n).length,l=new e(o+18+(a-(a+8&63))/4),w=new r(l.buffer))=>(w.set(n,4*o),t&&f(w,f(l)),[l,a]);var md5=(n,l,w)=>{var u=null!=l,[h,s]=a(n,16*u);if(u){let[r,n]=a(l,0),t=new e(32),f=16;for(n>64&&(r=o(r,n));f;)t[--f]=1785358954^(h[f]=909522486^r[f]);t.set(o(h,64+s),16),h=t,s=80}return h=o(h,s),u=new r(h.buffer),t&&f(u,f(h)),w?u:u.toHex()}}

package/main.js

@@ -7,6 +7,12 @@ let $Uint8Array = Uint8Array
 /** MD5 constants cached in memory */
 let K = new $Int32Array(64).map((v, i) => 2 ** 32 * Math.sin(++i % Math.PI))
 
+/** is big-endian */
+let isBE = /** @type {0 | 1} */(new $Uint8Array(K.buffer)[0] & 1)
+
+/** @type {(a: Uint8Array | Int32Array, ...x: any[]) => any} */
+let reverse = a => a.reverse()
+
 /**
  * Calculate the MD5 of an array of little-endian words, and a byte length.
  *
@@ -74,15 +80,13 @@ let wordsMD5 = (
  * Convert bytes to an array of little-endian words
  *
  * @param {*} input
- * @param {number} j pad int32 length (0 or 16)
- * 
- * @param {*} [i]
+ * @param {number} padLen pad int32 length (0 or 16)
  * 
  * @returns {[Int32Array<ArrayBuffer>, number]}
  */
 let inputToWords = (
   input,
-  j,
+  padLen,
   // var:
   byteLen = (
     // Don't replace the type check below with something like `input.big`; it's unreliable.
@@ -92,16 +96,13 @@ let inputToWords = (
   ).length,
   // Using `Array` to process inputs over 512 MiB could throw a `RangeError`,
   // so I replaced it with `Int32Array`.
-  output = new $Int32Array(j + 18 + (byteLen - (byteLen + 8 & 63)) / 4),
-  // (fast) little-endian
-  i = new $Uint8Array(K.buffer)[3] & 1 && new $Uint8Array(output.buffer, j * 4).set(input),
-) => {
-  // (slow) big-endian
-  for (; i < byteLen; ++i & 3 || j++) {
-    output[j] |= input[i] << 8 * i
-  }
-  return [output, byteLen]
-}
+  output = new $Int32Array(padLen + 18 + (byteLen - (byteLen + 8 & 63)) / 4),
+  outputBytes = new $Uint8Array(output.buffer),
+) => (
+  outputBytes.set(input, padLen * 4),
+  isBE && reverse(outputBytes, reverse(output)),
+  [output, byteLen]
+)
 
 /**
  * Computes the MD5 hash of the input data.  
@@ -116,35 +117,34 @@ let inputToWords = (
  */
 let md5 = (data, key, raw) => {
   // Do not use parameter defaults to declare variables in public functions.
-  var i = 16
-    , hasKey = key != null
-    , [bdata, temp] = inputToWords(data, /**@type {*}*/(hasKey) * i)
-    , out = new $Uint8Array(i)
+  /** @type {boolean | Uint8Array<ArrayBuffer>} */
+  var temp = key != null
+    , [bdata, dataByteLen] = inputToWords(data, /**@type {*}*/(temp) * 16)
 
-  if (hasKey) {
+  if (temp) {
     // HMAC
-    let [bkey, j] = inputToWords(key, 0)
+    let [bkey, keyByteLen] = inputToWords(key, 0)
       , opad = new $Int32Array(32)
-    if (j > 64) {
-      bkey = wordsMD5(bkey, j)
+      , i = 16
+    if (keyByteLen > 64) {
+      bkey = wordsMD5(bkey, keyByteLen)
     }
-    for (j = i; j;) {
+    for (; i;) {
       // (0x36363636 ^ 0x5c5c5c5c) == 0x6a6a6a6a
-      opad[--j] = 0x6a6a6a6a ^ (bdata[j] = 0x36363636 ^ bkey[j])
+      opad[--i] = 0x6a6a6a6a ^ (bdata[i] = 0x36363636 ^ bkey[i])
     }
-    opad.set(wordsMD5(bdata, 64 + temp), i)
+    opad.set(wordsMD5(bdata, 64 + dataByteLen), 16)
     bdata = opad
-    temp = 80
+    dataByteLen = 80
   }
 
-  bdata = wordsMD5(bdata, temp)
-
-  // words to bytes or hex
-  for (; i;) {
-    out[--i] = bdata[i >> 2] >> i * 8
-  }
+  bdata = wordsMD5(bdata, dataByteLen)
 
-  return raw ? out : out.toHex()
+  temp = new $Uint8Array(bdata.buffer)
+  isBE && reverse(temp, reverse(bdata))
+  return raw
+    ? temp
+    : temp.toHex()
 }
 
 export default md5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tinyhmacmd5",
-  "version": "0.5.1-es2026",
-  "description": "A tiny (923 Bytes), efficient and reliable HMAC-MD5 implementation for JavaScript.",
+  "version": "0.5.2-es2026",
+  "description": "A tiny (905 Bytes), fast and reliable implementation of MD5 and HMAC-MD5 for JavaScript.",
   "author": "bddjr",
   "license": "Unlicense",
   "type": "module",
@@ -58,6 +58,7 @@
     "crypto-js": "^4.2.0",
     "es-check": "^9.6.4",
     "js-md5": "^0.9.2",
+    "spark-md5": "^3.0.2",
     "terser": "^5.49.0",
     "tinyhmacmd5": "link:",
     "typescript": "^7.0.2"