tinyhmacmd5 0.1.7 → 0.2.0-es2026

package/README.md

@@ -2,11 +2,11 @@ English | [中文](README-zh.md)
 
 # Tiny HMAC MD5
 
-A tiny and reliable HMAC-MD5 implementation for JavaScript: [`browser.min.js`](browser.min.js) is only **997 bytes**.
+A tiny and reliable HMAC-MD5 implementation for JavaScript: [`browser.min.js`](browser.min.js) is only **951 bytes**.
 
 - **Input type**: `string` (UTF‑8), `Uint8Array` or `Uint8ClampedArray`
 - **Output type**: hex `string` or bytes `Uint8Array`
-- **Supports inputs ≥ 512 MiB**: The input length theoretically supports 0 to $2^{53}-1$ (`Number.MAX_SAFE_INTEGER`).
+- **Supports inputs ≥ 512 MiB**: The input length theoretically supports 0 to 2⁵³-1 (`Number.MAX_SAFE_INTEGER`).
 - **TypeScript‑ready**: [`main.d.ts`](main.d.ts)
 - **0 dependencies**
 
@@ -47,6 +47,14 @@ See https://www.jsdelivr.com/package/npm/tinyhmacmd5
 
 It will define the `md5` function using `var`.
 
+### UNPKG
+
+```html
+<script src="https://unpkg.com/tinyhmacmd5"></script>
+```
+
+It will define the `md5` function using `var`.
+
 ### Inline
 
 You can embed [`browser.min.js`](browser.min.js) directly into your script.  
@@ -100,8 +108,7 @@ md5(Uint8Array.of(1, 2, 3))
 md5(Uint8Array.of(1, 2, 3), null, true)
 ```
 
-`ArrayBuffer` must be wrapped in a `Uint8Array` before use as input;  
-otherwise, it will return an incorrect MD5 hash.
+`ArrayBuffer` must be wrapped in a `Uint8Array` before use as input; otherwise, it will return an incorrect MD5 hash.
 
 ```js
 let data = new ArrayBuffer(8)
@@ -118,8 +125,8 @@ You can also input a `Uint8ClampedArray`, which has the same effect as using a `
 md5(Uint8ClampedArray.of(1, 2, 3))
 ```
 
