tinyhmacmd5 0.5.2-es2026 → 0.5.3-es2026

package/README.md

@@ -4,9 +4,9 @@ English | [中文](README-zh.md)
 
 A tiny, fast and reliable implementation of MD5 and HMAC-MD5 for JavaScript.
 
-[`browser.min.js`](browser.min.js) is only **905 Bytes**.
+[`browser.min.js`](browser.min.js) is only **888 Bytes**.
 
-- **Input type**: `string` (UTF‑8), `Uint8Array` or `Uint8ClampedArray`
+- **Input type**: `string` (UTF‑8), `Uint8Array`, `Uint8ClampedArray`, `Int8Array` or `number[]`
 - **Output type**: hex `string` or bytes `Uint8Array`
 - **Supports inputs ≥ 512 MiB**: The input length theoretically supports 0 to 2⁵³-137
 - **TypeScript‑ready**: [`main.d.ts`](main.d.ts)
@@ -29,20 +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.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
+tinyhmacmd5     : 374.04 ms
+spark-md5       : 513.18 ms
+js-md5          : 481.65 ms
+crypto-js       : 1667.43 ms
+blueimp-md5     : 3753.25 ms
+node:crypto     : 130.88 ms
 --------------------------------------------------
 ✅ All pure JS implementations match node:crypto result.
 
 --- Pure 513MiB Test (No prior small tests) ---
-tinyhmacmd5 HMAC-MD5 timer: 1.867s
-node:crypto HMAC-MD5 timer: 548.332ms
-tinyhmacmd5 MD5 timer: 1.869s
-node:crypto MD5 timer: 551.244ms
+tinyhmacmd5 HMAC-MD5 timer: 1.794s
+node:crypto HMAC-MD5 timer: 550.872ms
+tinyhmacmd5 MD5 timer: 1.786s
+node:crypto MD5 timer: 548.873ms
 ```
 
 CPU: i5-10600KF  
@@ -80,21 +80,20 @@ See https://www.jsdelivr.com/package/npm/tinyhmacmd5
 <script src="https://cdn.jsdelivr.net/npm/tinyhmacmd5@es2026"></script>
 ```
 
-It will define the `md5` function using `var`.
-
 ### UNPKG
 
 ```html
 <script src="https://unpkg.com/tinyhmacmd5@es2026"></script>
 ```
 
-It will define the `md5` function using `var`.
+### cdnjs
+
+See https://cdnjs.com/libraries/tinyhmacmd5  
 
 ### Inline
 
 You can embed [`browser.min.js`](browser.min.js) directly into your script.  
-It will define the `md5` function using `var`.
-
+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
@@ -145,7 +144,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 `"0123456789abcdeffedcba9876543210"`.
 
 ```js
 let data = new ArrayBuffer(8)
@@ -154,24 +153,24 @@ let data = new ArrayBuffer(8)
 md5(new Uint8Array(data))
 ```
 
-You can also input a `Uint8ClampedArray`, which has the same effect as using a `Uint8Array`.
+You can also input `Uint8ClampedArray` or `Int8Array`.
 
 ```js
 // MD5: bytes to hex
 // returns "5289df737df57326fcdd22597afb1fac"
 md5(Uint8ClampedArray.of(1, 2, 3))
+
+// MD5: bytes to hex
+// returns "915273adf4c4b9b384bc5550b54d6319"
+md5(Int8Array.of(1, -2, 3, -4))
 ```
 
