tinyhmacmd5 0.2.3 → 0.3.0-es2026

package/README.md

@@ -2,7 +2,7 @@ English | [中文](README-zh.md)
 
 # Tiny HMAC MD5
 
-A tiny and reliable HMAC-MD5 implementation for JavaScript: [`browser.min.js`](browser.min.js) is only **982 bytes**.
+A tiny and reliable HMAC-MD5 implementation for JavaScript: [`browser.min.js`](browser.min.js) is only **963 bytes**.
 
 - **Input type**: `string` (UTF‑8), `Uint8Array` or `Uint8ClampedArray`
 - **Output type**: hex `string` or bytes `Uint8Array`
@@ -10,14 +10,10 @@ A tiny and reliable HMAC-MD5 implementation for JavaScript: [`browser.min.js`](b
 - **TypeScript‑ready**: [`main.d.ts`](main.d.ts)
 - **0 dependencies**
 
-**Live demo**: https://bddjr.github.io/tinyhmacmd5/
-
 `tinyhmacmd5` does not simply aim for the smallest possible size.  
 Its goal is to balance code size and runtime performance, so some performance-oriented implementations are intentionally retained.  
 As a result, the final size is not the smallest theoretically achievable.
 
-If you need a smaller implementation that targets ECMAScript 2026, see the [`es2026`](https://github.com/bddjr/tinyhmacmd5/tree/es2026) branch.
-
 > [!WARNING]  
 > MD5 is cryptographically broken and unsafe for security-sensitive applications.  
 > Do not rely on it for password hashing, digital signatures, or certificate verification.
@@ -27,7 +23,7 @@ If you need a smaller implementation that targets ECMAScript 2026, see the [`es2
 ### npm
 
 ```
-npm i tinyhmacmd5
+npm i tinyhmacmd5@es2026
 ```
 
 ```js
@@ -43,7 +39,7 @@ You can also use other package managers (e.g. `pnpm` or `yarn`) in place of `npm
 See https://www.jsdelivr.com/package/npm/tinyhmacmd5
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/tinyhmacmd5"></script>
+<script src="https://cdn.jsdelivr.net/npm/tinyhmacmd5@es2026"></script>
 ```
 
 It will define the `md5` function using `var`.
@@ -51,7 +47,7 @@ It will define the `md5` function using `var`.
 ### UNPKG
 
 ```html
-<script src="https://unpkg.com/tinyhmacmd5"></script>
+<script src="https://unpkg.com/tinyhmacmd5@es2026"></script>
 ```
 
 It will define the `md5` function using `var`.
@@ -142,27 +138,54 @@ md5(data)
 
 ## Runtime Environment
 
-Environments that support [Exponentiation (`**`)](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/Exponentiation) and [`TextEncoder`](https://developer.mozilla.org/docs/Web/API/TextEncoder) :
+Environments that support [`Uint8Array.prototype.toHex()`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex) :
 
 - Desktop
-  - Chrome ≥ 52 (2016-07-20)
-  - Edge ≥ 79 (2020-01-15)
-  - Firefox ≥ 52 (2017-03-07)
-  - Opera ≥ 39 (2016-08-02)
-  - Safari ≥ 10.1 (2017-03-27)
+  - Chrome ≥ 140 (2025-09-02)
+  - Edge ≥ 140 (2025-09-05)
+  - Firefox ≥ 133 (2024-11-26)
+  - Opera ≥ 124 (2025-11-13)
+  - Safari ≥ 18.2 (2024-12-11)
 - Mobile
-  - Chrome Android ≥ 52 (2016-07-27)
-  - Firefox for Android ≥ 52 (2017-03-07)
-  - Opera Android ≥ 41 (2016-10-25)
-  - Safari on iOS ≥ 10.3 (2017-03-27)
-  - Samsung Browser ≥ 6 (2017-08-23)
-  - WebView Android ≥ 51 (2016-06-08)
-  - WebView on iOS ≥ 10.3 (2017-03-27)
+  - Chrome Android ≥ 140 (2025-09-02)
+  - Firefox for Android ≥ 133 (2024-11-26)
+  - Opera Android ≥ 92 (2025-10-08)
+  - Safari on iOS ≥ 18.2 (2024-12-11)
+  - Samsung Browser ×
+  - WebView Android ≥ 140 (2025-09-02)
+  - WebView on iOS ≥ 18.2 (2024-12-11)
 
 Not recommended for use in environments that support `node:crypto`, as `node:crypto` already provides HMAC-MD5.
 
 ---
 
+## Benchmark
+
+```
+pnpm benchmark
+```
+
+```
+Generating 100MiB string data (this might take a moment)...
+Data length: 104857600 chars (100MiB)
+--------------------------------------------------
+tinyhmacmd5     : 718.27 ms
+js-md5          : 141.43 ms
+blueimp-md5     : 3934.98 ms
+crypto-js       : 1732.55 ms
+native crypto   : 136.60 ms
+--------------------------------------------------
+✅ All pure JS implementations match native crypto result.
+
+--- Pure 513MiB Test (No prior small tests) ---
+tinyhmacmd5 HMAC-MD5 timer: 3.465s
+node:crypto HMAC-MD5 timer: 572.686ms
+tinyhmacmd5 MD5 timer: 3.451s
+node:crypto MD5 timer: 571.58ms
+```
+
+---
+
 ## Why I Made This Project
 
 I initially used HMAC-MD5 just to call a certain website's API. That site signs the request body with `crypto-js`'s HMAC-MD5 to make reverse engineering harder.
@@ -179,7 +202,7 @@ During the adaptation, I discovered that `blueimp-md5` did not correctly handle
 
 I also found that using `Array` to process inputs over 512 MiB could throw a `RangeError`, so I replaced it with `Int32Array`.
 
-I demonstrated in practice that HMAC-MD5 can be implemented in an extremely small footprint (982 bytes) while also improving reliability.
+I demonstrated in practice that HMAC-MD5 can be implemented in an extremely small footprint (963 bytes) while also improving reliability.
 
 Maybe not many people care about saving just a few KB, but `tinyhmacmd5` exists precisely to "explore the unknown".
 

package/browser.min.js

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

package/main.js

@@ -2,15 +2,15 @@
 
 // Adapted from https://github.com/blueimp/JavaScript-MD5
 
-/** @type {number[]} MD5 constants cached in memory */
-let K = []
-
-let i = 0
-
 let $Math = Math
 
 let floor = $Math.floor
 
+let $Int32Array = Int32Array
+
+/** MD5 constants cached in memory */
+let K = new $Int32Array(64).map((v, i) => 2 ** 32 * $Math.abs($Math.sin(i + 1)))
+
 /** @param {number} byteLen */
 // `byteLen` may be >= 2**32, so cannot use `>>>` as a replacement for `floor`
 let wordsLen = (byteLen) => floor((byteLen + 72) / 64) * 16
@@ -18,64 +18,64 @@ let wordsLen = (byteLen) => floor((byteLen + 72) / 64) * 16
 /**
  * Calculate the MD5 of an array of little-endian words, and a byte length.
  *
- * @param {Int32Array | number[]} x Array of little-endian words
+ * @param {Int32Array<ArrayBuffer>} x little-endian words
  * @param {number} l Byte length
  * 
+ * @param {number} [j]
  * @param {number} [t2]
  * @param {number} [oi]
  * 
- * @returns {number[]} MD5 Array
+ * @returns {Int32Array<ArrayBuffer>} MD5 Array
  */
 let wordsMD5 = (
   x,
   l,
   // var:
   i = 0,
-  j = wordsLen(l),
+  j,
   t0 = 1732584193,
   t1 = 271733878,
   t2,
   oi,
-  output = [t0, ~t1, ~t0, t1],
-  oldOutput = [...output],
+  xLen = x.length,
+  output = $Int32Array.of(t0, ~t1, ~t0, t1),
+  oldOutput = new $Int32Array(output),
 ) => {
   // append padding
   // `l` may be >= 2**32, so cannot use `>>>` as a replacement for `floor`
-  x[j - 1] = 0 | l / 2 ** 29;
-  x[floor(l / 4)] |= 0x80 << (x[j - 2] = l << 3);
-
-  for (; i < x.length; i += 16) {
-    for (j = 0; j < 64;
-      output[oi &= 3] = 0 | (
-        (
-          t1 = 0 | (
-            output[oi] +
-            K[j] +
-            (
-              t0 = output[++oi & 3],
-              t1 = output[++oi & 3],
-              t2 = output[++oi & 3],
-              l
-                ? l > 4
-                  ? l > 8
-                    ? t1 ^ (t0 | ~t2)  // Round 4: I
-                    : t0 ^ t1 ^ t2     // Round 3: H
-                  : t0 & t2 | t1 & ~t2 // Round 2: G
-                : t0 & t1 | ~t0 & t2   // Round 1: F
-            ) +
-            (
-              0 | x[i + (j * (0x7351 >> l) + (0x0510 >> l) & 15)]
+  x[xLen - 1] = l / 2 ** 29;
+  x[floor(l / 4)] |= 0x80 << (x[xLen - 2] = l << 3);
+
+  for (; i < xLen; i += 16) {
+    for (l = 0; l < 16; l += 4) {
+      for (j = 0; j < 16;) {
+        output[oi &= 3] = (
+          (
+            t1 = (
+              output[oi] +
+              K[l * 4 | j] +
+              (
+                t0 = output[++oi & 3],
+                t1 = output[++oi & 3],
+                t2 = output[++oi & 3],
+                l
+                  ? l > 4
+                    ? l > 8
+                      ? t1 ^ (t0 | ~t2)  // Round 4: I
+                      : t0 ^ t1 ^ t2     // Round 3: H
+                    : t0 & t2 | t1 & ~t2 // Round 2: G
+                  : t0 & t1 | ~t0 & t2   // Round 1: F
+              ) +
+              x[i + (j * (0x7351 >> l) + (0x0510 >> l) & 15)]
             )
-          )
-        ) << (
-          t2 = "',16%).4$+07&*/5".charCodeAt(j++ & 3 | l)
-        ) | t1 >>> 64 - t2
-      ) + t0
-    ) {
-      l = j >> 4 << 2
+          ) << (
+            t2 = "',16%).4$+07&*/5".charCodeAt(j++ & 3 | l)
+          ) | t1 >>> 64 - t2
+        ) + t0
+      }
     }
     for (; oi;) {
-      oldOutput[--oi] = output[oi] = 0 | oldOutput[oi] + output[oi]
+      oldOutput[--oi] = output[oi] += oldOutput[oi]
     }
   }
   return output
@@ -87,7 +87,7 @@ let wordsMD5 = (
  * @param {*} input
  * @param {number} j pad int32 length
  * 
- * @returns {[Int32Array<ArrayBuffer> | number[], number]}
+ * @returns {[Int32Array<ArrayBuffer>, number]}
  */
 let inputToWords = (
   input,
@@ -100,7 +100,7 @@ let inputToWords = (
   ).length,
   // Using `Array` to process inputs over 512 MiB could throw a `RangeError`,
   // so I replaced it with `Int32Array`.
-  output = new Int32Array(wordsLen(j * 4 + byteLen)),
+  output = new $Int32Array(wordsLen(j * 4 + byteLen)),
   i = 0,
 ) => {
   for (; i < byteLen;) {
@@ -129,14 +129,12 @@ var md5 = (data, key, raw) => {
   var i = 16
     , hasKey = key != null
     , [bdata, temp] = inputToWords(data, /**@type {*}*/(hasKey) * i)
-
-  /** @type {*} */
-  var out = raw ? new Uint8Array(i) : ''
+    , out = new Uint8Array(i)
 
   if (hasKey) {
     // HMAC
     let [bkey, j] = inputToWords(key, 0)
-      , opad = []
+      , opad = new $Int32Array(32)
     if (j > 64) {
       bkey = wordsMD5(bkey, j)
     }
@@ -144,26 +142,19 @@ var md5 = (data, key, raw) => {
       // (0x36363636 ^ 0x5c5c5c5c) == 0x6a6a6a6a
       opad[--j] = 0x6a6a6a6a ^ (bdata[j] = 0x36363636 ^ bkey[j])
     }
-    bdata = opad.concat(wordsMD5(bdata, 64 + temp))
+    opad.set(wordsMD5(bdata, 64 + temp), 16)
+    bdata = opad
     temp = 80
   }
 
   bdata = wordsMD5(bdata, temp)
 
   // words to bytes or hex
-  for (; i;
-    raw
-      ? out[i] = temp
-      : out = (temp >> 4 && '') + temp.toString(16) + out
-  ) {
-    temp = bdata[--i >> 2] >> i * 8 & 0xff
+  for (; i;) {
+    out[--i] = bdata[i >> 2] >> i * 8
   }
 
-  return out
-}
-
-for (; i < 64;) {
-  K[i] = 0 | 2 ** 32 * $Math.abs($Math.sin(++i))
+  return raw ? out : out.toHex()
 }
 
 export default md5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tinyhmacmd5",
-  "version": "0.2.3",
-  "description": "A tiny and reliable HMAC-MD5 implementation for JavaScript: browser.min.js is only 982 bytes.",
+  "version": "0.3.0-es2026",
+  "description": "A tiny and reliable HMAC-MD5 implementation for JavaScript: browser.min.js is only 963 bytes.",
   "author": "bddjr",
   "license": "MIT",
   "type": "module",
@@ -54,16 +54,20 @@
     "url": "git+https://github.com/bddjr/tinyhmacmd5.git"
   },
   "devDependencies": {
+    "blueimp-md5": "^2.19.0",
+    "crypto-js": "^4.2.0",
     "es-check": "^9.6.4",
+    "js-md5": "^0.9.2",
     "terser": "^5.49.0",
     "tinyhmacmd5": "link:",
     "typescript": "^7.0.2"
   },
   "scripts": {
-    "build": "tsc && node scripts/build.mjs && es-check es2016 --module --checkFeatures main.js browser.min.js",
+    "build": "tsc && node scripts/build.mjs && es-check es2026 --module --checkFeatures main.js browser.min.js",
     "build:unchanged": "node scripts/build-unchanged.mjs",
     "test": "pnpm build && pnpm test:only",
-    "test:only": "node scripts/test.mjs",
-    "test:unchanged": "pnpm build:unchanged && pnpm test:only"
+    "test:only": "node scripts/test.mjs && node scripts/test-513MiB.mjs",
+    "test:unchanged": "pnpm build:unchanged && pnpm test:only",
+    "benchmark": "node scripts/benchmark.mjs && node scripts/test-513MiB.mjs"
   }
 }