-**[⚠️Unsafe]** You can also input a `number[]`, but every element must be an integer in the range `0 ≤ x ≤ 255`;  
-otherwise, it will return an incorrect MD5 hash.
+**[⚠️Unsafe]**  
+You can also input a `number[]`, but every element must be an integer in the range `0 ≤ x ≤ 255`; otherwise, it will return an incorrect MD5 hash.
 
 ```js
 let data = [0, 1, 127, 255]
@@ -134,12 +141,22 @@ md5(data)
 
 ## Runtime Environment
 
-Environments that support [Nullish coalescing assignment (`??=`)](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_assignment) :
-
-- Chrome ≥ 85 (2020-08-25)
-- Edge ≥ 85 (2020-08-27)
-- Firefox ≥ 79 (2020-07-28)
-- Safari ≥ 14 (2020-09-16)
+Environments that support [`Uint8Array.prototype.toHex()`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex) :
+
+- Desktop
+  - 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 ≥ 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.
 
@@ -161,13 +178,13 @@ 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 (997 bytes) while also improving reliability.
+I demonstrated in practice that HMAC-MD5 can be implemented in an extremely small footprint (951 bytes) while also improving reliability.
 
 Maybe not many people care about saving just a few KB, but `tinyhmacmd5` exists precisely to "explore the unknown".
 
 INVINCIBLE EXPERIMENT!
 
-[查看原文](README-zh.md#为什么做这个项目)
+[Read the original Chinese text](README-zh.md#为什么做这个项目)
 
 ---
 

package/browser.min.js

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

package/main.js

@@ -1,17 +1,19 @@
-/** @license https://bddjr.github.io/tinyhmacmd5/lic */
+/*! npmjs.com/tinyhmacmd5 */
 
 // 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
 
 /** @param {number} byteLen */
 // `byteLen` may be >= 2**32, so cannot use `>>>` as a replacement for `floor`
-let toBinlLen = (byteLen) => floor((byteLen + 72) / 64) * 16
+let wordsLen = (byteLen) => floor((byteLen + 72) / 64) * 16
 
 /**
  * Calculate the MD5 of an array of little-endian words, and a byte length.
@@ -24,12 +26,12 @@ let toBinlLen = (byteLen) => floor((byteLen + 72) / 64) * 16
  * 
  * @returns {number[]} MD5 Array
  */
-let binlMD5 = (
+let wordsMD5 = (
   x,
   l,
   // var:
   i = 0,
-  j = toBinlLen(l),
+  j = wordsLen(l),
   t0 = 1732584193,
   t1 = 271733878,
   t2,
@@ -37,8 +39,6 @@ let binlMD5 = (
   output = [t0, ~t1, ~t0, t1],
   oldOutput = [...output],
 ) => {
-  // console.time("binlMD5")
-
   // append padding
   // `l` may be >= 2**32, so cannot use `>>>` as a replacement for `floor`
   x[j - 1] = 0 | l / 2 ** 29;
@@ -47,35 +47,35 @@ let binlMD5 = (
   for (; i < x.length;) {
     for (j = 0; j < 64;) {
       output[oi &= 3] = 0 | (
-        (t1 = 0 | (
-          output[oi] +
-          (
-            t0 = output[++oi & 3],
-            t1 = output[++oi & 3],
-            t2 = output[++oi & 3],
-            (l = j >> 4 << 2)
-              ? 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)]
-          ) +
-          (
-            t2 = "',16%).4$+07&*/5".charCodeAt(j & 3 | l),
-            K[63 - j++] ??= 0 | 2 ** 32 * $Math.abs($Math.sin(j))
+        (
+          t1 = 0 | (
+            output[oi] +
+            K[j] +
+            (
+              t0 = output[++oi & 3],
+              t1 = output[++oi & 3],
+              t2 = output[++oi & 3],
+              (l = j >> 4 << 2)
+                ? 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)]
+            )
           )
-        )) << t2 | t1 >>> 64 - t2
+        ) << (
+          t2 = "',16%).4$+07&*/5".charCodeAt(j++ & 3 | l)
+        ) | t1 >>> 64 - t2
       ) + t0
     }
     for (; oi; i += 4) {
       oldOutput[--oi] = output[oi] = 0 | oldOutput[oi] + output[oi]
     }
   }
-  // console.timeEnd("binlMD5")
   return output
 }
 
@@ -87,7 +87,7 @@ let binlMD5 = (
  * 
  * @returns {[Int32Array<ArrayBuffer> | number[], number]}
  */
-let inputToBinl = (
+let inputToWords = (
   input,
   j,
   // var:
@@ -98,10 +98,9 @@ let inputToBinl = (
   ).length,
   // Using `Array` to process inputs over 512 MiB could throw a `RangeError`,
   // so I replaced it with `Int32Array`.
-  output = new Int32Array(toBinlLen(j * 4 + byteLen)),
+  output = new Int32Array(wordsLen(j * 4 + byteLen)),
   i = 0,
 ) => {
-  // console.time("inputToBinl")
   for (; i < byteLen;) {
     output[j++] = (
       input[i++] |
@@ -110,7 +109,6 @@ let inputToBinl = (
       input[i++] << 24
     )
   }
-  // console.timeEnd("inputToBinl")
   return [output, byteLen]
 }
 
@@ -128,41 +126,40 @@ let inputToBinl = (
 var md5 = (data, key, raw) => {
   var i = 16
     , hasKey = key != null
-    , [bdata, dataByteLen] = inputToBinl(data, /**@type {*}*/(hasKey) * i)
+    , [bdata, dataByteLen] = inputToWords(data, /**@type {*}*/(hasKey) * i)
 
   /** @type {*} */
   var temp = []
 
-  /** @type {*} */
-  var out = raw ? new Uint8Array(i) : ''
+  var out = new Uint8Array(i)
 
   if (hasKey) {
     // HMAC
-    let [bkey, keyByteLen] = inputToBinl(key, 0)
+    let [bkey, keyByteLen] = inputToWords(key, 0)
     if (keyByteLen > 64) {
-      bkey = binlMD5(bkey, keyByteLen)
+      bkey = wordsMD5(bkey, keyByteLen)
     }
     for (; i;) {
       // (0x36363636 ^ 0x5c5c5c5c) == 0x6a6a6a6a
       temp[--i] = 0x6a6a6a6a ^ (bdata[i] = 0x36363636 ^ bkey[i])
     }
     i = 16
-    bdata = temp.concat(binlMD5(bdata, 64 + dataByteLen))
+    bdata = temp.concat(wordsMD5(bdata, 64 + dataByteLen))
     dataByteLen = 80
   }
 
-  bdata = binlMD5(bdata, dataByteLen)
+  bdata = wordsMD5(bdata, dataByteLen)
 
-  // binl to bytes or hex
-  for (; i;
-    raw
-      ? out[i] = temp
-      : out = (temp >> 4 && '') + temp.toString(16) + out
-  ) {
-    temp = bdata[--i >> 2] >> i * 8 & 0xff
+  // words to bytes or hex
+  for (; i;) {
+    out[--i] = bdata[i >> 2] >> i * 8
   }
 
-  return out
+  return raw ? out : out.toHex()
+}
+
+for (; i < 64;) {
+  K[i] = 0 | 2 ** 32 * $Math.abs($Math.sin(++i))
 }
 
 export default md5

package/package.json

@@ -1,19 +1,24 @@
 {
   "name": "tinyhmacmd5",
-  "version": "0.1.7",
-  "description": "A tiny and reliable HMAC-MD5 implementation for JavaScript: browser.min.js is only 997 bytes.",
+  "version": "0.2.0-es2026",
+  "description": "A tiny and reliable HMAC-MD5 implementation for JavaScript: browser.min.js is only 951 bytes.",
   "author": "bddjr",
   "license": "MIT",
   "type": "module",
   "main": "main.js",
   "types": "main.d.ts",
-  "browser": "browser.min.js",
+  "jsdelivr": "browser.min.js",
+  "unpkg": "browser.min.js",
+  "cdn": "browser.min.js",
   "files": [
     "main.js",
     "main.d.ts",
     "browser.min.js"
   ],
   "homepage": "https://bddjr.github.io/tinyhmacmd5/",
+  "publishConfig": {
+    "tag": "es2026"
+  },
   "keywords": [
     "md5",
     "hash",
@@ -58,7 +63,7 @@
     "typescript": "^7.0.2"
   },
   "scripts": {
-    "build": "tsc && node scripts/build.mjs && es-check es2021 --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",