-**[⚠️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.
+You can also input a `number[]`, and each item will be converted to a byte.
 
 ```js
-let data = [0, 1, 127, 255]
-
 // MD5: bytes to hex
-// returns "b23d6235d525eed4c4b8d741d4c2a5a1"
-//@ts-ignore
-md5(data)
+// returns "47e3385934cd3e9abefb2f87c3bd4288"
+md5([0, 1, 127, 255, -9])
 ```
 
 ---

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

package/main.d.ts

@@ -11,18 +11,18 @@
  */
 declare var md5: {
     (
-        data: string | Uint8Array | Uint8ClampedArray,
-        key?: string | Uint8Array | Uint8ClampedArray | null,
+        data: string | Uint8Array | Uint8ClampedArray | Int8Array | number[],
+        key?: string | Uint8Array | Uint8ClampedArray | Int8Array | number[] | null,
         raw?: false
     ): string;
     (
-        data: string | Uint8Array | Uint8ClampedArray,
-        key: string | Uint8Array | Uint8ClampedArray | null | undefined,
+        data: string | Uint8Array | Uint8ClampedArray | Int8Array | number[],
+        key: string | Uint8Array | Uint8ClampedArray | Int8Array | number[] | null | undefined,
         raw: true
     ): Uint8Array<ArrayBuffer>;
     (
-        data: string | Uint8Array | Uint8ClampedArray,
-        key: string | Uint8Array | Uint8ClampedArray | null | undefined,
+        data: string | Uint8Array | Uint8ClampedArray | Int8Array | number[],
+        key: string | Uint8Array | Uint8ClampedArray | Int8Array | number[] | null | undefined,
         raw: boolean
     ): string | Uint8Array<ArrayBuffer>;
 };

package/main.js

@@ -10,18 +10,17 @@ 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()
+/** @type {<T extends { reverse(): T }>(a: T, ..._: any[]) => T} */
+let reverseOnBE = a => isBE ? a.reverse() : a
 
 /**
- * Calculate the MD5 of an array of little-endian words, and a byte length.
+ * Calculate the MD5 of an Int32Array of little-endian words, and a byte length.
  *
- * @param {Int32Array<ArrayBuffer>} x little-endian words
- * @param {number} l Byte length
- * 
- * @returns {Int32Array<ArrayBuffer>} MD5 Array
+ * @type {(x: Int32Array<ArrayBuffer>, l: number) => Int32Array<ArrayBuffer>}
+ * @param x words
+ * @param l Byte length
  */
-let wordsMD5 = (
+let wordsMD5 = ((
   x,
   l,
   // var:
@@ -42,6 +41,7 @@ let wordsMD5 = (
     let { 0: a, 1: b, 2: c, 3: d } = output
     for (l = j = 0; l < 16; l += 4) {
       for (
+        let mul = 0x7351 >> l, add = 0x0510 >> l
         ; j < 4 * l + 16
         ; b = 0 | (
           (
@@ -56,8 +56,8 @@ let wordsMD5 = (
                     ? d & (b ^ c)  // Round 2: G
                     : ~b & (c ^ d) // Round 1: F
               )) +
-              x[i + (j++ * (0x7351 >> l) + (0x0510 >> l) & 15)]
-            )) << cnt | a >>> 32 - cnt // Keep `32 -` so JS engines can recognize bit rotation (ROL/ROR).
+              x[i + (j++ * mul + add & 15)]
+            )) >>> cnt | a << 32 - cnt // Keep `32 -` so JS engines can recognize bit rotation (ROR).
           ) + (
             a = d,
             d = c,
@@ -65,7 +65,7 @@ let wordsMD5 = (
           )
         )
       ) {
-        cnt = "',16%).4$+07&*/5".charCodeAt(j & 3 | l)
+        cnt = "94/*;72,<50):61+".charCodeAt(j & 3 | l)
       }
     }
     output[0] += a
@@ -74,17 +74,17 @@ let wordsMD5 = (
     output[3] += d
   }
   return output
-}
+})
+
+/** @typedef {string | Uint8Array | Uint8ClampedArray | Int8Array | number[]} Input */
 
 /**
- * Convert bytes to an array of little-endian words
+ * Convert bytes to an Int32Array of little-endian words
  *
- * @param {*} input
- * @param {number} padLen pad int32 length (0 or 16)
- * 
- * @returns {[Int32Array<ArrayBuffer>, number]}
+ * @type {(input: Input, padLen: number) => [Int32Array<ArrayBuffer>, number]}
+ * @param padLen pad byte-length (0 or 64)
  */
