Update esptool-js to 0.6.0, replace crypto-js with inline MD5

Remove the esptool-js patch (no longer needed with Vite 8/Rolldown),
drop crypto-js dependency, and add a lightweight Uint8Array-based MD5
implementation for firmware flash verification.

Author: hhvrc

package.json

@@ -32,19 +32,18 @@
 		"@sveltejs/vite-plugin-svelte": "^7.0.0",
 		"@tailwindcss/vite": "^4.2.2",
 		"@tanstack/table-core": "^8.21.3",
-		"@types/crypto-js": "^4.2.2",
 		"@types/node": "^25.5.0",
 		"@types/semver": "^7.7.1",
 		"@types/w3c-web-serial": "^1.0.8",
 		"bits-ui": "2.16.3",
 		"boxen": "^8.0.1",
 		"chalk": "^5.6.2",
 		"clsx": "^2.1.1",
-		"crypto-js": "^4.2.0",
 		"eslint": "^10.1.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-compat": "^7.0.1",
 		"eslint-plugin-svelte": "^3.16.0",
+		"esptool-js": "0.6.0",
 		"formsnap": "^2.0.1",
 		"globals": "^17.4.0",
 		"husky": "^9.1.7",
@@ -71,7 +70,6 @@
 		"vitest": "^4.1.1"
 	},
 	"dependencies": {
-		"esptool-js": "^0.5.7",
 		"vite": "^8.0.2"
 	},
 	"engines": {
@@ -93,8 +91,7 @@
 			"workerd"
 		],
 		"patchedDependencies": {
-			"@microsoft/signalr@10.0.0": "patches/signalr.patch",
-			"esptool-js@0.5.7": "patches/esptool.patch"
+			"@microsoft/signalr@10.0.0": "patches/signalr.patch"
 		},
 		"overrides": {
 			"cookie@<0.7.0": ">=0.7.0",

patches/esptool.patch

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { md5 } from './md5';
+
+function fromString(s: string): Uint8Array {
+  return new TextEncoder().encode(s);
+}
+
+describe('md5', () => {
+  it('hashes an empty input', () => {
+    expect(md5(new Uint8Array([]))).toBe('d41d8cd98f00b204e9800998ecf8427e');
+  });
+
+  it('hashes "hello"', () => {
+    expect(md5(fromString('hello'))).toBe('5d41402abc4b2a76b9719d911017c592');
+  });
+
+  it('hashes "abc"', () => {
+    expect(md5(fromString('abc'))).toBe('900150983cd24fb0d6963f7d28e17f72');
+  });
+
+  it('hashes a string exactly 55 bytes (just fits in one block with padding)', () => {
+    const input = 'a'.repeat(55);
+    expect(md5(fromString(input))).toBe('ef1772b6dff9a122358552954ad0df65');
+  });
+
+  it('hashes a string of 56 bytes (forces a second block for padding)', () => {
+    const input = 'a'.repeat(56);
+    expect(md5(fromString(input))).toBe('3b0c8ac703f828b04c6c197006d17218');
+  });
+
+  it('hashes a string exactly 64 bytes (one full block)', () => {
+    const input = 'a'.repeat(64);
+    expect(md5(fromString(input))).toBe('014842d480b571495a4a0363793f7367');
+  });
+
+  it('hashes arbitrary binary data', () => {
+    const data = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+    expect(md5(data)).toBe('2f249230a8e7c2bf6005ccd2679259ec');
+  });
+
+  it('hashes a longer message spanning multiple blocks', () => {
+    const input = 'The quick brown fox jumps over the lazy dog';
+    expect(md5(fromString(input))).toBe('9e107d9d372bb6826bd81d3542a419d6');
+  });
+});

pnpm-lock.yaml

@@ -0,0 +1,155 @@
+// MD5 implementation adapted from Joseph Myers' public domain code
+// https://www.myersdaily.org/joseph/javascript/md5-text.html
+
+function add32(a: number, b: number): number {
+  return (a + b) & 0xffffffff;
+}
+
+function cmn(q: number, a: number, b: number, x: number, s: number, t: number): number {
+  a = add32(add32(a, q), add32(x, t));
+  return add32((a << s) | (a >>> (32 - s)), b);
+}
+
+function ff(a: number, b: number, c: number, d: number, x: number, s: number, t: number) {
+  return cmn((b & c) | (~b & d), a, b, x, s, t);
+}
+
+function gg(a: number, b: number, c: number, d: number, x: number, s: number, t: number) {
+  return cmn((b & d) | (c & ~d), a, b, x, s, t);
+}
+
+function hh(a: number, b: number, c: number, d: number, x: number, s: number, t: number) {
+  return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function ii(a: number, b: number, c: number, d: number, x: number, s: number, t: number) {
+  return cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+function md5blk(data: Uint8Array, offset: number): number[] {
+  const blks: number[] = [];
+  for (let i = 0; i < 64; i += 4) {
+    blks[i >> 2] =
+      data[offset + i] |
+      (data[offset + i + 1] << 8) |
+      (data[offset + i + 2] << 16) |
+      (data[offset + i + 3] << 24);
+  }
+  return blks;
+}
+
+function md5cycle(state: number[], blk: number[]) {
+  let a = state[0],
+    b = state[1],
+    c = state[2],
+    d = state[3];
+
+  a = ff(a, b, c, d, blk[0], 7, -680876936);
+  d = ff(d, a, b, c, blk[1], 12, -389564586);
+  c = ff(c, d, a, b, blk[2], 17, 606105819);
+  b = ff(b, c, d, a, blk[3], 22, -1044525330);
+  a = ff(a, b, c, d, blk[4], 7, -176418897);
+  d = ff(d, a, b, c, blk[5], 12, 1200080426);
+  c = ff(c, d, a, b, blk[6], 17, -1473231341);
+  b = ff(b, c, d, a, blk[7], 22, -45705983);
+  a = ff(a, b, c, d, blk[8], 7, 1770035416);
+  d = ff(d, a, b, c, blk[9], 12, -1958414417);
+  c = ff(c, d, a, b, blk[10], 17, -42063);
+  b = ff(b, c, d, a, blk[11], 22, -1990404162);
+  a = ff(a, b, c, d, blk[12], 7, 1804603682);
+  d = ff(d, a, b, c, blk[13], 12, -40341101);
+  c = ff(c, d, a, b, blk[14], 17, -1502002290);
+  b = ff(b, c, d, a, blk[15], 22, 1236535329);
+
+  a = gg(a, b, c, d, blk[1], 5, -165796510);
+  d = gg(d, a, b, c, blk[6], 9, -1069501632);
+  c = gg(c, d, a, b, blk[11], 14, 643717713);
+  b = gg(b, c, d, a, blk[0], 20, -373897302);
+  a = gg(a, b, c, d, blk[5], 5, -701558691);
+  d = gg(d, a, b, c, blk[10], 9, 38016083);
+  c = gg(c, d, a, b, blk[15], 14, -660478335);
+  b = gg(b, c, d, a, blk[4], 20, -405537848);
+  a = gg(a, b, c, d, blk[9], 5, 568446438);
+  d = gg(d, a, b, c, blk[14], 9, -1019803690);
+  c = gg(c, d, a, b, blk[3], 14, -187363961);
+  b = gg(b, c, d, a, blk[8], 20, 1163531501);
+  a = gg(a, b, c, d, blk[13], 5, -1444681467);
+  d = gg(d, a, b, c, blk[2], 9, -51403784);
+  c = gg(c, d, a, b, blk[7], 14, 1735328473);
+  b = gg(b, c, d, a, blk[12], 20, -1926607734);
+
+  a = hh(a, b, c, d, blk[5], 4, -378558);
+  d = hh(d, a, b, c, blk[8], 11, -2022574463);
+  c = hh(c, d, a, b, blk[11], 16, 1839030562);
+  b = hh(b, c, d, a, blk[14], 23, -35309556);
+  a = hh(a, b, c, d, blk[1], 4, -1530992060);
+  d = hh(d, a, b, c, blk[4], 11, 1272893353);
+  c = hh(c, d, a, b, blk[7], 16, -155497632);
+  b = hh(b, c, d, a, blk[10], 23, -1094730640);
+  a = hh(a, b, c, d, blk[13], 4, 681279174);
+  d = hh(d, a, b, c, blk[0], 11, -358537222);
+  c = hh(c, d, a, b, blk[3], 16, -722521979);
+  b = hh(b, c, d, a, blk[6], 23, 76029189);
+  a = hh(a, b, c, d, blk[9], 4, -640364487);
+  d = hh(d, a, b, c, blk[12], 11, -421815835);
+  c = hh(c, d, a, b, blk[15], 16, 530742520);
+  b = hh(b, c, d, a, blk[2], 23, -995338651);
+
+  a = ii(a, b, c, d, blk[0], 6, -198630844);
+  d = ii(d, a, b, c, blk[7], 10, 1126891415);
+  c = ii(c, d, a, b, blk[14], 15, -1416354905);
+  b = ii(b, c, d, a, blk[5], 21, -57434055);
+  a = ii(a, b, c, d, blk[12], 6, 1700485571);
+  d = ii(d, a, b, c, blk[3], 10, -1894986606);
+  c = ii(c, d, a, b, blk[10], 15, -1051523);
+  b = ii(b, c, d, a, blk[1], 21, -2054922799);
+  a = ii(a, b, c, d, blk[8], 6, 1873313359);
+  d = ii(d, a, b, c, blk[15], 10, -30611744);
+  c = ii(c, d, a, b, blk[6], 15, -1560198380);
+  b = ii(b, c, d, a, blk[13], 21, 1309151649);
+  a = ii(a, b, c, d, blk[4], 6, -145523070);
+  d = ii(d, a, b, c, blk[11], 10, -1120210379);
+  c = ii(c, d, a, b, blk[2], 15, 718787259);
+  b = ii(b, c, d, a, blk[9], 21, -343485551);
+
+  state[0] = add32(a, state[0]);
+  state[1] = add32(b, state[1]);
+  state[2] = add32(c, state[2]);
+  state[3] = add32(d, state[3]);
+}
+
+const HEX_CHARS = '0123456789abcdef';
+
+function rhex(n: number): string {
+  let s = '';
+  for (let j = 0; j < 4; j++) {
+    s += HEX_CHARS[(n >> (j * 8 + 4)) & 0x0f] + HEX_CHARS[(n >> (j * 8)) & 0x0f];
+  }
+  return s;
+}
+
+export function md5(data: Uint8Array): string {
+  const n = data.length;
+  const state = [1732584193, -271733879, -1732584194, 271733878];
+
+  let i: number;
+  for (i = 64; i <= n; i += 64) {
+    md5cycle(state, md5blk(data, i - 64));
+  }
+
+  const tail = new Array<number>(16).fill(0);
+  const rem = n % 64;
+  const offset = n - rem;
+  for (i = 0; i < rem; i++) {
+    tail[i >> 2] |= data[offset + i] << ((i % 4) << 3);
+  }
+  tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+  if (i > 55) {
+    md5cycle(state, tail);
+    tail.fill(0);
+  }
+  tail[14] = n * 8;
+  md5cycle(state, tail);
+
+  return state.map(rhex).join('');
+}