-let inputToWords = (
+let inputToWords = ((
   input,
   padLen,
   // var:
@@ -94,14 +94,16 @@ let inputToWords = (
       ? input = new TextEncoder().encode(input)
       : input
   ).length,
-  // Using `Array` to process inputs over 512 MiB could throw a `RangeError`,
-  // so I replaced it with `Int32Array`.
-  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]
+  outputBytes = new $Uint8Array(padLen + byteLen + 72 - (byteLen + 8 & 63)),
+) =>
+  [
+    reverseOnBE(
+      new $Int32Array(outputBytes.buffer),
+      outputBytes.set(/** @type {Exclude<Input, string>} */(input), padLen),
+      reverseOnBE(outputBytes)
+    ),
+    byteLen
+  ]
 )
 
 /**
@@ -110,8 +112,8 @@ let inputToWords = (
  * By default, returns the hash as a lowercase hexadecimal string.  
  * If `raw` is true, returns a Uint8Array.  
  *
- * @param {string | Uint8Array | Uint8ClampedArray} data The input data to hash. Strings are UTF‑8 encoded.
- * @param {string | Uint8Array | Uint8ClampedArray | null} [key] Optional HMAC key. When given, HMAC‑MD5 is calculated instead of plain MD5.
+ * @param {Input} data The input data to hash. Strings are UTF‑8 encoded.
+ * @param {Input | null} [key] Optional HMAC key. When given, HMAC‑MD5 is calculated instead of plain MD5.
  * @param {boolean} [raw] If true, the hash is returned as raw bytes (Uint8Array); otherwise, as a hex string.
  * @returns {string | Uint8Array<ArrayBuffer>} The MD5 (or HMAC‑MD5) digest, either as a hex string or a Uint8Array.
  */
@@ -119,17 +121,16 @@ let md5 = (data, key, raw) => {
   // Do not use parameter defaults to declare variables in public functions.
   /** @type {boolean | Uint8Array<ArrayBuffer>} */
   var temp = key != null
-    , [bdata, dataByteLen] = inputToWords(data, /**@type {*}*/(temp) * 16)
+    , [bdata, dataByteLen] = inputToWords(data, /** @type {*} */(temp) * 64)
 
   if (temp) {
     // HMAC
-    let [bkey, keyByteLen] = inputToWords(key, 0)
+    let [bkey, i] = inputToWords(key, 0)
       , opad = new $Int32Array(32)
-      , i = 16
-    if (keyByteLen > 64) {
-      bkey = wordsMD5(bkey, keyByteLen)
+    if (i > 64) {
+      bkey = wordsMD5(bkey, i)
     }
-    for (; i;) {
+    for (i = 16; i;) {
       // (0x36363636 ^ 0x5c5c5c5c) == 0x6a6a6a6a
       opad[--i] = 0x6a6a6a6a ^ (bdata[i] = 0x36363636 ^ bkey[i])
     }
@@ -138,10 +139,13 @@ let md5 = (data, key, raw) => {
     dataByteLen = 80
   }
 
-  bdata = wordsMD5(bdata, dataByteLen)
-
-  temp = new $Uint8Array(bdata.buffer)
-  isBE && reverse(temp, reverse(bdata))
+  temp = reverseOnBE(
+    new $Uint8Array(
+      reverseOnBE(
+        wordsMD5(bdata, dataByteLen)
+      ).buffer
+    )
+  )
   return raw
     ? temp
     : temp.toHex()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tinyhmacmd5",
-  "version": "0.5.2-es2026",
-  "description": "A tiny (905 Bytes), fast and reliable implementation of MD5 and HMAC-MD5 for JavaScript.",
+  "version": "0.5.3-es2026",
+  "description": "A tiny (888 Bytes), fast and reliable implementation of MD5 and HMAC-MD5 for JavaScript.",
   "author": "bddjr",
   "license": "Unlicense",
   "type": "module",
@@ -56,10 +56,10 @@
   "devDependencies": {
     "blueimp-md5": "^2.19.0",
     "crypto-js": "^4.2.0",
-    "es-check": "^9.6.4",
+    "es-check": "^9.7.1",
     "js-md5": "^0.9.2",
     "spark-md5": "^3.0.2",
-    "terser": "^5.49.0",
+    "terser": "^5.51.2",
     "tinyhmacmd5": "link:",
     "typescript": "^7.0.2"
   },